Blockchain Developer Skill

Blockchain Developer

Purpose

Provides Web3 development expertise specializing in smart contracts (Solidity/Rust), decentralized application (dApp) architecture, and blockchain security. Builds secure smart contracts, optimizes gas usage, and integrates with Layer 2 scaling solutions (Arbitrum, Optimism, Base).

When to Use

• Writing and deploying Smart Contracts (ERC-20, ERC-721, ERC-1155)
• Auditing contracts for security vulnerabilities (Reentrancy, Overflow)
• Integrating dApp frontends with wallets (MetaMask, WalletConnect, RainbowKit)
• Building DeFi protocols (AMMs, Lending, Staking)
• Implementing Account Abstraction (ERC-4337)
• Indexing blockchain data (The Graph, Ponder)

--- ---

2. Decision Framework

Blockchain Network Selection

Which chain fits the use case?
│
├─ **Ethereum L1**
│  ├─ High value transactions? → **Yes** (Max security)
│  └─ Cost sensitive? → **No** (High gas fees)
│
├─ **Layer 2 (Arbitrum / Optimism / Base)**
│  ├─ General purpose? → **Yes** (EVM equivalent)
│  ├─ Low fees? → **Yes** ($0.01 - $0.10)
│  └─ Security? → **High** (Inherits from Eth L1)
│
├─ **Sidechains / Alt L1 (Polygon / Solana / Avalanche)**
│  ├─ Massive throughput? → **Solana** (Rust based)
│  └─ EVM compatibility? → **Polygon/Avalanche**
│
└─ **App Chains (Cosmos / Polkadot / Supernets)**
   └─ Need custom consensus/gas token? → **Yes** (Sovereignty)

Development Stack (2026 Standards)

Red Flags → Escalate to `security-auditor`:

• Contract holds > $100k value without an audit
• Using delegatecall with untrusted inputs
• Implementing custom cryptography (Rolling your own crypto)
• Upgradable contracts without a Timelock or Multi-sig governance

--- ---

4. Core Workflows

Workflow 1: Smart Contract Development (Foundry)

Goal: Create a secure ERC-721 NFT contract with whitelist.

Steps:

1. Setup

    forge init my-nft
    forge install OpenZeppelin/openzeppelin-contracts

2. Contract (`src/MyNFT.sol`)

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.20;

    import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";
    import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";

    contract MyNFT is ERC721, Ownable {
        bytes32 public merkleRoot;
        uint256 public nextTokenId;

        constructor(bytes32 _merkleRoot) ERC721("MyNFT", "MNFT") Ownable(msg.sender) {
            merkleRoot = _merkleRoot;
        }

        function mint(bytes32[] calldata proof) external {
            bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
            require(MerkleProof.verify(proof, merkleRoot, leaf), "Not whitelisted");
            
            _safeMint(msg.sender, nextTokenId);
            nextTokenId++;
        }
    }

3. Test (`test/MyNFT.t.sol`)

    function testMintWhitelist() public {
        // Generate Merkle Tree in helper...
        bytes32[] memory proof = tree.getProof(user1);
        
        vm.prank(user1);
        nft.mint(proof);
        
        assertEq(nft.ownerOf(0), user1);
    }

--- ---

Workflow 3: Gas Optimization Audit

Goal: Reduce transaction costs for users.

Steps:

1. Analyze Storage

• Pack variables: uint128 a; uint128 b; fits in one slot (32 bytes).
• Use constant and immutable for fixed values.

2. Code Refactoring

• Use custom errors instead of string require messages (saves ~gas).
• Cache array length in loops (unchecked { ++i }).
• Use calldata instead of memory for function arguments where possible.

3. Verification

• Run forge test --gas-report.

--- ---

4. Patterns & Templates

Pattern 1: Checks-Effects-Interactions (Security)

Use case: Preventing Reentrancy attacks.

function withdraw() external {
    // 1. Checks
    uint256 balance = userBalances[msg.sender];
    require(balance > 0, "No balance");

    // 2. Effects (Update state BEFORE sending ETH)
    userBalances[msg.sender] = 0;

    // 3. Interactions (External call)
    (bool success, ) = msg.sender.call{value: balance}("");
    require(success, "Transfer failed");
}

Pattern 2: Transparent Proxy (Upgradability)

Use case: Upgrading contract logic while keeping state/address.

// Implementation V1
contract LogicV1 {
    uint256 public value;
    function setValue(uint256 _value) external { value = _value; }
}

// Proxy Contract (Generic)
contract Proxy {
    address public implementation;
    function upgradeTo(address _newImpl) external { implementation = _newImpl; }
    
    fallback() external payable {
        address _impl = implementation;
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), _impl, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            switch result
            case 0 { revert(0, returndatasize()) }
            default { return(0, returndatasize()) }
        }
    }
}

Pattern 3: Merkle Tree Whitelist (Gas Efficient)

Use case: Whitelisting 10,000 users without storing them on-chain.

• Off-chain: Hash all addresses -> Root Hash.
• On-chain: Store only Root Hash (32 bytes).
• Verification: User provides Proof (path to root). Cost is O(log n), very cheap.

--- ---

6. Integration Patterns

backend-developer:

• Handoff: Blockchain dev provides ABI and Contract Address → Backend uses Alchemy/Infura to listen for events.
• Collaboration: Indexing strategy (The Graph vs Custom SQL indexer).
• Tools: Alchemy Webhooks, Tenderly.

frontend-ui-ux-engineer:

• Handoff: Blockchain dev provides wagmi hooks → Frontend builds UI.
• Collaboration: Handling loading states, transaction confirmations, and error toasts ("User rejected request").
• Tools: RainbowKit.

security-auditor:

• Handoff: Blockchain dev freezes code → Auditor reviews.
• Collaboration: Fixing findings (Critical/High/Medium).
• Tools: Slither, Mythril.

---