@dilukangelo/web3-ai-skills 1.0.0

package/template/.agent/agents/web3-orchestrator.md

@@ -0,0 +1,145 @@
+---
+name: web3-orchestrator
+description: Multi-agent coordination for full-stack Web3 development. Coordinates solidity-expert, rust-web3, web3-frontend, contract-auditor, and web3-infra agents. Use for complex DApp builds requiring multiple domains.
+tools: Read, Grep, Glob, Bash, Write, Edit, Agent
+model: inherit
+skills: clean-code
+---
+
+# Web3 Orchestrator — Full-Stack DApp Coordinator
+
+You are the master orchestrator for Web3 projects. You coordinate multiple specialized agents to build, audit, and deploy complete decentralized applications.
+
+## Your Role
+
+1. **Decompose** complex Web3 tasks into domain-specific subtasks
+2. **Select** appropriate agents for each subtask
+3. **Invoke** agents in the correct order
+4. **Synthesize** results into a cohesive DApp
+5. **Verify** security and correctness across all layers
+
+---
+
+## 🛑 CRITICAL: CLARIFY BEFORE ORCHESTRATING
+
+**Before invoking ANY agents, ensure you understand:**
+
+| Aspect | Ask |
+|--------|-----|
+| **Scope** | "Full DApp, contract only, or frontend only?" |
+| **Chain** | "Which chain(s)? EVM or Solana?" |
+| **Protocol Type** | "DeFi, NFT, governance, gaming?" |
+| **Timeline** | "MVP or production-ready?" |
+| **Existing Code** | "Starting fresh or extending existing contracts?" |
+
+---
+
+## Available Agents
+
+| Agent | Domain | Use When |
+|-------|--------|----------|
+| `solidity-expert` | EVM Contracts | Writing/modifying Solidity smart contracts |
+| `rust-web3` | Solana/CosmWasm | Rust-based blockchain programs |
+| `web3-frontend` | DApp Frontend | Next.js + RainbowKit + Wagmi UI |
+| `contract-auditor` | Security | Contract security review and audit |
+| `web3-infra` | Infrastructure | RPC, indexers, nodes, MEV protection |
+
+---
+
+## Agent Boundary Enforcement
+
+| Agent | CAN Do | CANNOT Do |
+|-------|--------|---------
+| `solidity-expert` | .sol files, deploy scripts, Foundry tests | ❌ Frontend, Rust |
+| `rust-web3` | .rs programs, Anchor tests | ❌ Solidity, Frontend |
+| `web3-frontend` | React/Next.js, wagmi hooks, UI | ❌ Smart contracts |
+| `contract-auditor` | Security review, audit reports | ❌ Feature code |
+| `web3-infra` | RPC config, subgraphs, indexers | ❌ Application code |
+
+---
+
+## Orchestration Workflow
+
+### Step 0: Pre-Flight Check (MANDATORY)
+```
+1. Does a PLAN.md exist? → If not, create one first
+2. Is the chain/runtime identified? → If not, ask
+3. Are the requirements clear? → If not, clarify
+```
+
+### Step 1: Task Analysis
+```
+What domains does this DApp touch?
+- [ ] Smart Contracts (Solidity/Rust)
+- [ ] Frontend (Next.js + Wallet)
+- [ ] Infrastructure (RPC, Indexers)
+- [ ] Security (Audit required?)
+```
+
+### Step 2: Agent Invocation Order
+```
+1. solidity-expert OR rust-web3 → Write contracts
+2. contract-auditor → Audit contracts
+3. web3-infra → Set up RPC, indexers
+4. web3-frontend → Build DApp frontend
+5. contract-auditor → Final security review
+```
+
+### Step 3: Synthesis Report
+```markdown
+## DApp Build Report
+
+### Contracts
+- [Contract names and addresses]
+- [Test results and coverage]
+
+### Frontend
+- [Pages and components built]
+- [Wallet integration status]
+
+### Infrastructure
+- [RPC providers configured]
+- [Indexers deployed]
+
+### Security
+- [Audit findings and resolutions]
+- [Risk assessment]
+
+### Next Steps
+- [ ] Deploy to testnet
+- [ ] Complete audit
+- [ ] Deploy to mainnet
+```
+
+---
+
+## Example: Full DApp Build
+
+**User**: "Build an NFT minting DApp on Base"
+
+**Orchestrator Response**:
+```
+🔴 Pre-Flight Check
+→ Chain: Base (EVM) ✅
+→ Type: NFT Minting ✅
+→ Proceeding with orchestration.
+
+1. Using solidity-expert to write ERC-721 contract...
+   → Contract written with Foundry tests
+   
+2. Using contract-auditor to review security...
+   → No critical issues found
+   
+3. Using web3-infra to set up Base RPC + indexer...
+   → Alchemy Base configured with Multicall3
+   
+4. Using web3-frontend to build mint UI...
+   → Next.js + RainbowKit mint page ready
+
+## Synthesis Report
+[Combined deliverables]
+```
+
+---
+
+> **Remember:** You ARE the coordinator. Each agent is a specialist. Your job is to sequence their work correctly and ensure nothing falls through the cracks.

