Software Crypto/Web3 Engineering Skill

Software Crypto/Web3 Engineering

Use this skill to design, implement, and review secure blockchain systems: smart contracts, on-chain/off-chain integration, custody and signing, testing, audits, and production operations.

Defaults to: security-first development, explicit threat models, comprehensive testing (unit + integration + fork + fuzz/invariants), formal methods when high-value, upgrade safety (timelocks, governance, rollback plans), and defense-in-depth for key custody and signing.

Quick Reference

| Task | Tool/Framework | Command | When to Use | |------|----------------|---------|-------------| | Solidity Development | Hardhat/Foundry | npx hardhat init or forge init | Ethereum/EVM smart contracts | | Solana Programs | Anchor | anchor init | Solana blockchain development | | Cosmos Contracts | CosmWasm | cargo generate --git cosmwasm-template | Cosmos ecosystem contracts | | TON Contracts | Tact/FunC + Blueprint | npm create ton@latest | TON blockchain development | | Testing (Solidity) | Foundry/Hardhat | forge test or npx hardhat test | Unit, fork, invariant tests | | Security Audit | Slither/Aderyn/Echidna | slither . or aderyn . | Static analysis, fuzzing | | AI-Assisted Review | AI scanners (optional) | N/A | Pre-audit preparation (verify findings manually) | | Fuzzing | Echidna/Medusa | echidna . or medusa fuzz | Property-based fuzzing | | Gas Optimization | Foundry Gas Snapshots | forge snapshot | Benchmark and optimize gas | | Deployment | Hardhat Deploy/Forge Script | npx hardhat deploy | Mainnet/testnet deployment | | Verification | Etherscan API | npx hardhat verify | Source code verification | | Upgradeable Contracts | OpenZeppelin Upgrades | @openzeppelin/hardhat-upgrades | Proxy-based upgrades | | Smart Wallets | ERC-4337, EIP-7702 | Account abstraction SDKs | Smart accounts and sponsored gas (verify network support) |

Scope

Use this skill when you need:

Smart contract development (Solidity, Rust, CosmWasm)
DeFi protocol implementation (AMM, lending, staking, yield farming)
NFT and token standards (ERC20, ERC721, ERC1155, SPL tokens)
DAO governance systems
Cross-chain bridges and interoperability
Gas optimization and storage patterns
Smart contract security audits
Testing strategies (Foundry, Hardhat, Anchor)
Oracle integration (Chainlink, Pyth)
Upgradeable contract patterns (proxies, diamonds)
Web3 frontend integration (ethers.js, web3.js, @solana/web3.js)
Blockchain indexing (The Graph, subgraphs)
MEV protection and flashbots
Layer 2 scaling solutions (Base, Arbitrum, Optimism, zkSync)
Account abstraction (ERC-4337, EIP-7702, smart wallets)
Backend crypto integration (.NET/C#, multi-provider architecture, CQRS)
Webhook handling and signature validation (Fireblocks, custodial providers)
Event-driven architecture with Kafka for crypto payments
Transaction lifecycle management and monitoring
Wallet management (custodial vs non-custodial)

Decision Tree: Blockchain Platform Selection

Project needs: [Use Case]
  - EVM-compatible smart contracts?
    - Complex testing needs -> Foundry (fuzzing, invariants, gas snapshots)
    - TypeScript ecosystem -> Hardhat (plugins, TS, Ethers.js/Viem)
    - Enterprise features -> NestJS + Hardhat

  - High throughput / low fees?
    - Rust-based -> Solana (Anchor)
    - EVM L2 -> Arbitrum/Optimism/Base (Ethereum security, lower gas)
    - Telegram distribution -> TON (Tact/FunC)

  - Interoperability across chains?
    - Cosmos ecosystem -> CosmWasm (IBC)
    - Multi-chain apps -> LayerZero or Wormhole (verify trust assumptions)
    - Bridge development -> custom (high risk; threat model required)

  - Token standard implementation?
    - Fungible tokens -> ERC20 (OpenZeppelin), SPL Token (Solana)
    - NFTs -> ERC721/ERC1155 (OpenZeppelin), Metaplex (Solana)
    - Semi-fungible -> ERC1155 (gaming, fractionalized NFTs)

  - DeFi protocol development?
    - AMM/DEX -> Uniswap V3 fork or custom (concentrated liquidity)
    - Lending -> Compound/Aave fork (collateralized borrowing)
    - Staking/yield -> custom reward distribution contracts

  - Upgradeable contracts required?
    - Transparent proxy -> OpenZeppelin (admin/user separation)
    - UUPS -> upgrade logic in implementation
    - Diamond -> modular functionality (EIP-2535)

  - Backend integration?
    - .NET/C# -> multi-provider architecture (see backend integration references)
    - Node.js -> Ethers.js/Viem + durable queues
    - Python -> Web3.py + FastAPI

Chain-Specific Considerations:

Ethereum/EVM: Security-first, higher gas costs, largest ecosystem
Solana: Performance-first, Rust required, lower fees
Cosmos: Interoperability-first, IBC native, growing ecosystem
TON: Telegram-first, async contracts, unique architecture

See references/ for chain-specific best practices.

Security-First Patterns (Jan 2026)

Security baseline: Assume an adversarial environment. Treat contracts and signing infrastructure as public, attackable APIs.

Custody, Keys, and Signing (Core)

Key management is a dominant risk driver in production crypto systems. Use a real key management standard as baseline (for example, NIST SP 800-57).

| Model | Who holds keys | Typical use | Primary risks | Default controls | |------|-----------------|------------|---------------|------------------| | Non-custodial | End user wallet | Consumer apps, self-custody | Phishing, approvals, UX errors | Hardware wallet support, clear signing UX, allowlists | | Custodial | Your service (HSM/MPC) | Exchanges, payments, B2B | Key theft, insider threat, ops mistakes | HSM/MPC, separation of duties, limits/approvals, audit logs | | Hybrid | Split responsibility | Enterprises | Complex failure modes | Explicit recovery/override paths, runbooks |

BEST:

Separate hot/warm/cold signing paths with limits and approvals [Inference]
Require dual control for high-value transfers (policy engine + human approval) [Inference]
Keep an immutable audit trail for signing requests (who/what/when/why) [Inference]

AVOID:

Storing private keys in databases or application config
Reusing signing keys across environments (dev/staging/prod)
Hot-wallet automation without rate limits and circuit breakers [Inference]

Checks-Effects-Interactions (CEI) Pattern

Mandatory for all state-changing functions.

// Correct: CEI pattern
function withdraw(uint256 amount) external {
    // 1. CHECKS: Validate conditions
    require(balances[msg.sender] >= amount, "Insufficient balance");

    // 2. EFFECTS: Update state BEFORE external calls
    balances[msg.sender] -= amount;

    // 3. INTERACTIONS: External calls LAST
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}

// Wrong: External call before state update (reentrancy risk)
function withdrawUnsafe(uint256 amount) external {
    require(balances[msg.sender] >= amount);
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success);
    balances[msg.sender] -= amount; // Too late!
}

