AgentSkillsCN

blockchain-integration-builder

在区块链架构与智能合约设计、Web3 集成、代币机制，以及去中心化身份认证等领域，注重模式而非特定技术的应用。当您需要构建 Web3 应用、智能合约系统、代币经济模型、去中心化身份认证，或实现区块链验证的数据应用时，此功能将助您事半功倍。无论您使用以太坊、Solana，还是新兴公链，此功能都同样适用。

SKILL.md
--- frontmatter
name: blockchain-integration-builder
description: Design and implement blockchain integrations across chains and frameworks with emphasis on patterns over specific technologies. Use when building Web3 applications, smart contract systems, token mechanics, decentralized identity, or blockchain-verified data. Triggers on blockchain architecture, smart contract design, Web3 integration, token systems, or decentralized application development. Framework-agnostic—applies to Ethereum, Solana, or emerging chains.
license: MIT

Blockchain Integration Builder

Design blockchain systems using universal patterns applicable across chains.

Core Abstractions

Blockchain-agnostic thinking: focus on what you're trying to achieve, then select chain/framework.

Fundamental Primitives

PrimitiveWhat It IsChain Examples
AccountIdentity with balanceEOA (Eth), Wallet (Solana), Account (Near)
TransactionState change requestSigned message + gas
BlockBatch of transactionsTime-ordered, immutable
ContractOn-chain programSolidity, Rust, Move
Event/LogIndexed side-effectEmitted by contracts, queryable
StatePersistent dataMappings, storage slots

Selection Criteria

NeedConsiderWhy
ProgrammabilityEthereum, Arbitrum, BaseMature tooling, EVM ecosystem
Speed/CostSolana, Sui, AptosHigh throughput, low fees
PrivacyAztec, ZcashZero-knowledge proofs
InteroperabilityCosmos, PolkadotCross-chain communication
SimplicityBitcoin, LitecoinLimited scripting, proven security

Pattern Library

Identity Patterns

Wallet-Based Identity

code
User → Wallet → Sign Message → Verify Signature → Authenticated
  • •No passwords stored
  • •User controls identity
  • •Works across applications

Soul-Bound Tokens (SBTs)

code
Issuer → Mint SBT → User Wallet (non-transferable)
  • •Credentials, achievements, reputation
  • •Cannot be sold or transferred
  • •Revocable by issuer (optionally)

Decentralized Identifiers (DIDs)

code
did:method:identifier → Resolve → DID Document → Public Keys, Services
  • •Self-sovereign identity
  • •Cross-chain portable
  • •W3C standard

Token Patterns

Fungible Tokens (ERC-20 pattern)

solidity
// Universal interface
balanceOf(address) → uint256
transfer(to, amount) → bool
approve(spender, amount) → bool
transferFrom(from, to, amount) → bool

Non-Fungible Tokens (ERC-721 pattern)

solidity
// Universal interface
ownerOf(tokenId) → address
transferFrom(from, to, tokenId)
tokenURI(tokenId) → string (metadata)

Semi-Fungible (ERC-1155 pattern)

solidity
// Batch operations, mixed fungible/non-fungible
balanceOf(account, id) → uint256
balanceOfBatch(accounts[], ids[]) → uint256[]
safeTransferFrom(from, to, id, amount, data)

Governance Patterns

Token Voting

code
Proposal → Snapshot Balances → Vote Period → Tally → Execute (if passed)

Quadratic Voting

code
Cost of N votes = N² tokens
Reduces plutocratic dominance

Optimistic Governance

code
Proposal → Challenge Period → Execute if unchallenged

Economic Patterns

Bonding Curves

code
Price = f(Supply)
Buy: Price increases with supply
Sell: Price decreases with supply
Creates automatic market making

Staking/Slashing

code
Stake tokens → Perform duties → Earn rewards
Misbehave → Lose stake (slashing)

Streaming Payments

code
Deposit → Linear unlock over time → Recipient claims

Architecture Patterns

On-Chain vs Off-Chain

AspectOn-ChainOff-Chain
CostHigh (gas fees)Low/free
SpeedSlow (block time)Fast
TrustTrustlessRequires trust
PrivacyPublicCan be private
StorageExpensiveCheap

Hybrid approach:

code
Off-chain: Computation, storage, user experience
On-chain: Verification, settlement, ownership
Bridge: Oracles, merkle proofs, signatures

Indexing Pattern

Blockchain data is hard to query directly. Use indexers:

code
Blockchain → Events → Indexer → Database → API → Frontend

Tools: The Graph, Goldsky, custom indexers

Oracle Pattern

Bring external data on-chain:

code
External Data → Oracle Network → Consensus → On-chain Value

Use cases: Price feeds, random numbers, API data

Security Principles

Smart Contract Security

  1. •Check-Effects-Interactions: Update state before external calls
  2. •Reentrancy Guards: Prevent recursive calls
  3. •Access Control: Verify caller permissions
  4. •Input Validation: Never trust user input
  5. •Upgrade Patterns: Plan for bug fixes (proxies, migrations)

Common Vulnerabilities

VulnerabilityDescriptionPrevention
ReentrancyRecursive calls drain fundsChecks-effects-interactions
Integer overflowMath wraps aroundSafeMath or Solidity 0.8+
Front-runningMiners/validators see pending txsCommit-reveal, flashbots
Oracle manipulationFake price dataMultiple oracles, TWAP
Access controlMissing permission checksRole-based access

Integration Workflow

1. Define Requirements

  • •What needs to be trustless?
  • •What can stay off-chain?
  • •Who are the actors?
  • •What are the assets?

2. Select Chain

Based on: throughput needs, cost constraints, ecosystem fit, team expertise

3. Design Contracts

  • •Keep contracts simple and focused
  • •Separate concerns into multiple contracts
  • •Plan upgrade path

4. Build Indexing

  • •Determine query patterns
  • •Index relevant events
  • •Build API layer

5. Create Frontend

  • •Wallet connection
  • •Transaction signing
  • •State display
  • •Error handling

6. Test & Audit

  • •Unit tests
  • •Integration tests
  • •Formal verification (for critical contracts)
  • •Third-party audit

References

  • •references/contract-patterns.md - Common smart contract patterns
  • •references/chain-comparison.md - Chain-specific considerations