package/template/.agent/skills/clean-code/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: clean-code
+description: Pragmatic coding standards for Web3 development. Concise, secure, gas-aware code. No over-engineering, no unnecessary comments. Applied globally to all Web3 code.
+---
+
+# Clean Code — Web3 Standards
+
+Pragmatic coding standards applied globally to all Web3 development.
+
+## Core Principles
+
+1. **Security over cleverness** — Simple code is auditable code
+2. **Gas-aware** — Every line costs money on-chain
+3. **Self-documenting** — Good names eliminate the need for comments
+4. **Test everything** — Untested code is broken code
+5. **Fail fast** — Revert early with descriptive errors
+
+---
+
+## Solidity Standards
+
+### Naming
+```solidity
+// Constants: UPPER_SNAKE_CASE
+uint256 public constant MAX_SUPPLY = 10_000;
+
+// State variables: camelCase
+uint256 public totalMinted;
+
+// Functions: camelCase, verb-first
+function mintToken(address to) external;
+function _validateInput(uint256 amount) internal;
+
+// Events: PascalCase, past tense
+event TokenMinted(address indexed to, uint256 tokenId);
+
+// Custom errors: PascalCase, descriptive
+error InsufficientBalance(uint256 available, uint256 required);
+```
+
+### File Organization
+```solidity
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+// 1. Imports
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+// 2. Interfaces
+// 3. Libraries
+// 4. Contract
+
+contract MyToken is ERC721 {
+    // a. Type declarations
+    // b. State variables
+    // c. Events
+    // d. Errors
+    // e. Modifiers
+    // f. Constructor
+    // g. External functions
+    // h. Public functions
+    // i. Internal functions
+    // j. Private functions
+    // k. View/Pure functions
+}
+```
+
+---
+
+## TypeScript / Frontend Standards
+
+### Naming
+```typescript
+// Components: PascalCase
+function MintButton() {}
+
+// Hooks: camelCase, 'use' prefix
+function useTokenBalance() {}
+
+// Constants: UPPER_SNAKE_CASE
+const RPC_URL = process.env.NEXT_PUBLIC_RPC_URL
+
+// Types: PascalCase
+interface TokenMetadata { name: string; symbol: string }
+```
+
+### Patterns
+```typescript
+// ✅ Early returns
+function validateAddress(address: string) {
+  if (!address) return null
+  if (!isAddress(address)) return null
+  return getAddress(address) // checksummed
+}
+
+// ✅ Exhaustive error handling
+try {
+  await writeContract({ ... })
+} catch (error) {
+  if (error instanceof UserRejectedRequestError) {
+    toast.error('Transaction rejected')
+  } else if (error instanceof ContractFunctionExecutionError) {
+    toast.error(`Contract error: ${error.shortMessage}`)
+  } else {
+    toast.error('Unexpected error')
+    console.error(error)
+  }
+}
+```
+
+---
+
+## Rust Standards
+
+### Naming
+```rust
+// Structs/Enums: PascalCase
+pub struct UserAccount { ... }
+
+// Functions/Methods: snake_case
+pub fn process_transfer() -> Result<()> { ... }
+
+// Constants: UPPER_SNAKE_CASE
+pub const MAX_STAKE: u64 = 1_000_000;
+
+// Modules: snake_case
+mod instructions;
+```
+
+---
+
+## Anti-Patterns (Global)
+
+| ❌ Don't | ✅ Do |
+|----------|-------|
+| Comment obvious code | Write self-documenting code |
+| Over-engineer for "future needs" | Solve today's problem well |
+| Copy-paste code | Extract into shared functions |
+| Ignore errors | Handle every error path explicitly |
+| Use magic numbers | Define named constants |
+| Leave dead code | Delete unused code |
+| Skip tests | Write tests alongside code |

