These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses ChatGPT and Claude for explaining Solidity concepts, debugging contracts, and learning security patterns. Verifies AI answers for accuracy, especially for cryptographic and security questions.
Applies AI for contract code review, unit test generation, and NatSpec documentation. Creates prompts for security vulnerability analysis. Understands hallucination risks for Solidity code.
Integrates AI into smart contract development workflow. Creates custom prompts for threat modeling, formal specification writing, and architecture review. Trains the team on effective usage.
Defines AI usage strategy for smart contract teams. Establishes code confidentiality policies. Evaluates advanced AI tools: Claude Code, Cursor for Solidity development.
Uses Cursor for blockchain dev: AI-assisted Solidity coding, contract generation.
Configures Cursor: Solidity-specific rules, security-focused suggestions, Hardhat integration.
Optimizes Cursor for blockchain: security audit prompts, gas optimization suggestions.
Defines AI IDE standards: approved configurations, security review for AI-generated contracts.
Uses GitHub Copilot to accelerate writing Solidity tests and TypeScript integration code. Critically reviews suggestions for security issues and gas inefficiencies.
Effectively uses Copilot for boilerplate Solidity code, test generation, and NatSpec documentation. Knows AI limitations for security-critical Solidity code and combines with manual review.
Establishes guidelines for using AI coding assistants for smart contract development. Configures workspace context for Solidity-specific suggestions. Evaluates security risks of AI-generated code.
Defines AI-assisted development policy for smart contract organizations. Establishes training and evaluates ROI from AI tools for contract development productivity and code quality.
Algorithms & Data Structures
▼
Understands Big-O notation and applies it to evaluating gas costs of Solidity operations. Avoids O(n) loops in contracts with unbounded arrays. Selects optimal structures for on-chain storage.
Optimizes algorithmic complexity of on-chain operations: Merkle trees O(log n), bitmap operations O(1). Analyzes gas profiles of functions and minimizes SLOAD/SSTORE operations.
Designs gas-optimal algorithms for DeFi math: fixed-point arithmetic, sqrt algorithms for AMM. Applies amortized analysis for batch operations and optimizes contract hot paths.
Establishes gas optimization guidelines for the organization. Conducts algorithmic review of contracts and defines computation budgets for on-chain vs off-chain balance decisions.
Understands Solidity storage structures: mappings, arrays, structs. Knows slot allocation and storage layout. Uses events for off-chain indexing of data not needed on-chain.
Applies advanced storage patterns: EnumerableSet, packed structs, bitmap flags. Optimizes storage via SSTORE2/SSTORE3. Understands cold vs warm SLOAD costs and their impact.
Designs custom storage solutions: transient storage (EIP-1153), SSTORE2 code-as-data, memory-mapped structures. Implements gas-efficient linked lists and priority queues on-chain.
Defines storage architecture standards for the organization. Establishes guidelines for data structure selection and storage optimization. Mentors the team on advanced storage patterns.
API Management
▼
Documents blockchain API: describes RPC endpoints, contract ABIs, integration guides.
Creates blockchain documentation: contract API docs, SDK guides, deployment procedures.
Designs documentation strategy: auto-generated ABI docs, interactive examples, versioning.
Defines documentation standards: mandatory contract docs, review process.
API Protocols
▼
Uses WebSocket for subscribing to contract events: Transfer, Approval, custom events. Handles reconnection and missed events via getLogs fallback. Works with viem WebSocket provider.
Designs event monitoring infrastructure for smart contracts: multi-contract event aggregation, filtered subscriptions, real-time notification pipeline for critical contract events.
Designs scalable event processing architecture for smart contract platforms: ordered event delivery, exactly-once processing, cross-contract event correlation.
Defines event infrastructure strategy for smart contract organizations. Establishes event schema standards, monitoring, and alerting. Coordinates event-driven architecture adoption.
Application Security
▼
Understands basic secure coding concepts for Solidity/Vyper development — checks-effects-interactions pattern, integer overflow prevention with SafeMath, and access control modifier usage. Follows security guidelines from SWC registry and recognizes common smart contract vulnerability patterns.
Applies secure coding practices in smart contract development — conducts security reviews using checks-effects-interactions patterns, implements reentrancy guards and access control hierarchies, and validates economic invariants. Uses Slither, Echidna, and Foundry fuzzing for automated vulnerability detection and property-based testing.
Designs secure coding methodologies for DeFi protocol ecosystems — implements formal verification compatible patterns, creates security invariant test suites, and architects upgrade-safe contract systems with minimal attack surface. Conducts economic threat modeling and mentors team on adversarial thinking for financial contract development.
Defines secure coding strategy for smart contract development spanning protocol design, audit processes, and deployment safeguards. Establishes security policies for formal verification requirements, economic invariant testing, and vulnerability bounty programs. Coordinates security incident response for DeFi protocols and trains teams on adversarial secure coding practices.
Understands basic threat modeling for smart contracts: identifies common vulnerability patterns (integer overflow, access control flaws, unchecked external calls). Follows OWASP Smart Contract Top 10 guidelines. Documents potential threats in contract designs under mentorship.
Independently applies threat modeling to multi-contract systems and cross-chain interactions. Analyzes protocol-level attack vectors (bridge exploits, oracle dependencies, upgrade mechanism abuse). Understands trade-offs between proxy patterns and immutability from a security perspective. Maps threats to formal verification targets.
Designs comprehensive threat modeling processes for DeFi protocol ecosystems. Creates formal threat taxonomies covering economic, cryptographic, and governance attack surfaces. Mentors teams on invariant-driven security design and automated threat detection in smart contract upgrades. Optimizes security audit scope based on threat model coverage.
Defines threat modeling strategy for smart contract development teams and protocol products. Establishes security review standards integrating formal verification with threat analysis. Coordinates cross-protocol threat assessments for composability and upgrade risks. Drives adoption of threat modeling as a mandatory pre-audit practice across all contract development.
Architecture Patterns
▼
Understands how smart contracts function in a distributed system context: global state, transactional model, eventual settlement. Knows EVM limitations for real-time operations.
Designs contracts considering distributed systems constraints: block timestamp manipulation, frontrunning, cross-contract atomicity. Implements patterns for reliable multi-step execution.
Designs smart contract systems with understanding of distributed state: cross-chain state consistency, oracle reliability, sequencer dependency. Models failure scenarios and implements fallback mechanisms.
Defines distributed systems guidelines for smart contract development. Establishes best practices for handling distributed state and cross-chain consistency in the organization.
Blockchain Fundamentals
▼
Understands applied cryptography for smart contracts: hash commitments, signature verification (ecrecover), and Merkle proof validation. Follows team patterns for implementing commit-reveal schemes and signature-based authorization.
Independently develops with Applied Cryptography in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs cryptographic smart contract patterns: ZK-SNARK/STARK verifiers, multi-signature schemes, and privacy-preserving computations. Conducts security audits of on-chain cryptographic implementations and evaluates gas-efficient crypto libraries.
Defines cryptographic architecture for smart contract platform: proof system selection, signature aggregation strategies, and privacy protocol integration. Establishes cryptographic review standards and gas optimization guidelines for on-chain proofs.
Understands Merkle trees and their application in smart contracts: whitelist verification, airdrop claims, data integrity proofs. Implements Merkle proof verification in Solidity via OpenZeppelin.
Implements advanced Merkle proof patterns: multi-proof verification, incremental Merkle trees for on-chain accumulation. Optimizes proof verification gas cost through calldata optimization.
Designs Merkle-based protocols: cross-chain state proof verification, storage proof validation, receipt proofs. Implements custom Merkle tree variants for specific smart contract use cases.
Defines Merkle proof standards for smart contract organizations. Establishes guidelines for proof generation infrastructure and on-chain verification optimization.
Understands basic ZKP concepts and their application in smart contracts: private transactions, identity verification, scalability proofs. Implements a simple zk-proof verifier in Solidity.
Integrates ZKP verification into smart contracts: Groth16 verifier, PLONK verifier. Optimizes on-chain verification gas cost. Works with Circom for circuit development.
Designs ZKP-based smart contract systems: private DeFi, zk-identity, verifiable computation. Optimizes proof verification contracts and integrates with DeFi protocols.
Defines ZKP integration strategy for smart contract organizations. Builds team expertise in circuit development and proof verification. Evaluates ZKP for privacy and compliance.
Blockchain Infrastructure
▼
Deploys contracts to L2 networks (Arbitrum, Optimism, zkSync). Understands differences in gas models and EVM compatibility. Tests on L2 testnets and compares deployment costs.
Adapts contracts for L2 deployment: accounts for L1-data costs in gas calculation, L2-specific precompiles. Implements L1↔L2 contract messaging for deposit/withdrawal flows.
Designs cross-L2 contract architectures. Implements L2-native features and optimizes for L2-specific gas models. Analyzes security implications of sequencer centralization.
Defines L2 deployment strategy for the organization. Selects L2 for various contract use cases. Establishes L2 compatibility testing requirements and deployment automation.
Understands zk-rollup architecture and how it affects smart contract development. Deploys contracts on zkSync and StarkNet. Studies differences in EVM compatibility (type 1-4 zkEVM).
Adapts contracts for zk-rollup deployment: accounts for opcode differences, gas model specifics. Implements cross-layer contract messaging between L1 and zk-rollup. Tests on zkSync testnets.
Designs contract systems optimized for zk-rollup: minimizing storage slots, optimization for prover efficiency. Analyzes zk-specific vulnerability patterns.
Defines zk-rollup deployment strategy for smart contract organizations. Establishes zk-specific testing requirements and compatibility guidelines. Coordinates multi-rollup deployment.
Caching
▼
Uses Redis for blockchain: caches RPC responses, stores pending transactions. Understands caching benefits.
Designs caching: gas price caching, transaction pool management, rate limiting for RPC.
Designs caching architecture: multi-chain cache, real-time updates, cache coherence.
Defines caching standards: cache policies, monitoring, performance requirements.
CI/CD
▼
Uses GitHub Actions for blockchain: smart contract compilation, basic testing. Understands CI workflow.
Designs CI for blockchain: Hardhat/Foundry testing, security scanning, deployment verification.
Defines CI/CD architecture: multi-chain deployment, automated auditing, testnet deployment pipelines.
Defines CI/CD standards: mandatory security checks, deployment approval, audit requirements.
Clean Code & Refactoring
▼
Follows clean code principles in Solidity: meaningful names, small functions, NatSpec documentation. Uses solhint and prettier-solidity for formatting. Writes readable modifiers.
Applies clean code practices for smart contract systems: clear separation of concerns between contracts, consistent naming conventions, readable require messages. Refactors legacy contracts.
Designs clean architecture for contract systems: interface segregation, abstract contracts, library patterns. Mentors the team on principles of clean Solidity code and maintainability.
Establishes clean code standards for smart contract organizations. Introduces automated quality gates: NatSpec coverage, complexity metrics. Conducts architecture reviews for maintainability.
Follows code style guides and uses solhint, slither to check Solidity code quality. Writes NatSpec comments for all public and external functions. Passes code review without critical findings.
Configures CI pipeline with solhint, slither, forge test, and coverage check for smart contract projects. Conducts code review for junior developers focusing on gas optimization and security.
Designs quality pipeline for smart contracts: linting, static analysis, fuzzing gates, formal verification checks. Defines severity classification for Slither findings and coverage thresholds.
Establishes code quality standards for smart contract organizations. Introduces metrics: mutation score, invariant coverage, gas regression detection. Trains leads on conducting quality reviews.
Cloud Providers
▼
Works with AWS for blockchain: EC2 for nodes, RDS for indexer. Understands basic cloud deployment.
Deploys blockchain infrastructure: managed blockchain nodes, auto-scaling indexers, S3 for data.
Designs cloud blockchain architecture: multi-region nodes, high-availability, disaster recovery.
Defines cloud standards: node deployment, cost optimization, infrastructure review.
Code Review
▼
Goes through code review for smart contracts, applying feedback on security, gas optimization, and readability. Learns common vulnerabilities from senior developer review comments.
Conducts code review for Solidity contracts: checks gas optimization, access control, reentrancy protection, and event emission. Leaves constructive comments with security context.
Conducts architecture and security-focused reviews for smart contract systems. Establishes review checklists for DeFi, governance, and upgradeable contracts. Mentors reviewers on security review.
Defines code review process for smart contract organizations. Establishes review SLA, mandatory reviewers for security-critical changes, and escalation for audit-level findings.
Concurrency & Parallelism
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using Solidity/Vyper. Follows recommendations from senior developers when solving problems.
Independently applies async programming in blockchain development: async transaction submission and confirmation, concurrent event monitoring, non-blocking contract interaction patterns. Understands trade-offs between polling and WebSocket-based async patterns for on-chain data.
Designs async architectures for blockchain applications: event-driven contract monitoring, async multi-chain transaction management, concurrent state reconciliation patterns. Mentors team on async patterns for blockchain application reliability.
Defines async programming standards for smart contract team: async event monitoring guidelines, concurrent transaction management reviews, non-blocking contract interaction patterns. Establishes best practices for async patterns in Web3 applications.
Understands concurrency for blockchain: parallel transaction processing, concurrent RPC calls.
Implements concurrent processing: parallel chain indexing, concurrent transaction submission, thread-safe state.
Designs concurrent systems: parallel multi-chain processing, lock-free indexing patterns.
Defines concurrency standards: parallel processing policies, thread safety requirements.
Containerization
▼
Uses Docker for blockchain dev: local node setup, development containers. Understands basic Docker commands.
Designs Docker for blockchain: multi-node test networks, Hardhat/Foundry containers, CI images.
Designs container architecture: blockchain node deployment, multi-chain test environments.
Defines Docker standards: node deployment patterns, development environment guidelines.
DeFi
▼
Understands token standards and their economic purpose: ERC-20 (utility/governance), ERC-721 (ownership), ERC-4626 (yield). Implements basic token mechanics: mint, burn, transfer hooks.
Implements token economics in contracts: vesting schedules, staking rewards, fee distribution mechanisms. Models emission schedules and optimizes gas for mass operations.
Designs complex token systems: ve-tokenomics, bonding curves, rebase mechanics, real yield distribution. Conducts game-theoretic analysis and simulates economic attacks at the contract level.
Defines tokenomics design framework for the organization. Coordinates with economists and legal for regulatory compliance. Establishes review process for token contract launches.
Git & Workflows
▼
Uses Git for smart contract development: feature branches, commits with conventional messages, pull requests. Understands Git Flow and works with Foundry/Hardhat project structure.
Applies advanced Git: interactive rebase, cherry-pick, bisect for finding regressions in contracts. Configures branch protection with mandatory Slither and test checks before merge.
Designs Git workflow for smart contract monorepo: contract versioning strategy, deployment tracking via git tags, automated changelog generation for contract upgrades.
Defines Git strategy for smart contract organizations. Establishes branching model with audit branch, release process with deployment verification, and rollback procedures.
GraphQL
▼
Understands GraphQL for blockchain: The Graph for indexed queries, subgraph basics.
Designs subgraphs: The Graph schema design, entity relationships, event handlers. Optimizes queries.
Designs GraphQL architecture: multi-chain subgraphs, custom indexers, performance optimization.
Defines GraphQL standards: subgraph design guidelines, schema governance.
Kubernetes & Orchestration
▼
Understands K8s for blockchain: containerized nodes, basic deployment. Uses kubectl.
Deploys blockchain in K8s: stateful sets for nodes, persistent volumes, health checks.
Designs K8s architecture: multi-chain node management, auto-scaling, rolling updates.
Defines K8s standards: node deployment patterns, storage requirements, security.
Logging
▼
Uses logging for blockchain: event logs in smart contracts, off-chain structured logging. Monitors transactions.
Implements blockchain logging: event indexing, structured off-chain logs, transaction tracking.
Designs logging architecture: event-driven monitoring, chain indexing, anomaly detection.
Defines logging standards: event design, monitoring requirements, alerting.
Metrics & Monitoring
▼
Monitors blockchain via Prometheus: node metrics, block height, peer count. Views Grafana dashboards.
Creates blockchain dashboards: node health, gas prices, contract metrics, chain synchronization.
Designs monitoring: multi-chain monitoring, anomaly alerting, performance tracking.
Defines monitoring standards for blockchain systems with Prometheus & Grafana: establishes mandatory metrics for smart contract execution and gas usage, creates dashboard templates for on-chain activity monitoring, implements alerting policies for contract anomalies and security events.
Networking
▼
Understands networking fundamentals specific to smart contract development — RPC endpoint configuration for contract deployment, WebSocket subscriptions for event listening, and P2P network topology impact on transaction propagation and finality. Follows team guidelines for node provider selection and RPC rate limiting.
Implements blockchain networking: P2P node configuration, secure RPC endpoints, load balancing.
Designs network architecture: multi-region P2P, RPC infrastructure, network security.
Defines networking standards: RPC architecture, security policies, performance requirements.
OOP & Design Patterns
▼
Applies basic Solidity patterns: Ownable, Pausable, ReentrancyGuard. Uses Factory and Clones (EIP-1167) for contract creation. Follows the checks-effects-interactions pattern.
Applies advanced smart contract patterns: Proxy (UUPS/Transparent), Diamond (EIP-2535), Pull Payment, Commit-Reveal. Designs modular contracts with interface segregation.
Designs architectural patterns for smart contract systems: hook-based extensions (Uniswap V4 style), plugin architectures, abstract accounts. Analyzes pattern trade-offs for specific use cases.
Defines pattern library for smart contract organizations. Establishes architectural decision framework for pattern selection. Conducts architecture reviews for new contract systems.
Applies OOP for blockchain: contract inheritance in Solidity, interface patterns. Understands contract composability.
Uses OOP patterns: upgradeable contracts, proxy patterns, diamond pattern. Designs modular contracts.
Designs contract architecture: composable protocols, library design, upgrade mechanisms.
Defines architectural standards: contract design patterns, upgrade governance, composability guidelines.
Prompt Engineering
▼
Formulates effective prompts for AI when working with Solidity: explaining vulnerabilities, generating tests, writing NatSpec. Uses chain-of-thought for complex contract logic questions.
Creates structured prompts for smart contract tasks: security review templates, test generation, formal spec writing. Applies few-shot examples for Solidity-specific AI assistance.
Designs prompt library for smart contract organizations: security audit prompts, architecture review, gas optimization analysis. Integrates AI prompts into development workflows.
Defines prompt engineering strategy for smart contract teams. Establishes best practices and training. Evaluates effectiveness of AI prompts for various contract development tasks.
Relational Databases
▼
Works with PostgreSQL for blockchain: stores indexed chain data, transaction history. Writes basic SQL queries.
Designs databases for blockchain: event indexing schema, block data storage, query optimization.
Designs data architecture: multi-chain indexing, historical data storage, analytics database.
Defines database standards: indexer schema guidelines, performance requirements.
REST API
▼
Understands REST API for blockchain: interacts with blockchain via RPC/REST, indexer APIs. Creates basic endpoints.
Designs blockchain API: indexer API design, webhook endpoints, transaction submission API.
Designs API architecture: blockchain data API, event streaming, multi-chain API abstraction.
Defines API standards: blockchain API guidelines, versioning, error handling.
Smart Contracts
▼
Understands formal verification concepts: invariants, pre/post-conditions, state machine specification. Studies Certora and K-framework on basic examples. Writes simple property specs.
Applies formal verification to production contracts: writes Certora specs for critical invariants, uses SMTChecker. Verifies access control, balance conservation, and state transitions.
Designs comprehensive formal specifications for DeFi protocols: state machine models, economic invariants, liveness properties. Integrates formal verification into CI/CD and coordinates with auditors.
Defines formal verification strategy for the organization. Builds team expertise in Certora, K-framework, and SMTChecker. Defines coverage requirements for formal specs.
Understands the EVM gas model: SLOAD/SSTORE costs, calldata vs memory, opcode pricing. Applies basic optimizations: storage packing, immutable variables, unchecked arithmetic for safe operations.
Applies advanced gas optimizations: calldata instead of memory, custom errors instead of require strings, bit manipulation. Profiles gas via forge test --gas-report and optimizes hot paths.
Designs gas-optimal architectures: inline assembly for critical paths, SSTORE2 for cheap data storage, EIP-1153 transient storage. Optimizes deployment and runtime costs for DeFi protocols.
Defines gas optimization standards for the organization. Establishes gas budget framework and regression detection. Coordinates optimization initiatives for production protocols.
Knows key vulnerabilities: reentrancy, integer overflow, access control, oracle manipulation. Uses Slither for static analysis. Follows the checks-effects-interactions pattern.
Conducts manual security review of contracts: analyzes access control, economic attack vectors, and flash loan scenarios. Uses Mythril, Slither, Aderyn. Writes PoC exploits for findings.
Conducts comprehensive audits: formal verification (Certora), fuzzing (Echidna/Medusa), symbolic execution (Mythril/Manticore). Has discovered 15+ critical issues in production protocols.
Manages the audit program for the organization. Defines security requirements and audit scope for all contracts. Coordinates bug bounty and relationships with external audit firms.
Understands various smart contract platforms: EVM (Ethereum, Arbitrum), SVM (Solana), CosmWasm, Move (Sui, Aptos). Deploys contracts on EVM-compatible networks and studies VM differences.
Develops contracts for multiple platforms: Solidity for EVM, Vyper for security-critical, explores Move/Cairo. Implements cross-platform deployment and testing infrastructure.
Designs multi-platform contract strategy: selects platform by security model and gas efficiency. Analyzes VM-specific vulnerabilities and adapts security review for each platform.
Defines smart contract platform strategy for the organization. Evaluates emerging platforms for adoption. Establishes platform-specific security guidelines and audit requirements.
Understands fundamentals of smart contract security: access control, input validation, and safe math operations. Uses static analysis tools like Slither for basic vulnerability detection. Learns from audit reports and documented exploits.
Independently develops with Smart Contract Security in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs and executes comprehensive smart contract audits: formal verification, fuzz testing with Echidna, and symbolic execution with Manticore. Identifies complex attack vectors including flash loan exploits and oracle manipulation. Mentors developers on writing audit-ready code.
Defines security-first development culture for smart contract teams. Establishes mandatory audit gates in CI/CD, security review processes, and incident response playbooks for on-chain exploits. Coordinates bug bounty programs.
Understands Solidity fundamentals: contract structure, inheritance, events, and error handling. Implements basic smart contracts following OpenZeppelin patterns. Writes unit tests with Foundry/Hardhat and uses Remix for rapid prototyping.
Independently develops with Solidity in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs production-grade Solidity contracts for DeFi protocols: AMMs, lending, and yield strategies. Masters assembly-level optimizations (Yul), storage layout packing, and EVM opcode costs. Implements formal verification with Certora. Mentors developers on gas-efficient and secure Solidity.
Defines Solidity best practices and smart contract architecture standards for the team. Establishes testing frameworks (unit, integration, invariant tests), CI/CD pipelines for on-chain deployments, and upgrade governance procedures. Reviews all production contract code.
Writes contracts in Solidity 0.8+: ERC-20, ERC-721, access control with OpenZeppelin. Understands visibility modifiers, events, and custom errors. Uses Foundry for compile, test, and deploy.
Implements complex contracts: staking with multiple reward strategies, vesting with cliff/linear unlock, multi-sig treasury. Optimizes gas through storage packing and calldata. Coverage 95%+.
Designs upgradeable systems: UUPS, Diamond proxy (EIP-2535). Writes inline assembly for gas-critical paths. Implements formal specifications and conducts comprehensive security review.
Defines Solidity development standards: style guide, pattern library, security checklist, gas budgets. Establishes contract architecture guidelines for an organization of 20+ developers.
Understands upgradeable contract patterns: Transparent Proxy, UUPS Proxy. Deploys upgradeable contracts via OpenZeppelin Upgrades plugin. Knows storage layout restrictions.
Implements upgrade flows: storage layout validation, initialization functions, access control for upgrades. Tests upgrade paths and storage compatibility. Uses forge-std for testing.
Designs complex upgradeable systems: Diamond proxy with multiple facets, beacon proxy for factory patterns. Implements emergency upgrade procedures and governance-controlled upgrades.
Defines upgrade strategy for the organization: when to use proxy vs immutable, governance requirements for upgrades. Establishes upgrade checklist and audit requirements.
Understands the fundamentals of Vyper. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently develops with Vyper in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs blockchain solutions with Vyper. Conducts security audits. Optimizes protocols. Mentors the team.
Defines blockchain product architecture. Establishes security standards. Coordinates audits.
Studies Vyper syntax and its security-by-design philosophy: no inheritance, bounded loops, explicit overflow checks. Writes simple contracts and compares with Solidity equivalents.
Develops production contracts in Vyper: DeFi pools, governance modules. Uses Titanoboa for comprehensive testing. Understands Vyper compiler security considerations.
Designs complex Vyper systems: Curve-style stableswap pools, concentrated liquidity. Analyzes Vyper compiler bugs and their impact. Conducts comparative security analysis of Vyper vs Solidity.
Defines Vyper adoption strategy for the organization: when Vyper vs Solidity. Establishes Vyper development guidelines and training program for smart contract developers.
System Design
▼
Understands basic system design concepts in the smart contract context: state management, composability, upgrade patterns. Draws contract diagrams and describes interaction flows.
Designs smart contract system architecture: separation of concerns, proxy patterns for upgradeability, registry patterns for service discovery. Documents architectural decisions.
Designs complex contract systems: multi-protocol integration, cross-chain deployment architecture, emergency pause and recovery mechanisms. Ensures modularity and extensibility.
Defines system design principles for smart contract organizations. Conducts architecture reviews and establishes design templates. Coordinates cross-team architectural decisions.
Test Strategy
▼
Understands mutation testing basics for smart contracts. Runs mutation testing tools on Solidity/Vyper test suites to identify weak assertions and uncovered contract logic branches.
Applies mutation testing to validate smart contract security test coverage. Implements custom mutation operators for blockchain-specific patterns (reentrancy, overflow) and integrates results into audit workflows.
Designs mutation testing frameworks for smart contract security assurance across DeFi protocols. Implements formal verification-guided mutation strategies and mentors team on combining fuzzing with mutation analysis for critical contract paths.
Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.
Understands the fundamentals of property-based testing for smart contracts. Writes basic invariant tests using Foundry fuzz testing and Echidna. Follows team practices for defining contract state properties and assertion checks.
Independently develops invariant test suites for smart contract protocols using Foundry and Echidna. Designs property assertions for token balances, access control, and state transitions. Integrates fuzz campaigns into CI/CD pipelines.
Designs comprehensive invariant testing strategy for DeFi protocols and complex contract systems. Implements multi-contract stateful fuzzing with Echidna and Foundry. Optimizes fuzz campaign configurations for maximum vulnerability discovery. Mentors the team.
Defines testing strategy at product level. Establishes quality assurance standards. Introduces shift-left testing culture.
Type Systems
▼
Understands the fundamentals of Type Safety & Type Systems at a basic level. Applies simple concepts in work tasks using Solidity/Vyper. Follows recommendations from senior developers when solving problems.
Independently applies Solidity/Vyper type systems for smart contract safety — using custom types for token amounts and addresses, interface inheritance for contract composition, and type-safe event definitions. Understands trade-offs between gas optimization and type safety in contract storage patterns. Applies type-safe patterns in contract audits.
Has deep expertise in smart contract type safety — designs type-safe DeFi protocol interfaces with custom value types for financial primitives, implements formal verification compatible type patterns, and architects upgradeable contract systems with type-safe storage layouts. Mentors team on ABI encoding type safety, cross-contract type compatibility, and type-driven security patterns for preventing common vulnerabilities.
Defines type safety standards for smart contract development teams — establishes custom type requirements for financial primitives, ABI-safe interface patterns, and formal verification compatible type hierarchies. Conducts architectural reviews ensuring type-safe storage layouts, upgrade compatibility, and cross-protocol type consistency.
Unit Testing
▼
Writes unit tests for Solidity contracts using Foundry or Hardhat. Tests individual functions: state changes, reverts, event emission. Uses assertions and expect for verification.
Writes parameterized and property-based tests for contracts. Tests boundary values, overflow scenarios, and access control edge cases. Uses fixtures and helpers for DRY tests.
Designs unit testing architecture: shared test base contracts, helper libraries, mock contracts. Implements mutation testing to assess test quality and identify weak spots.
Defines unit testing standards for the organization. Establishes tiered coverage requirements by contract criticality. Mentors developers on testing best practices and test design.
Web3 Development
▼
Understands cross-chain messaging protocols: LayerZero, Axelar, CCIP. Implements a simple cross-chain token transfer contract. Tests message passing on two-network testnets.
Implements cross-chain contracts: OApp (LayerZero), GMP (Axelar) with failed message handling and replay protection. Tests edge cases: timeouts, partial failures, gas estimation.
Designs cross-chain protocol architecture: message verification, security validations, state synchronization between contracts on different networks. Analyzes bridge attack vectors.
Defines cross-chain contract architecture for the organization. Evaluates messaging protocols by security and cost. Establishes security requirements and testing standards for bridge contracts.
Implements a basic Governor contract with OpenZeppelin: proposal creation, voting, execution via TimelockController. Tests the full governance lifecycle in Foundry.
Implements advanced governance contracts: delegation, quorum calculation, multiple voting strategies (simple, weighted, quadratic). Integrates Snapshot for off-chain voting.
Designs governance architecture for DeFi protocols: veToken governance, optimistic governance, cross-chain voting. Analyzes and defends against governance attack vectors.
Defines governance contract framework for the organization. Establishes security checklist for governance contracts. Coordinates governance contract upgrades and parameter changes.
Develops the frontend part of dApps for contract interaction: wallet connection, calling view/write functions, tracking transaction status. Uses wagmi and React.
Develops full-featured DeFi dApps: multicall for batch reads, event-driven UI updates, error handling for reverted transactions. Integrates contract ABIs automatically.
Designs dApp architecture for complex smart contract systems: multi-contract interaction flows, gasless transactions via relayers, offline-first with on-chain settlement.
Defines dApp development standards for the organization. Establishes shared UI components for contract interactions. Coordinates frontend-contract integration architecture.
Understands NFT smart contract fundamentals: ERC-721/ERC-1155 implementations, tokenURI patterns, and royalty standards (EIP-2981). Follows team patterns for writing mint functions, access control, and metadata on-chain/off-chain strategies.
Independently develops with NFT Development in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs advanced NFT contract systems: ERC-6551 token-bound accounts, dynamic NFTs with Chainlink oracles, and gas-optimized batch operations. Conducts security audits of NFT marketplace logic and implements novel token standards.
Defines NFT smart contract architecture and governance: upgrade strategies for NFT contracts, royalty enforcement mechanisms, and on-chain provenance tracking. Establishes security audit requirements and testing standards for NFT protocol development.
Implements ERC-721 and ERC-1155 contracts with OpenZeppelin. Configures metadata JSON schema and IPFS storage for NFT assets. Tests mint, transfer, approval, and royalty functions.
Implements advanced NFT contracts: ERC-721A for batch mint, EIP-2981 royalties, dynamic metadata with on-chain updates. Integrates with marketplaces via Seaport protocol.
Designs NFT contract systems: token-bound accounts (EIP-6551), composable NFTs, on-chain SVG generation. Optimizes for large-scale mints with MEV protection and fair distribution.
Defines NFT contract architecture standards for the organization. Establishes metadata standards and royalty enforcement strategy. Coordinates marketplace protocol integrations.
Implements core token standards: ERC-20, ERC-721, ERC-1155, ERC-4626. Understands interface requirements and extension points of each standard. Tests compliance via reference tests.
Implements extended token mechanics: fee-on-transfer, rebasing tokens, permit (EIP-2612). Understands edge cases: zero-amount transfers, self-transfers, approval race conditions.
Designs custom token systems: multi-token vaults, wrapped token bridges, synthetic assets. Analyzes composability risks with DeFi protocols and ensures standards compliance.
Defines token standard strategy for the organization. Establishes guidelines for standard selection per use case. Coordinates adoption of new standards and token migration processes.
Understands wallet integration fundamentals: connecting MetaMask and WalletConnect to dApps, signing transactions, and reading on-chain state. Implements basic wallet UI flows using wagmi hooks. Follows established connection patterns from documentation.
Independently develops with Wallet Integration in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs multi-wallet integration systems with automatic provider detection, session management, and chain-agnostic transaction signing. Implements EIP-712 structured data signing for complex DeFi interactions and gasless meta-transactions. Optimizes wallet UX for mobile and desktop. Mentors developers on secure wallet interaction patterns.
Defines wallet integration architecture standards for smart contract platforms. Establishes security protocols for transaction approval flows, wallet provider vetting, and key management practices. Coordinates cross-team wallet UX consistency and accessibility standards.
Understands Web3 frontend fundamentals: using ethers.js and wagmi for contract interaction, event listening, and transaction status tracking. Implements basic UI components for token balances, allowances, and contract reads. Tests interactions on testnets.
Independently develops with Web3 Frontend in Hardhat/Foundry/OpenZeppelin. Conducts basic audits. Optimizes gas.
Designs advanced Web3 frontend systems: custom hooks for complex contract interactions, subgraph-powered data layers, and gasless transaction UX with relayers. Implements real-time price feeds, DEX aggregation interfaces, and multi-chain switching. Mentors developers on efficient RPC management and Web3 state synchronization.
Defines Web3 frontend standards for smart contract platform teams. Establishes testing strategies for contract interaction layers, ABI type-safety practices with TypeChain, and monitoring for failed transactions. Coordinates frontend-contract integration patterns across teams.
Uses ethers.js and viem for contract interaction: reading state, sending transactions, decoding events. Works with ABI encoding/decoding and contract factory patterns.
Develops TypeScript SDK for smart contract interaction: type-safe contract calls via viem/wagmi, multicall batching, event subscription. Generates types from ABI automatically.
Designs contract interaction infrastructure: transaction management, gas estimation, nonce handling, retry logic. Optimizes for reliable execution and high-throughput batch operations.
Defines Web3 library strategy for the organization. Establishes shared contract SDK and coordinates ethers→viem migration. Defines TypeScript contract interaction standards.