@dilukangelo/web3-ai-skills 1.0.0 → 1.1.0

package/README.md

@@ -38,7 +38,7 @@ This creates a `.agent/` folder in your current directory with all Web3 agents,
 | **web3-infra** | RPC optimization, Multicall3, MEV protection |
 | **web3-orchestrator** | Multi-agent coordination for full-stack DApps |
 
-### 🧩 8 Skills
+### 🧩 12 Skills
 
 | Skill | Description |
 |-------|-------------|
@@ -50,6 +50,10 @@ This creates a `.agent/` folder in your current directory with all Web3 agents,
 | **rpc-optimization** | Multicall3, batching, caching, MEV protection |
 | **subgraph-indexing** | The Graph, Ponder, Subsquid, Envio |
 | **clean-code** | Web3-specific coding standards |
+| **web3-api-providers** | Alchemy, Moralis, Infura, QuickNode enhanced APIs |
+| **thirdweb-sdk** | Contract deploy, embed wallets, Engine, Pay |
+| **hardhat-foundry-testing** | Forge cheatcodes, Hardhat plugins, fuzz/invariant, CI |
+| **account-abstraction** | ERC-4337, paymasters, session keys, EIP-7702 |
 
 ### 🔄 4 Workflows
 
@@ -71,7 +75,7 @@ After running `init`, your project will have a `.agent/` folder:
 ├── GEMINI.md            # Core AI instructions
 ├── ARCHITECTURE.md      # System overview
 ├── agents/              # 6 specialist agents
-├── skills/              # 8 domain skills
+├── skills/              # 12 domain skills
 ├── workflows/           # 4 slash commands
 └── scripts/             # Validation scripts
 ```

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dilukangelo/web3-ai-skills",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "CLI to initialize Web3 AI Agent Skills — Solidity, Rust, DApp frontends, auditing, RPC, and indexing for 2026",
   "main": "bin/cli.js",
   "type": "module",
   "bin": {
-    "web3-ai-skills": "./bin/cli.js",
-    "w3ai": "./bin/cli.js"
+    "web3-ai-skills": "bin/cli.js",
+    "w3ai": "bin/cli.js"
   },
   "files": [
     "bin/",
@@ -42,6 +42,7 @@
   },
   "homepage": "https://github.com/dilukangelosl/web3-ai-skills#readme",
   "dependencies": {
+    "@dilukangelo/web3-ai-skills": "file:dilukangelo-web3-ai-skills-1.0.1.tgz",
     "chalk": "^5.3.0",
     "commander": "^14.0.3",
     "fs-extra": "^11.3.3",

package/template/.agent/ARCHITECTURE.md

@@ -9,7 +9,7 @@
 Web3 AI Skills is a modular system consisting of:
 
 - **6 Specialist Agents** — Web3-specific role-based AI personas
-- **8 Skills** — Deep domain knowledge modules for blockchain development
+- **12 Skills** — Deep domain knowledge modules for blockchain development
 - **4 Workflows** — Slash command procedures for common Web3 tasks
 
 ---
@@ -21,7 +21,7 @@ Web3 AI Skills is a modular system consisting of:
 ├── GEMINI.md                # Core instructions
 ├── ARCHITECTURE.md          # This file
 ├── agents/                  # 6 Specialist Agents
-├── skills/                  # 8 Skills
+├── skills/                  # 12 Skills
 ├── workflows/               # 4 Slash Commands
 └── scripts/                 # Validation Scripts
 ```
@@ -32,16 +32,16 @@ Web3 AI Skills is a modular system consisting of:
 
 | Agent                  | Focus                             | Skills Used                                      |
 | ---------------------- | --------------------------------- | ------------------------------------------------ |
-| `solidity-expert`      | EVM smart contracts, Foundry      | solidity-patterns, smart-contract-auditing        |
+| `solidity-expert`      | EVM smart contracts, Foundry      | solidity-patterns, smart-contract-auditing, hardhat-foundry-testing |
 | `rust-web3`            | Solana/Anchor, CosmWasm, Rust     | rust-smart-contracts                              |
-| `web3-frontend`        | Next.js + RainbowKit + Wagmi      | rainbowkit-wagmi, dapp-patterns                   |
-| `contract-auditor`     | Security audits, Slither, Mythril | smart-contract-auditing                           |
-| `web3-infra`           | RPC, indexers, nodes, subgraphs   | rpc-optimization, subgraph-indexing               |
+| `web3-frontend`        | Next.js + RainbowKit + Wagmi      | rainbowkit-wagmi, dapp-patterns, thirdweb-sdk, account-abstraction |
+| `contract-auditor`     | Security audits, Slither, Mythril | smart-contract-auditing, hardhat-foundry-testing  |
+| `web3-infra`           | RPC, indexers, nodes, subgraphs   | rpc-optimization, subgraph-indexing, web3-api-providers |
 | `web3-orchestrator`    | Multi-agent Web3 coordination     | All skills                                        |
 
 ---
 
-## 🧩 Skills (8)
+## 🧩 Skills (12)
 
 ### Smart Contracts
 
@@ -50,6 +50,7 @@ Web3 AI Skills is a modular system consisting of:
 | `solidity-patterns`         | Solidity 0.8.x+, ERC standards, gas optimization  |
 | `rust-smart-contracts`      | Anchor/Solana programs, CosmWasm, Stylus           |
 | `smart-contract-auditing`   | Audit methodology, Slither, Mythril, Aderyn        |