package/template/.agent/skills/dapp-patterns/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: dapp-patterns
+description: DApp architecture patterns, IPFS, ENS, token gating, gasless transactions, account abstraction, signing patterns, and metadata standards.
+---
+
+# DApp Patterns — Web3 Application Architecture
+
+Expert knowledge for designing and building decentralized application architectures.
+
+## Use this skill when
+
+- Designing DApp architecture and data flow
+- Implementing token gating or access control
+- Working with IPFS and decentralized storage
+- Setting up gasless transactions (meta-transactions)
+- Implementing account abstraction (ERC-4337)
+- Building NFT metadata and reveal systems
+
+---
+
+## Architecture Patterns
+
+### DApp Data Flow
+```
+User Wallet → DApp Frontend → Contract Interaction
+                    ↓
+              Wagmi/viem → RPC Provider → Blockchain
+                    ↓
+              Subgraph/Indexer → Read Historical Data
+                    ↓
+              IPFS/Arweave → Decentralized Storage
+```
+
+### Backend for DApps
+| Pattern | When to Use |
+|---------|-------------|
+| **Fully On-Chain** | Simple contracts, low data requirements |
+| **Hybrid** | On-chain state + off-chain metadata/API |
+| **Indexed** | Complex queries via The Graph/Ponder |
+| **Off-Chain + Proof** | Large data with on-chain verification |
+
+---
+
+## Token Gating
+
+```typescript
+// Check NFT ownership for access
+import { useReadContract } from 'wagmi'
+
+function useTokenGate(contractAddress: Address, userAddress: Address) {
+  const { data: balance } = useReadContract({
+    address: contractAddress,
+    abi: erc721Abi,
+    functionName: 'balanceOf',
+    args: [userAddress],
+  })
+
+  return { hasAccess: balance && balance > 0n }
+}
+```
+
+---
+
+## Decentralized Storage
+
+### IPFS
+```typescript
+// Upload to IPFS via Pinata
+const uploadToIPFS = async (file: File) => {
+  const formData = new FormData()
+  formData.append('file', file)
+
+  const res = await fetch('https://api.pinata.cloud/pinning/pinFileToIPFS', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${PINATA_JWT}` },
+    body: formData,
+  })
+
+  const { IpfsHash } = await res.json()
+  return `ipfs://${IpfsHash}`
+}
+```
+
+### NFT Metadata Standard
+```json
+{
+  "name": "My NFT #1",
+  "description": "Description of the NFT",
+  "image": "ipfs://Qm.../1.png",
+  "animation_url": "ipfs://Qm.../1.mp4",
+  "external_url": "https://myproject.com/nft/1",
+  "attributes": [
+    { "trait_type": "Background", "value": "Blue" },
+    { "trait_type": "Power", "value": 85, "display_type": "number" }
+  ]
+}
+```
+
+---
+
+## Account Abstraction (ERC-4337)
+
+### Key Concepts
+- **Smart Contract Wallets**: Wallets are contracts, not EOAs
+- **UserOperations**: Bundled transactions via alt-mempool
+- **Paymasters**: Sponsor gas for users
+- **Bundlers**: Submit UserOps to chain
+
+### Libraries
+| Library | Purpose |
+|---------|---------|
+| **Pimlico** | Bundler + Paymaster infrastructure |
+| **ZeroDev** | SDK for smart accounts |
+| **Alchemy AA SDK** | Account abstraction toolkit |
+| **Safe{Core}** | Modular smart account |
+
+---
+
+## Gasless Transactions
+
+### ERC-2771 (Meta-Transactions)
+```solidity
+// Trusted forwarder pattern
+import "@openzeppelin/contracts/metatx/ERC2771Context.sol";
+
+contract MyContract is ERC2771Context {
+    constructor(address trustedForwarder) ERC2771Context(trustedForwarder) {}
+
+    function doSomething() external {
+        address sender = _msgSender(); // Works with meta-tx
+    }
+}
+```
+
+### ERC-2612 (Permit)
+```typescript
+// Gasless token approval via signature
+const { signTypedDataAsync } = useSignTypedData()
+
+const signature = await signTypedDataAsync({
+  domain: { name: 'Token', version: '1', chainId, verifyingContract: tokenAddress },
+  types: { Permit: [/* EIP-2612 types */] },
+  primaryType: 'Permit',
+  message: { owner, spender, value, nonce, deadline },
+})
+```
+
+---
+
+## Signing Patterns
+
+### EIP-712 (Typed Structured Data)
+```solidity
+bytes32 public constant DOMAIN_TYPEHASH = keccak256(
+    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+);
+
+bytes32 public constant ORDER_TYPEHASH = keccak256(
+    "Order(address maker,address token,uint256 amount,uint256 nonce,uint256 deadline)"
+);
+```
+
+### Best Practices
+- Always include `chainId` to prevent cross-chain replay
+- Always include `nonce` to prevent same-chain replay
+- Always include `deadline` for time-bounded signatures
+- Use `EIP-712` for human-readable signature requests
+
+---
+
+## ENS Integration
+
+```typescript
+import { useEnsName, useEnsAddress, useEnsAvatar } from 'wagmi'
+
+// Address → ENS name
+const { data: ensName } = useEnsName({ address: '0x...' })
+
+// ENS name → Address
+const { data: address } = useEnsAddress({ name: 'vitalik.eth' })
+
+// ENS avatar
+const { data: avatar } = useEnsAvatar({ name: 'vitalik.eth' })
+```