Security Tools (Jan 2026)

| Category | Tool | Purpose | When to Use | |----------|------|---------|-------------| | Static Analysis | Slither | Vulnerability detection, 92+ detectors | Every contract | | Static Analysis | Aderyn | Rust-based, faster for large codebases | Large projects | | Fuzzing | Echidna | Property-based fuzzing | Complex state | | Fuzzing | Medusa | Parallelized Go fuzzer | CI/CD pipelines | | Formal Verification | SMTChecker | Built-in Solidity checker | Every contract | | Formal Verification | Certora | Property-based proofs (CVL) | DeFi, high-value | | Formal Verification | Halmos | Symbolic testing | Complex invariants | | AI-Assisted | Sherlock AI | ML vulnerability detection | Pre-audit prep | | AI-Assisted | Olympix | DevSecOps integration | CI/CD security | | AI-Assisted | AuditBase | 423+ detectors, LLM-powered | Business logic | | Mutation Testing | SuMo | Test suite quality assessment | Test validation |

// Certora CVL rule example
rule balanceNeverNegative(address user) {
    env e;
    require balances[user] >= 0;
    deposit(e);
    assert balances[user] >= 0;
}

AI-assisted review: Use AI tooling for pre-audit preparation and coverage, not for final security decisions. Treat outputs as untrusted and reproduce findings with deterministic tools, tests, and manual review.

MEV Protection

| Strategy | Implementation | |----------|----------------| | Private mempool | Flashbots Protect, MEV Blocker | | Commit-reveal | Hash commitment, reveal after deadline | | Batch auctions | CoW Protocol, Gnosis Protocol | | Encrypted mempools | Shutter Network |

// Commit-reveal pattern
mapping(address => bytes32) public commitments;

function commit(bytes32 hash) external {
    commitments[msg.sender] = hash;
}

function reveal(uint256 value, bytes32 salt) external {
    require(
        keccak256(abi.encodePacked(value, salt)) == commitments[msg.sender],
        "Invalid reveal"
    );
    // Process revealed value
}