+| `hardhat-foundry-testing`   | Toolchains, cheatcodes, fuzz/invariant testing, CI |
 
 ### DApp Frontend
 
@@ -57,13 +58,16 @@ Web3 AI Skills is a modular system consisting of:
 | --------------------------- | -------------------------------------------------- |
 | `rainbowkit-wagmi`          | RainbowKit v2, Wagmi v2, viem, wallet integration |
 | `dapp-patterns`             | DApp architecture, IPFS, ENS, signing patterns     |
+| `thirdweb-sdk`              | Contract deploy, in-app wallets, Engine, Pay       |
+| `account-abstraction`       | ERC-4337, paymasters, session keys, EIP-7702       |
 
 ### Infrastructure
 
 | Skill                       | Description                                        |
 | --------------------------- | -------------------------------------------------- |
 | `rpc-optimization`          | RPC management, Multicall3, batching, MEV          |
-| `subgraph-indexing`         | The Graph, Ponder, custom indexers, event parsing  |
+| `subgraph-indexing`         | The Graph, Ponder, Subsquid, Envio, event parsing  |
+| `web3-api-providers`        | Alchemy, Moralis, Infura, QuickNode enhanced APIs  |
 
 ### General
 
@@ -111,9 +115,9 @@ skill-name/
 | Metric              | Value        |
 | ------------------- | ------------ |
 | **Total Agents**    | 6            |
-| **Total Skills**    | 8            |
+| **Total Skills**    | 12           |
 | **Total Workflows** | 4            |
-| **Coverage**        | Web3 / EVM / Solana / DApp |
+| **Coverage**        | Web3 / EVM / Solana / DApp / AA / APIs |
 
 ---
 
@@ -121,9 +125,10 @@ skill-name/
 
 | Need               | Agent                | Skills                                       |
 | ------------------- | -------------------- | -------------------------------------------- |
-| Solidity Contract   | `solidity-expert`    | solidity-patterns, smart-contract-auditing   |
+| Solidity Contract   | `solidity-expert`    | solidity-patterns, hardhat-foundry-testing    |
 | Rust Contract       | `rust-web3`          | rust-smart-contracts                          |
-| DApp Frontend       | `web3-frontend`      | rainbowkit-wagmi, dapp-patterns              |
-| Contract Audit      | `contract-auditor`   | smart-contract-auditing                       |
-| RPC / Infra         | `web3-infra`         | rpc-optimization, subgraph-indexing          |
+| DApp Frontend       | `web3-frontend`      | rainbowkit-wagmi, dapp-patterns, thirdweb-sdk |
+| Contract Audit      | `contract-auditor`   | smart-contract-auditing, hardhat-foundry-testing |
+| RPC / Infra         | `web3-infra`         | rpc-optimization, subgraph-indexing, web3-api-providers |
+| Account Abstraction | `web3-frontend`      | account-abstraction, thirdweb-sdk            |
 | Full-Stack DApp     | `web3-orchestrator`  | All skills                                    |

package/template/.agent/GEMINI.md

@@ -67,11 +67,11 @@ When auto-applying an agent, inform the user:
 
 | Project Type                                 | Primary Agent         | Skills                                       |
 | -------------------------------------------- | --------------------- | -------------------------------------------- |
-| **SMART CONTRACTS** (Solidity, EVM)          | `solidity-expert`     | solidity-patterns, smart-contract-auditing   |
-| **RUST CONTRACTS** (Solana, Anchor, CosmWasm) | `rust-web3`           | rust-smart-contracts, solana-patterns        |
-| **DAPP FRONTEND** (Next.js, RainbowKit)      | `web3-frontend`       | rainbowkit-wagmi, dapp-patterns              |
-| **SECURITY AUDIT** (Contract audit)          | `contract-auditor`    | smart-contract-auditing, vulnerability-scanner|
-| **RPC / INFRA** (Nodes, indexers)            | `web3-infra`          | rpc-optimization, subgraph-indexing          |
+| **SMART CONTRACTS** (Solidity, EVM)          | `solidity-expert`     | solidity-patterns, smart-contract-auditing, hardhat-foundry-testing |
+| **RUST CONTRACTS** (Solana, Anchor, CosmWasm) | `rust-web3`           | rust-smart-contracts                         |
+| **DAPP FRONTEND** (Next.js, RainbowKit)      | `web3-frontend`       | rainbowkit-wagmi, dapp-patterns, thirdweb-sdk, account-abstraction |
+| **SECURITY AUDIT** (Contract audit)          | `contract-auditor`    | smart-contract-auditing, hardhat-foundry-testing |
+| **RPC / INFRA** (Nodes, indexers, APIs)      | `web3-infra`          | rpc-optimization, subgraph-indexing, web3-api-providers |
 
 ---
 
@@ -130,6 +130,6 @@ When user's prompt is NOT in English:
 ### Agents & Skills
 
 - **Core Agents**: `solidity-expert`, `rust-web3`, `web3-frontend`, `contract-auditor`, `web3-infra`, `web3-orchestrator`