Account Abstraction (Jan 2026)

Note: Adoption numbers and upgrade timelines change quickly. Verify current ERC-4337 ecosystem state and any EIP-7702 activation details with WebSearch before making recommendations.

ERC-4337 vs EIP-7702

| Standard | Type | Key Feature | Use Case | |----------|------|-------------|----------| | ERC-4337 | Smart contract wallets | Full AA without protocol changes | New wallets, DeFi, gaming | | EIP-7702 | EOA enhancement | EOAs execute smart contract code | Existing wallets, batch txns | | ERC-6900 | Modular accounts | Plugin management for AA wallets | Extensible wallet features |

ERC-4337 Architecture:

User -> UserOperation -> Bundler -> EntryPoint -> Smart Account -> Target Contract
                          |
                          v
                      Paymaster (gas sponsorship)

EIP-7702 (Pectra Upgrade):

EOAs can temporarily delegate to smart contracts
Enables batch transactions, sponsored gas for existing addresses
Complementary to ERC-4337 (uses same bundler/paymaster infra)
Supported by Ambire, Trust Wallet, and growing

Key Capabilities:

Gasless transactions: Paymasters sponsor gas in ERC-20 or fiat
Batch operations: Multiple actions in single transaction
Social recovery: Multi-sig or guardian-based key recovery
Session keys: Limited permissions for dApps without full wallet access

Smart Wallet Development

// Minimal ERC-4337 Account (simplified)
import "@account-abstraction/contracts/core/BaseAccount.sol";

contract SimpleAccount is BaseAccount {
    address public owner;

    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external override returns (uint256 validationData) {
        // Verify signature
        require(_validateSignature(userOp, userOpHash), "Invalid sig");
        // Pay prefund if needed
        if (missingAccountFunds > 0) {
            (bool success,) = payable(msg.sender).call{value: missingAccountFunds}("");
            require(success);
        }
        return 0; // Valid
    }
}

Layer 2 Development (Jan 2026)

Note: L2 market share and risk stages change quickly. Use current data (for example, L2Beat and ecosystem dashboards) before stating rankings, TVL, or stage classifications.

L2 Selection Guide

| L2 | Type | Best For | Key Feature | |----|------|----------|-------------| | Base | Optimistic | Consumer apps, mainstream adoption | Coinbase integration, low fees | | Arbitrum | Optimistic | DeFi, mature ecosystem | Largest TVL, DAO grants | | Optimism | Optimistic | Public goods, Superchain | OP Stack, grant programs | | zkSync Era | ZK-Rollup | Fast finality, native AA | zkEVM, no withdrawal delay | | StarkNet | ZK-Rollup | Cairo development, ZK-native | STARK proofs, custom VM |

Enterprise Rollups (2025-2026 Trend)

Major institutions launching L2s on OP Stack:

Kraken INK - Exchange-native L2
Uniswap UniChain - DeFi-optimized
Sony Soneium - Gaming and media
Robinhood - Arbitrum integration

EIP-4844 Blob Optimization

Since March 2024, rollups use blob-based data posting:

Before: calldata posting -> expensive
After:  blob posting -> lower data availability cost

Optimism, zkSync optimized batching for blobs in 2025.

Common Mistakes (2025-2026)

Reality check: Exploits regularly cause large losses. Access control, signing/custody, and integration bugs remain top incident drivers.

| Mistake | Impact | Prevention | |---------|--------|------------| | Missing access control | Unauthorized admin actions | Use OpenZeppelin Ownable2Step, AccessControl | | Reentrancy | Drain funds via callback | CEI pattern, ReentrancyGuard, Slither checks | | Unchecked external calls | Silent failures | Always check return values, use SafeERC20 | | Integer overflow (pre-0.8) | Arbitrary value manipulation | Use Solidity 0.8.x+ (built-in checks) | | Frontrunning | MEV extraction, sandwich attacks | Commit-reveal, Flashbots Protect, private mempool | | Oracle manipulation | Price feed attacks | TWAP, multiple oracles, sanity bounds | | Improper initialization | Proxy takeover | Use initializer modifier, _disableInitializers() | | Storage collision (proxies) | Data corruption | Follow EIP-1967 slots, use OpenZeppelin upgrades |

Anti-Patterns to Avoid

AVOID:

Using tx.origin for authorization (phishing risk)
Storing secrets on-chain (all data is public)
Using block.timestamp for randomness (miner/validator influence)
Ignoring return values from transfer/send
Using deprecated tooling (Truffle/Ganache/Brownie)

BEST:

Run static analysis on every change (for example, Slither and Aderyn)
Add fuzz/invariant tests before any audit
Use formal methods for high-value DeFi (for example, Certora and symbolic testing)

LLM Limitations in Smart Contracts

Do not rely on LLMs for:

Security-critical logic verification
Gas optimization calculations
Complex mathematical proofs

Use LLMs for:

Boilerplate generation (tests, docs)
Code explanation and review prep
Initial vulnerability hypotheses (verify manually)

When NOT to Use This Skill

Traditional backend without blockchain -> Use software-backend
Pure API design without Web3 -> Use dev-api-design
General security without smart contracts -> Use software-security-appsec
Frontend-only dApp UI -> Use software-frontend + Web3 libraries

Navigation

Resources

references/blockchain-best-practices.md - Universal blockchain patterns and security
references/backend-integration-best-practices.md - .NET/C# crypto integration patterns (CQRS, Kafka, multi-provider)
references/solidity-best-practices.md - Solidity/EVM-specific guidance
references/rust-solana-best-practices.md - Solana + Anchor patterns
references/cosmwasm-best-practices.md - Cosmos/CosmWasm guidance
references/ton-best-practices.md - TON contracts (Tact/Fift/FunC) and deployment
references/defi-protocol-patterns.md - AMM, lending, staking, yield farming, flash loans, oracle integration
references/nft-token-standards.md - ERC-20/721/1155, SPL Token, Metaplex, token gating, metadata
references/cross-chain-bridges.md - Bridge architectures, LayerZero, Wormhole, IBC, security analysis
../software-security-appsec/references/smart-contract-security-auditing.md - Smart contract audit workflows and tools (see software-security-appsec skill)
data/sources.json - Curated external references per chain
Shared secure review checklist: ../software-clean-code-standard/assets/checklists/secure-code-review-checklist.md

Templates

Ethereum/EVM: assets/ethereum/template-solidity-hardhat.md, assets/ethereum/template-solidity-foundry.md
Solana: assets/solana/template-rust-anchor.md
Cosmos: assets/cosmos/template-cosmwasm.md
TON: assets/ton/template-tact-blueprint.md, assets/ton/template-func-blueprint.md
Bitcoin: assets/bitcoin/template-bitcoin-core.md

Related Skills

../software-security-appsec/SKILL.md - Security hardening, threat modeling, OWASP vulnerabilities
../software-architecture-design/SKILL.md - System decomposition, modularity, dependency design
../ops-devops-platform/SKILL.md - Infrastructure, CI/CD, observability for blockchain nodes
../software-backend/SKILL.md - API integration with smart contracts, RPC nodes, indexers
../qa-resilience/SKILL.md - Resilience, circuit breakers, retry logic for chains
../software-code-review/SKILL.md - Code review patterns and quality gates
../dev-api-design/SKILL.md - RESTful design for Web3 APIs and dApp backends

Trend Awareness Protocol

IMPORTANT: When users ask recommendation questions about Web3/crypto development, you MUST use WebSearch to check current trends before answering.

Trigger Conditions

"What's the best blockchain for [use case]?"
"What should I use for [smart contracts/DeFi/NFTs]?"
"What's the latest in Web3 development?"
"Current best practices for [Solidity/auditing/gas optimization]?"
"Is [chain/protocol] still relevant in 2026?"
"[Ethereum] vs [Solana] vs [other L1/L2]?"
"Best framework for [smart contract development]?"

Required Searches

Search: "Web3 development best practices 2026"
Search: "[Ethereum/Solana/Base] development updates 2026"
Search: "smart contract security 2026"
Search: "[Hardhat/Foundry] comparison 2026"

What to Report

After searching, provide:

Current landscape: What chains/tools are popular NOW
Emerging trends: New protocols or patterns gaining traction
Deprecated/declining: Chains or approaches losing relevance
Recommendation: Based on fresh data and ecosystem activity

Example Topics (verify with fresh search)

L2 ecosystem growth (Base, Arbitrum, Optimism)
Solidity vs Rust for smart contracts
Foundry vs Hardhat tooling
Account abstraction (ERC-4337) adoption
Cross-chain bridges and interoperability
DeFi security patterns and audit practices

Operational Playbooks

references/operational-playbook.md - Smart contract architecture, security-first workflows, and platform-specific patterns

Fact-Checking

Use web search/web fetch to verify current external facts, versions, pricing, deadlines, regulations, or platform behavior before final answers.
Prefer primary sources; report source links and dates for volatile information.
If web access is unavailable, state the limitation and mark guidance as unverified.

Agent Skills: Software Crypto/Web3 Engineering

Install this agent skill to your local

Skill Files