-- **Key Skills**: `solidity-patterns`, `rust-smart-contracts`, `rainbowkit-wagmi`, `smart-contract-auditing`, `rpc-optimization`, `dapp-patterns`, `clean-code`, `subgraph-indexing`
+- **Key Skills**: `solidity-patterns`, `rust-smart-contracts`, `rainbowkit-wagmi`, `smart-contract-auditing`, `rpc-optimization`, `dapp-patterns`, `clean-code`, `subgraph-indexing`, `web3-api-providers`, `thirdweb-sdk`, `hardhat-foundry-testing`, `account-abstraction`
 
 ---

package/template/.agent/skills/account-abstraction/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: account-abstraction
+description: ERC-4337 smart accounts, paymasters, bundlers, session keys, and gas sponsorship. Alchemy AA SDK, Pimlico, ZeroDev, Safe, and EIP-7702.
+---
+
+# Account Abstraction — Smart Accounts & Gas Sponsorship
+
+Expert knowledge for implementing ERC-4337 account abstraction in Web3 applications.
+
+## Use this skill when
+
+- Implementing smart contract wallets (not EOAs)
+- Sponsoring gas for users (gasless transactions)
+- Setting up session keys for limited permissions
+- Batching multiple transactions into one
+- Building onboarding flows without requiring ETH
+
+## Do not use this skill when
+
+- Connecting external wallets like MetaMask (use `rainbowkit-wagmi`)
+- General DApp architecture (use `dapp-patterns`)
+
+---
+
+## Core Concepts
+
+### Architecture
+```
+User → Signs UserOperation
+         ↓
+Bundler → Bundles UserOps into single tx
+         ↓
+EntryPoint Contract → Validates & executes
+         ↓
+Smart Account → Executes the actual call(s)
+         ↓
+Paymaster → Sponsors gas (optional)
+```
+
+### Key Components
+| Component | Role |
+|-----------|------|
+| **Smart Account** | Contract wallet that holds assets and executes operations |
+| **UserOperation** | Pseudo-transaction signed by the user |
+| **Bundler** | Service that batches UserOps into on-chain transactions |
+| **Paymaster** | Contract that pays gas on behalf of users |
+| **EntryPoint** | Singleton contract that validates and executes UserOps |
+| **Account Factory** | Contract that deploys new smart accounts |
+
+---
+
+## Alchemy Account Kit (AA SDK)
+
+### Setup
+```typescript
+import { createModularAccountAlchemyClient } from '@account-kit/smart-contracts'
+import { alchemy, sepolia } from '@account-kit/infra'
+import { LocalAccountSigner } from '@aa-sdk/core'
+
+const client = await createModularAccountAlchemyClient({
+  transport: alchemy({ apiKey: ALCHEMY_API_KEY }),
+  chain: sepolia,
+  signer: LocalAccountSigner.privateKeyToAccountSigner(PRIVATE_KEY),
+  // Gas sponsorship
+  gasManagerConfig: {
+    policyId: ALCHEMY_GAS_POLICY_ID,
+  },
+})
+```
+
+### Send Sponsored Transaction
+```typescript
+const { hash } = await client.sendUserOperation({
+  uo: {
+    target: contractAddress,
+    data: encodeFunctionData({
+      abi: contractAbi,
+      functionName: 'mint',
+      args: [1n],
+    }),
+    value: 0n,
+  },
+})
+
+// Wait for confirmation
+const receipt = await client.waitForUserOperationTransaction({ hash })
+```
+
+### Batch Transactions
+```typescript
+const { hash } = await client.sendUserOperation({
+  uo: [
+    {
+      target: tokenAddress,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'approve',
+        args: [spender, amount],
+      }),
+    },
+    {
+      target: spender,
+      data: encodeFunctionData({
+        abi: spenderAbi,
+        functionName: 'deposit',
+        args: [amount],
+      }),
+    },
+  ],
+})
+```
+
+---
+
+## Pimlico (Bundler + Paymaster)
+
+### Setup
+```typescript
+import { createSmartAccountClient } from 'permissionless'
+import { toSimpleSmartAccount } from 'permissionless/accounts'
+import { createPimlicoClient } from 'permissionless/clients/pimlico'
+
+// Pimlico bundler + paymaster client
+const pimlicoClient = createPimlicoClient({
+  transport: http(`https://api.pimlico.io/v2/${chainId}/rpc?apikey=${PIMLICO_KEY}`),
+  entryPoint: { address: entryPoint07Address, version: '0.7' },
+})
+
+// Smart account
+const account = await toSimpleSmartAccount({
+  client: publicClient,
+  owner: signer,
+  entryPoint: { address: entryPoint07Address, version: '0.7' },
+})
+
+// Smart account client with gas sponsorship
+const smartAccountClient = createSmartAccountClient({
+  account,
+  chain,
+  bundlerTransport: http(`https://api.pimlico.io/v2/${chainId}/rpc?apikey=${PIMLICO_KEY}`),
+  paymaster: pimlicoClient,
+})
+```
+
+### Send Gasless Transaction
+```typescript
+const hash = await smartAccountClient.sendTransaction({
+  to: contractAddress,
+  data: calldata,
+  value: 0n,
+})
+```
+
+---
+
+## ZeroDev (Kernel Accounts)
+
+### Setup
+```typescript
+import { createKernelAccount, createKernelAccountClient } from '@zerodev/sdk'
+import { signerToEcdsaValidator } from '@zerodev/ecdsa-validator'
+
+const ecdsaValidator = await signerToEcdsaValidator(publicClient, { signer })
+
+const account = await createKernelAccount(publicClient, {
+  plugins: { sudo: ecdsaValidator },
+  entryPoint: entryPoint07Address,
+})
+```
+
+### Session Keys
+```typescript
+import { signerToSessionKeyValidator } from '@zerodev/session-key'
+
+const sessionKeyValidator = await signerToSessionKeyValidator(publicClient, {
+  signer: sessionKeySigner,
+  validatorData: {
+    permissions: [{
+      target: contractAddress,
+      functionName: 'transfer',
+      args: [{ condition: 'EQUAL', value: recipientAddress }],
+      valueLimit: parseEther('0.1'),
+    }],
+  },
+})
+```
+
+---
+
+## Safe Smart Accounts
+
+```typescript
+import Safe from '@safe-global/protocol-kit'
+
+const protocolKit = await Safe.init({
+  provider: rpcUrl,
+  signer: privateKey,
+  safeAddress: existingSafeAddress,
+})
+
+// Create transaction
+const safeTransaction = await protocolKit.createTransaction({
+  transactions: [{
+    to: recipient,
+    value: parseEther('0.1').toString(),
+    data: '0x',
+  }],
+})
+
+// Sign and execute
+const signedTx = await protocolKit.signTransaction(safeTransaction)
+const result = await protocolKit.executeTransaction(signedTx)
+```
+
+---
+
+## EIP-7702 (Native AA — Pectra Upgrade)
+
+The next evolution: EOAs can temporarily delegate to smart contract code.
+
+```typescript
+// EOA signs an authorization to delegate to a smart contract
+const authorization = {
+  chainId: 1,
+  codeAddress: smartAccountImplementation, // Contract to delegate to
+  nonce: await getTransactionCount(client, { address: eoa }),
+}
+
+// Send transaction with authorization list
+const hash = await sendTransaction(client, {
+  authorizationList: [authorization],
+  to: targetContract,
+  data: calldata,
+})
+```
+
+### EIP-7702 vs ERC-4337
+| Feature | ERC-4337 | EIP-7702 |
+|---------|----------|----------|
+| **Type** | Smart contract wallet | EOA delegation |
+| **Deployment** | New contract per user | No deployment needed |
+| **Compatibility** | New address | Same EOA address |
+| **Bundler** | Required | Optional |
+| **Gas Efficiency** | Higher overhead | Lower overhead |
+| **Adoption** | Production-ready | Pectra upgrade |
+
+---
+
+## Provider Selection
+
+| Provider | Smart Accounts | Paymaster | Bundler | Session Keys |
+|----------|---------------|-----------|---------|-------------|
+| **Alchemy AA** | Modular Account | ✅ Gas Manager | ✅ | ✅ |
+| **Pimlico** | Any (Simple, Kernel, Safe) | ✅ Verifying | ✅ | Via account |
+| **ZeroDev** | Kernel Account | ✅ | ✅ | ✅ Native |
+| **Safe** | Safe Multisig | Via relay | Via relay | ✅ Modules |
+| **Biconomy** | Nexus Account | ✅ | ✅ | ✅ |
+| **thirdweb** | In-App Wallet | ✅ Built-in | ✅ Built-in | ❌ |

package/template/.agent/skills/hardhat-foundry-testing/SKILL.md

@@ -0,0 +1,289 @@
+---
+name: hardhat-foundry-testing
+description: Smart contract development toolchains and testing strategies. Foundry cheatcodes, Hardhat plugins, fuzz testing, invariant testing, fork testing, gas snapshots, and CI/CD pipelines.
+---
+
+# Hardhat & Foundry Testing — Smart Contract Toolchains
+
+Expert knowledge for testing, debugging, and deploying smart contracts with Foundry and Hardhat.
+
+## Use this skill when
+
+- Setting up Foundry or Hardhat projects
+- Writing unit, fuzz, or invariant tests
+- Fork testing against mainnet state
+- Debugging failing transactions
+- Setting up CI/CD for Solidity projects
+- Comparing Foundry vs Hardhat for a project
+
+---
+
+## Foundry
+
+### Project Commands
+```bash
+forge init my-project          # New project
+forge build                    # Compile
+forge test                     # Run tests
+forge test -vvvv               # Verbose (show traces)
+forge test --match-test "test_Transfer"  # Single test
+forge test --gas-report        # Gas usage
+forge coverage                 # Code coverage
+forge snapshot                 # Gas snapshots
+forge fmt                      # Format code
+```
+
+### Cheatcodes (vm.)
+
+```solidity
+// Identity
+vm.prank(alice);             // Next call as alice
+vm.startPrank(alice);        // All calls as alice until stopPrank
+vm.stopPrank();
+
+// State manipulation
+vm.deal(alice, 10 ether);   // Set ETH balance
+deal(address(token), alice, 1000e18);  // Set ERC-20 balance
+vm.store(addr, slot, value); // Set storage slot
+
+// Time & block
+vm.warp(block.timestamp + 1 days);  // Set timestamp
+vm.roll(block.number + 100);        // Set block number
+
+// Expectations
+vm.expectRevert(MyContract.InsufficientBalance.selector);
+vm.expectEmit(true, true, false, true);
+emit Transfer(alice, bob, 100);
+
+// Environment
+vm.envUint("PRIVATE_KEY");   // Read .env
+vm.createSelectFork("mainnet"); // Fork mainnet
+
+// Snapshots
+uint256 snap = vm.snapshot();  // Save state
+vm.revertTo(snap);             // Restore state
+
+// Labels (for traces)
+vm.label(alice, "Alice");
+vm.label(address(token), "USDC");
+```
+
+### Fuzz Testing
+```solidity
+function testFuzz_Deposit(uint256 amount) public {
+    // Bound inputs to valid range
+    amount = bound(amount, 1, MAX_DEPOSIT);
+
+    vm.deal(alice, amount);
+    vm.prank(alice);
+    vault.deposit{value: amount}();
+
+    assertEq(vault.balanceOf(alice), amount);
+}
+```
+
+### Invariant Testing
+```solidity
+// Define target contract and selectors
+function setUp() public {
+    targetContract(address(vault));
+    // Only call these functions during invariant testing
+    bytes4[] memory selectors = new bytes4[](2);
+    selectors[0] = vault.deposit.selector;
+    selectors[1] = vault.withdraw.selector;
+    targetSelector(FuzzSelector(address(vault), selectors));
+}
+
+function invariant_TotalAssetsMatchDeposits() public {
+    assertEq(
+        address(vault).balance,
+        vault.totalDeposits()
+    );
+}
+
+function invariant_NoNegativeBalances() public {
+    for (uint i = 0; i < actors.length; i++) {
+        assertGe(vault.balanceOf(actors[i]), 0);
+    }
+}
+```
+
+### Fork Testing
+```solidity
+function setUp() public {
+    // Fork mainnet at specific block
+    vm.createSelectFork("mainnet", 18_000_000);
+}
+
+function test_SwapOnUniswap() public {
+    // Interact with real mainnet contracts
+    IUniswapV2Router02 router = IUniswapV2Router02(UNISWAP_ROUTER);
+
+    vm.deal(alice, 1 ether);
+    vm.startPrank(alice);
+
+    address[] memory path = new address[](2);
+    path[0] = WETH;
+    path[1] = USDC;
+
+    router.swapExactETHForTokens{value: 1 ether}(
+        0, path, alice, block.timestamp
+    );
+
+    assertGt(IERC20(USDC).balanceOf(alice), 0);
+}
+```
+
+### Deployment Scripts
+```solidity
+// script/Deploy.s.sol
+contract DeployScript is Script {
+    function run() public {
+        uint256 key = vm.envUint("PRIVATE_KEY");
+        vm.startBroadcast(key);
+
+        MyContract c = new MyContract(arg1, arg2);
+        console.log("Deployed:", address(c));
+
+        vm.stopBroadcast();
+    }
+}
+```
+```bash
+forge script script/Deploy.s.sol \
+  --rpc-url $RPC_URL \
+  --broadcast \
+  --verify \
+  --etherscan-api-key $ETHERSCAN_KEY \
+  -vvvv
+```
+
+---
+
+## Hardhat
+
+### Project Setup
+```bash
+npx hardhat init                 # New project
+npx hardhat compile              # Compile
+npx hardhat test                 # Run tests
+npx hardhat node                 # Local node
+npx hardhat run scripts/deploy.ts --network mainnet
+```
+
+### Configuration
+```typescript
+// hardhat.config.ts
+import { HardhatUserConfig } from 'hardhat/config'
+import '@nomicfoundation/hardhat-toolbox'
+
+const config: HardhatUserConfig = {
+  solidity: {
+    version: '0.8.24',
+    settings: {
+      optimizer: { enabled: true, runs: 200 },
+      viaIR: false,
+    },
+  },
+  networks: {
+    mainnet: {
+      url: process.env.ETH_RPC_URL,
+      accounts: [process.env.PRIVATE_KEY!],
+    },
+    base: {
+      url: process.env.BASE_RPC_URL,
+      accounts: [process.env.PRIVATE_KEY!],
+    },
+  },
+  etherscan: {
+    apiKey: process.env.ETHERSCAN_KEY,
+  },
+}
+
+export default config
+```
+
+### Essential Plugins
+| Plugin | Purpose |
+|--------|---------|
+| `@nomicfoundation/hardhat-toolbox` | All-in-one (ethers, chai, coverage, gas) |
+| `@nomicfoundation/hardhat-verify` | Contract verification |
+| `hardhat-gas-reporter` | Gas usage per function |
+| `hardhat-deploy` | Deterministic deployments |
+| `@openzeppelin/hardhat-upgrades` | Proxy deploy + upgrade |
+
+### Testing with Hardhat
+```typescript
+import { expect } from 'chai'
+import { ethers } from 'hardhat'
+import { loadFixture } from '@nomicfoundation/hardhat-network-helpers'
+
+describe('MyToken', () => {
+  async function deployFixture() {
+    const [owner, alice, bob] = await ethers.getSigners()
+    const Token = await ethers.getContractFactory('MyToken')
+    const token = await Token.deploy('MyToken', 'MTK')
+    return { token, owner, alice, bob }
+  }
+
+  it('should transfer tokens', async () => {
+    const { token, owner, alice } = await loadFixture(deployFixture)
+    await token.mint(owner.address, 1000)
+    await token.transfer(alice.address, 500)
+    expect(await token.balanceOf(alice.address)).to.equal(500)
+  })
+})
+```
+
+---
+
+## CI/CD (GitHub Actions)
+
+```yaml
+# .github/workflows/ci.yml
+name: Solidity CI
+
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Build
+        run: forge build --sizes
+
+      - name: Test
+        run: forge test -vvv
+
+      - name: Gas Snapshot
+        run: forge snapshot --check
+
+      - name: Coverage
+        run: forge coverage --report lcov
+
+      - name: Slither
+        uses: crytic/slither-action@v0.4.0
+```
+
+---
+
+## Foundry vs Hardhat
+
+| Feature | Foundry | Hardhat |
+|---------|---------|---------|
+| **Speed** | ⚡ Very fast (Rust) | Slower (Node.js) |
+| **Test Language** | Solidity | TypeScript/JS |
+| **Fuzz Testing** | ✅ Built-in | ❌ Needs plugins |
+| **Invariant Testing** | ✅ Built-in | ❌ |
+| **Fork Testing** | ✅ Fast | ✅ Slower |
+| **Cheatcodes** | ✅ Extensive | ✅ network-helpers |
+| **Plugin Ecosystem** | Growing | Mature |
+| **Deployment** | forge script | hardhat-deploy |
+| **When to Use** | Performance, Solidity-native | TypeScript ecosystem, plugins |

package/template/.agent/skills/thirdweb-sdk/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: thirdweb-sdk
+description: thirdweb SDK for deploying contracts, connecting wallets (email/passkey/social), gasless transactions, Engine backend, and cross-chain payments.
+---
+
+# thirdweb SDK — Unified Web3 Development Platform
+
+Expert knowledge for building with thirdweb's SDK across frontend, backend, and on-chain.
+
+## Use this skill when
+
+- Deploying contracts without writing deploy scripts
+- Adding wallet connection with email, passkey, or social login
+- Setting up gasless/sponsored transactions
+- Using thirdweb Engine for backend wallet management
+- Implementing cross-chain payments or token swaps
+
+## Do not use this skill when
+
+- Using RainbowKit for wallet connection (use `rainbowkit-wagmi`)
+- Writing raw Solidity patterns (use `solidity-patterns`)
+
+---
+
+## Setup
+
+### Installation
+```bash
+npm install thirdweb
+```
+
+### Client
+```typescript
+import { createThirdwebClient } from 'thirdweb'
+
+const client = createThirdwebClient({
+  clientId: process.env.NEXT_PUBLIC_THIRDWEB_CLIENT_ID!,
+})
+```
+
+---
+
+## Wallet Connection (Connect)
+
+### ConnectButton (Quick Setup)
+```typescript
+import { ConnectButton } from 'thirdweb/react'
+import { ThirdwebProvider } from 'thirdweb/react'
+
+export default function App() {
+  return (
+    <ThirdwebProvider>
+      <ConnectButton client={client} />
+    </ThirdwebProvider>
+  )
+}
+```
+
+### In-App Wallets (Email, Passkey, Social)
+```typescript
+import { ConnectButton } from 'thirdweb/react'
+import { inAppWallet, createWallet } from 'thirdweb/wallets'
+
+const wallets = [
+  inAppWallet({
+    auth: {
+      options: ['email', 'passkey', 'google', 'apple', 'discord'],
+    },
+    executionMode: {
+      mode: 'EIP7702',
+      sponsorGas: true, // Gasless for users
+    },
+  }),
+  createWallet('io.metamask'),
+  createWallet('com.coinbase.wallet'),
+]
+
+<ConnectButton client={client} wallets={wallets} />
+```
+
+### ConnectEmbed (Inline)
+```typescript
+import { ConnectEmbed } from 'thirdweb/react'
+
+// Renders wallet options directly on page (not modal)
+<ConnectEmbed client={client} wallets={wallets} />
+```
+
+---
+
+## Contract Interaction
+
+### Read Contract
+```typescript
+import { getContract, readContract } from 'thirdweb'
+import { ethereum } from 'thirdweb/chains'
+
+const contract = getContract({
+  client,
+  chain: ethereum,
+  address: '0x...',
+})
+
+const totalSupply = await readContract({
+  contract,
+  method: 'function totalSupply() view returns (uint256)',
+  params: [],
+})
+```
+
+### Write Contract
+```typescript
+import { prepareContractCall, sendTransaction } from 'thirdweb'
+import { useActiveAccount } from 'thirdweb/react'
+
+const account = useActiveAccount()
+
+const transaction = prepareContractCall({
+  contract,
+  method: 'function mint(address to, uint256 amount)',
+  params: [account.address, 100n],
+})
+
+const { transactionHash } = await sendTransaction({
+  account,
+  transaction,
+})
+```
+
+### Deploy Contract
+```bash
+# Deploy from CLI
+npx thirdweb deploy
+
+# Or programmatically
+import { deployContract } from 'thirdweb/deploys'
+
+const address = await deployContract({
+  client,
+  chain: ethereum,
+  account,
+  bytecode: '0x...',
+  abi: contractAbi,
+  constructorParams: [param1, param2],
+})
+```
+
+---
+
+## React Hooks
+
+```typescript
+import {
+  useActiveAccount,
+  useActiveWallet,
+  useReadContract,
+  useSendTransaction,
+  useWalletBalance,
+} from 'thirdweb/react'
+
+// Current account
+const account = useActiveAccount()
+
+// Read data
+const { data, isLoading } = useReadContract({
+  contract,
+  method: 'function balanceOf(address) view returns (uint256)',
+  params: [account?.address],
+})
+
+// Send transaction
+const { mutate: sendTx, isPending } = useSendTransaction()
+sendTx(transaction)
+
+// Wallet balance
+const { data: balance } = useWalletBalance({
+  client,
+  chain: ethereum,
+  address: account?.address,
+})
+```
+
+---
+
+## thirdweb Engine (Backend)
+
+Server-side wallet management and transaction processing.
+
+```typescript
+// Engine is a self-hosted HTTP server
+// POST /contract/:chain/:address/write
+
+const response = await fetch(
+  `${ENGINE_URL}/contract/${chainId}/${contractAddress}/write`,
+  {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${ENGINE_ACCESS_TOKEN}`,
+      'x-backend-wallet-address': backendWalletAddress,
+    },
+    body: JSON.stringify({
+      functionName: 'transfer',
+      args: [toAddress, amount],
+    }),
+  }
+)
+```
+
+### Engine Features
+| Feature | Description |
+|---------|-------------|
+| **Managed Wallets** | Create and manage wallets server-side |
+| **Nonce Management** | Automatic nonce handling for parallel tx |
+| **Gas Management** | Auto gas estimation and retries |
+| **Webhooks** | Transaction status notifications |
+| **Idempotent Tx** | Prevent duplicate transactions |
+
+---
+
+## Pay (Onramp + Bridge)
+
+```typescript
+import { PayEmbed } from 'thirdweb/react'
+
+// Fiat → Crypto onramp + cross-chain bridge
+<PayEmbed client={client} />
+```
+
+---
+
+## thirdweb vs RainbowKit
+
+| Feature | thirdweb | RainbowKit |
+|---------|----------|------------|
+| **Wallet UI** | ConnectButton/Embed | ConnectButton |
+| **In-App Wallets** | ✅ Email, passkey, social | ❌ External only |
+| **Account Abstraction** | ✅ Built-in | ❌ Separate |
+| **Contract Deploy** | ✅ CLI + SDK | ❌ |
+| **Backend Engine** | ✅ | ❌ |
+| **Customization** | Moderate | High |
+| **Dependency** | thirdweb only | Wagmi + viem |

package/template/.agent/skills/web3-api-providers/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: web3-api-providers
+description: Enhanced APIs from Alchemy, Moralis, Infura, and QuickNode. NFT APIs, Token APIs, Webhooks, Streams, and blockchain data services for production DApps.
+---
+
+# Web3 API Providers — Enhanced Blockchain Data Services
+
+Expert knowledge for leveraging Web3 API provider SDKs and enhanced APIs beyond basic RPC.
+
+## Use this skill when
+
+- Fetching NFT data (metadata, ownership, transfers)
+- Querying token balances and transfer history
+- Setting up webhooks for real-time blockchain events
+- Using enhanced APIs (asset transfers, trace calls)
+- Choosing between Alchemy, Moralis, Infura, or QuickNode
+
+## Do not use this skill when
+
+- Optimizing raw RPC calls or Multicall3 (use `rpc-optimization`)
+- Building subgraphs or indexers (use `subgraph-indexing`)
+
+---
+
+## Alchemy SDK
+
+### Setup
+```typescript
+import { Alchemy, Network } from 'alchemy-sdk'
+
+const alchemy = new Alchemy({
+  apiKey: process.env.ALCHEMY_API_KEY,
+  network: Network.ETH_MAINNET,
+})
+```
+
+### NFT API
+```typescript
+// Get all NFTs for an owner
+const nfts = await alchemy.nft.getNftsForOwner('0x...')
+
+// Get NFT metadata
+const metadata = await alchemy.nft.getNftMetadata(contractAddress, tokenId)
+
+// Get owners of an NFT collection
+const owners = await alchemy.nft.getOwnersForContract(contractAddress)
+
+// Get NFTs for a contract
+const contractNfts = await alchemy.nft.getNftsForContract(contractAddress)
+
+// Verify NFT ownership
+const isOwner = await alchemy.nft.verifyNftOwnership(ownerAddress, contractAddress)
+
+// Get floor price
+const floorPrice = await alchemy.nft.getFloorPrice(contractAddress)
+```
+
+### Token API
+```typescript
+// Get all token balances
+const balances = await alchemy.core.getTokenBalances(ownerAddress)
+
+// Get token metadata (name, symbol, decimals, logo)
+const metadata = await alchemy.core.getTokenMetadata(tokenAddress)
+
+// Get asset transfers (ERC-20, ERC-721, ERC-1155, native)
+const transfers = await alchemy.core.getAssetTransfers({
+  fromBlock: '0x0',
+  toBlock: 'latest',
+  toAddress: '0x...',
+  category: ['erc20', 'erc721', 'external'],
+})
+```
+
+### Webhooks (Alchemy Notify)
+```typescript
+// Create address activity webhook
+const webhook = await alchemy.notify.createWebhook({
+  url: 'https://your-server.com/webhook',
+  type: 'ADDRESS_ACTIVITY',
+  addresses: ['0x...'],
+})
+
+// Mined transaction webhook
+const minedWebhook = await alchemy.notify.createWebhook({
+  url: 'https://your-server.com/webhook',
+  type: 'MINED_TRANSACTION',
+  addresses: ['0x...'],
+})
+```
+
+### Enhanced WebSockets
+```typescript
+// Subscribe to pending transactions
+alchemy.ws.on({
+  method: 'alchemy_pendingTransactions',
+  toAddress: contractAddress,
+}, (tx) => {
+  console.log('Pending tx:', tx.hash)
+})
+
+// Subscribe to log events
+alchemy.ws.on({
+  method: 'eth_subscribe',
+  params: ['logs', { address: contractAddress, topics: [] }],
+}, (log) => {
+  console.log('New log:', log)
+})
+```
+
+---
+
+## Moralis SDK
+
+### Setup
+```typescript
+import Moralis from 'moralis'
+
+await Moralis.start({ apiKey: process.env.MORALIS_API_KEY })
+```
+
+### NFT API
+```typescript
+// Get NFTs by wallet
+const nfts = await Moralis.EvmApi.nft.getWalletNFTs({
+  address: '0x...',
+  chain: '0x1', // Ethereum
+})
+
+// Get NFT metadata
+const metadata = await Moralis.EvmApi.nft.getNFTMetadata({
+  address: contractAddress,
+  tokenId: '1',
+  chain: '0x1',
+})
+
+// Get NFT transfers
+const transfers = await Moralis.EvmApi.nft.getNFTTransfers({
+  address: contractAddress,
+  tokenId: '1',
+  chain: '0x1',
+})
+```
+
+### Token API
+```typescript
+// Get ERC-20 balances
+const balances = await Moralis.EvmApi.token.getWalletTokenBalances({
+  address: '0x...',
+  chain: '0x1',
+})
+
+// Get token price
+const price = await Moralis.EvmApi.token.getTokenPrice({
+  address: tokenAddress,
+  chain: '0x1',
+})
+
+// Get token transfers
+const transfers = await Moralis.EvmApi.token.getWalletTokenTransfers({
+  address: '0x...',
+  chain: '0x1',
+})
+```
+
+### Streams API (Real-Time Webhooks)
+```typescript
+// Create a stream for contract events
+const stream = await Moralis.Streams.add({
+  chains: ['0x1'],
+  tag: 'my-stream',
+  description: 'Track USDC transfers',
+  webhookUrl: 'https://your-server.com/moralis-webhook',
+  includeContractLogs: true,
+  abi: usdcAbi,
+  topic0: ['Transfer(address,address,uint256)'],
+})
+
+// Add address to stream
+await Moralis.Streams.addAddress({
+  id: stream.result.id,
+  address: usdcAddress,
+})
+```
+
+### DeFi API
+```typescript
+// Get DeFi positions
+const positions = await Moralis.EvmApi.defi.getDefiPositionsByProtocol({
+  address: '0x...',
+  chain: '0x1',
+  protocol: 'uniswap-v3',
+})
+```
+
+---
+
+## Infura
+
+### Setup
+```typescript
+import { InfuraProvider } from 'ethers'
+
+const provider = new InfuraProvider('mainnet', process.env.INFURA_PROJECT_ID)
+```
+
+### IPFS Gateway
+```typescript
+// Upload to IPFS via Infura
+const response = await fetch('https://ipfs.infura.io:5001/api/v0/add', {
+  method: 'POST',
+  headers: {
+    Authorization: `Basic ${Buffer.from(`${PROJECT_ID}:${PROJECT_SECRET}`).toString('base64')}`,
+  },
+  body: formData,
+})
+```
+
+### MetaMask SDK Integration
+```typescript
+import { MetaMaskSDK } from '@metamask/sdk'
+
+const MMSDK = new MetaMaskSDK({
+  infuraAPIKey: process.env.INFURA_API_KEY,
+  dappMetadata: {
+    name: 'My DApp',
+    url: window.location.href,
+  },
+})
+
+const ethereum = MMSDK.getProvider()
+```
+
+---
+
+## QuickNode
+
+### Streams (Real-time)
+```typescript
+// QuickNode Streams — configured via dashboard or API
+// Delivers filtered blockchain data to your endpoint
+
+// Stream filter example (QN API):
+const filter = {
+  network: 'ethereum-mainnet',
+  expression: `
+    tx_logs_address == '${contractAddress}' &&
+    tx_logs_topic0 == '${transferTopic}'
+  `,
+  destination: 'https://your-server.com/qn-webhook',
+}
+```
+
+### Functions (Serverless)
+```javascript
+// QuickNode Functions — serverless JS at the edge
+// Triggered by blockchain events or HTTP requests
+export async function main(params) {
+  const { data } = params
+  // Process blockchain data
+  return { statusCode: 200, body: JSON.stringify(result) }
+}
+```
+
+---
+
+## Provider Selection Guide
+
+| Provider | Best For | NFT API | Token API | Webhooks | Free Tier |
+|----------|----------|---------|-----------|----------|-----------|
+| **Alchemy** | Full-stack DApps | ✅ Rich | ✅ Enhanced | ✅ Notify | 300M CU/mo |
+| **Moralis** | Rapid prototyping | ✅ Rich | ✅ + Prices | ✅ Streams | 40K CU/day |
+| **Infura** | MetaMask ecosystem | ❌ Basic | ❌ Basic | ❌ | 100K req/day |
+| **QuickNode** | High-perf infra | ✅ Addon | ✅ Addon | ✅ Streams | 10M credits |
+
+### When to Use What
+- **Need NFT/Token data fast?** → Alchemy or Moralis
+- **Need real-time webhooks?** → Moralis Streams or Alchemy Notify
+- **Need MetaMask integration?** → Infura
+- **Need custom streaming + functions?** → QuickNode
+- **Need DeFi positions?** → Moralis