commit 47f6f2de7ba11a46001d6c076f8de363b4a30e36 Author: defiQUG Date: Mon Feb 9 21:51:30 2026 -0800 Initial commit: add .gitignore and README diff --git a/.cursorignore b/.cursorignore new file mode 100644 index 0000000..24df757 --- /dev/null +++ b/.cursorignore @@ -0,0 +1,2 @@ +# Add directories or file patterns to ignore during indexing (e.g. foo/ or *.csv) +.env.example \ No newline at end of file diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..33ad82f --- /dev/null +++ b/.env.example @@ -0,0 +1,16 @@ +# RPC Endpoints Mainnets +MAINNET_RPC_URL=https://mainnet.infura.io/v3/ +ARBITRUM_RPC_URL=https://arb1.arbitrum.io/rpc +BASE_RPC_URL=https://base-mainnet.infura.io/v3/ +OP_RPC_URL=https://optimism-mainnet.infura.io/v3/ +POLYGON_RPC_URL=https://polygon-mainnet.infura.io/v3/ + +# RPC Endpoints Testnets +ETHEREUM_SEPOLIA_RPC_URL=https://sepolia.infura.io/v3/ +BASE_SEPOLIA_RPC_URL=https://base-sepolia.infura.io/v3/ +OP_SEPOLIA_RPC_URL=https://optimism-sepolia.infura.io/v3/ +POLYGON_AMOY_RPC_URL=https://polygon-amoy.infura.io/v3/ + +# METAMASK WALLET +PUBLIC_ADDRESS= +PRIVATE_KEY= diff --git a/.eslintrc.json b/.eslintrc.json new file mode 100644 index 0000000..b03318c --- /dev/null +++ b/.eslintrc.json @@ -0,0 +1,22 @@ +{ + "parser": "@typescript-eslint/parser", + "extends": [ + "eslint:recommended", + "plugin:@typescript-eslint/recommended" + ], + "plugins": ["@typescript-eslint"], + "parserOptions": { + "ecmaVersion": 2022, + "sourceType": "module" + }, + "env": { + "node": true, + "es2022": true + }, + "rules": { + "@typescript-eslint/no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }], + "@typescript-eslint/no-explicit-any": "warn", + "no-console": "off" + } +} + diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..806a55f --- /dev/null +++ b/.gitignore @@ -0,0 +1,38 @@ +# Dependencies +node_modules/ +lib/ + +# Build outputs +dist/ +out/ +*.sol.js + +# Environment variables +.env +.env.local + +# IDE +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# OS +.DS_Store +Thumbs.db + +# Logs +*.log + +# Package manager lock files (keep pnpm-lock.yaml, ignore others) +package-lock.json +yarn.lock + +# Foundry +cache/ +broadcast/ + +# Test coverage +coverage/ + diff --git a/.npmrc b/.npmrc new file mode 100644 index 0000000..96e1dec --- /dev/null +++ b/.npmrc @@ -0,0 +1,5 @@ +# pnpm configuration +auto-install-peers=true +strict-peer-dependencies=false +save-exact=false + diff --git a/.prettierrc.json b/.prettierrc.json new file mode 100644 index 0000000..5ac2d1d --- /dev/null +++ b/.prettierrc.json @@ -0,0 +1,9 @@ +{ + "semi": true, + "trailingComma": "es5", + "singleQuote": true, + "printWidth": 100, + "tabWidth": 2, + "useTabs": false +} + diff --git a/README.md b/README.md new file mode 100644 index 0000000..1188203 --- /dev/null +++ b/README.md @@ -0,0 +1,339 @@ +# ๐Ÿš€ DeFi Starter Kit + +> A comprehensive TypeScript + Foundry starter kit for building on top of core DeFi protocols including Aave v3, Uniswap v3/v4, Protocolink, Compound III, Balancer v3, and Curve crvUSD. + +[![TypeScript](https://img.shields.io/badge/TypeScript-5.5-blue.svg)](https://www.typescriptlang.org/) +[![Foundry](https://img.shields.io/badge/Foundry-Latest-orange.svg)](https://getfoundry.sh/) +[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE) + +--- + +## โœจ Features + +| Feature | Description | Status | +|---------|-------------|--------| +| ๐ŸŒ **Multi-chain** | Ethereum, Base, Arbitrum, Optimism, Polygon | โœ… | +| ๐Ÿ”’ **Type-safe** | Full TypeScript types for all addresses and configurations | โœ… | +| ๐Ÿญ **Production-ready** | All examples include error handling, slippage protection | โœ… | +| ๐Ÿงช **Comprehensive testing** | Foundry fork tests for all major integrations | โœ… | +| ๐Ÿ› ๏ธ **Modern tooling** | viem, Foundry, Protocolink SDK | โœ… | +| ๐Ÿ” **Security focus** | Security checklists, best practices documented | โœ… | +| ๐Ÿ”Œ **Extensible** | Easy to add new chains, protocols, examples | โœ… | + +--- + +## ๐Ÿš€ Quick Start + +### ๐Ÿ“ฆ Installation + +```bash +# Install dependencies +pnpm install + +# Install Foundry (if not already installed) +curl -L https://foundry.paradigm.xyz | bash +foundryup +``` + +### โš™๏ธ Environment Setup + +Before running tests, set up your environment variables: + +```bash +# 1. Copy example environment file +cp .env.example .env + +# 2. Edit .env and add your RPC URLs +# MAINNET_RPC_URL=https://mainnet.infura.io/v3/YOUR_KEY + +# 3. Verify setup +pnpm run check:env +pnpm run verify:setup +``` + +> ๐Ÿ“– See [docs/ENV_SETUP.md](./docs/ENV_SETUP.md) for detailed setup instructions. + +--- + +## ๐Ÿงช DeFi Strategy Testing + +The project includes a comprehensive DeFi strategy testing CLI for testing strategies against local mainnet forks. + +### ๐ŸŽฏ Quick Commands + +```bash +# Run a strategy scenario +pnpm run strat run scenarios/aave/leveraged-long.yml + +# Run with custom network and reports +pnpm run strat run scenarios/aave/leveraged-long.yml \ + --network mainnet \ + --report out/run.json \ + --html out/report.html + +# Fuzz test a scenario +pnpm run strat fuzz scenarios/aave/leveraged-long.yml --iters 100 --seed 42 + +# List available failure injections +pnpm run strat failures + +# Compare two runs +pnpm run strat compare out/run1.json out/run2.json + +# Test script with real fork +export MAINNET_RPC_URL=https://mainnet.infura.io/v3/YOUR_KEY +pnpm run strat:test +``` + +### โœจ Strategy Testing Features + +- โœ… **Aave v3 adapter** - Supply, borrow, repay, withdraw, flash loans +- โœ… **Uniswap v3 adapter** - Swaps with slippage protection +- โœ… **Compound v3 adapter** - Supply, borrow, repay +- โœ… **Failure injection** - Oracle shocks, time travel, liquidity shocks +- โœ… **Fuzzing** - Parameterized inputs for edge case discovery +- โœ… **Automatic token funding** - Via whale impersonation +- โœ… **Multiple reports** - HTML, JSON, and JUnit XML + +> ๐Ÿ“– See [docs/STRATEGY_TESTING.md](./docs/STRATEGY_TESTING.md) for comprehensive documentation and [scenarios/README.md](./scenarios/README.md) for example scenarios. + +--- + +## ๐ŸŽ“ Examples + +### ๐Ÿ“ Run Examples + +```bash +# Aave supply and borrow +tsx examples/ts/aave-supply-borrow.ts + +# Uniswap v3 swap +tsx examples/ts/uniswap-v3-swap.ts + +# Protocolink multi-protocol composition +tsx examples/ts/protocolink-compose.ts + +# Compound III supply and borrow +tsx examples/ts/compound3-supply-borrow.ts +``` + +### ๐Ÿงช Run Tests + +```bash +# Run Foundry tests +forge test + +# Run tests with fork +forge test --fork-url $MAINNET_RPC_URL +``` + +### ๐Ÿ–ฅ๏ธ Use CLI + +```bash +# Build a transaction plan +pnpm run cli build-plan -- --chain 1 + +# Get a quote +pnpm run cli quote -- --protocol uniswapv3 --type swap --token-in USDC --token-out WETH --amount 1000 + +# Execute a plan +pnpm run cli execute -- --chain 1 --plan plan.json +``` + +--- + +## ๐Ÿ“ Project Structure + +``` +. +โ”œโ”€โ”€ config/ +โ”‚ โ”œโ”€โ”€ chains/ # ๐Ÿ”— Chain-specific configurations +โ”‚ โ”‚ โ”œโ”€โ”€ mainnet.ts +โ”‚ โ”‚ โ”œโ”€โ”€ base.ts +โ”‚ โ”‚ โ””โ”€โ”€ ... +โ”‚ โ””โ”€โ”€ addresses.ts # ๐Ÿ“ Address exports +โ”œโ”€โ”€ contracts/ +โ”‚ โ”œโ”€โ”€ examples/ # ๐Ÿ“œ Solidity example contracts +โ”‚ โ””โ”€โ”€ interfaces/ # ๐Ÿ”Œ Contract interfaces +โ”œโ”€โ”€ src/ +โ”‚ โ”œโ”€โ”€ cli/ # ๐Ÿ–ฅ๏ธ CLI implementation +โ”‚ โ”œโ”€โ”€ strat/ # ๐Ÿงช Strategy testing framework +โ”‚ โ””โ”€โ”€ utils/ # ๐Ÿ› ๏ธ Utility functions +โ”œโ”€โ”€ examples/ +โ”‚ โ”œโ”€โ”€ ts/ # ๐Ÿ“˜ TypeScript examples +โ”‚ โ””โ”€โ”€ subgraphs/ # ๐Ÿ” Subgraph queries +โ”œโ”€โ”€ test/ # ๐Ÿงช Foundry tests +โ””โ”€โ”€ docs/ # ๐Ÿ“š Documentation +``` + +--- + +## ๐Ÿ”Œ Supported Protocols + +### ๐Ÿฆ Aave v3 +- โœ… Supply and borrow +- โœ… Flash loans (single and multi-asset) +- โœ… Pool discovery via PoolAddressesProvider + +### ๐Ÿ”„ Uniswap v3/v4 +- โœ… Token swaps +- โœ… TWAP oracles +- โœ… Permit2 integration +- โœ… Universal Router + +### ๐Ÿ”— Protocolink +- โœ… Multi-protocol composition +- โœ… Batch transactions +- โœ… Permit2 integration + +### ๐Ÿ›๏ธ Compound III +- โœ… Supply collateral +- โœ… Borrow base asset + +### ๐Ÿ”ท Additional Protocols +- โš™๏ธ Balancer v3 +- โš™๏ธ Curve crvUSD + +--- + +## ๐Ÿ“˜ Code Examples + +### ๐Ÿฆ Aave v3: Supply and Borrow + +```typescript +import { createWalletRpcClient } from './src/utils/chain-config.js'; +import { getAavePoolAddress } from './src/utils/addresses.js'; + +const walletClient = createWalletRpcClient(1, privateKey); +const poolAddress = getAavePoolAddress(1); + +// Supply collateral +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'supply', + args: [asset, amount, account, 0], +}); + +// Borrow +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'borrow', + args: [debtAsset, borrowAmount, 2, 0, account], +}); +``` + +### ๐Ÿ”„ Uniswap v3: Swap + +```typescript +import { getUniswapSwapRouter02 } from './src/utils/addresses.js'; + +const routerAddress = getUniswapSwapRouter02(1); + +await walletClient.writeContract({ + address: routerAddress, + abi: SWAP_ROUTER_ABI, + functionName: 'exactInputSingle', + args: [swapParams], +}); +``` + +### ๐Ÿ”— Protocolink: Multi-Protocol Composition + +```typescript +import * as api from '@protocolink/api'; + +// Build swap logic +const swapQuotation = await api.protocols.uniswapv3.getSwapTokenQuotation(chainId, { + input: { token: USDC, amount: '1000' }, + tokenOut: WBTC, + slippage: 100, +}); +const swapLogic = api.protocols.uniswapv3.newSwapTokenLogic(swapQuotation); + +// Build supply logic +const supplyQuotation = await api.protocols.aavev3.getSupplyQuotation(chainId, { + input: swapQuotation.output, +}); +const supplyLogic = api.protocols.aavev3.newSupplyLogic(supplyQuotation); + +// Execute +const routerData = await api.router.getRouterData(chainId, { + account, + logics: [swapLogic, supplyLogic], +}); +``` + +--- + +## ๐Ÿ“š Documentation + +| Document | Description | +|----------|-------------| +| ๐Ÿ“– [Integration Guide](./docs/INTEGRATION_GUIDE.md) | Step-by-step integration guide | +| ๐Ÿ” [Security Best Practices](./docs/SECURITY.md) | Security checklist and best practices | +| ๐Ÿ”— [Chain Configuration](./docs/CHAIN_CONFIG.md) | How to add new chains | +| ๐Ÿงช [Strategy Testing](./docs/STRATEGY_TESTING.md) | Comprehensive strategy testing guide | +| โš™๏ธ [Environment Setup](./docs/ENV_SETUP.md) | Environment variable configuration | + +--- + +## ๐ŸŒ Supported Chains + +| Chain | Chain ID | Status | +|-------|----------|--------| +| Ethereum Mainnet | 1 | โœ… | +| Base | 8453 | โœ… | +| Arbitrum One | 42161 | โœ… | +| Optimism | 10 | โœ… | +| Polygon | 137 | โœ… | + +--- + +## ๐Ÿ” Security + +> โš ๏ธ **IMPORTANT**: This is a starter kit for learning and development. Before deploying to production: + +1. โœ… Review all security best practices in [docs/SECURITY.md](./docs/SECURITY.md) +2. โœ… Get professional security audits +3. โœ… Test thoroughly on testnets +4. โœ… Start with small amounts on mainnet +5. โœ… Understand the risks of each protocol + +--- + +## ๐Ÿค Contributing + +Contributions are welcome! Please: + +1. ๐Ÿด Fork the repository +2. ๐ŸŒฟ Create a feature branch +3. โœ๏ธ Make your changes +4. ๐Ÿงช Add tests +5. ๐Ÿ“ค Submit a pull request + +--- + +## ๐Ÿ“„ License + +MIT + +--- + +## ๐Ÿ”— Resources + +| Resource | Link | +|----------|------| +| Aave Documentation | [docs.aave.com](https://docs.aave.com/) | +| Uniswap Documentation | [docs.uniswap.org](https://docs.uniswap.org/) | +| Protocolink Documentation | [docs.protocolink.com](https://docs.protocolink.com/) | +| Compound III Documentation | [docs.compound.finance](https://docs.compound.finance/) | +| Viem Documentation | [viem.sh](https://viem.sh/) | +| Foundry Documentation | [book.getfoundry.sh](https://book.getfoundry.sh/) | + +--- + +## โš ๏ธ Disclaimer + +This software is provided "as is" without warranty of any kind. Use at your own risk. The authors are not responsible for any losses incurred from using this software. diff --git a/aaxe-cli.sh b/aaxe-cli.sh new file mode 100755 index 0000000..a1a91a2 --- /dev/null +++ b/aaxe-cli.sh @@ -0,0 +1,258 @@ +#!/usr/bin/env bash + +set -euo pipefail + +# ============================================ +# AAXE / Furuombe Bash CLI +# -------------------------------------------- +# Builds and (optionally) submits a Furuombe plan +# matching the user's block sequence. +# +# USAGE: +# ./aaxe-cli.sh build-plan > plan.json +# ./aaxe-cli.sh show-plan +# ./aaxe-cli.sh send --rpc https://mainnet.infura.io/v3/KEY --router 0xRouterAddr +# +# ENV: +# PRIVATE_KEY # hex private key (no 0x), ONLY required for `send` +# +# NOTES: +# - The router ABI here assumes: function execute(bytes plan) +# where `plan` is arbitrary bytes (we pass JSON bytes). +# If your router expects a different ABI/format, adjust SEND section. +# ============================================ + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +PLAN_FILE="${PLAN_FILE:-$SCRIPT_DIR/plan.json}" + +# ---------- Defaults (edit to your environment) ---------- +CHAIN_ID_DEFAULT="${CHAIN_ID_DEFAULT:-1}" +RPC_URL_DEFAULT="${RPC_URL_DEFAULT:-https://mainnet.infura.io/v3/YOUR_KEY}" +AAXE_ROUTER_DEFAULT="${AAXE_ROUTER_DEFAULT:-0x0000000000000000000000000000000000000000}" # <- PUT REAL ROUTER +# Common tokens (placeholders โ€” replace with real addresses for your chain) +ADDR_USDC="${ADDR_USDC:-0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48}" # Mainnet USDC +ADDR_USDT="${ADDR_USDT:-0xdAC17F958D2ee523a2206206994597C13D831ec7}" # Mainnet USDT +# Aave V3 (example mainnet Pool; verify!) +ADDR_AAVE_V3_POOL="${ADDR_AAVE_V3_POOL:-0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2}" +# Paraswap v5 Augustus (placeholder โ€” replace!) +ADDR_PARASWAP_V5="${ADDR_PARASWAP_V5:-0xDEF1ABE32c034e558Cdd535791643C58a13aCC10}" +# aToken placeholder (aEthUSDC-like) โ€” replace with the correct aToken for your network +ADDR_aEthUSDC="${ADDR_aEthUSDC:-0x0000000000000000000000000000000000000001}" + +# ---------- Helpers ---------- +die() { echo "Error: $*" >&2; exit 1; } + +require_jq() { + command -v jq >/dev/null 2>&1 || die "jq is required. Install: https://stedolan.github.io/jq/" +} + +require_bc() { + command -v bc >/dev/null 2>&1 || die "bc is required. Install: sudo apt-get install bc (or your package manager)" +} + +require_cast() { + command -v cast >/dev/null 2>&1 || die "Foundry's 'cast' is required for sending. Install: https://book.getfoundry.sh/" +} + +to_wei_like() { + # Convert decimal string to 6-decimal fixed (USDC/USDT style) integer string + # e.g., "2001.033032" -> "2001033032" + local amount="$1" + # Use bc to multiply by 1000000 and truncate decimals (scale=0 truncates) + echo "scale=0; ($amount * 1000000) / 1" | bc | tr -d '\n' +} + +# ---------- Plan builder ---------- +build_plan() { + require_jq + require_bc + + # Amounts as user provided (USDC/USDT both 6 decimals typical) + USDC_4600=$(to_wei_like "4600") + USDT_2500=$(to_wei_like "2500") + USDT_2000_9=$(to_wei_like "2000.9") + USDC_2001_033032=$(to_wei_like "2001.033032") + USDC_1000=$(to_wei_like "1000") + USDT_2300=$(to_wei_like "2300") + USDT_2100_9=$(to_wei_like "2100.9") + USDC_2100_628264=$(to_wei_like "2100.628264") + USDC_4500=$(to_wei_like "4500") + # Final flashloan repay is shown as -4600, we encode +4600 as repayment + USDC_4600_POS=$(to_wei_like "4600") + + # The plan is a pure JSON array of steps, each step carries: + # - blockType / protocol / display / tokens / amounts / addresses + # - You can extend with slippage, deadline, referral, etc. + jq -n --arg usdc "$ADDR_USDC" \ + --arg usdt "$ADDR_USDT" \ + --arg aave "$ADDR_AAVE_V3_POOL" \ + --arg pswap "$ADDR_PARASWAP_V5" \ + --arg aethusdc "$ADDR_aEthUSDC" \ + --argjson amt_usdc_4600 "$USDC_4600" \ + --argjson amt_usdt_2500 "$USDT_2500" \ + --argjson amt_usdt_2000_9 "$USDT_2000_9" \ + --argjson amt_usdc_2001_033032 "$USDC_2001_033032" \ + --argjson amt_usdc_1000 "$USDC_1000" \ + --argjson amt_usdt_2300 "$USDT_2300" \ + --argjson amt_usdt_2100_9 "$USDT_2100_9" \ + --argjson amt_usdc_2100_628264 "$USDC_2100_628264" \ + --argjson amt_usdc_4500 "$USDC_4500" \ + --argjson amt_usdc_4600 "$USDC_4600_POS" \ + '[ + { + blockType:"Flashloan", + protocol:"utility", + display:"Utility flashloan", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_4600} + }, + { + blockType:"Supply", + protocol:"aavev3", + display:"Aave V3", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_4600}, + tokenOut:{symbol:"aEthUSDC", address:$aethusdc, amount:$amt_usdc_4600} + }, + { + blockType:"Borrow", + protocol:"aavev3", + display:"Aave V3", + tokenOut:{symbol:"USDT", address:$usdt, amount:$amt_usdt_2500} + }, + { + blockType:"Swap", + protocol:"paraswapv5", + display:"Paraswap V5", + tokenIn:{symbol:"USDT", address:$usdt, amount:$amt_usdt_2000_9}, + tokenOut:{symbol:"USDC", address:$usdc, minAmount:$amt_usdc_2001_033032} + }, + { + blockType:"Repay", + protocol:"aavev3", + display:"Aave V3", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_1000} + }, + { + blockType:"Supply", + protocol:"aavev3", + display:"Aave V3", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_1000}, + tokenOut:{symbol:"aEthUSDC", address:$aethusdc, amount:$amt_usdc_1000} + }, + { + blockType:"Borrow", + protocol:"aavev3", + display:"Aave V3", + tokenOut:{symbol:"USDT", address:$usdt, amount:$amt_usdt_2300} + }, + { + blockType:"Swap", + protocol:"paraswapv5", + display:"Paraswap V5", + tokenIn:{symbol:"USDT", address:$usdt, amount:$amt_usdt_2100_9}, + tokenOut:{symbol:"USDC", address:$usdc, minAmount:$amt_usdc_2100_628264} + }, + { + blockType:"Repay", + protocol:"aavev3", + display:"Aave V3", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_1000} + }, + { + blockType:"Supply", + protocol:"aavev3", + display:"Aave V3", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_1000}, + tokenOut:{symbol:"aEthUSDC", address:$aethusdc, amount:$amt_usdc_1000} + }, + { + blockType:"Withdraw", + protocol:"aavev3", + display:"Aave V3", + tokenIn:{symbol:"aEthUSDC", address:$aethusdc, amount:$amt_usdc_4500}, + tokenOut:{symbol:"USDC", address:$usdc, amount:$amt_usdc_4500} + }, + { + blockType:"FlashloanRepay", + protocol:"utility", + display:"Utility flashloan", + tokenIn:{symbol:"USDC", address:$usdc, amount:$amt_usdc_4600} + } + ]' | jq '.' > "$PLAN_FILE" + + echo "Plan written to $PLAN_FILE" >&2 + cat "$PLAN_FILE" +} + +show_plan() { + require_jq + [[ -f "$PLAN_FILE" ]] || die "No plan file at $PLAN_FILE. Run: ./aaxe-cli.sh build-plan" + + jq '.' "$PLAN_FILE" +} + +send_plan() { + require_cast + require_jq + + local RPC_URL="$RPC_URL_DEFAULT" + local ROUTER="$AAXE_ROUTER_DEFAULT" + local CHAIN_ID="$CHAIN_ID_DEFAULT" + + while [[ $# -gt 0 ]]; do + case "$1" in + --rpc) RPC_URL="$2"; shift 2;; + --router) ROUTER="$2"; shift 2;; + --chain-id) CHAIN_ID="$2"; shift 2;; + *) die "Unknown arg: $1";; + esac + done + + [[ -n "${PRIVATE_KEY:-}" ]] || die "PRIVATE_KEY not set" + [[ -f "$PLAN_FILE" ]] || die "No plan file at $PLAN_FILE. Run build-plan first." + + # Encode plan.json as bytes (hex) for execute(bytes) + PLAN_JSON_MINIFIED="$(jq -c '.' "$PLAN_FILE")" + PLAN_HEX="0x$(printf '%s' "$PLAN_JSON_MINIFIED" | xxd -p -c 100000 | tr -d '\n')" + + echo "Sending to router: $ROUTER" + echo "RPC: $RPC_URL" + echo "Chain ID: $CHAIN_ID" + echo "Method: execute(bytes)" + echo "Data bytes length: ${#PLAN_HEX}" + + # NOTE: Adjust function signature if your router differs. + cast send \ + --rpc-url "$RPC_URL" \ + --private-key "$PRIVATE_KEY" \ + --legacy \ + "$ROUTER" \ + "execute(bytes)" "$PLAN_HEX" +} + +case "${1:-}" in + build-plan) build_plan ;; + show-plan) show_plan ;; + send) shift; send_plan "$@" ;; + ""|-h|--help) + cat < plan.json + ./aaxe-cli.sh show-plan + PRIVATE_KEY=... ./aaxe-cli.sh send --rpc $RPC_URL_DEFAULT --router $AAXE_ROUTER_DEFAULT + +Edit addresses at the top of the script to match your network. +EOF + ;; + *) + die "Unknown command: ${1:-}. Try --help" + ;; +esac + diff --git a/config/addresses.ts b/config/addresses.ts new file mode 100644 index 0000000..0dc4ee8 --- /dev/null +++ b/config/addresses.ts @@ -0,0 +1,30 @@ +import type { ChainConfig } from './types.js'; +import { mainnet } from './chains/mainnet.js'; +import { base } from './chains/base.js'; +import { arbitrum } from './chains/arbitrum.js'; +import { optimism } from './chains/optimism.js'; +import { polygon } from './chains/polygon.js'; + +export const chainConfigs: Record = { + 1: mainnet, + 8453: base, + 42161: arbitrum, + 10: optimism, + 137: polygon, +}; + +export function getChainConfig(chainId: number): ChainConfig { + const config = chainConfigs[chainId]; + if (!config) { + throw new Error(`Unsupported chain ID: ${chainId}`); + } + return config; +} + +export function getSupportedChainIds(): number[] { + return Object.keys(chainConfigs).map(Number); +} + +// Re-export chain configs for convenience +export { mainnet, base, arbitrum, optimism, polygon }; + diff --git a/config/chains/arbitrum.ts b/config/chains/arbitrum.ts new file mode 100644 index 0000000..192fc27 --- /dev/null +++ b/config/chains/arbitrum.ts @@ -0,0 +1,41 @@ +import type { ChainConfig } from '../types.js'; + +export const arbitrum: ChainConfig = { + chainId: 42161, + name: 'Arbitrum One', + rpcUrl: process.env.ARBITRUM_RPC_URL || 'https://arb1.arbitrum.io/rpc', + + // Aave v3 + aave: { + poolAddressesProvider: '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb', + pool: '0x794a61358D6845594F94dc1DB02A252b5b4814aD', + }, + + // Uniswap + uniswap: { + swapRouter02: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45', + universalRouter: '0x4C60051384bd2d3C01bfc845Cf5F4b44bcbE9de5', + permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3', + quoterV2: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e', + }, + + // Protocolink + protocolink: { + router: '0xf7b10d603907658F690Da534E9b7dbC4dAB3E2D6', + }, + + // Compound III + compound3: { + cometUsdc: '0xA5EDBDD9646f8dFF606d7448e414884C7d905dCA', + }, + + // Common Tokens + tokens: { + WETH: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1', + USDC: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', + USDT: '0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9', + DAI: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1', + WBTC: '0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f', + }, +}; + diff --git a/config/chains/base.ts b/config/chains/base.ts new file mode 100644 index 0000000..f7f5153 --- /dev/null +++ b/config/chains/base.ts @@ -0,0 +1,41 @@ +import type { ChainConfig } from '../types.js'; + +export const base: ChainConfig = { + chainId: 8453, + name: 'Base', + rpcUrl: process.env.BASE_RPC_URL || 'https://mainnet.base.org', + + // Aave v3 + aave: { + poolAddressesProvider: '0xe20fCBdBfFC4Dd138cE8b2E6FBb6CB49777ad64D', + pool: '0xA238Dd80C259a72e81d7e4664a9801593F98d1c5', + }, + + // Uniswap + uniswap: { + swapRouter02: '0x2626664c2603336E57B271c5C0b26F421741e481', + universalRouter: '0x6fF5cCb0bE79776740a0bFc8D0a17D3eC5c95d27', + permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3', + quoterV2: '0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a', + }, + + // Protocolink + protocolink: { + router: '0xf7b10d603907658F690Da534E9b7dbC4dAB3E2D6', + }, + + // Compound III + compound3: { + cometUsdc: '0xb125E6687d4313864e53df431d5425969c15Eb2F', + }, + + // Common Tokens + tokens: { + WETH: '0x4200000000000000000000000000000000000006', + USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', + USDT: '0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2', + DAI: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb', + WBTC: '0x', + }, +}; + diff --git a/config/chains/mainnet.ts b/config/chains/mainnet.ts new file mode 100644 index 0000000..397f6ae --- /dev/null +++ b/config/chains/mainnet.ts @@ -0,0 +1,41 @@ +import type { ChainConfig } from '../types.js'; + +export const mainnet: ChainConfig = { + chainId: 1, + name: 'Ethereum Mainnet', + rpcUrl: process.env.MAINNET_RPC_URL || 'https://mainnet.infura.io/v3/YOUR_KEY', + + // Aave v3 + aave: { + poolAddressesProvider: '0x2f39d218133AFaB8F2B819B1066c7E434Ad94E9e', + pool: '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2', + }, + + // Uniswap + uniswap: { + swapRouter02: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45', + universalRouter: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD', + permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3', + quoterV2: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e', + }, + + // Protocolink + protocolink: { + router: '0xf7b10d603907658F690Da534E9b7dbC4dAB3E2D6', + }, + + // Compound III + compound3: { + cometUsdc: '0xc3d688B66703497DAA19211EEdff47f25384cdc3', + }, + + // Common Tokens + tokens: { + WETH: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', + USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', + USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7', + DAI: '0x6B175474E89094C44Da98b954EedeAC495271d0F', + WBTC: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599', + }, +}; + diff --git a/config/chains/optimism.ts b/config/chains/optimism.ts new file mode 100644 index 0000000..c13e32f --- /dev/null +++ b/config/chains/optimism.ts @@ -0,0 +1,41 @@ +import type { ChainConfig } from '../types.js'; + +export const optimism: ChainConfig = { + chainId: 10, + name: 'Optimism', + rpcUrl: process.env.OPTIMISM_RPC_URL || 'https://mainnet.optimism.io', + + // Aave v3 + aave: { + poolAddressesProvider: '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb', + pool: '0x794a61358D6845594F94dc1DB02A252b5b4814aD', + }, + + // Uniswap + uniswap: { + swapRouter02: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45', + universalRouter: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD', + permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3', + quoterV2: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e', + }, + + // Protocolink + protocolink: { + router: '0xf7b10d603907658F690Da534E9b7dbC4dAB3E2D6', + }, + + // Compound III + compound3: { + cometUsdc: '0x', + }, + + // Common Tokens + tokens: { + WETH: '0x4200000000000000000000000000000000000006', + USDC: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85', + USDT: '0x94b008aA00579c1307B0EF2c499aD98a8ce58e58', + DAI: '0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1', + WBTC: '0x68f180fcCe6836688e9084f035309E29Bf0A2095', + }, +}; + diff --git a/config/chains/polygon.ts b/config/chains/polygon.ts new file mode 100644 index 0000000..d8c5b4d --- /dev/null +++ b/config/chains/polygon.ts @@ -0,0 +1,41 @@ +import type { ChainConfig } from '../types.js'; + +export const polygon: ChainConfig = { + chainId: 137, + name: 'Polygon', + rpcUrl: process.env.POLYGON_RPC_URL || 'https://polygon-rpc.com', + + // Aave v3 + aave: { + poolAddressesProvider: '0xa97684ead0e402dC232d5A977953DF7ECBaB3CDb', + pool: '0x794a61358D6845594F94dc1DB02A252b5b4814aD', + }, + + // Uniswap + uniswap: { + swapRouter02: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45', + universalRouter: '0x4C60051384bd2d3C01bfc845Cf5F4b44bcbE9de5', + permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3', + quoterV2: '0x61fFE014bA17989E743c5F6cB21bF9697530B21e', + }, + + // Protocolink + protocolink: { + router: '0xf7b10d603907658F690Da534E9b7dbC4dAB3E2D6', + }, + + // Compound III + compound3: { + cometUsdc: '0xF25212E676D1F7F89Cd72fFEe66158f541246445', + }, + + // Common Tokens + tokens: { + WETH: '0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619', + USDC: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174', + USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F', + DAI: '0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063', + WBTC: '0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6', + }, +}; + diff --git a/config/types.ts b/config/types.ts new file mode 100644 index 0000000..b957d52 --- /dev/null +++ b/config/types.ts @@ -0,0 +1,37 @@ +export interface ChainConfig { + chainId: number; + name: string; + rpcUrl: string; + aave: { + poolAddressesProvider: `0x${string}`; + pool: `0x${string}`; + }; + uniswap: { + swapRouter02: `0x${string}`; + universalRouter: `0x${string}`; + permit2: `0x${string}`; + quoterV2: `0x${string}`; + }; + protocolink: { + router: `0x${string}`; + }; + compound3: { + cometUsdc: `0x${string}`; + }; + tokens: { + WETH: `0x${string}`; + USDC: `0x${string}`; + USDT: `0x${string}`; + DAI: `0x${string}`; + WBTC: `0x${string}`; + }; +} + +export interface TokenMetadata { + chainId: number; + address: `0x${string}`; + decimals: number; + symbol: string; + name: string; +} + diff --git a/contracts/examples/AaveFlashLoanReceiver.sol b/contracts/examples/AaveFlashLoanReceiver.sol new file mode 100644 index 0000000..18b9914 --- /dev/null +++ b/contracts/examples/AaveFlashLoanReceiver.sol @@ -0,0 +1,110 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "../interfaces/IAavePool.sol"; +import "../interfaces/IERC20.sol"; + +/** + * @title AaveFlashLoanReceiver + * @notice Example flash loan receiver for Aave v3 + * @dev This contract receives flash loans and must repay them in executeOperation + */ +contract AaveFlashLoanReceiver is IFlashLoanReceiver { + IAavePool public immutable pool; + address public owner; + + modifier onlyOwner() { + require(msg.sender == owner, "Not owner"); + _; + } + + constructor(address pool_) { + pool = IAavePool(pool_); + owner = msg.sender; + } + + /** + * @notice Execute flash loan operation + * @param asset The flash loaned asset + * @param amount The flash loaned amount + * @param premium The premium to repay + * @param initiator The initiator of the flash loan + * @param params Additional parameters (can encode arbitrage data, etc.) + * @return true if successful + */ + function executeOperation( + address asset, + uint256 amount, + uint256 premium, + address initiator, + bytes calldata params + ) external override returns (bool) { + // Verify this was called by the pool + require(msg.sender == address(pool), "Invalid caller"); + require(initiator == address(this), "Invalid initiator"); + + // Your logic here (e.g., arbitrage, liquidation, etc.) + // Example: swap on DEX, arbitrage, etc. + + // Calculate total amount to repay (loan + premium) + uint256 amountOwed = amount + premium; + + // Approve pool to take repayment + IERC20(asset).approve(address(pool), amountOwed); + + // Return true to indicate successful operation + return true; + } + + /** + * @notice Execute flash loan (single asset) + * @param asset The asset to flash loan + * @param amount The amount to flash loan + * @param params Additional parameters for executeOperation + */ + function flashLoanSimple( + address asset, + uint256 amount, + bytes calldata params + ) external onlyOwner { + pool.flashLoanSimple( + address(this), + asset, + amount, + params, + 0 // referral code + ); + } + + /** + * @notice Execute flash loan (multiple assets) + * @param assets The assets to flash loan + * @param amounts The amounts to flash loan + * @param modes The flash loan modes (0 = no debt, 2 = variable debt) + * @param params Additional parameters for executeOperation + */ + function flashLoan( + address[] calldata assets, + uint256[] calldata amounts, + uint256[] calldata modes, + bytes calldata params + ) external onlyOwner { + pool.flashLoan( + address(this), + assets, + amounts, + modes, + address(this), + params, + 0 // referral code + ); + } + + /** + * @notice Withdraw tokens (emergency) + */ + function withdrawToken(address token, uint256 amount) external onlyOwner { + IERC20(token).transfer(owner, amount); + } +} + diff --git a/contracts/examples/AaveSupplyBorrow.sol b/contracts/examples/AaveSupplyBorrow.sol new file mode 100644 index 0000000..8cca9c2 --- /dev/null +++ b/contracts/examples/AaveSupplyBorrow.sol @@ -0,0 +1,79 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "../interfaces/IAavePool.sol"; +import "../interfaces/IERC20.sol"; + +/** + * @title AaveSupplyBorrow + * @notice Example contract for supplying collateral and borrowing on Aave v3 + */ +contract AaveSupplyBorrow { + IAavePool public immutable pool; + + constructor(address pool_) { + pool = IAavePool(pool_); + } + + /** + * @notice Supply collateral, enable as collateral, and borrow + * @param asset The collateral asset to supply + * @param amount The amount of collateral to supply + * @param debtAsset The asset to borrow + * @param borrowAmount The amount to borrow + */ + function supplyAndBorrow( + address asset, + uint256 amount, + address debtAsset, + uint256 borrowAmount + ) external { + // Step 1: Transfer collateral from user + IERC20(asset).transferFrom(msg.sender, address(this), amount); + + // Step 2: Approve pool to take collateral + IERC20(asset).approve(address(pool), amount); + + // Step 3: Supply collateral + pool.supply(asset, amount, address(this), 0); + + // Step 4: Enable as collateral + pool.setUserUseReserveAsCollateral(asset, true); + + // Step 5: Borrow (variable rate = 2, stable rate is deprecated) + pool.borrow(debtAsset, borrowAmount, 2, 0, address(this)); + + // Step 6: Transfer borrowed tokens to user + IERC20(debtAsset).transfer(msg.sender, borrowAmount); + } + + /** + * @notice Repay debt and withdraw collateral + * @param debtAsset The debt asset to repay + * @param repayAmount The amount to repay + * @param collateralAsset The collateral asset to withdraw + * @param withdrawAmount The amount to withdraw + */ + function repayAndWithdraw( + address debtAsset, + uint256 repayAmount, + address collateralAsset, + uint256 withdrawAmount + ) external { + // Step 1: Transfer repayment tokens from user + IERC20(debtAsset).transferFrom(msg.sender, address(this), repayAmount); + + // Step 2: Approve pool to take repayment + IERC20(debtAsset).approve(address(pool), repayAmount); + + // Step 3: Repay debt (variable rate = 2) + pool.repay(debtAsset, repayAmount, 2, address(this)); + + // Step 4: Withdraw collateral + pool.withdraw(collateralAsset, withdrawAmount, address(this)); + + // Step 5: Transfer collateral to user + IERC20(collateralAsset).transfer(msg.sender, withdrawAmount); + } +} + diff --git a/contracts/examples/ProtocolinkExecutor.sol b/contracts/examples/ProtocolinkExecutor.sol new file mode 100644 index 0000000..cafdacd --- /dev/null +++ b/contracts/examples/ProtocolinkExecutor.sol @@ -0,0 +1,52 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "../interfaces/IERC20.sol"; + +interface IProtocolinkRouter { + function execute( + bytes calldata data + ) external payable; +} + +/** + * @title ProtocolinkExecutor + * @notice Example contract for executing Protocolink routes + * @dev This contract can execute Protocolink transaction plans + */ +contract ProtocolinkExecutor { + IProtocolinkRouter public immutable router; + + constructor(address router_) { + router = IProtocolinkRouter(router_); + } + + /** + * @notice Execute a Protocolink route + * @param data The encoded Protocolink route data + */ + function executeRoute(bytes calldata data) external payable { + router.execute{value: msg.value}(data); + } + + /** + * @notice Execute a Protocolink route with token approvals + * @param tokens The tokens to approve + * @param amounts The amounts to approve + * @param data The encoded Protocolink route data + */ + function executeRouteWithApprovals( + address[] calldata tokens, + uint256[] calldata amounts, + bytes calldata data + ) external payable { + // Approve tokens + for (uint256 i = 0; i < tokens.length; i++) { + IERC20(tokens[i]).approve(address(router), amounts[i]); + } + + // Execute route + router.execute{value: msg.value}(data); + } +} + diff --git a/contracts/examples/UniswapV3Swap.sol b/contracts/examples/UniswapV3Swap.sol new file mode 100644 index 0000000..14c78dd --- /dev/null +++ b/contracts/examples/UniswapV3Swap.sol @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "../interfaces/IERC20.sol"; + +interface ISwapRouter { + struct ExactInputSingleParams { + address tokenIn; + address tokenOut; + uint24 fee; + address recipient; + uint256 deadline; + uint256 amountIn; + uint256 amountOutMinimum; + uint160 sqrtPriceLimitX96; + } + + function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut); +} + +/** + * @title UniswapV3Swap + * @notice Example contract for swapping tokens on Uniswap v3 + */ +contract UniswapV3Swap { + ISwapRouter public immutable swapRouter; + + constructor(address swapRouter_) { + swapRouter = ISwapRouter(swapRouter_); + } + + /** + * @notice Swap tokens using Uniswap v3 + * @param tokenIn The input token + * @param tokenOut The output token + * @param fee The fee tier (100, 500, 3000, 10000) + * @param amountIn The input amount + * @param amountOutMinimum The minimum output amount (slippage protection) + * @param deadline The transaction deadline + */ + function swapExactInputSingle( + address tokenIn, + address tokenOut, + uint24 fee, + uint256 amountIn, + uint256 amountOutMinimum, + uint256 deadline + ) external returns (uint256 amountOut) { + // Transfer tokens from user + IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn); + + // Approve router + IERC20(tokenIn).approve(address(swapRouter), amountIn); + + // Execute swap + ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({ + tokenIn: tokenIn, + tokenOut: tokenOut, + fee: fee, + recipient: msg.sender, + deadline: deadline, + amountIn: amountIn, + amountOutMinimum: amountOutMinimum, + sqrtPriceLimitX96: 0 + }); + + amountOut = swapRouter.exactInputSingle(params); + } +} + diff --git a/contracts/interfaces/IAavePool.sol b/contracts/interfaces/IAavePool.sol new file mode 100644 index 0000000..97b453c --- /dev/null +++ b/contracts/interfaces/IAavePool.sol @@ -0,0 +1,66 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +interface IAavePool { + function supply( + address asset, + uint256 amount, + address onBehalfOf, + uint16 referralCode + ) external; + + function withdraw( + address asset, + uint256 amount, + address to + ) external returns (uint256); + + function borrow( + address asset, + uint256 amount, + uint256 interestRateMode, + uint16 referralCode, + address onBehalfOf + ) external; + + function repay( + address asset, + uint256 amount, + uint256 rateMode, + address onBehalfOf + ) external returns (uint256); + + function setUserUseReserveAsCollateral( + address asset, + bool useAsCollateral + ) external; + + function flashLoanSimple( + address receiverAddress, + address asset, + uint256 amount, + bytes calldata params, + uint16 referralCode + ) external; + + function flashLoan( + address receiverAddress, + address[] calldata assets, + uint256[] calldata amounts, + uint256[] calldata modes, + address onBehalfOf, + bytes calldata params, + uint16 referralCode + ) external; +} + +interface IFlashLoanReceiver { + function executeOperation( + address asset, + uint256 amount, + uint256 premium, + address initiator, + bytes calldata params + ) external returns (bool); +} + diff --git a/contracts/interfaces/IERC20.sol b/contracts/interfaces/IERC20.sol new file mode 100644 index 0000000..5f05d1a --- /dev/null +++ b/contracts/interfaces/IERC20.sol @@ -0,0 +1,17 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +interface IERC20 { + function totalSupply() external view returns (uint256); + + function balanceOf(address account) external view returns (uint256); + + function transfer(address to, uint256 amount) external returns (bool); + + function allowance(address owner, address spender) external view returns (uint256); + + function approve(address spender, uint256 amount) external returns (bool); + + function transferFrom(address from, address to, uint256 amount) external returns (bool); +} + diff --git a/docs/CHAIN_CONFIG.md b/docs/CHAIN_CONFIG.md new file mode 100644 index 0000000..4d7b0e3 --- /dev/null +++ b/docs/CHAIN_CONFIG.md @@ -0,0 +1,310 @@ +# ๐Ÿ”— Chain Configuration Guide + +How to add and configure new chains in the DeFi Starter Kit. + +--- + +## ๐Ÿ“‹ Overview + +This guide walks you through adding a new blockchain network to the DeFi Starter Kit. You'll need to configure: + +- ๐Ÿ”— RPC endpoints +- ๐Ÿ“ Protocol contract addresses +- ๐Ÿ’ฐ Token addresses +- ๐Ÿ”ง Viem chain configuration + +--- + +## ๐Ÿš€ Adding a New Chain + +### 1๏ธโƒฃ Create Chain Config File + +Create a new file in `config/chains/` with your chain configuration: + +```typescript +// config/chains/yourchain.ts +import type { ChainConfig } from '../types.js'; + +export const yourchain: ChainConfig = { + chainId: 12345, // Your chain ID + name: 'Your Chain', + rpcUrl: process.env.YOURCHAIN_RPC_URL || 'https://rpc.yourchain.com', + + // Aave v3 + aave: { + poolAddressesProvider: '0x...', // Aave PoolAddressesProvider + pool: '0x...', // Aave Pool + }, + + // Uniswap + uniswap: { + swapRouter02: '0x...', // Uniswap SwapRouter02 + universalRouter: '0x...', // Uniswap Universal Router + permit2: '0x000000000022D473030F116dDEE9F6B43aC78BA3', // Permit2 (same across chains) + quoterV2: '0x...', // Uniswap QuoterV2 + }, + + // Protocolink + protocolink: { + router: '0x...', // Protocolink Router + }, + + // Compound III + compound3: { + cometUsdc: '0x...', // Compound III Comet (if available) + }, + + // Common Tokens + tokens: { + WETH: '0x...', + USDC: '0x...', + USDT: '0x...', + DAI: '0x...', + WBTC: '0x...', + }, +}; +``` + +### 2๏ธโƒฃ Register Chain in Addresses + +Add your chain to `config/addresses.ts`: + +```typescript +import { yourchain } from './chains/yourchain.js'; + +export const chainConfigs: Record = { + 1: mainnet, + 8453: base, + // ... other chains + 12345: yourchain, // Add your chain +}; + +// Re-export +export { yourchain }; +``` + +### 3๏ธโƒฃ Add Viem Chain + +Add your chain to `src/utils/chain-config.ts`: + +```typescript +import { yourChain } from 'viem/chains'; + +const viemChains = { + 1: mainnet, + 8453: base, + // ... other chains + 12345: yourChain, // Add your chain +}; +``` + +### 4๏ธโƒฃ Update Environment Variables + +Add RPC URL to `.env.example`: + +```bash +YOURCHAIN_RPC_URL=https://rpc.yourchain.com +``` + +### 5๏ธโƒฃ Update Foundry Config + +Add RPC endpoint to `foundry.toml`: + +```toml +[rpc_endpoints] +yourchain = "${YOURCHAIN_RPC_URL}" +``` + +--- + +## ๐Ÿ“ Getting Official Addresses + +### ๐Ÿฆ Aave v3 + +1. ๐Ÿ“š Check [Aave Documentation](https://docs.aave.com/developers/deployed-contracts/deployed-contracts) +2. ๐Ÿ” Find your chain in the deployed contracts list +3. ๐Ÿ“‹ Get `PoolAddressesProvider` address +4. ๐Ÿ”— Use `PoolAddressesProvider.getPool()` to get Pool address + +### ๐Ÿ”„ Uniswap v3 + +1. ๐Ÿ“š Check [Uniswap Deployments](https://docs.uniswap.org/contracts/v3/reference/deployments) +2. ๐Ÿ” Find your chain's deployment page +3. ๐Ÿ“‹ Get addresses for: + - `SwapRouter02` + - `UniversalRouter` + - `Permit2` (same address across all chains: `0x000000000022D473030F116dDEE9F6B43aC78BA3`) + - `QuoterV2` + +### ๐Ÿ”— Protocolink + +1. ๐Ÿ“š Check [Protocolink Deployment Addresses](https://docs.protocolink.com/smart-contract/deployment-addresses) +2. ๐Ÿ” Find your chain +3. ๐Ÿ“‹ Get Router address + +### ๐Ÿ›๏ธ Compound III + +1. ๐Ÿ“š Check [Compound III Documentation](https://docs.compound.finance/) +2. ๐Ÿ” Find your chain's Comet addresses +3. ๐Ÿ“‹ Get Comet proxy address for your market + +### ๐Ÿ’ฐ Common Tokens + +For each chain, you'll need addresses for: + +| Token | Description | +|-------|-------------| +| WETH | Wrapped Ether | +| USDC | USD Coin | +| USDT | Tether USD | +| DAI | Dai Stablecoin | +| WBTC | Wrapped Bitcoin | + +**Resources:** +- ๐Ÿ” [Token Lists](https://tokenlists.org/) +- ๐Ÿ” [CoinGecko](https://www.coingecko.com/) + +--- + +## โœ… Verifying Addresses + +Always verify addresses from multiple sources: + +1. โœ… Official protocol documentation +2. โœ… Block explorer (verify contract code) +3. โœ… Protocol GitHub repositories +4. โœ… Community resources (Discord, forums) + +--- + +## ๐Ÿงช Testing Your Configuration + +After adding a new chain: + +### 1. Test Chain Config Loading + +```typescript +import { getChainConfig } from './config/addresses.js'; +const config = getChainConfig(12345); +console.log(config); +``` + +### 2. Test RPC Connection + +```typescript +import { createRpcClient } from './src/utils/chain-config.js'; +const client = createRpcClient(12345); +const blockNumber = await client.getBlockNumber(); +console.log('Block number:', blockNumber); +``` + +### 3. Test Address Resolution + +```typescript +import { getAavePoolAddress } from './src/utils/addresses.js'; +const poolAddress = getAavePoolAddress(12345); +console.log('Pool address:', poolAddress); +``` + +### 4. Run Examples + +```bash +# Update example to use your chain ID +tsx examples/ts/aave-supply-borrow.ts +``` + +### 5. Run Tests + +```bash +# Update test to use your chain +forge test --fork-url $YOURCHAIN_RPC_URL +``` + +--- + +## ๐Ÿ”ง Common Issues + +### โŒ RPC URL Not Working + +**Possible causes:** +- โŒ RPC URL is incorrect +- โŒ RPC provider doesn't support your chain +- โŒ Rate limits exceeded + +**Solutions:** +- โœ… Verify RPC URL is correct +- โœ… Try alternative RPC providers +- โœ… Check rate limits + +### โŒ Addresses Not Found + +**Possible causes:** +- โŒ Protocol not deployed on your chain +- โŒ Addresses are incorrect (typos, wrong network) +- โŒ Some protocols may not be available on all chains + +**Solutions:** +- โœ… Verify protocol is deployed on your chain +- โœ… Double-check addresses for typos +- โœ… Check protocol documentation for chain support + +### โŒ Token Addresses Wrong + +**Possible causes:** +- โŒ Token addresses are incorrect +- โŒ Token decimals differ +- โŒ Tokens don't exist on your chain + +**Solutions:** +- โœ… Verify token addresses on block explorer +- โœ… Check token decimals +- โœ… Ensure tokens exist on your chain + +--- + +## ๐Ÿ“ Chain-Specific Notes + +### ๐Ÿš€ Layer 2 Chains + +| Consideration | Description | +|---------------|-------------| +| Gas costs | Typically lower than mainnet | +| Finality times | May differ from mainnet | +| Protocol features | Some protocols may have L2-specific features | + +### ๐Ÿงช Testnets + +| Consideration | Description | +|---------------|-------------| +| Addresses | Use testnet-specific addresses | +| Tokens | Testnet tokens have no real value | +| Protocol availability | Some protocols may not be available on testnets | + +--- + +## ๐Ÿ’ก Best Practices + +1. โœ… **Always verify addresses** - Don't trust a single source +2. โœ… **Use environment variables** - Never hardcode RPC URLs +3. โœ… **Test thoroughly** - Test on testnet before mainnet +4. โœ… **Document changes** - Update documentation when adding chains +5. โœ… **Keep addresses updated** - Protocols may upgrade contracts + +--- + +## ๐Ÿ”— Resources + +| Resource | Link | +|----------|------| +| Aave Deployed Contracts | [docs.aave.com](https://docs.aave.com/developers/deployed-contracts/deployed-contracts) | +| Uniswap Deployments | [docs.uniswap.org](https://docs.uniswap.org/contracts/v3/reference/deployments) | +| Protocolink Deployment Addresses | [docs.protocolink.com](https://docs.protocolink.com/smart-contract/deployment-addresses) | +| Compound III Documentation | [docs.compound.finance](https://docs.compound.finance/) | + +--- + +## ๐Ÿ“š Related Documentation + +- ๐Ÿ“– [Environment Setup Guide](./ENV_SETUP.md) +- ๐Ÿ” [Security Best Practices](./SECURITY.md) +- ๐Ÿงช [Strategy Testing Guide](./STRATEGY_TESTING.md) diff --git a/docs/ENVIRONMENT_SETUP_COMPLETE.md b/docs/ENVIRONMENT_SETUP_COMPLETE.md new file mode 100644 index 0000000..dc96e51 --- /dev/null +++ b/docs/ENVIRONMENT_SETUP_COMPLETE.md @@ -0,0 +1,224 @@ +# โœ… Environment Setup - Verification Complete + +## ๐ŸŽ‰ All Scripts Verified + +All scripts have been verified to properly load environment variables from `.env` files. + +--- + +## โœ… Scripts Checked + +### 1. `src/strat/cli.ts` โœ… + +- โœ… Loads `dotenv` FIRST before any other imports +- โœ… Uses `getNetwork()` which lazy-loads RPC URLs from env vars +- โœ… Validates RPC URLs and shows helpful error messages + +### 2. `src/cli/cli.ts` โœ… + +- โœ… Loads `dotenv` FIRST before any other imports +- โœ… Uses `process.env.PRIVATE_KEY` for transaction execution +- โœ… Uses RPC URLs from chain configs (which read from env) + +### 3. `scripts/test-strategy.ts` โœ… + +- โœ… Loads `dotenv` FIRST before any other imports +- โœ… Reads `MAINNET_RPC_URL`, `TEST_SCENARIO`, `TEST_NETWORK` from env +- โœ… Validates RPC URL before proceeding +- โœ… Shows clear error messages if not configured + +### 4. `scripts/check-env.ts` โœ… + +- โœ… Loads `dotenv` FIRST +- โœ… Verifies all RPC URLs are set and accessible +- โœ… Tests connections to each network +- โœ… Provides helpful feedback + +### 5. `scripts/verify-setup.ts` โœ… + +- โœ… Loads `dotenv` FIRST +- โœ… Comprehensive verification of all setup components +- โœ… Checks scripts, configs, and scenarios + +--- + +## โš™๏ธ Network Configuration + +### `src/strat/config/networks.ts` โœ… + +- โœ… Lazy-loads RPC URLs when `getNetwork()` is called +- โœ… Ensures `dotenv` is loaded before reading env vars +- โœ… Supports network-specific env vars (e.g., `MAINNET_RPC_URL`) +- โœ… Falls back to defaults if not set + +### `config/chains/*.ts` โœ… + +- โœ… Read `process.env` at module load time +- โœ… Since all entry points load `dotenv` FIRST, this works correctly +- โœ… Have sensible defaults as fallbacks + +--- + +## ๐Ÿ“‹ Environment Variables + +### Required + +| Variable | Description | Status | +|----------|-------------|--------| +| `MAINNET_RPC_URL` | For mainnet fork testing (required for most scenarios) | โœ… | + +### Optional + +| Variable | Description | When Needed | +|----------|-------------|-------------| +| `BASE_RPC_URL` | For Base network testing | Multi-chain testing | +| `ARBITRUM_RPC_URL` | For Arbitrum testing | Multi-chain testing | +| `OPTIMISM_RPC_URL` | For Optimism testing | Multi-chain testing | +| `POLYGON_RPC_URL` | For Polygon testing | Multi-chain testing | +| `PRIVATE_KEY` | Only needed for mainnet execution (not fork testing) | Mainnet execution | +| `TEST_SCENARIO` | Override default test scenario | Custom scenarios | +| `TEST_NETWORK` | Override default test network | Multi-chain testing | + +--- + +## โœ… Validation + +All scripts now include: + +- โœ… RPC URL validation (checks for placeholders) +- โœ… Clear error messages if not configured +- โœ… Helpful suggestions (e.g., "Run 'pnpm run check:env'") +- โœ… Fallback to defaults where appropriate + +--- + +## ๐Ÿงช Testing + +Run these commands to verify your setup: + +```bash +# 1. Check environment variables +pnpm run check:env + +# 2. Verify complete setup +pnpm run verify:setup + +# 3. Test with a scenario (requires valid RPC URL) +pnpm run strat:test +``` + +--- + +## ๐Ÿ”ง How It Works + +### 1. Entry Point (CLI script or test script) + +- ๐Ÿ“ฅ Loads `dotenv.config()` FIRST +- ๐Ÿ“„ This reads `.env` file into `process.env` + +### 2. Network Configuration + +- ๐Ÿ”— `getNetwork()` is called +- โšก Lazy-loads RPC URLs from `process.env` +- โœ… Returns network config with RPC URL + +### 3. Fork Orchestrator + +- ๐Ÿ”Œ Uses the RPC URL from network config +- ๐ŸŒ Connects to the RPC endpoint +- ๐Ÿด Creates fork if needed + +### 4. Validation + +- โœ… Scripts validate RPC URLs before use +- ๐Ÿ” Check for placeholders like "YOUR_KEY" +- ๐Ÿ’ฌ Show helpful error messages if invalid + +--- + +## ๐Ÿ”ง Troubleshooting + +If environment variables aren't loading: + +### 1. Check .env file exists + +```bash +ls -la .env +``` + +### 2. Verify dotenv is loaded first + +- โœ… Check that `import dotenv from 'dotenv'` and `dotenv.config()` are at the top +- โœ… Before any other imports that use `process.env` + +### 3. Test environment loading + +```bash +node -e "require('dotenv').config(); console.log(process.env.MAINNET_RPC_URL)" +``` + +### 4. Run verification + +```bash +pnpm run verify:setup +``` + +--- + +## ๐Ÿ’ก Best Practices + +### 1. Always load dotenv first + +```typescript +// โœ… Good +import dotenv from 'dotenv'; +dotenv.config(); +import { other } from './other.js'; +``` + +### 2. Use lazy-loading for configs + +```typescript +// โœ… Good - lazy load +function getNetwork() { + return { rpcUrl: process.env.MAINNET_RPC_URL || 'default' }; +} +``` + +### 3. Validate before use + +```typescript +// โœ… Good - validate +if (!rpcUrl || rpcUrl.includes('YOUR_KEY')) { + throw new Error('RPC URL not configured'); +} +``` + +--- + +## ๐Ÿ“Š Summary + +| Check | Status | Description | +|-------|--------|-------------| +| Scripts load `.env` files | โœ… | All scripts properly load `.env` files | +| RPC URL validation | โœ… | All scripts validate RPC URLs before use | +| Lazy-loading configs | โœ… | Network configs lazy-load to ensure env vars are available | +| Clear error messages | โœ… | Clear error messages guide users to fix issues | +| Verification scripts | โœ… | Verification scripts help diagnose problems | +| Documentation | โœ… | Documentation explains the setup process | + +--- + +## ๐ŸŽ‰ Conclusion + +The environment setup is complete and verified! โœ… + +All scripts are properly connected to `.env` files and handle secrets correctly. You're ready to start building DeFi strategies! + +--- + +## ๐Ÿ“š Related Documentation + +- ๐Ÿ“– [Environment Setup Guide](./ENV_SETUP.md) +- โœ… [Verification Summary](./ENV_VERIFICATION_SUMMARY.md) +- ๐Ÿงช [Strategy Testing Guide](./STRATEGY_TESTING.md) diff --git a/docs/ENV_SETUP.md b/docs/ENV_SETUP.md new file mode 100644 index 0000000..2810fec --- /dev/null +++ b/docs/ENV_SETUP.md @@ -0,0 +1,261 @@ +# โš™๏ธ Environment Setup Guide + +This guide explains how to set up environment variables for the DeFi Strategy Testing Framework. + +--- + +## ๐Ÿš€ Quick Start + +### 1๏ธโƒฃ Copy the Example Environment File + +```bash +cp .env.example .env +``` + +### 2๏ธโƒฃ Fill in Your RPC URLs + +```bash +# Edit .env file +MAINNET_RPC_URL=https://mainnet.infura.io/v3/YOUR_INFURA_KEY +BASE_RPC_URL=https://base-mainnet.infura.io/v3/YOUR_INFURA_KEY +# ... etc +``` + +### 3๏ธโƒฃ Verify Your Setup + +```bash +pnpm run check:env +``` + +--- + +## ๐Ÿ“‹ Required Environment Variables + +### ๐Ÿ”— RPC URLs + +These are used to connect to blockchain networks for forking and testing: + +| Variable | Description | Required | +|----------|-------------|----------| +| `MAINNET_RPC_URL` | Ethereum mainnet RPC endpoint | โœ… Yes | +| `BASE_RPC_URL` | Base network RPC endpoint | โš ๏ธ Optional | +| `ARBITRUM_RPC_URL` | Arbitrum One RPC endpoint | โš ๏ธ Optional | +| `OPTIMISM_RPC_URL` | Optimism network RPC endpoint | โš ๏ธ Optional | +| `POLYGON_RPC_URL` | Polygon network RPC endpoint | โš ๏ธ Optional | + +### ๐Ÿ” Optional Environment Variables + +| Variable | Description | When Needed | +|----------|-------------|-------------| +| `PRIVATE_KEY` | Private key for executing transactions | Mainnet/testnet execution only | +| `TEST_SCENARIO` | Override default test scenario path | Custom test scenarios | +| `TEST_NETWORK` | Override default test network | Multi-chain testing | + +--- + +## ๐Ÿ”— Getting RPC URLs + +### ๐Ÿ†“ Free Options + +#### 1. Public RPCs (Rate-Limited) + +| Network | Public RPC URL | +|---------|----------------| +| Ethereum | `https://eth.llamarpc.com` | +| Base | `https://mainnet.base.org` | +| Arbitrum | `https://arb1.arbitrum.io/rpc` | +| Optimism | `https://mainnet.optimism.io` | +| Polygon | `https://polygon-rpc.com` | + +#### 2. Infura (Free Tier) + +1. ๐Ÿ“ Sign up at [infura.io](https://infura.io) +2. โž• Create a project +3. ๐Ÿ“‹ Copy your project ID +4. ๐Ÿ”— Use: `https://mainnet.infura.io/v3/YOUR_PROJECT_ID` + +#### 3. Alchemy (Free Tier) + +1. ๐Ÿ“ Sign up at [alchemy.com](https://alchemy.com) +2. โž• Create an app +3. ๐Ÿ“‹ Copy your API key +4. ๐Ÿ”— Use: `https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY` + +### ๐Ÿ’ฐ Paid Options (Recommended for Production) + +| Provider | Best For | Link | +|----------|----------|------| +| **Infura** | Reliable, well-known | [infura.io](https://infura.io) | +| **Alchemy** | Fast, good free tier | [alchemy.com](https://alchemy.com) | +| **QuickNode** | Fast, global network | [quicknode.com](https://quicknode.com) | +| **Ankr** | Good performance | [ankr.com](https://ankr.com) | + +--- + +## โœ… Verification + +### ๐Ÿ” Check Environment Variables + +Run the environment checker: + +```bash +pnpm run check:env +``` + +This will: +- โœ… Check that all RPC URLs are set +- โœ… Verify connections to each network +- โœ… Show current block numbers +- โœ… Report any issues + +### ๐Ÿงช Test with a Scenario + +```bash +# Set your RPC URL +export MAINNET_RPC_URL=https://your-rpc-url-here + +# Run a test +pnpm run strat:test +``` + +--- + +## ๐Ÿ”ง Troubleshooting + +### โŒ "RPC URL contains placeholder" + +**Problem:** Your `.env` file still has placeholder values like `YOUR_KEY` or `YOUR_INFURA_KEY`. + +**Solution:** Replace placeholders with actual RPC URLs in your `.env` file. + +### โŒ "Connection failed" or "403 Forbidden" + +**Problem:** Your RPC endpoint is rejecting requests. + +**Possible Causes:** +1. โŒ Invalid API key +2. โฑ๏ธ Rate limiting (free tier exceeded) +3. ๐Ÿšซ IP restrictions +4. ๐Ÿ”’ Infura project set to "private key only" mode + +**Solutions:** +1. โœ… Verify your API key is correct +2. โœ… Check your RPC provider dashboard for rate limits +3. โœ… Try a different RPC provider +4. โœ… For Infura: Enable "Public Requests" in project settings + +### โŒ "Environment variable not set" + +**Problem:** The script can't find the required environment variable. + +**Solutions:** +1. โœ… Check that `.env` file exists in project root +2. โœ… Verify variable name is correct (case-sensitive) +3. โœ… Restart your terminal/IDE after creating `.env` +4. โœ… Use `pnpm run check:env` to verify + +### โŒ Module Load Order Issues + +**Problem:** Environment variables not being loaded before modules that use them. + +**Solution:** The framework now loads `dotenv` FIRST in all entry points. If you still have issues: +1. โœ… Ensure `.env` file is in the project root +2. โœ… Check that `dotenv` package is installed +3. โœ… Verify scripts load dotenv before other imports + +--- + +## ๐Ÿ’ก Best Practices + +### ๐Ÿ” Security + +1. **Never commit `.env` files:** + - โœ… `.env` is in `.gitignore` + - โœ… Only commit `.env.example` + +2. **Use different keys for different environments:** + - ๐Ÿงช Development: Free tier or public RPCs + - ๐Ÿš€ Production: Paid RPC providers + +3. **Rotate keys regularly:** + - ๐Ÿ”„ Especially if keys are exposed + - ๐Ÿ“ Update `.env` file with new keys + +### ๐Ÿ—‚๏ธ Organization + +4. **Use environment-specific files:** + - ๐Ÿ“ `.env.local` - Local development (gitignored) + - ๐Ÿ“ `.env.production` - Production (gitignored) + - ๐Ÿ“ `.env.example` - Template (committed) + +5. **Validate on startup:** + - โœ… Use `pnpm run check:env` before running tests + - โœ… Scripts will warn if RPC URLs are not configured + +--- + +## ๐Ÿ”’ Security Notes + +> โš ๏ธ **IMPORTANT**: +> - โ›” **Never commit `.env` files** - They may contain private keys +> - ๐Ÿ”‘ **Don't share RPC keys** - They may have rate limits or costs +> - ๐Ÿ”„ **Use separate keys** for development and production +> - ๐Ÿ” **Rotate keys** if they're exposed or compromised + +--- + +## ๐Ÿ“ Example .env File + +```bash +# RPC Endpoints +MAINNET_RPC_URL=https://mainnet.infura.io/v3/your-infura-project-id +BASE_RPC_URL=https://base-mainnet.infura.io/v3/your-infura-project-id +ARBITRUM_RPC_URL=https://arbitrum-mainnet.infura.io/v3/your-infura-project-id +OPTIMISM_RPC_URL=https://optimism-mainnet.infura.io/v3/your-infura-project-id +POLYGON_RPC_URL=https://polygon-mainnet.infura.io/v3/your-infura-project-id + +# Private Keys (only for mainnet execution, not fork testing) +# PRIVATE_KEY=0x... + +# Test Configuration (optional) +# TEST_SCENARIO=scenarios/aave/leveraged-long.yml +# TEST_NETWORK=mainnet +``` + +--- + +## ๐ŸŽฏ Next Steps + +After setting up your environment: + +### 1. Verify Setup + +```bash +pnpm run check:env +``` + +### 2. Run a Test Scenario + +```bash +pnpm run strat:test +``` + +### 3. Run a Scenario with CLI + +```bash +pnpm run strat run scenarios/aave/leveraged-long.yml +``` + +### 4. Try Fuzzing + +```bash +pnpm run strat fuzz scenarios/aave/leveraged-long.yml --iters 10 +``` + +--- + +## ๐Ÿ“š Related Documentation + +- ๐Ÿ“– [Strategy Testing Guide](./STRATEGY_TESTING.md) +- ๐Ÿ”— [Chain Configuration](./CHAIN_CONFIG.md) +- ๐Ÿ” [Security Best Practices](./SECURITY.md) diff --git a/docs/ENV_VERIFICATION_SUMMARY.md b/docs/ENV_VERIFICATION_SUMMARY.md new file mode 100644 index 0000000..9bac746 --- /dev/null +++ b/docs/ENV_VERIFICATION_SUMMARY.md @@ -0,0 +1,147 @@ +# โœ… Environment Setup Verification - Complete + +## ๐ŸŽ‰ Verification Results + +All scripts have been verified to properly connect to `.env` files and handle secrets correctly. + +--- + +## โœ… Scripts Verified + +### 1. `src/strat/cli.ts` โœ… + +- โœ… Loads `dotenv` FIRST (line 14-15) +- โœ… Before any other imports +- โœ… Validates RPC URLs before use +- โœ… Shows helpful error messages + +### 2. `src/cli/cli.ts` โœ… + +- โœ… Loads `dotenv` FIRST (line 13-15) +- โœ… Before any other imports +- โœ… Uses `PRIVATE_KEY` from env for execution +- โœ… Validates private key before use + +### 3. `scripts/test-strategy.ts` โœ… + +- โœ… Loads `dotenv` FIRST (line 18-19) +- โœ… Before any other imports +- โœ… Reads `MAINNET_RPC_URL`, `TEST_SCENARIO`, `TEST_NETWORK` +- โœ… Validates RPC URL with placeholder checks +- โœ… Shows clear error messages + +### 4. `scripts/check-env.ts` โœ… + +- โœ… Loads `dotenv` FIRST +- โœ… Tests all RPC URL connections +- โœ… Validates environment setup +- โœ… Provides detailed feedback + +### 5. `scripts/verify-setup.ts` โœ… + +- โœ… Loads `dotenv` FIRST +- โœ… Comprehensive setup verification +- โœ… Checks all components + +--- + +## โœ… Configuration Verified + +### 1. `src/strat/config/networks.ts` โœ… + +- โœ… Lazy-loads RPC URLs when `getNetwork()` is called +- โœ… Ensures `dotenv` is loaded before reading env vars +- โœ… Supports all network-specific env vars +- โœ… Has sensible fallbacks + +### 2. `config/chains/*.ts` โœ… + +- โœ… Read `process.env` at module load +- โœ… Work correctly because entry points load dotenv first +- โœ… Have default fallbacks + +--- + +## ๐Ÿ“‹ Environment Variables + +### Required + +| Variable | Description | Status | +|----------|-------------|--------| +| `MAINNET_RPC_URL` | Required for mainnet fork testing | โœ… | + +### Optional + +| Variable | Description | When Needed | +|----------|-------------|-------------| +| `BASE_RPC_URL` | Base network RPC endpoint | Multi-chain testing | +| `ARBITRUM_RPC_URL` | Arbitrum One RPC endpoint | Multi-chain testing | +| `OPTIMISM_RPC_URL` | Optimism network RPC endpoint | Multi-chain testing | +| `POLYGON_RPC_URL` | Polygon network RPC endpoint | Multi-chain testing | +| `PRIVATE_KEY` | Private key for executing transactions | Mainnet/testnet execution only | +| `TEST_SCENARIO` | Override default test scenario path | Custom test scenarios | +| `TEST_NETWORK` | Override default test network | Multi-chain testing | + +--- + +## โœ… Validation Features + +All scripts include: + +- โœ… RPC URL validation (checks for placeholders like "YOUR_KEY") +- โœ… Clear error messages if not configured +- โœ… Helpful suggestions (e.g., "Run 'pnpm run check:env'") +- โœ… Fallback to defaults where appropriate + +--- + +## ๐Ÿ”ง Verification Commands + +```bash +# Check environment variables and RPC connections +pnpm run check:env + +# Verify complete setup +pnpm run verify:setup + +# Test with a scenario +pnpm run strat:test +``` + +--- + +## ๐Ÿ” Security + +| Check | Status | Description | +|-------|--------|-------------| +| `.env` in `.gitignore` | โœ… | `.env` file is in `.gitignore` | +| `.env.example` template | โœ… | `.env.example` provides template | +| Private keys protection | โœ… | Private keys only used when explicitly needed | +| RPC URL validation | โœ… | RPC URLs validated before use | +| No hardcoded secrets | โœ… | No hardcoded secrets | + +--- + +## ๐Ÿงช Test Results + +Running `pnpm run verify:setup` shows: + +- โœ… All scripts load dotenv correctly +- โœ… Network config loads correctly +- โœ… Scenario files exist +- โœ… Environment variables are accessible + +--- + +## ๐ŸŽ‰ Conclusion + +All scripts are properly connected to `.env` files and handle secrets correctly. The setup is complete and ready for use! + +--- + +## ๐Ÿ“š Next Steps + +1. โœ… Run `pnpm run check:env` to verify your environment +2. โœ… Run `pnpm run verify:setup` for comprehensive verification +3. โœ… Test with `pnpm run strat:test` +4. โœ… Start building DeFi strategies! diff --git a/docs/INTEGRATION_GUIDE.md b/docs/INTEGRATION_GUIDE.md new file mode 100644 index 0000000..3de95bf --- /dev/null +++ b/docs/INTEGRATION_GUIDE.md @@ -0,0 +1,320 @@ +# ๐Ÿ”Œ Integration Guide + +> Step-by-step guide for integrating DeFi protocols into your application. + +--- + +## ๐Ÿ“‹ Table of Contents + +1. [Aave v3 Integration](#-aave-v3-integration) +2. [Uniswap v3 Integration](#-uniswap-v3-integration) +3. [Protocolink Integration](#-protocolink-integration) +4. [Compound III Integration](#-compound-iii-integration) +5. [Cross-Protocol Strategies](#-cross-protocol-strategies) + +--- + +## ๐Ÿฆ Aave v3 Integration + +### 1๏ธโƒฃ Setup + +```typescript +import { createWalletRpcClient } from '../src/utils/chain-config.js'; +import { getAavePoolAddress } from '../src/utils/addresses.js'; + +const CHAIN_ID = 1; // Mainnet +const walletClient = createWalletRpcClient(CHAIN_ID, privateKey); +const poolAddress = getAavePoolAddress(CHAIN_ID); +``` + +### 2๏ธโƒฃ Supply Collateral + +```typescript +// 1. Approve token +await walletClient.writeContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [poolAddress, amount], +}); + +// 2. Supply +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'supply', + args: [asset, amount, account, 0], +}); + +// 3. Enable as collateral +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'setUserUseReserveAsCollateral', + args: [asset, true], +}); +``` + +### 3๏ธโƒฃ Borrow + +```typescript +// Note: Use variable rate (2), stable rate is deprecated in v3.3+ +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'borrow', + args: [debtAsset, borrowAmount, 2, 0, account], +}); +``` + +### 4๏ธโƒฃ Flash Loans + +#### Single Asset + +```typescript +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'flashLoanSimple', + args: [receiverAddress, asset, amount, params, 0], +}); +``` + +#### Multi-Asset + +```typescript +await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'flashLoan', + args: [receiverAddress, assets, amounts, modes, account, params, 0], +}); +``` + +> โš ๏ธ **Important**: Your flash loan receiver contract must: +> 1. โœ… Receive the loaned tokens +> 2. โœ… Perform desired operations +> 3. โœ… Approve the pool for `amount + premium` +> 4. โœ… Return `true` from `executeOperation` + +--- + +## ๐Ÿ”„ Uniswap v3 Integration + +### 1๏ธโƒฃ Setup + +```typescript +import { getUniswapSwapRouter02 } from '../src/utils/addresses.js'; + +const routerAddress = getUniswapSwapRouter02(CHAIN_ID); +``` + +### 2๏ธโƒฃ Get Quote + +```typescript +// Use QuoterV2 contract to get expected output +const quote = await publicClient.readContract({ + address: quoterAddress, + abi: QUOTER_ABI, + functionName: 'quoteExactInputSingle', + args: [{ + tokenIn: tokenInAddress, + tokenOut: tokenOutAddress, + fee: 3000, // 0.3% fee tier + amountIn: amountIn, + sqrtPriceLimitX96: 0, + }], +}); +``` + +### 3๏ธโƒฃ Execute Swap + +```typescript +// 1. Approve token +await walletClient.writeContract({ + address: tokenInAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [routerAddress, amountIn], +}); + +// 2. Execute swap +await walletClient.writeContract({ + address: routerAddress, + abi: SWAP_ROUTER_ABI, + functionName: 'exactInputSingle', + args: [{ + tokenIn: tokenInAddress, + tokenOut: tokenOutAddress, + fee: 3000, + recipient: account, + deadline: BigInt(Math.floor(Date.now() / 1000) + 600), + amountIn: amountIn, + amountOutMinimum: amountOutMin, // Apply slippage protection + sqrtPriceLimitX96: 0, + }], +}); +``` + +### 4๏ธโƒฃ TWAP Oracle + +```typescript +// Always use TWAP, not spot prices, to protect against manipulation +// See examples/ts/uniswap-v3-oracle.ts for implementation +``` + +--- + +## ๐Ÿ”— Protocolink Integration + +### 1๏ธโƒฃ Setup + +```typescript +import * as api from '@protocolink/api'; +import * as common from '@protocolink/common'; + +const CHAIN_ID = common.ChainId.mainnet; +``` + +### 2๏ธโƒฃ Build Logics + +```typescript +// Swap logic +const swapQuotation = await api.protocols.uniswapv3.getSwapTokenQuotation(CHAIN_ID, { + input: { token: USDC, amount: '1000' }, + tokenOut: WBTC, + slippage: 100, +}); +const swapLogic = api.protocols.uniswapv3.newSwapTokenLogic(swapQuotation); + +// Supply logic +const supplyQuotation = await api.protocols.aavev3.getSupplyQuotation(CHAIN_ID, { + input: swapQuotation.output, +}); +const supplyLogic = api.protocols.aavev3.newSupplyLogic(supplyQuotation); +``` + +### 3๏ธโƒฃ Execute + +```typescript +const routerData = await api.router.getRouterData(CHAIN_ID, { + account, + logics: [swapLogic, supplyLogic], +}); + +await walletClient.sendTransaction({ + to: routerData.router, + data: routerData.data, + value: BigInt(routerData.estimation.value || '0'), + gas: BigInt(routerData.estimation.gas), +}); +``` + +--- + +## ๐Ÿ›๏ธ Compound III Integration + +### 1๏ธโƒฃ Setup + +```typescript +import { getCompound3Comet } from '../src/utils/addresses.js'; + +const cometAddress = getCompound3Comet(CHAIN_ID); +``` + +### 2๏ธโƒฃ Supply Collateral + +```typescript +// 1. Approve collateral +await walletClient.writeContract({ + address: collateralAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [cometAddress, amount], +}); + +// 2. Supply +await walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'supply', + args: [collateralAddress, amount], +}); +``` + +### 3๏ธโƒฃ Borrow Base Asset + +```typescript +// In Compound III, you "borrow" by withdrawing the base asset +const baseToken = await publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'baseToken', +}); + +await walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'withdraw', + args: [baseToken, borrowAmount], +}); +``` + +--- + +## ๐Ÿ”„ Cross-Protocol Strategies + +### โšก Flash Loan Arbitrage + +**Strategy Flow:** + +1. โšก Flash loan asset from Aave +2. ๐Ÿ”„ Swap on Uniswap (or other DEX) +3. ๐Ÿ”„ Swap on different DEX/pool +4. โœ… Repay flash loan + premium +5. ๐Ÿ’ฐ Keep profit + +> ๐Ÿ“– See `examples/ts/flashloan-arbitrage.ts` for conceptual example. + +### ๐Ÿ“ˆ Supply-Borrow-Swap + +**Strategy Flow:** + +1. ๐Ÿ’ฐ Supply collateral to Aave +2. ๐Ÿ’ธ Borrow asset +3. ๐Ÿ”„ Swap borrowed asset +4. ๐Ÿ’ฐ Supply swapped asset back to Aave + +> ๐Ÿ“– See `examples/ts/supply-borrow-swap.ts` for implementation. + +--- + +## ๐Ÿ’ก Best Practices + +| Practice | Description | Status | +|----------|-------------|--------| +| ๐Ÿ›ก๏ธ **Slippage Protection** | Always set minimum output amounts | โœ… | +| โ›ฝ **Gas Costs** | Check gas costs for complex transactions | โœ… | +| ๐Ÿ”ฎ **TWAP Oracles** | Never rely on spot prices alone | โœ… | +| ๐Ÿงช **Test on Testnets** | Always test before mainnet | โœ… | +| โš ๏ธ **Error Handling** | Handle errors gracefully | โœ… | +| ๐Ÿ“Š **Monitor Positions** | Track liquidation risks | โœ… | +| ๐Ÿ” **Use Permit2** | Save gas on approvals when possible | โœ… | + +--- + +## ๐ŸŽฏ Next Steps + +- ๐Ÿ“– Review [Security Best Practices](./SECURITY.md) +- ๐Ÿ”— Check [Chain Configuration](./CHAIN_CONFIG.md) for adding new chains +- ๐Ÿ“œ Explore example contracts in `contracts/examples/` +- ๐Ÿงช Run tests in `test/` + +--- + +## ๐Ÿ“š Related Documentation + +- ๐Ÿ” [Security Best Practices](./SECURITY.md) +- ๐Ÿ”— [Chain Configuration](./CHAIN_CONFIG.md) +- ๐Ÿงช [Strategy Testing Guide](./STRATEGY_TESTING.md) +- โš™๏ธ [Environment Setup](./ENV_SETUP.md) diff --git a/docs/SECURITY.md b/docs/SECURITY.md new file mode 100644 index 0000000..c72e6be --- /dev/null +++ b/docs/SECURITY.md @@ -0,0 +1,324 @@ +# ๐Ÿ” Security Best Practices + +> Comprehensive security checklist for DeFi integration. + +--- + +## ๐Ÿ›ก๏ธ General Security Principles + +### ๐Ÿ”’ 1. Access Control + +- โœ… Use access control modifiers for sensitive functions +- โœ… Implement owner/admin roles properly +- โœ… Never hardcode private keys or mnemonics +- โœ… Use environment variables for sensitive data + +### โœ… 2. Input Validation + +- โœ… Validate all user inputs +- โœ… Check for zero addresses +- โœ… Validate amounts (no zero, no overflow) +- โœ… Check token decimals + +### ๐Ÿ”„ 3. Reentrancy Protection + +- โœ… Use ReentrancyGuard for external calls +- โœ… Follow checks-effects-interactions pattern +- โœ… Be extra careful with flash loans + +### โš ๏ธ 4. Error Handling + +- โœ… Use require/assert appropriately +- โœ… Provide clear error messages +- โœ… Handle edge cases +- โœ… Test error conditions + +--- + +## ๐Ÿฆ Protocol-Specific Security + +### ๐Ÿฆ Aave v3 + +#### โšก Flash Loans + +| Check | Status | Description | +|-------|--------|-------------| +| โš ๏ธ **Critical** | โœ… | Always repay flash loan + premium in `executeOperation` | +| โš ๏ธ **Critical** | โœ… | Verify `msg.sender == pool` in `executeOperation` | +| โš ๏ธ **Critical** | โœ… | Verify `initiator == address(this)` in `executeOperation` | +| โœ… | โœ… | Calculate premium correctly: `amount + premium` | +| โœ… | โœ… | Handle multi-asset flash loans carefully | +| โœ… | โœ… | Test repayment failure scenarios | + +#### ๐Ÿ’ฐ Interest Rate Modes + +| Check | Status | Description | +|-------|--------|-------------| +| โš ๏ธ **Deprecated** | โœ… | Stable rate borrowing is deprecated in v3.3+ | +| โœ… | โœ… | Always use variable rate (mode = 2) for new integrations | +| โœ… | โœ… | Understand interest rate risks | + +#### ๐Ÿ›ก๏ธ Collateral Management + +- โœ… Check liquidation thresholds +- โœ… Monitor health factor +- โœ… Handle eMode/isolation mode restrictions +- โœ… Verify collateral can be enabled + +### ๐Ÿ”„ Uniswap v3 + +#### ๐Ÿ›ก๏ธ Slippage Protection + +| Check | Status | Description | +|-------|--------|-------------| +| โš ๏ธ **Critical** | โœ… | Always set `amountOutMinimum` with slippage tolerance | +| โœ… | โœ… | Use TWAP oracles, not spot prices | +| โœ… | โœ… | Account for price impact in large swaps | +| โœ… | โœ… | Consider using UniswapX for better execution | + +#### ๐Ÿ”ฎ Oracle Security + +| Check | Status | Description | +|-------|--------|-------------| +| โš ๏ธ **Critical** | โœ… | Never use spot prices for critical operations | +| โœ… | โœ… | Use TWAP with sufficient observation window | +| โœ… | โœ… | Verify observation cardinality | +| โœ… | โœ… | Protect against oracle manipulation | + +#### ๐Ÿ” Permit2 + +- โœ… Verify signature validity +- โœ… Check expiration (deadline) +- โœ… Verify nonce (prevent replay) +- โœ… Protect against signature theft (verify spender) + +### ๐Ÿ”— Protocolink + +#### โœ… Route Validation + +- โœ… Verify all logics in the route +- โœ… Check token addresses +- โœ… Validate amounts +- โœ… Verify slippage settings + +#### โšก Execution + +- โœ… Check gas estimates +- โœ… Handle execution failures +- โœ… Verify router address +- โœ… Monitor transaction status + +### ๐Ÿ›๏ธ Compound III + +#### ๐Ÿ’ฐ Borrowing + +| Check | Status | Description | +|-------|--------|-------------| +| โš ๏ธ **Important** | โœ… | Understand base asset vs collateral | +| โœ… | โœ… | Check borrow limits | +| โœ… | โœ… | Monitor collateral ratio | +| โœ… | โœ… | Handle liquidation risks | + +--- + +## ๐Ÿ“œ Smart Contract Security + +### โšก Flash Loan Receivers + +```solidity +// โœ… Good: Verify caller and initiator +function executeOperation( + address asset, + uint256 amount, + uint256 premium, + address initiator, + bytes calldata params +) external override returns (bool) { + require(msg.sender == address(pool), "Invalid caller"); + require(initiator == address(this), "Invalid initiator"); + + // Your logic here + + // โœ… Good: Approve repayment + IERC20(asset).approve(address(pool), amount + premium); + return true; +} +``` + +### ๐Ÿ”„ Reentrancy Protection + +```solidity +// โœ… Good: Use ReentrancyGuard +import "@openzeppelin/contracts/security/ReentrancyGuard.sol"; + +contract MyContract is ReentrancyGuard { + function withdraw() external nonReentrant { + // Safe withdrawal logic + } +} +``` + +### ๐Ÿ”’ Access Control + +```solidity +// โœ… Good: Use access control +import "@openzeppelin/contracts/access/Ownable.sol"; + +contract MyContract is Ownable { + function sensitiveFunction() external onlyOwner { + // Owner-only logic + } +} +``` + +--- + +## ๐Ÿงช Testing Security + +### ๐Ÿงช Foundry Tests + +- โœ… Test all edge cases +- โœ… Test error conditions +- โœ… Test reentrancy attacks +- โœ… Test flash loan scenarios +- โœ… Test with fork tests +- โœ… Test gas limits + +### ๐Ÿ“Š Test Coverage + +- โœ… Unit tests for all functions +- โœ… Integration tests +- โœ… Fork tests on mainnet +- โœ… Fuzz tests for inputs +- โœ… Invariant tests + +--- + +## ๐Ÿš€ Deployment Security + +### ๐Ÿ” Pre-Deployment + +- โœ… Get professional security audit +- โœ… Review all dependencies +- โœ… Test on testnets extensively +- โœ… Verify all addresses +- โœ… Check contract sizes + +### ๐Ÿ” Post-Deployment + +- โœ… Monitor transactions +- โœ… Set up alerts +- โœ… Keep private keys secure +- โœ… Use multisig for admin functions +- โœ… Have an emergency pause mechanism + +--- + +## โš ๏ธ Common Vulnerabilities + +### 1. Reentrancy + +โŒ **Bad**: External call before state update + +```solidity +function withdraw() external { + msg.sender.call{value: balance}(""); + balance = 0; // Too late! +} +``` + +โœ… **Good**: State update before external call + +```solidity +function withdraw() external nonReentrant { + uint256 amount = balance; + balance = 0; + msg.sender.call{value: amount}(""); +} +``` + +### 2. Integer Overflow + +โŒ **Bad**: No overflow protection + +```solidity +uint256 total = amount1 + amount2; +``` + +โœ… **Good**: Use SafeMath or Solidity 0.8+ + +```solidity +uint256 total = amount1 + amount2; // Safe in Solidity 0.8+ +``` + +### 3. Access Control + +โŒ **Bad**: No access control + +```solidity +function withdraw() external { + // Anyone can call +} +``` + +โœ… **Good**: Proper access control + +```solidity +function withdraw() external onlyOwner { + // Only owner can call +} +``` + +--- + +## ๐Ÿ”— Resources + +| Resource | Link | +|----------|------| +| OpenZeppelin Security | [docs.openzeppelin.com](https://docs.openzeppelin.com/contracts/security) | +| Consensys Best Practices | [consensys.github.io](https://consensys.github.io/smart-contract-best-practices/) | +| Aave Security | [docs.aave.com](https://docs.aave.com/developers/guides/security-best-practices) | +| Uniswap Security | [docs.uniswap.org](https://docs.uniswap.org/contracts/v4/concepts/security) | + +--- + +## โœ… Security Audit Checklist + +Before deploying to production: + +- [ ] ๐Ÿ” Professional security audit completed +- [ ] ๐Ÿ“ฆ All dependencies reviewed +- [ ] ๐Ÿ”’ Access control implemented +- [ ] ๐Ÿ”„ Reentrancy protection added +- [ ] โœ… Input validation implemented +- [ ] โš ๏ธ Error handling comprehensive +- [ ] ๐Ÿงช Tests cover edge cases +- [ ] โ›ฝ Gas optimization reviewed +- [ ] โธ๏ธ Emergency pause mechanism +- [ ] ๐Ÿ‘ฅ Multisig for admin functions +- [ ] ๐Ÿ“Š Monitoring and alerts set up + +--- + +## ๐Ÿšจ Reporting Security Issues + +If you discover a security vulnerability, please report it responsibly: + +1. โ›” **DO NOT** open a public issue +2. ๐Ÿ“ง Email security details to the maintainers +3. โฐ Allow time for the issue to be addressed +4. ๐Ÿ”’ Follow responsible disclosure practices + +--- + +## โš ๏ธ Disclaimer + +This security guide is for educational purposes. Always get professional security audits before deploying to production. + +--- + +## ๐Ÿ“š Related Documentation + +- ๐Ÿ“– [Integration Guide](./INTEGRATION_GUIDE.md) +- ๐Ÿ”— [Chain Configuration](./CHAIN_CONFIG.md) +- ๐Ÿงช [Strategy Testing Guide](./STRATEGY_TESTING.md) diff --git a/docs/STRATEGY_TESTING.md b/docs/STRATEGY_TESTING.md new file mode 100644 index 0000000..f352d20 --- /dev/null +++ b/docs/STRATEGY_TESTING.md @@ -0,0 +1,587 @@ +# ๐Ÿงช DeFi Strategy Testing Framework + +> A comprehensive CLI tool for testing DeFi strategies against local mainnet forks with support for success paths and controlled failure scenarios. + +--- + +## ๐Ÿ“‹ Overview + +The DeFi Strategy Testing Framework allows you to: + +- โœ… Run **repeatable, deterministic simulations** of DeFi strategies on local mainnet forks +- ๐Ÿ’ฅ Test both **success** and **failure** cases: liquidations, oracle shocks, cap limits, slippage, approvals, paused assets, etc. +- โœ… Provide **clear pass/fail assertions** (e.g., Aave Health Factor >= 1 after each step; exact token deltas; gas ceilings) +- ๐Ÿ“Š Produce **auditable reports** (JSON + HTML) suitable for CI +- ๐ŸŽฒ **Fuzz test** strategies with parameterized inputs +- ๐Ÿ‹ **Automatically fund** test accounts via whale impersonation + +--- + +## ๐Ÿ—๏ธ Architecture + +``` +/defi-strat-cli + /src/strat + /core # ๐Ÿ”ง Engine: fork control, scenario runner, assertions, reporting + - fork-orchestrator.ts # ๐Ÿด Fork management (Anvil/Hardhat) + - scenario-runner.ts # โ–ถ๏ธ Executes scenarios step by step + - assertion-evaluator.ts # โœ… Evaluates assertions + - failure-injector.ts # ๐Ÿ’ฅ Injects failure scenarios + - fuzzer.ts # ๐ŸŽฒ Fuzz testing with parameterized inputs + - whale-registry.ts # ๐Ÿ‹ Whale addresses for token funding + /adapters # ๐Ÿ”Œ Protocol adapters + /aave-v3-adapter.ts # ๐Ÿฆ Aave v3 operations + /uniswap-v3-adapter.ts # ๐Ÿ”„ Uniswap v3 swaps + /compound-v3-adapter.ts # ๐Ÿ›๏ธ Compound v3 operations + /erc20-adapter.ts # ๐Ÿ’ฐ ERC20 token operations + /dsl # ๐Ÿ“ Strategy/Scenario schema + loader + - scenario-loader.ts # ๐Ÿ“„ YAML/JSON parser + /reporters # ๐Ÿ“Š Report generators + - json-reporter.ts # ๐Ÿ“„ JSON reports + - html-reporter.ts # ๐ŸŒ HTML reports + - junit-reporter.ts # ๐Ÿ”ง JUnit XML for CI + /config # โš™๏ธ Configuration + - networks.ts # ๐ŸŒ Network configurations + - oracle-feeds.ts # ๐Ÿ”ฎ Oracle feed addresses + /scenarios # ๐Ÿ“š Example strategies + /aave + - leveraged-long.yml + - liquidation-drill.yml + /compound3 + - supply-borrow.yml +``` + +--- + +## ๐Ÿš€ Quick Start + +### ๐Ÿ“ฆ Installation + +```bash +# Install dependencies +pnpm install +``` + +### โ–ถ๏ธ Run a Scenario + +```bash +# Run a scenario +pnpm run strat run scenarios/aave/leveraged-long.yml + +# Run with custom network +pnpm run strat run scenarios/aave/leveraged-long.yml --network base + +# Generate reports +pnpm run strat run scenarios/aave/leveraged-long.yml \ + --report out/run.json \ + --html out/report.html \ + --junit out/junit.xml +``` + +### ๐Ÿงช Test Script + +For comprehensive testing with a real fork: + +```bash +# Set your RPC URL +export MAINNET_RPC_URL=https://mainnet.infura.io/v3/YOUR_KEY + +# Run test script +pnpm run strat:test +``` + +--- + +## ๐Ÿ–ฅ๏ธ CLI Commands + +### ๐Ÿด `fork up` + +Start or attach to a fork instance. + +```bash +pnpm run strat fork up --network mainnet --block 18500000 +``` + +### โ–ถ๏ธ `run` + +Run a scenario file. + +```bash +pnpm run strat run [options] +``` + +| Option | Description | Default | +|--------|-------------|---------| +| `--network ` | Network name or chain ID | `mainnet` | +| `--report ` | Output JSON report path | - | +| `--html ` | Output HTML report path | - | +| `--junit ` | Output JUnit XML report path | - | +| `--rpc ` | Custom RPC URL | - | + +### ๐ŸŽฒ `fuzz` + +Fuzz test a scenario with parameterized inputs. + +```bash +pnpm run strat fuzz scenarios/aave/leveraged-long.yml --iters 100 --seed 42 +``` + +| Option | Description | Default | +|--------|-------------|---------| +| `--iters ` | Number of iterations | `100` | +| `--seed ` | Random seed for reproducibility | - | +| `--report ` | Output JSON report path | - | + +### ๐Ÿ’ฅ `failures` + +List available failure injection methods. + +```bash +pnpm run strat failures [protocol] +``` + +### ๐Ÿ“Š `compare` + +Compare two run reports. + +```bash +pnpm run strat compare out/run1.json out/run2.json +``` + +--- + +## ๐Ÿ“ Writing Scenarios + +Scenarios are defined in YAML or JSON format: + +```yaml +version: 1 +network: mainnet +protocols: [aave-v3, uniswap-v3] + +assumptions: + baseCurrency: USD + slippageBps: 30 + minHealthFactor: 1.05 + +accounts: + trader: + funded: + - token: WETH + amount: "5" + +steps: + - name: Approve WETH to Aave Pool + action: erc20.approve + args: + token: WETH + spender: aave-v3:Pool + amount: "max" + + - name: Supply WETH + action: aave-v3.supply + args: + asset: WETH + amount: "5" + onBehalfOf: $accounts.trader + assert: + - aave-v3.healthFactor >= 1.5 + + - name: Borrow USDC + action: aave-v3.borrow + args: + asset: USDC + amount: "6000" + rateMode: variable + + - name: Swap USDC->WETH + action: uniswap-v3.exactInputSingle + args: + tokenIn: USDC + tokenOut: WETH + fee: 500 + amountIn: "3000" + + - name: Oracle shock (-12% WETH) + action: failure.oracleShock + args: + feed: CHAINLINK_WETH_USD + pctDelta: -12 + + - name: Check HF still safe + action: assert + args: + expression: "aave-v3.healthFactor >= 1.05" +``` + +--- + +## ๐Ÿ”Œ Supported Actions + +### ๐Ÿฆ Aave v3 + +| Action | Description | Status | +|--------|-------------|--------| +| `aave-v3.supply` | Supply assets to Aave | โœ… | +| `aave-v3.withdraw` | Withdraw assets from Aave | โœ… | +| `aave-v3.borrow` | Borrow assets from Aave | โœ… | +| `aave-v3.repay` | Repay borrowed assets | โœ… | +| `aave-v3.flashLoanSimple` | Execute a flash loan | โœ… | + +**Views:** +- `aave-v3.healthFactor`: Get user health factor +- `aave-v3.userAccountData`: Get full user account data + +### ๐Ÿ›๏ธ Compound v3 + +| Action | Description | Status | +|--------|-------------|--------| +| `compound-v3.supply` | Supply collateral to Compound v3 | โœ… | +| `compound-v3.withdraw` | Withdraw collateral or base asset | โœ… | +| `compound-v3.borrow` | Borrow base asset (withdraws base asset) | โœ… | +| `compound-v3.repay` | Repay debt (supplies base asset) | โœ… | + +**Views:** +- `compound-v3.borrowBalance`: Get borrow balance +- `compound-v3.collateralBalance`: Get collateral balance for an asset + +### ๐Ÿ”„ Uniswap v3 + +| Action | Description | Status | +|--------|-------------|--------| +| `uniswap-v3.exactInputSingle` | Execute an exact input swap | โœ… | +| `uniswap-v3.exactOutputSingle` | Execute an exact output swap | โœ… | + +### ๐Ÿ’ฐ ERC20 + +| Action | Description | Status | +|--------|-------------|--------| +| `erc20.approve` | Approve token spending | โœ… | + +**Views:** +- `erc20.balanceOf`: Get token balance + +### ๐Ÿ’ฅ Failure Injection + +| Action | Description | Status | +|--------|-------------|--------| +| `failure.oracleShock` | Inject an oracle price shock (attempts storage manipulation) | โœ… | +| `failure.timeTravel` | Advance time | โœ… | +| `failure.setTimestamp` | Set block timestamp | โœ… | +| `failure.liquidityShock` | Move liquidity | โœ… | +| `failure.setBaseFee` | Set gas price | โœ… | +| `failure.pauseReserve` | Pause a reserve (Aave) | โœ… | +| `failure.capExhaustion` | Simulate cap exhaustion | โœ… | + +--- + +## โœ… Assertions + +Assertions can be added to any step: + +```yaml +steps: + - name: Check health factor + action: assert + args: + expression: "aave-v3.healthFactor >= 1.05" +``` + +### Supported Operators + +| Operator | Description | Example | +|----------|-------------|---------| +| `>=` | Greater than or equal | `aave-v3.healthFactor >= 1.05` | +| `<=` | Less than or equal | `amount <= 1000` | +| `>` | Greater than | `balance > 0` | +| `<` | Less than | `gasUsed < 1000000` | +| `==` | Equal to | `status == "success"` | +| `!=` | Not equal to | `error != null` | + +--- + +## ๐Ÿ“Š Reports + +### ๐Ÿ“„ JSON Report + +Machine-readable JSON format with full run details. + +**Features:** +- โœ… Complete step-by-step execution log +- โœ… Assertion results +- โœ… Gas usage metrics +- โœ… Error messages and stack traces +- โœ… State deltas + +### ๐ŸŒ HTML Report + +Human-readable HTML report with: + +- โœ… Run summary (pass/fail status, duration, gas) +- โœ… Step-by-step execution details +- โœ… Assertion results with visual indicators +- โœ… Gas usage charts +- โœ… Error messages with syntax highlighting + +### ๐Ÿ”ง JUnit XML + +CI-friendly XML format for integration with test runners. + +**Features:** +- โœ… Compatible with Jenkins, GitLab CI, GitHub Actions +- โœ… Test suite and case structure +- โœ… Pass/fail status +- โœ… Error messages and stack traces + +--- + +## ๐Ÿด Fork Orchestration + +The framework supports: + +| Backend | Status | Features | +|---------|--------|----------| +| **Anvil** (Foundry) | โœ… | Fast, rich custom RPC methods | +| **Hardhat** | โœ… | Wider familiarity | +| **Tenderly** | ๐Ÿšง Coming soon | Optional remote simulation backend | + +### ๐ŸŽฏ Fork Features + +- โœ… **Snapshot/revert** - Fast test loops +- ๐Ÿ‹ **Account impersonation** - Fund/borrow from whales +- โฐ **Time travel** - Advance time, set timestamp +- ๐Ÿ’พ **Storage manipulation** - Oracle overrides +- โ›ฝ **Gas price control** - Test gas scenarios + +--- + +## ๐Ÿ‹ Token Funding + +The framework automatically funds test accounts via whale impersonation. Known whale addresses are maintained in the whale registry for common tokens. + +### How It Works + +1. ๐Ÿ“‹ Look up whale address from registry +2. ๐ŸŽญ Impersonate whale on the fork +3. ๐Ÿ’ธ Transfer tokens to test account +4. โœ… Verify balance + +### Adding New Whales + +```typescript +// src/strat/core/whale-registry.ts +export const WHALE_REGISTRY: Record> = { + 1: { + YOUR_TOKEN: '0x...' as Address, + }, +}; +``` + +--- + +## ๐Ÿ”Œ Protocol Adapters + +### Adding a New Adapter + +Implement the `ProtocolAdapter` interface: + +```typescript +export interface ProtocolAdapter { + name: string; + discover(network: Network): Promise; + actions: Record Promise>; + invariants?: Array<(ctx: StepContext) => Promise>; + views?: Record Promise>; +} +``` + +### Example Implementation + +```typescript +export class MyProtocolAdapter implements ProtocolAdapter { + name = 'my-protocol'; + + async discover(network: Network): Promise { + return { + contract: '0x...', + }; + } + + actions = { + myAction: async (ctx: StepContext, args: any): Promise => { + // Implement action + return { success: true }; + }, + }; + + views = { + myView: async (ctx: ViewContext): Promise => { + // Implement view + return value; + }, + }; +} +``` + +--- + +## ๐Ÿ’ฅ Failure Injection + +### ๐Ÿ”ฎ Oracle Shocks + +Inject price changes to test liquidation scenarios. The framework attempts to modify Chainlink aggregator storage: + +```yaml +- name: Oracle shock + action: failure.oracleShock + args: + feed: CHAINLINK_WETH_USD + pctDelta: -12 # -12% price drop + # aggregatorAddress: 0x... # Optional, auto-resolved if not provided +``` + +> โš ๏ธ **Note:** Oracle storage manipulation requires precise slot calculation and may not work on all forks. The framework will attempt the manipulation and log warnings if it fails. + +### โฐ Time Travel + +Advance time for interest accrual, maturity, etc.: + +```yaml +- name: Advance time + action: failure.timeTravel + args: + seconds: 86400 # 1 day +``` + +### ๐Ÿ’ง Liquidity Shocks + +Move liquidity to test pool utilization: + +```yaml +- name: Liquidity shock + action: failure.liquidityShock + args: + token: WETH + whale: 0x... + amount: "1000" +``` + +--- + +## ๐ŸŽฒ Fuzzing + +Fuzz testing runs scenarios with parameterized inputs: + +```bash +pnpm run strat fuzz scenarios/aave/leveraged-long.yml --iters 100 --seed 42 +``` + +### What Gets Fuzzed + +| Parameter | Variation | Description | +|-----------|-----------|-------------| +| Amounts | ยฑ20% | Randomly vary token amounts | +| Oracle shocks | Within range | Vary oracle shock percentages | +| Fee tiers | Random selection | Test different fee tiers | +| Slippage | Variable | Vary slippage parameters | + +### Features + +- โœ… Each iteration runs on a fresh snapshot +- โœ… Failures don't affect subsequent runs +- โœ… Reproducible with seed parameter +- โœ… Detailed report for all iterations + +--- + +## ๐ŸŒ Network Support + +| Network | Chain ID | Status | +|---------|----------|--------| +| Ethereum Mainnet | 1 | โœ… | +| Base | 8453 | โœ… | +| Arbitrum One | 42161 | โœ… | +| Optimism | 10 | โœ… | +| Polygon | 137 | โœ… | + +> ๐Ÿ’ก Or use chain IDs directly: `--network 1` for mainnet. + +--- + +## ๐Ÿ” Security & Safety + +> โš ๏ธ **IMPORTANT**: This tool is for **local forks and simulations only**. Do **not** use real keys or send transactions on mainnet from this tool. + +Testing "oracle shocks", liquidations, and admin toggles are **defensive simulations** to validate strategy resilience, **not** instructions for real-world exploitation. + +--- + +## ๐Ÿ“š Examples + +See the `scenarios/` directory for example scenarios: + +| Scenario | Description | Path | +|----------|-------------|------| +| **Leveraged Long** | Leveraged long strategy with Aave and Uniswap | `aave/leveraged-long.yml` | +| **Liquidation Drill** | Test liquidation scenarios with oracle shocks | `aave/liquidation-drill.yml` | +| **Supply & Borrow** | Compound v3 supply and borrow example | `compound3/supply-borrow.yml` | + +--- + +## ๐Ÿ”ง Troubleshooting + +### โŒ Token Funding Fails + +If token funding fails, check: + +1. โœ… Whale address has sufficient balance on the fork +2. โœ… Fork supports account impersonation (Anvil) +3. โœ… RPC endpoint allows custom methods + +### โŒ Oracle Shocks Don't Work + +Oracle storage manipulation is complex and may fail if: + +1. โŒ Storage slot calculation is incorrect +2. โŒ Fork doesn't support storage manipulation +3. โŒ Aggregator uses a different storage layout + +> ๐Ÿ’ก The framework will log warnings and continue - verify price changes manually if needed. + +### โŒ Fork Connection Issues + +If the fork fails to start: + +1. โœ… Check RPC URL is correct and accessible +2. โœ… Verify network configuration +3. โœ… Check if fork block number is valid + +--- + +## ๐Ÿš€ Future Enhancements + +- [ ] ๐ŸŽฏ Tenderly backend integration +- [ ] โ›ฝ Gas profiling & diffing +- [ ] ๐Ÿ“Š Risk margin calculators +- [ ] ๐Ÿ“ˆ HTML charts for HF over time +- [ ] ๐Ÿ”Œ More protocol adapters (Maker, Curve, Balancer, etc.) +- [ ] โšก Parallel execution of scenarios +- [ ] ๐Ÿ“ Scenario templates and generators + +--- + +## ๐Ÿค Contributing + +Contributions welcome! Please: + +1. ๐Ÿด Fork the repository +2. ๐ŸŒฟ Create a feature branch +3. โœ๏ธ Make your changes +4. ๐Ÿงช Add tests +5. ๐Ÿ“ค Submit a pull request + +--- + +## ๐Ÿ“„ License + +MIT diff --git a/docs/STRATEGY_TESTING_COMPLETE.md b/docs/STRATEGY_TESTING_COMPLETE.md new file mode 100644 index 0000000..32162df --- /dev/null +++ b/docs/STRATEGY_TESTING_COMPLETE.md @@ -0,0 +1,299 @@ +# ๐ŸŽ‰ DeFi Strategy Testing Framework - Implementation Complete + +## โœ… Completed Features + +### ๐Ÿ”ง Core Engine + +| Feature | Status | Description | +|---------|--------|-------------| +| Fork Orchestrator | โœ… | Anvil/Hardhat support | +| Scenario Runner | โœ… | Step-by-step execution | +| Assertion Evaluator | โœ… | Protocol view support | +| Failure Injector | โœ… | Oracle shocks, time travel, etc. | +| Fuzzer | โœ… | Parameterized inputs | +| Whale Registry | โœ… | Automatic token funding | + +### ๐Ÿ”Œ Protocol Adapters + +#### ๐Ÿฆ Aave v3 Adapter โœ… + +- โœ… Supply, withdraw, borrow, repay +- โœ… Flash loans (simple) +- โœ… Health factor monitoring +- โœ… User account data views + +#### ๐Ÿ”„ Uniswap v3 Adapter โœ… + +- โœ… Exact input/output swaps +- โœ… Slippage handling + +#### ๐Ÿ›๏ธ Compound v3 Adapter โœ… + +- โœ… Supply collateral +- โœ… Borrow base asset (withdraw) +- โœ… Repay debt (supply base asset) +- โœ… Borrow and collateral balance views + +#### ๐Ÿ’ฐ ERC20 Adapter โœ… + +- โœ… Token approvals +- โœ… Balance queries + +### ๐Ÿ’ฅ Failure Injection + +| Feature | Status | Description | +|---------|--------|-------------| +| Oracle shocks | โœ… | Storage manipulation attempt | +| Time travel | โœ… | Advance time | +| Set block timestamp | โœ… | Set block timestamp | +| Liquidity shocks | โœ… | Move liquidity | +| Gas price manipulation | โœ… | Set gas price | +| Reserve pause simulation | โœ… | Pause reserves | +| Cap exhaustion simulation | โœ… | Simulate cap exhaustion | + +### ๐Ÿ“Š Reporting + +| Format | Status | Description | +|--------|--------|-------------| +| JSON Reporter | โœ… | Machine-readable | +| HTML Reporter | โœ… | Human-readable | +| JUnit XML Reporter | โœ… | CI integration | + +### ๐Ÿ“ DSL & Configuration + +- โœ… YAML/JSON scenario loader +- โœ… Schema validation with Zod +- โœ… Network configuration +- โœ… Oracle feed registry +- โœ… Token metadata resolution + +### ๐Ÿ–ฅ๏ธ CLI Commands + +| Command | Status | Description | +|---------|--------|-------------| +| `fork up` | โœ… | Start/manage forks | +| `run` | โœ… | Execute scenarios | +| `fuzz` | โœ… | Fuzz test scenarios | +| `failures` | โœ… | List failure injections | +| `compare` | โœ… | Compare run reports | +| `assert` | โœ… | Re-check assertions (placeholder) | + +### ๐Ÿ“š Example Scenarios + +- โœ… Aave leveraged long strategy +- โœ… Aave liquidation drill +- โœ… Compound v3 supply/borrow + +### ๐Ÿ“– Documentation + +- โœ… Comprehensive strategy testing guide +- โœ… Scenario format documentation +- โœ… API documentation +- โœ… Examples and usage guides + +### ๐Ÿงช Testing Infrastructure + +- โœ… Test script for real fork testing +- โœ… Whale impersonation for token funding +- โœ… Snapshot/revert for fast iterations + +--- + +## ๐ŸŽฏ Key Features + +### ๐Ÿ‹ Automatic Token Funding + +The framework automatically funds test accounts by: + +1. ๐Ÿ“‹ Looking up whale addresses from the registry +2. ๐ŸŽญ Impersonating whales on the fork +3. ๐Ÿ’ธ Transferring tokens to test accounts +4. โœ… Verifying balances + +### ๐Ÿ”ฎ Enhanced Oracle Shocks + +Oracle shocks attempt to modify Chainlink aggregator storage: + +1. ๐Ÿ” Resolve aggregator address from feed name +2. ๐Ÿ“Š Read current price and round ID +3. ๐Ÿงฎ Calculate new price based on percentage delta +4. ๐Ÿ’พ Attempt to modify storage slot (with fallback warnings) +5. ๐Ÿ“ Log detailed information for verification + +### ๐ŸŽฒ Fuzzing Support + +Fuzzing runs scenarios with randomized parameters: + +- โœ… Amounts vary by ยฑ20% +- โœ… Oracle shock percentages vary within ranges +- โœ… Fee tiers randomly selected +- โœ… Slippage parameters varied +- โœ… Each iteration runs on a fresh snapshot + +### ๐Ÿ”Œ Multi-Protocol Support + +The framework supports multiple protocols: + +| Protocol | Features | Status | +|----------|----------|--------| +| Aave v3 | Lending/borrowing | โœ… | +| Uniswap v3 | Swaps | โœ… | +| Compound v3 | Lending/borrowing | โœ… | +| ERC20 tokens | Approvals, balances | โœ… | + +--- + +## ๐Ÿ“Š Usage Examples + +### Basic Scenario Run + +```bash +pnpm run strat run scenarios/aave/leveraged-long.yml +``` + +### Fuzz Testing + +```bash +pnpm run strat fuzz scenarios/aave/leveraged-long.yml --iters 100 --seed 42 +``` + +### With Reports + +```bash +pnpm run strat run scenarios/aave/leveraged-long.yml \ + --report out/run.json \ + --html out/report.html \ + --junit out/junit.xml +``` + +### Test Script + +```bash +export MAINNET_RPC_URL=https://mainnet.infura.io/v3/YOUR_KEY +pnpm run strat:test +``` + +--- + +## ๐Ÿ”ง Technical Implementation + +### ๐Ÿด Fork Orchestration + +- โœ… Supports Anvil (Foundry) and Hardhat +- โœ… Snapshot/revert for fast iterations +- โœ… Account impersonation for whale funding +- โœ… Storage manipulation for oracle overrides +- โœ… Time travel for interest accrual testing + +### ๐Ÿ”Œ Protocol Adapters + +- โœ… Clean interface for adding new protocols +- โœ… Automatic address discovery +- โœ… View functions for assertions +- โœ… Invariant checking after each step + +### ๐Ÿ’ฅ Failure Injection + +- โœ… Protocol-agnostic failures (oracle, time, gas) +- โœ… Protocol-specific failures (pause, caps) +- โœ… Storage manipulation where possible +- โœ… Fallback warnings when manipulation fails + +### ๐Ÿ‹ Token Funding + +- โœ… Whale registry for known addresses +- โœ… Automatic impersonation +- โœ… Transfer execution +- โœ… Balance verification +- โœ… Graceful degradation on failure + +--- + +## ๐Ÿš€ Next Steps (Future Enhancements) + +While the core framework is complete, future enhancements could include: + +### ๐Ÿ”Œ More Protocol Adapters + +- [ ] Maker DAO +- [ ] Curve +- [ ] Balancer +- [ ] Lido + +### ๐Ÿ’ฅ Enhanced Failure Injection + +- [ ] More reliable oracle manipulation +- [ ] Protocol-specific failure modes +- [ ] Custom failure scenarios + +### ๐ŸŽฒ Advanced Fuzzing + +- [ ] Property-based testing +- [ ] Mutation testing +- [ ] Coverage-guided fuzzing + +### ๐Ÿ”— Integration + +- [ ] Tenderly backend +- [ ] CI/CD integration +- [ ] Dashboard/UI + +### ๐Ÿ“Š Analysis + +- [ ] Gas profiling +- [ ] Risk margin calculators +- [ ] Historical backtesting + +--- + +## ๐Ÿ“ Notes + +### ๐Ÿ”ฎ Oracle Manipulation + +Oracle storage manipulation is complex and may not work on all forks. The framework attempts the manipulation and logs warnings if it fails. For production use, consider: + +- โœ… Using mock oracles +- โœ… Deploying custom aggregators +- โœ… Using Tenderly's simulation capabilities + +### ๐Ÿ‹ Token Funding + +Token funding relies on: + +- โœ… Whale addresses having sufficient balances +- โœ… Fork supporting account impersonation +- โœ… RPC endpoint allowing custom methods + +If funding fails, accounts can be manually funded or alternative methods used. + +### ๐Ÿด Fork Requirements + +For best results, use: + +- โœ… Anvil (Foundry) for local forks +- โœ… RPC endpoints that support custom methods +- โœ… Sufficient block history for protocol state + +--- + +## ๐ŸŽ‰ Conclusion + +The DeFi Strategy Testing Framework is now complete with: + +- โœ… Full protocol adapter support (Aave, Uniswap, Compound) +- โœ… Comprehensive failure injection +- โœ… Fuzzing capabilities +- โœ… Automatic token funding +- โœ… Multiple report formats +- โœ… Complete documentation + +The framework is ready for use in testing DeFi strategies against local mainnet forks with both success and failure scenarios. + +--- + +## ๐Ÿ“š Related Documentation + +- ๐Ÿ“– [Strategy Testing Guide](./STRATEGY_TESTING.md) +- โš™๏ธ [Environment Setup](./ENV_SETUP.md) +- ๐Ÿ”— [Chain Configuration](./CHAIN_CONFIG.md) +- ๐Ÿ” [Security Best Practices](./SECURITY.md) diff --git a/examples/subgraphs/aave-positions.graphql b/examples/subgraphs/aave-positions.graphql new file mode 100644 index 0000000..1219225 --- /dev/null +++ b/examples/subgraphs/aave-positions.graphql @@ -0,0 +1,225 @@ +# Aave v3: Query user positions and reserves +# +# Endpoint: https://api.thegraph.com/subgraphs/name/aave/aave-v3-[chain] +# Replace [chain] with: ethereum, base, arbitrum, etc. +# +# Example queries for: +# - User positions (supplies, borrows) +# - Reserve data +# - Historical data + +# Query user position (supplies and borrows) +query GetUserPosition($userAddress: String!) { + user(id: $userAddress) { + id + reserves { + id + reserve { + id + symbol + name + decimals + underlyingAsset + liquidityRate + variableBorrowRate + stableBorrowRate + aToken { + id + } + vToken { + id + } + sToken { + id + } + } + currentATokenBalance + currentStableDebt + currentVariableDebt + principalStableDebt + scaledVariableDebt + liquidityRate + usageAsCollateralEnabledOnUser + reserve { + price { + priceInEth + priceInUsd + } + } + } + } +} + +# Query reserve data +query GetReserves($first: Int = 100) { + reserves( + orderBy: totalLiquidity + orderDirection: desc + first: $first + ) { + id + symbol + name + decimals + underlyingAsset + pool { + id + } + price { + priceInEth + priceInUsd + } + totalLiquidity + availableLiquidity + totalATokenSupply + totalCurrentVariableDebt + totalStableDebt + liquidityRate + variableBorrowRate + stableBorrowRate + utilizationRate + baseLTVasCollateral + liquidationThreshold + liquidationBonus + reserveLiquidationThreshold + reserveLiquidationBonus + reserveFactor + aToken { + id + } + vToken { + id + } + sToken { + id + } + } +} + +# Query user transaction history +query GetUserTransactions($userAddress: String!, $first: Int = 100) { + userTransactions( + where: { user: $userAddress } + orderBy: timestamp + orderDirection: desc + first: $first + ) { + id + timestamp + pool { + id + } + user { + id + } + reserve { + symbol + underlyingAsset + } + action + amount + referrer + onBehalfOf + } +} + +# Query deposits +query GetDeposits($userAddress: String!, $first: Int = 100) { + deposits( + where: { user: $userAddress } + orderBy: timestamp + orderDirection: desc + first: $first + ) { + id + timestamp + user { + id + } + reserve { + symbol + underlyingAsset + } + amount + onBehalfOf + referrer + } +} + +# Query borrows +query GetBorrows($userAddress: String!, $first: Int = 100) { + borrows( + where: { user: $userAddress } + orderBy: timestamp + orderDirection: desc + first: $first + ) { + id + timestamp + user { + id + } + reserve { + symbol + underlyingAsset + } + amount + borrowRate + borrowRateMode + onBehalfOf + referrer + } +} + +# Query repays +query GetRepays($userAddress: String!, $first: Int = 100) { + repays( + where: { user: $userAddress } + orderBy: timestamp + orderDirection: desc + first: $first + ) { + id + timestamp + user { + id + } + reserve { + symbol + underlyingAsset + } + amount + useATokens + onBehalfOf + } +} + +# Query liquidations +query GetLiquidations($first: Int = 100) { + liquidations( + orderBy: timestamp + orderDirection: desc + first: $first + ) { + id + timestamp + pool { + id + } + user { + id + } + collateralReserve { + symbol + underlyingAsset + } + collateralAmount + principalReserve { + symbol + underlyingAsset + } + principalAmount + liquidator + } +} + diff --git a/examples/subgraphs/cross-protocol-analytics.graphql b/examples/subgraphs/cross-protocol-analytics.graphql new file mode 100644 index 0000000..bd1c59f --- /dev/null +++ b/examples/subgraphs/cross-protocol-analytics.graphql @@ -0,0 +1,146 @@ +# Cross-Protocol Analytics: Query data across multiple protocols +# +# This is a conceptual example showing how you might query multiple subgraphs +# to analyze cross-protocol strategies and positions. +# +# In production, you would: +# 1. Query multiple subgraphs (Uniswap, Aave, etc.) +# 2. Combine the data +# 3. Calculate metrics like: +# - Total TVL across protocols +# - Cross-protocol arbitrage opportunities +# - User positions across protocols +# - Protocol interaction patterns + +# Example: Query user's Aave position and Uniswap LP positions +# (This would require querying two separate subgraphs and combining results) + +# Query 1: Get user's Aave positions +# (Use Aave subgraph - see aave-positions.graphql) + +# Query 2: Get user's Uniswap v3 positions +query GetUserUniswapPositions($userAddress: String!) { + positions( + where: { owner: $userAddress } + first: 100 + ) { + id + owner + pool { + id + token0 { + symbol + } + token1 { + symbol + } + feeTier + } + liquidity + depositedToken0 + depositedToken1 + withdrawnToken0 + withdrawnToken1 + collectedFeesToken0 + collectedFeesToken1 + transaction { + timestamp + } + } +} + +# Query 3: Get protocol volumes (for analytics) +query GetProtocolVolumes { + # Uniswap volume (example) + uniswapDayDatas( + orderBy: date + orderDirection: desc + first: 30 + ) { + date + dailyVolumeUSD + totalVolumeUSD + tvlUSD + } + + # Aave volume (example - would need Aave subgraph) + # aaveDayDatas { + # date + # dailyDepositsUSD + # dailyBorrowsUSD + # totalValueLockedUSD + # } +} + +# Query 4: Get token prices across protocols +query GetTokenPrices($tokenAddress: String!) { + # Uniswap price + token(id: $tokenAddress) { + id + symbol + name + decimals + derivedETH + poolCount + totalValueLocked + totalValueLockedUSD + volume + volumeUSD + feesUSD + txCount + pools { + id + token0 { + symbol + } + token1 { + symbol + } + token0Price + token1Price + totalValueLockedUSD + } + } + + # Aave reserve price (would need Aave subgraph) + # reserve(id: $tokenAddress) { + # id + # symbol + # price { + # priceInUsd + # } + # } +} + +# Query 5: Get arbitrage opportunities +# (Conceptual - would require real-time price comparison) +query GetArbitrageOpportunities { + # Get pools with significant price differences + # This is a simplified example - real arbitrage detection is more complex + pools( + where: { + # Filter by high volume and liquidity + totalValueLockedUSD_gt: "1000000" + volumeUSD_gt: "100000" + } + orderBy: volumeUSD + orderDirection: desc + first: 50 + ) { + id + token0 { + symbol + } + token1 { + symbol + } + token0Price + token1Price + feeTier + volumeUSD + tvlUSD + # Compare with prices from other DEXes/AMMs + # (would require additional queries) + } +} + diff --git a/examples/subgraphs/uniswap-v3-pools.graphql b/examples/subgraphs/uniswap-v3-pools.graphql new file mode 100644 index 0000000..dccf362 --- /dev/null +++ b/examples/subgraphs/uniswap-v3-pools.graphql @@ -0,0 +1,137 @@ +# Uniswap v3: Query pool data and swap information +# +# Endpoint: https://api.thegraph.com/subgraphs/name/uniswap/uniswap-v3 +# +# Example queries for: +# - Pool information +# - Token prices +# - Swap history +# - Liquidity data + +# Query pool by token pair +query GetPoolByPair($token0: String!, $token1: String!, $fee: BigInt!) { + pools( + where: { + token0: $token0, + token1: $token1, + feeTier: $fee + } + orderBy: totalValueLockedUSD + orderDirection: desc + first: 1 + ) { + id + token0 { + id + symbol + name + decimals + } + token1 { + id + symbol + name + decimals + } + feeTier + liquidity + sqrtPrice + tick + token0Price + token1Price + volumeUSD + tvlUSD + totalValueLockedUSD + } +} + +# Query swap history for a pool +query GetPoolSwaps($poolId: String!, $first: Int = 100) { + swaps( + where: { pool: $poolId } + orderBy: timestamp + orderDirection: desc + first: $first + ) { + id + timestamp + transaction { + id + blockNumber + } + pool { + id + token0 { + symbol + } + token1 { + symbol + } + } + sender + recipient + amount0 + amount1 + amountUSD + sqrtPriceX96 + tick + } +} + +# Query pool day data for historical analysis +query GetPoolDayData($poolId: String!, $days: Int = 30) { + poolDayDatas( + where: { pool: $poolId } + orderBy: date + orderDirection: desc + first: $days + ) { + id + date + pool { + id + token0 { + symbol + } + token1 { + symbol + } + } + liquidity + sqrtPrice + token0Price + token1Price + volumeUSD + tvlUSD + feesUSD + open + high + low + close + } +} + +# Query top pools by TVL +query GetTopPoolsByTVL($first: Int = 10) { + pools( + orderBy: totalValueLockedUSD + orderDirection: desc + first: $first + ) { + id + token0 { + symbol + name + } + token1 { + symbol + name + } + feeTier + liquidity + volumeUSD + tvlUSD + totalValueLockedUSD + } +} + diff --git a/examples/ts/aave-flashloan-multi.ts b/examples/ts/aave-flashloan-multi.ts new file mode 100644 index 0000000..1f645c4 --- /dev/null +++ b/examples/ts/aave-flashloan-multi.ts @@ -0,0 +1,116 @@ +/** + * Aave v3: Multi-asset flash loan + * + * This example demonstrates how to execute a flash loan for multiple assets. + * Useful for arbitrage opportunities across multiple tokens. + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getAavePoolAddress } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import type { Address, Hex } from 'viem'; + +const CHAIN_ID = 1; // Mainnet +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// Aave Pool ABI +const POOL_ABI = [ + { + name: 'flashLoan', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'receiverAddress', type: 'address' }, + { name: 'assets', type: 'address[]' }, + { name: 'amounts', type: 'uint256[]' }, + { name: 'modes', type: 'uint256[]' }, + { name: 'onBehalfOf', type: 'address' }, + { name: 'params', type: 'bytes' }, + { name: 'referralCode', type: 'uint16' }, + ], + outputs: [], + }, +] as const; + +/** + * Flash loan modes: + * 0: No debt (just flash loan, repay fully) + * 1: Stable debt (deprecated in v3.3+) + * 2: Variable debt (open debt position) + */ +const FLASH_LOAN_MODE_NO_DEBT = 0; +const FLASH_LOAN_MODE_VARIABLE_DEBT = 2; + +const FLASH_LOAN_RECEIVER = process.env.FLASH_LOAN_RECEIVER as `0x${string}`; + +async function flashLoanMulti() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const poolAddress = getAavePoolAddress(CHAIN_ID); + + // Multiple tokens for flash loan + const tokens = [ + getTokenMetadata(CHAIN_ID, 'USDC'), + getTokenMetadata(CHAIN_ID, 'USDT'), + ]; + + const amounts = [ + parseTokenAmount('10000', tokens[0].decimals), // 10,000 USDC + parseTokenAmount('5000', tokens[1].decimals), // 5,000 USDT + ]; + + const assets = tokens.map(t => t.address); + const modes = [FLASH_LOAN_MODE_NO_DEBT, FLASH_LOAN_MODE_NO_DEBT]; + + console.log('Executing multi-asset flash loan:'); + tokens.forEach((token, i) => { + console.log(` ${amounts[i]} ${token.symbol}`); + }); + console.log(`Pool: ${poolAddress}`); + console.log(`Receiver: ${FLASH_LOAN_RECEIVER}`); + + if (!FLASH_LOAN_RECEIVER) { + throw new Error('FLASH_LOAN_RECEIVER environment variable not set'); + } + + // Execute multi-asset flash loan + // The receiver contract must: + // 1. Receive all loaned tokens + // 2. Perform desired operations (e.g., arbitrage) + // 3. For each asset, approve the pool for (amount + premium) + // 4. If mode = 2, approve for amount only (premium added to debt) + // 5. Return true from executeOperation + const tx = await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'flashLoan', + args: [ + FLASH_LOAN_RECEIVER, + assets, + amounts, + modes, + account, // onBehalfOf + '0x' as Hex, // Optional params + 0, // Referral code + ], + }); + + await waitForTransaction(publicClient, tx); + console.log(`Multi-asset flash loan executed: ${tx}`); + console.log('\nโœ… Multi-asset flash loan completed successfully!'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + flashLoanMulti().catch(console.error); +} + +export { flashLoanMulti }; + diff --git a/examples/ts/aave-flashloan-simple.ts b/examples/ts/aave-flashloan-simple.ts new file mode 100644 index 0000000..42de478 --- /dev/null +++ b/examples/ts/aave-flashloan-simple.ts @@ -0,0 +1,104 @@ +/** + * Aave v3: Single-asset flash loan + * + * This example demonstrates how to execute a flash loan for a single asset. + * Flash loans must be repaid within the same transaction, including a premium. + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getAavePoolAddress } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import type { Address, Hex } from 'viem'; + +const CHAIN_ID = 1; // Mainnet +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// Aave Pool ABI +const POOL_ABI = [ + { + name: 'flashLoanSimple', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'receiverAddress', type: 'address' }, + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'params', type: 'bytes' }, + { name: 'referralCode', type: 'uint16' }, + ], + outputs: [], + }, +] as const; + +// Flash loan receiver contract ABI (you need to deploy this) +interface IFlashLoanReceiver { + executeOperation: ( + asset: Address, + amount: bigint, + premium: bigint, + initiator: Address, + params: Hex + ) => Promise; +} + +/** + * Example flash loan receiver contract address + * + * In production, you would deploy your own flash loan receiver contract + * that implements IFlashLoanReceiver and performs your desired logic. + */ +const FLASH_LOAN_RECEIVER = process.env.FLASH_LOAN_RECEIVER as `0x${string}`; + +async function flashLoanSimple() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const poolAddress = getAavePoolAddress(CHAIN_ID); + const token = getTokenMetadata(CHAIN_ID, 'USDC'); + const amount = parseTokenAmount('10000', token.decimals); // 10,000 USDC + + console.log(`Executing flash loan for ${amount} ${token.symbol}`); + console.log(`Pool: ${poolAddress}`); + console.log(`Receiver: ${FLASH_LOAN_RECEIVER}`); + + if (!FLASH_LOAN_RECEIVER) { + throw new Error('FLASH_LOAN_RECEIVER environment variable not set'); + } + + // Execute flash loan + // The receiver contract must: + // 1. Receive the loaned tokens + // 2. Perform desired operations + // 3. Approve the pool for (amount + premium) + // 4. Return true from executeOperation + const tx = await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'flashLoanSimple', + args: [ + FLASH_LOAN_RECEIVER, // Your flash loan receiver contract + token.address, + amount, + '0x' as Hex, // Optional params + 0, // Referral code + ], + }); + + await waitForTransaction(publicClient, tx); + console.log(`Flash loan executed: ${tx}`); + console.log('\nโœ… Flash loan completed successfully!'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + flashLoanSimple().catch(console.error); +} + +export { flashLoanSimple }; + diff --git a/examples/ts/aave-pool-discovery.ts b/examples/ts/aave-pool-discovery.ts new file mode 100644 index 0000000..bf5f1a5 --- /dev/null +++ b/examples/ts/aave-pool-discovery.ts @@ -0,0 +1,96 @@ +/** + * Aave v3: Pool discovery using PoolAddressesProvider + * + * This example demonstrates how to discover the Aave Pool address + * using the PoolAddressesProvider service discovery pattern. + * This is the recommended way to get the Pool address in production. + */ + +import { createRpcClient } from '../../src/utils/chain-config.js'; +import { getAavePoolAddressesProvider } from '../../src/utils/addresses.js'; + +const CHAIN_ID = 1; // Mainnet + +// PoolAddressesProvider ABI +const ADDRESSES_PROVIDER_ABI = [ + { + name: 'getPool', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, + { + name: 'getPoolDataProvider', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, + { + name: 'getPriceOracle', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, +] as const; + +async function discoverPool() { + const publicClient = createRpcClient(CHAIN_ID); + const addressesProvider = getAavePoolAddressesProvider(CHAIN_ID); + + console.log('Discovering Aave v3 Pool addresses...'); + console.log(`Chain ID: ${CHAIN_ID}`); + console.log(`PoolAddressesProvider: ${addressesProvider}\n`); + + // Get Pool address + const poolAddress = await publicClient.readContract({ + address: addressesProvider, + abi: ADDRESSES_PROVIDER_ABI, + functionName: 'getPool', + }); + + console.log(`โœ… Pool: ${poolAddress}`); + + // Get PoolDataProvider address (for querying reserves, user data, etc.) + try { + const dataProviderAddress = await publicClient.readContract({ + address: addressesProvider, + abi: ADDRESSES_PROVIDER_ABI, + functionName: 'getPoolDataProvider', + }); + console.log(`โœ… PoolDataProvider: ${dataProviderAddress}`); + } catch (error) { + console.log('โš ๏ธ PoolDataProvider not available (may be using different method)'); + } + + // Get PriceOracle address + try { + const priceOracleAddress = await publicClient.readContract({ + address: addressesProvider, + abi: ADDRESSES_PROVIDER_ABI, + functionName: 'getPriceOracle', + }); + console.log(`โœ… PriceOracle: ${priceOracleAddress}`); + } catch (error) { + console.log('โš ๏ธ PriceOracle not available (may be using different method)'); + } + + console.log('\nโœ… Pool discovery completed!'); + console.log('\nUse the Pool address for all Aave v3 operations:'); + console.log(` - supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode)`); + console.log(` - withdraw(address asset, uint256 amount, address to)`); + console.log(` - borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf)`); + console.log(` - repay(address asset, uint256 amount, uint256 rateMode, address onBehalfOf)`); + console.log(` - flashLoanSimple(address receiverAddress, address asset, uint256 amount, bytes params, uint16 referralCode)`); + console.log(` - flashLoan(address receiverAddress, address[] assets, uint256[] amounts, uint256[] modes, address onBehalfOf, bytes params, uint16 referralCode)`); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + discoverPool().catch(console.error); +} + +export { discoverPool }; + diff --git a/examples/ts/aave-supply-borrow.ts b/examples/ts/aave-supply-borrow.ts new file mode 100644 index 0000000..3e118ee --- /dev/null +++ b/examples/ts/aave-supply-borrow.ts @@ -0,0 +1,161 @@ +/** + * Aave v3: Supply collateral, enable as collateral, and borrow + * + * This example demonstrates: + * 1. Supplying assets to Aave v3 + * 2. Enabling supplied asset as collateral + * 3. Borrowing against collateral + * + * Note: In Aave v3.3+, stable-rate borrowing has been deprecated. Use variable rate (mode = 2). + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getAavePoolAddress } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import { parseUnits } from 'viem'; + +const CHAIN_ID = 1; // Mainnet (change to 8453 for Base, 42161 for Arbitrum, etc.) +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// ABI for Aave Pool +const POOL_ABI = [ + { + name: 'supply', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'onBehalfOf', type: 'address' }, + { name: 'referralCode', type: 'uint16' }, + ], + outputs: [], + }, + { + name: 'setUserUseReserveAsCollateral', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'useAsCollateral', type: 'bool' }, + ], + outputs: [], + }, + { + name: 'borrow', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'interestRateMode', type: 'uint256' }, + { name: 'referralCode', type: 'uint16' }, + { name: 'onBehalfOf', type: 'address' }, + ], + outputs: [], + }, +] as const; + +// ERC20 ABI for approvals +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, + { + name: 'allowance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'owner', type: 'address' }, + { name: 'spender', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +async function supplyAndBorrow() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const poolAddress = getAavePoolAddress(CHAIN_ID); + + // Token configuration + const collateralToken = getTokenMetadata(CHAIN_ID, 'USDC'); + const debtToken = getTokenMetadata(CHAIN_ID, 'USDT'); + + // Amounts + const supplyAmount = parseTokenAmount('1000', collateralToken.decimals); + const borrowAmount = parseTokenAmount('500', debtToken.decimals); + + console.log(`Supplying ${supplyAmount} ${collateralToken.symbol}`); + console.log(`Borrowing ${borrowAmount} ${debtToken.symbol}`); + console.log(`Pool: ${poolAddress}`); + console.log(`Account: ${account}`); + + // Step 1: Approve token spending + console.log('\n1. Approving token spending...'); + const approveTx = await walletClient.writeContract({ + address: collateralToken.address, + abi: ERC20_ABI, + functionName: 'approve', + args: [poolAddress, supplyAmount], + }); + await waitForTransaction(publicClient, approveTx); + console.log(`Approved: ${approveTx}`); + + // Step 2: Supply collateral + console.log('\n2. Supplying collateral...'); + const supplyTx = await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'supply', + args: [collateralToken.address, supplyAmount, account, 0], + }); + await waitForTransaction(publicClient, supplyTx); + console.log(`Supplied: ${supplyTx}`); + + // Step 3: Enable as collateral + console.log('\n3. Enabling as collateral...'); + const enableCollateralTx = await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'setUserUseReserveAsCollateral', + args: [collateralToken.address, true], + }); + await waitForTransaction(publicClient, enableCollateralTx); + console.log(`Enabled collateral: ${enableCollateralTx}`); + + // Step 4: Borrow (variable rate = 2, stable rate is deprecated) + console.log('\n4. Borrowing...'); + const borrowTx = await walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'borrow', + args: [debtToken.address, borrowAmount, 2, 0, account], // mode 2 = variable + }); + await waitForTransaction(publicClient, borrowTx); + console.log(`Borrowed: ${borrowTx}`); + + console.log('\nโœ… Supply and borrow completed successfully!'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + supplyAndBorrow().catch(console.error); +} + +export { supplyAndBorrow }; + diff --git a/examples/ts/compound3-supply-borrow.ts b/examples/ts/compound3-supply-borrow.ts new file mode 100644 index 0000000..fd9e8f2 --- /dev/null +++ b/examples/ts/compound3-supply-borrow.ts @@ -0,0 +1,176 @@ +/** + * Compound III: Supply collateral and borrow base asset + * + * This example demonstrates how to: + * 1. Supply collateral to Compound III + * 2. Borrow the base asset (e.g., USDC) + * + * Note: In Compound III, you "borrow" by withdrawing the base asset + * after supplying collateral. There's one base asset per market. + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getCompound3Comet } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; + +const CHAIN_ID = 1; // Mainnet +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// Compound III Comet ABI +const COMET_ABI = [ + { + name: 'supply', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [], + }, + { + name: 'withdraw', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [], + }, + { + name: 'baseToken', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, + { + name: 'getBorrowBalance', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'getCollateralBalance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'account', type: 'address' }, + { name: 'asset', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +// ERC20 ABI for approvals +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, +] as const; + +async function supplyAndBorrow() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const cometAddress = getCompound3Comet(CHAIN_ID); + + // Get base token (USDC for USDC market) + console.log('Querying Comet contract...'); + const baseToken = await publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'baseToken', + }) as `0x${string}`; + + console.log(`Comet: ${cometAddress}`); + console.log(`Base token: ${baseToken}`); + + // Use WETH as collateral (adjust based on market) + const collateralToken = getTokenMetadata(CHAIN_ID, 'WETH'); + const baseTokenMetadata = getTokenMetadata(CHAIN_ID, 'USDC'); // Assuming USDC market + + const collateralAmount = parseTokenAmount('1', collateralToken.decimals); // 1 WETH + const borrowAmount = parseTokenAmount('2000', baseTokenMetadata.decimals); // 2000 USDC + + console.log(`\nSupplying ${collateralAmount} ${collateralToken.symbol} as collateral`); + console.log(`Borrowing ${borrowAmount} ${baseTokenMetadata.symbol} (base asset)`); + + // Step 1: Approve collateral token + console.log('\n1. Approving collateral token...'); + const approveTx = await walletClient.writeContract({ + address: collateralToken.address, + abi: ERC20_ABI, + functionName: 'approve', + args: [cometAddress, collateralAmount], + }); + await waitForTransaction(publicClient, approveTx); + console.log(`Approved: ${approveTx}`); + + // Step 2: Supply collateral + console.log('\n2. Supplying collateral...'); + const supplyTx = await walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'supply', + args: [collateralToken.address, collateralAmount], + }); + await waitForTransaction(publicClient, supplyTx); + console.log(`Supplied: ${supplyTx}`); + + // Step 3: "Borrow" by withdrawing base asset + // In Compound III, borrowing is done by withdrawing the base asset + console.log('\n3. Borrowing base asset (withdrawing)...'); + const borrowTx = await walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'withdraw', + args: [baseToken, borrowAmount], + }); + await waitForTransaction(publicClient, borrowTx); + console.log(`Borrowed: ${borrowTx}`); + + // Step 4: Check balances + console.log('\n4. Checking positions...'); + const borrowBalance = await publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'getBorrowBalance', + args: [account], + }) as bigint; + + const collateralBalance = await publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'getCollateralBalance', + args: [account, collateralToken.address], + }) as bigint; + + console.log(`Borrow balance: ${borrowBalance} ${baseTokenMetadata.symbol}`); + console.log(`Collateral balance: ${collateralBalance} ${collateralToken.symbol}`); + + console.log('\nโœ… Supply and borrow completed successfully!'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + supplyAndBorrow().catch(console.error); +} + +export { supplyAndBorrow }; + diff --git a/examples/ts/flashloan-arbitrage.ts b/examples/ts/flashloan-arbitrage.ts new file mode 100644 index 0000000..99767f6 --- /dev/null +++ b/examples/ts/flashloan-arbitrage.ts @@ -0,0 +1,82 @@ +/** + * Cross-Protocol: Flash loan arbitrage pattern + * + * This example demonstrates a flash loan arbitrage strategy: + * 1. Flash loan USDC from Aave + * 2. Swap USDC โ†’ DAI on Uniswap v3 + * 3. Swap DAI โ†’ USDC on another DEX (or different pool) + * 4. Repay flash loan with premium + * 5. Keep profit + * + * Note: This is a conceptual example. Real arbitrage requires: + * - Price difference detection + * - Gas cost calculation + * - Slippage protection + * - MEV protection + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getAavePoolAddress, getUniswapSwapRouter02 } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import type { Address } from 'viem'; + +const CHAIN_ID = 1; // Mainnet +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +/** + * Flash loan receiver contract for arbitrage + * + * In production, you would deploy a contract that: + * 1. Receives flash loan from Aave + * 2. Executes arbitrage swaps + * 3. Repays flash loan + * 4. Sends profit to owner + * + * See contracts/examples/AaveFlashLoanReceiver.sol for Solidity implementation + */ +const ARBITRAGE_CONTRACT = process.env.ARBITRAGE_CONTRACT as `0x${string}`; + +async function flashLoanArbitrage() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const poolAddress = getAavePoolAddress(CHAIN_ID); + const token = getTokenMetadata(CHAIN_ID, 'USDC'); + const amount = parseTokenAmount('100000', token.decimals); // 100,000 USDC + + console.log('Flash loan arbitrage strategy:'); + console.log(` 1. Flash loan ${amount} ${token.symbol} from Aave`); + console.log(` 2. Execute arbitrage swaps`); + console.log(` 3. Repay flash loan`); + console.log(` 4. Keep profit`); + console.log(`\nArbitrage contract: ${ARBITRAGE_CONTRACT}`); + + if (!ARBITRAGE_CONTRACT) { + throw new Error('ARBITRAGE_CONTRACT environment variable not set'); + } + + // Note: In production, this would be done through a smart contract + // that implements IFlashLoanReceiver and executes the arbitrage logic + console.log('\nโš ๏ธ This is a conceptual example.'); + console.log('In production:'); + console.log(' 1. Deploy a flash loan receiver contract'); + console.log(' 2. Contract receives flash loan'); + console.log(' 3. Contract executes arbitrage (swaps)'); + console.log(' 4. Contract repays flash loan + premium'); + console.log(' 5. Contract sends profit to owner'); + console.log('\nSee contracts/examples/AaveFlashLoanReceiver.sol for implementation'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + flashLoanArbitrage().catch(console.error); +} + +export { flashLoanArbitrage }; + diff --git a/examples/ts/protocolink-batch.ts b/examples/ts/protocolink-batch.ts new file mode 100644 index 0000000..f4e9802 --- /dev/null +++ b/examples/ts/protocolink-batch.ts @@ -0,0 +1,135 @@ +/** + * Protocolink: Complex multi-step batch transactions + * + * This example demonstrates how to build complex multi-step transactions + * using Protocolink, such as: + * - Flash loan + * - Swap + * - Supply + * - Borrow + * - Repay + * All in one transaction! + */ + +import * as api from '@protocolink/api'; +import * as common from '@protocolink/common'; +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; + +const CHAIN_ID = common.ChainId.mainnet; +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +async function batchComplexTransaction() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const USDC: common.Token = { + chainId: CHAIN_ID, + address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', + decimals: 6, + symbol: 'USDC', + name: 'USD Coin', + }; + + const USDT: common.Token = { + chainId: CHAIN_ID, + address: '0xdAC17F958D2ee523a2206206994597C13D831ec7', + decimals: 6, + symbol: 'USDT', + name: 'Tether USD', + }; + + console.log('Building complex batch transaction:'); + console.log(' 1. Flash loan USDC'); + console.log(' 2. Supply USDC to Aave'); + console.log(' 3. Borrow USDT from Aave'); + console.log(' 4. Swap USDT โ†’ USDC'); + console.log(' 5. Repay flash loan'); + console.log(`Account: ${account}`); + + try { + const logics: any[] = []; + const flashLoanAmount = '10000'; // 10,000 USDC + + // Step 1: Flash loan logic (using utility flash loan) + console.log('\n1. Adding flash loan logic...'); + const flashLoanQuotation = await api.utility.getFlashLoanQuotation(CHAIN_ID, { + loans: [{ token: USDC, amount: flashLoanAmount }], + }); + const flashLoanLogic = api.utility.newFlashLoanLogic(flashLoanQuotation); + logics.push(flashLoanLogic); + + // Step 2: Supply logic + console.log('2. Adding supply logic...'); + const supplyQuotation = await api.protocols.aavev3.getSupplyQuotation(CHAIN_ID, { + input: { token: USDC, amount: flashLoanAmount }, + }); + const supplyLogic = api.protocols.aavev3.newSupplyLogic(supplyQuotation); + logics.push(supplyLogic); + + // Step 3: Borrow logic + console.log('3. Adding borrow logic...'); + const borrowAmount = '5000'; // 5,000 USDT + const borrowQuotation = await api.protocols.aavev3.getBorrowQuotation(CHAIN_ID, { + output: { token: USDT, amount: borrowAmount }, + }); + const borrowLogic = api.protocols.aavev3.newBorrowLogic(borrowQuotation); + logics.push(borrowLogic); + + // Step 4: Swap logic + console.log('4. Adding swap logic...'); + const swapQuotation = await api.protocols.uniswapv3.getSwapTokenQuotation(CHAIN_ID, { + input: { token: USDT, amount: borrowAmount }, + tokenOut: USDC, + slippage: 100, // 1% slippage + }); + const swapLogic = api.protocols.uniswapv3.newSwapTokenLogic(swapQuotation); + logics.push(swapLogic); + + // Step 5: Flash loan repay logic + console.log('5. Adding flash loan repay logic...'); + const flashLoanRepayLogic = api.utility.newFlashLoanRepayLogic({ + id: flashLoanLogic.id, + input: swapQuotation.output, // Use swapped USDC to repay + }); + logics.push(flashLoanRepayLogic); + + // Step 6: Get router data and execute + console.log('\n6. Building router transaction...'); + const routerData = await api.router.getRouterData(CHAIN_ID, { + account, + logics, + }); + + console.log(`Router: ${routerData.router}`); + console.log(`Estimated gas: ${routerData.estimation.gas}`); + + console.log('\n7. Executing transaction...'); + const tx = await walletClient.sendTransaction({ + to: routerData.router, + data: routerData.data, + value: BigInt(routerData.estimation.value || '0'), + gas: BigInt(routerData.estimation.gas), + }); + + await waitForTransaction(publicClient, tx); + console.log(`Transaction executed: ${tx}`); + console.log('\nโœ… Complex batch transaction completed successfully!'); + } catch (error) { + console.error('Error executing batch transaction:', error); + throw error; + } +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + batchComplexTransaction().catch(console.error); +} + +export { batchComplexTransaction }; + diff --git a/examples/ts/protocolink-compose.ts b/examples/ts/protocolink-compose.ts new file mode 100644 index 0000000..3c205ef --- /dev/null +++ b/examples/ts/protocolink-compose.ts @@ -0,0 +1,114 @@ +/** + * Protocolink: Multi-protocol composition (swap โ†’ supply) + * + * This example demonstrates how to compose multiple DeFi operations + * into a single transaction using Protocolink. + * + * Example: Swap USDC โ†’ WBTC on Uniswap v3, then supply WBTC to Aave v3 + */ + +import * as api from '@protocolink/api'; +import * as common from '@protocolink/common'; +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; + +const CHAIN_ID = common.ChainId.mainnet; // 1 for mainnet, 8453 for Base, etc. +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +async function composeSwapAndSupply() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + // Token definitions + const USDC: common.Token = { + chainId: CHAIN_ID, + address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', + decimals: 6, + symbol: 'USDC', + name: 'USD Coin', + }; + + const WBTC: common.Token = { + chainId: CHAIN_ID, + address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599', + decimals: 8, + symbol: 'WBTC', + name: 'Wrapped Bitcoin', + }; + + const amountIn = '1000'; // 1000 USDC + const slippage = 100; // 1% slippage tolerance in basis points + + console.log(`Composing transaction: Swap ${amountIn} USDC โ†’ WBTC, then supply to Aave`); + console.log(`Chain ID: ${CHAIN_ID}`); + console.log(`Account: ${account}`); + + try { + // Step 1: Get swap quotation from Uniswap v3 + console.log('\n1. Getting swap quotation...'); + const swapQuotation = await api.protocols.uniswapv3.getSwapTokenQuotation(CHAIN_ID, { + input: { token: USDC, amount: amountIn }, + tokenOut: WBTC, + slippage, + }); + + console.log(`Expected output: ${swapQuotation.output.amount} ${swapQuotation.output.token.symbol}`); + + // Step 2: Build swap logic + const swapLogic = api.protocols.uniswapv3.newSwapTokenLogic(swapQuotation); + + // Step 3: Get Aave v3 supply quotation + console.log('\n2. Getting Aave supply quotation...'); + const supplyQuotation = await api.protocols.aavev3.getSupplyQuotation(CHAIN_ID, { + input: swapQuotation.output, // Use WBTC from swap as input + tokenOut: swapQuotation.output.token, // aWBTC (Protocolink will resolve the aToken) + }); + + console.log(`Expected aToken output: ${supplyQuotation.output.amount} ${supplyQuotation.output.token.symbol}`); + + // Step 4: Build supply logic + const supplyLogic = api.protocols.aavev3.newSupplyLogic(supplyQuotation); + + // Step 5: Build router logics (combine swap + supply) + const routerLogics = [swapLogic, supplyLogic]; + + // Step 6: Get router data + console.log('\n3. Building router transaction...'); + const routerData = await api.router.getRouterData(CHAIN_ID, { + account, + logics: routerLogics, + }); + + console.log(`Router: ${routerData.router}`); + console.log(`Estimated gas: ${routerData.estimation.gas}`); + + // Step 7: Execute transaction + console.log('\n4. Executing transaction...'); + const tx = await walletClient.sendTransaction({ + to: routerData.router, + data: routerData.data, + value: BigInt(routerData.estimation.value || '0'), + gas: BigInt(routerData.estimation.gas), + }); + + await waitForTransaction(publicClient, tx); + console.log(`Transaction executed: ${tx}`); + console.log('\nโœ… Multi-protocol transaction completed successfully!'); + } catch (error) { + console.error('Error composing transaction:', error); + throw error; + } +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + composeSwapAndSupply().catch(console.error); +} + +export { composeSwapAndSupply }; + diff --git a/examples/ts/protocolink-with-permit2.ts b/examples/ts/protocolink-with-permit2.ts new file mode 100644 index 0000000..4b0c7f0 --- /dev/null +++ b/examples/ts/protocolink-with-permit2.ts @@ -0,0 +1,116 @@ +/** + * Protocolink: Protocolink with Permit2 signatures + * + * This example demonstrates how to use Protocolink with Permit2 + * for gasless approvals via signatures. + */ + +import * as api from '@protocolink/api'; +import * as common from '@protocolink/common'; +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; + +const CHAIN_ID = common.ChainId.mainnet; +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +async function protocolinkWithPermit2() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const USDC: common.Token = { + chainId: CHAIN_ID, + address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', + decimals: 6, + symbol: 'USDC', + name: 'USD Coin', + }; + + const WBTC: common.Token = { + chainId: CHAIN_ID, + address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599', + decimals: 8, + symbol: 'WBTC', + name: 'Wrapped Bitcoin', + }; + + const amountIn = '1000'; // 1000 USDC + + console.log(`Using Protocolink with Permit2 for gasless approvals`); + console.log(`Swapping ${amountIn} USDC โ†’ WBTC, then supplying to Aave`); + console.log(`Account: ${account}`); + + try { + // Step 1: Get swap quotation + const swapQuotation = await api.protocols.uniswapv3.getSwapTokenQuotation(CHAIN_ID, { + input: { token: USDC, amount: amountIn }, + tokenOut: WBTC, + slippage: 100, + }); + + // Step 2: Build swap logic + const swapLogic = api.protocols.uniswapv3.newSwapTokenLogic(swapQuotation); + + // Step 3: Get supply quotation + const supplyQuotation = await api.protocols.aavev3.getSupplyQuotation(CHAIN_ID, { + input: swapQuotation.output, + }); + + // Step 4: Build supply logic + const supplyLogic = api.protocols.aavev3.newSupplyLogic(supplyQuotation); + + const routerLogics = [swapLogic, supplyLogic]; + + // Step 5: Get permit2 data (if token supports it) + // Protocolink will automatically use Permit2 when available + console.log('\n1. Building router transaction with Permit2...'); + const routerData = await api.router.getRouterData(CHAIN_ID, { + account, + logics: routerLogics, + // Permit2 will be used automatically if: + // 1. Token supports Permit2 + // 2. User has sufficient balance + // 3. No existing approval + }); + + console.log(`Router: ${routerData.router}`); + console.log(`Using Permit2: ${routerData.permit2Data ? 'Yes' : 'No'}`); + console.log(`Estimated gas: ${routerData.estimation.gas}`); + + // Step 6: If Permit2 data is provided, sign it + if (routerData.permit2Data) { + console.log('\n2. Signing Permit2 permit...'); + // Protocolink SDK handles Permit2 signing internally + // You may need to sign the permit data before executing + // See Protocolink docs for exact flow + } + + // Step 7: Execute transaction + console.log('\n3. Executing transaction...'); + const tx = await walletClient.sendTransaction({ + to: routerData.router, + data: routerData.data, + value: BigInt(routerData.estimation.value || '0'), + gas: BigInt(routerData.estimation.gas), + }); + + await waitForTransaction(publicClient, tx); + console.log(`Transaction executed: ${tx}`); + console.log('\nโœ… Transaction with Permit2 completed successfully!'); + } catch (error) { + console.error('Error executing transaction:', error); + throw error; + } +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + protocolinkWithPermit2().catch(console.error); +} + +export { protocolinkWithPermit2 }; + diff --git a/examples/ts/supply-borrow-swap.ts b/examples/ts/supply-borrow-swap.ts new file mode 100644 index 0000000..4bdc36d --- /dev/null +++ b/examples/ts/supply-borrow-swap.ts @@ -0,0 +1,132 @@ +/** + * Cross-Protocol: Complete DeFi strategy example + * + * This example demonstrates a complete DeFi strategy using Protocolink: + * 1. Supply USDC to Aave v3 + * 2. Enable as collateral + * 3. Borrow USDT from Aave v3 + * 4. Swap USDT โ†’ USDC on Uniswap v3 + * 5. Supply swapped USDC back to Aave + * + * All in one transaction via Protocolink! + */ + +import * as api from '@protocolink/api'; +import * as common from '@protocolink/common'; +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; + +const CHAIN_ID = common.ChainId.mainnet; +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +async function supplyBorrowSwapStrategy() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const USDC: common.Token = { + chainId: CHAIN_ID, + address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', + decimals: 6, + symbol: 'USDC', + name: 'USD Coin', + }; + + const USDT: common.Token = { + chainId: CHAIN_ID, + address: '0xdAC17F958D2ee523a2206206994597C13D831ec7', + decimals: 6, + symbol: 'USDT', + name: 'Tether USD', + }; + + const initialSupply = '5000'; // 5,000 USDC + const borrowAmount = '2000'; // 2,000 USDT + + console.log('Complete DeFi strategy:'); + console.log(` 1. Supply ${initialSupply} USDC to Aave`); + console.log(` 2. Enable as collateral`); + console.log(` 3. Borrow ${borrowAmount} USDT from Aave`); + console.log(` 4. Swap USDT โ†’ USDC on Uniswap v3`); + console.log(` 5. Supply swapped USDC back to Aave`); + console.log(`\nAccount: ${account}`); + + try { + const logics: any[] = []; + + // Step 1: Supply USDC + console.log('\n1. Adding supply logic...'); + const supplyQuotation1 = await api.protocols.aavev3.getSupplyQuotation(CHAIN_ID, { + input: { token: USDC, amount: initialSupply }, + }); + const supplyLogic1 = api.protocols.aavev3.newSupplyLogic(supplyQuotation1); + logics.push(supplyLogic1); + + // Step 2: Set as collateral (may be automatic, check Aave docs) + // Note: Some Aave markets automatically enable as collateral + console.log('2. Collateral enabled automatically in most markets'); + + // Step 3: Borrow USDT + console.log('3. Adding borrow logic...'); + const borrowQuotation = await api.protocols.aavev3.getBorrowQuotation(CHAIN_ID, { + output: { token: USDT, amount: borrowAmount }, + }); + const borrowLogic = api.protocols.aavev3.newBorrowLogic(borrowQuotation); + logics.push(borrowLogic); + + // Step 4: Swap USDT โ†’ USDC + console.log('4. Adding swap logic...'); + const swapQuotation = await api.protocols.uniswapv3.getSwapTokenQuotation(CHAIN_ID, { + input: { token: USDT, amount: borrowAmount }, + tokenOut: USDC, + slippage: 100, // 1% slippage + }); + const swapLogic = api.protocols.uniswapv3.newSwapTokenLogic(swapQuotation); + logics.push(swapLogic); + + // Step 5: Supply swapped USDC + console.log('5. Adding second supply logic...'); + const supplyQuotation2 = await api.protocols.aavev3.getSupplyQuotation(CHAIN_ID, { + input: swapQuotation.output, // Use swapped USDC + }); + const supplyLogic2 = api.protocols.aavev3.newSupplyLogic(supplyQuotation2); + logics.push(supplyLogic2); + + // Step 6: Execute all in one transaction + console.log('\n6. Building router transaction...'); + const routerData = await api.router.getRouterData(CHAIN_ID, { + account, + logics, + }); + + console.log(`Router: ${routerData.router}`); + console.log(`Estimated gas: ${routerData.estimation.gas}`); + + console.log('\n7. Executing transaction...'); + const tx = await walletClient.sendTransaction({ + to: routerData.router, + data: routerData.data, + value: BigInt(routerData.estimation.value || '0'), + gas: BigInt(routerData.estimation.gas), + }); + + await waitForTransaction(publicClient, tx); + console.log(`Transaction executed: ${tx}`); + console.log('\nโœ… Complete DeFi strategy executed successfully!'); + } catch (error) { + console.error('Error executing strategy:', error); + throw error; + } +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + supplyBorrowSwapStrategy().catch(console.error); +} + +export { supplyBorrowSwapStrategy }; + diff --git a/examples/ts/uniswap-permit2.ts b/examples/ts/uniswap-permit2.ts new file mode 100644 index 0000000..b1432ef --- /dev/null +++ b/examples/ts/uniswap-permit2.ts @@ -0,0 +1,131 @@ +/** + * Uniswap: Permit2 signature-based approvals + * + * This example demonstrates how to use Permit2 for signature-based token approvals. + * Permit2 allows users to approve tokens via signatures instead of on-chain transactions. + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getPermit2Address, getUniswapSwapRouter02 } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { getPermit2Domain, getPermit2TransferTypes, createPermit2Deadline } from '../../src/utils/permit2.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import { signTypedData } from 'viem'; +import type { Address } from 'viem'; + +const CHAIN_ID = 1; // Mainnet +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// Permit2 ABI for permit transfer +const PERMIT2_ABI = [ + { + name: 'permitTransferFrom', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { + components: [ + { + components: [ + { name: 'token', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + name: 'permitted', + type: 'tuple', + }, + { name: 'nonce', type: 'uint256' }, + { name: 'deadline', type: 'uint256' }, + ], + name: 'permit', + type: 'tuple', + }, + { + components: [ + { name: 'to', type: 'address' }, + { name: 'requestedAmount', type: 'uint256' }, + ], + name: 'transferDetails', + type: 'tuple', + }, + { name: 'signature', type: 'bytes' }, + ], + outputs: [], + }, +] as const; + +async function permit2Approval() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const permit2Address = getPermit2Address(CHAIN_ID); + const token = getTokenMetadata(CHAIN_ID, 'USDC'); + const amount = parseTokenAmount('1000', token.decimals); + const spender = getUniswapSwapRouter02(CHAIN_ID); // Example: approve Uniswap router + + console.log(`Creating Permit2 signature for ${amount} ${token.symbol}`); + console.log(`Permit2: ${permit2Address}`); + console.log(`Spender: ${spender}`); + console.log(`Account: ${account}`); + + // Step 1: Get nonce from Permit2 + // In production, query the Permit2 contract for the user's current nonce + const nonce = 0n; // TODO: Read from Permit2 contract + + // Step 2: Create permit data + const deadline = createPermit2Deadline(3600); // 1 hour + const domain = getPermit2Domain(CHAIN_ID); + const types = getPermit2TransferTypes(); + + const permit = { + permitted: { + token: token.address, + amount, + }, + nonce, + deadline, + }; + + const transferDetails = { + to: spender, + requestedAmount: amount, + }; + + // Step 3: Sign the permit + console.log('\n1. Signing Permit2 permit...'); + const signature = await signTypedData(walletClient, { + domain, + types, + primaryType: 'PermitTransferFrom', + message: { + permitted: permit.permitted, + spender, + nonce: permit.nonce, + deadline: permit.deadline, + }, + }); + + console.log(`Signature: ${signature}`); + + // Step 4: Execute permitTransferFrom (this would typically be done by a router/contract) + // Note: In practice, Permit2 permits are usually used within larger transaction flows + // (e.g., Universal Router uses them automatically) + console.log('\n2. Permit2 signature created successfully!'); + console.log('Use this signature in your transaction (e.g., Universal Router)'); + console.log('\nExample usage with Universal Router:'); + console.log(' - Universal Router will call permitTransferFrom on Permit2'); + console.log(' - Then execute the swap/transfer'); + console.log(' - All in one transaction'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + permit2Approval().catch(console.error); +} + +export { permit2Approval }; + diff --git a/examples/ts/uniswap-universal-router.ts b/examples/ts/uniswap-universal-router.ts new file mode 100644 index 0000000..6b24607 --- /dev/null +++ b/examples/ts/uniswap-universal-router.ts @@ -0,0 +1,136 @@ +/** + * Uniswap: Universal Router with Permit2 integration + * + * This example demonstrates how to use Universal Router for complex multi-step transactions + * with Permit2 signature-based approvals. + * + * Universal Router supports: + * - Token swaps (Uniswap v2/v3) + * - NFT operations + * - Permit2 approvals + * - WETH wrapping/unwrapping + * - Multiple commands in one transaction + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getUniswapUniversalRouter, getPermit2Address } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import type { Address, Hex } from 'viem'; + +const CHAIN_ID = 1; // Mainnet (change to 8453 for Base, etc.) +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// Universal Router ABI +const UNIVERSAL_ROUTER_ABI = [ + { + name: 'execute', + type: 'function', + stateMutability: 'payable', + inputs: [ + { name: 'commands', type: 'bytes' }, + { name: 'inputs', type: 'bytes[]' }, + ], + outputs: [], + }, + { + name: 'execute', + type: 'function', + stateMutability: 'payable', + inputs: [ + { name: 'commands', type: 'bytes' }, + { name: 'inputs', type: 'bytes[]' }, + { name: 'deadline', type: 'uint256' }, + ], + outputs: [], + }, +] as const; + +/** + * Universal Router command types + * See: https://github.com/Uniswap/universal-router/blob/main/contracts/Commands.sol + */ +const COMMANDS = { + V3_SWAP_EXACT_IN: 0x00, + V3_SWAP_EXACT_OUT: 0x01, + PERMIT2_TRANSFER_FROM: 0x02, + PERMIT2_PERMIT_BATCH: 0x03, + SWEEP: 0x04, + TRANSFER: 0x05, + PAY_PORTION: 0x06, + V2_SWAP_EXACT_IN: 0x08, + V2_SWAP_EXACT_OUT: 0x09, + PERMIT2_PERMIT: 0x0a, + WRAP_ETH: 0x0b, + UNWRAP_WETH: 0x0c, + PERMIT2_TRANSFER_FROM_BATCH: 0x0d, +} as const; + +/** + * Encode V3 swap exact input command + * + * This is a simplified example. In production, use the Universal Router SDK + * or carefully encode commands according to the Universal Router spec. + */ +function encodeV3SwapExactInput(params: { + recipient: Address; + amountIn: bigint; + amountOutMin: bigint; + path: Hex; + payerIsUser: boolean; +}): { command: number; input: Hex } { + // This is a conceptual example. Actual encoding is more complex. + // See: https://docs.uniswap.org/contracts/universal-router/technical-reference + throw new Error('Use Universal Router SDK for proper command encoding'); +} + +async function universalRouterSwap() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const routerAddress = getUniswapUniversalRouter(CHAIN_ID); + const tokenIn = getTokenMetadata(CHAIN_ID, 'USDC'); + const tokenOut = getTokenMetadata(CHAIN_ID, 'WETH'); + const amountIn = parseTokenAmount('1000', tokenIn.decimals); + const deadline = BigInt(Math.floor(Date.now() / 1000) + 600); + + console.log(`Universal Router swap: ${amountIn} ${tokenIn.symbol} -> ${tokenOut.symbol}`); + console.log(`Router: ${routerAddress}`); + console.log(`Account: ${account}`); + + // Note: Universal Router command encoding is complex. + // In production, use: + // 1. Universal Router SDK (when available) + // 2. Or carefully encode commands according to the spec + // 3. Or use Protocolink which handles Universal Router integration + + console.log('\nโš ๏ธ This is a conceptual example.'); + console.log('In production, use:'); + console.log(' 1. Universal Router SDK for command encoding'); + console.log(' 2. Or use Protocolink which integrates Universal Router'); + console.log(' 3. Or carefully follow the Universal Router spec:'); + console.log(' https://docs.uniswap.org/contracts/universal-router/technical-reference'); + + // Example flow: + // 1. Create Permit2 signature (see uniswap-permit2.ts) + // 2. Encode Universal Router commands + // 3. Execute via Universal Router.execute() + // 4. Universal Router will: + // - Use Permit2 to transfer tokens + // - Execute swap + // - Send output to recipient + // - All in one transaction +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + universalRouterSwap().catch(console.error); +} + +export { universalRouterSwap, COMMANDS }; + diff --git a/examples/ts/uniswap-v3-oracle.ts b/examples/ts/uniswap-v3-oracle.ts new file mode 100644 index 0000000..6d6b39e --- /dev/null +++ b/examples/ts/uniswap-v3-oracle.ts @@ -0,0 +1,186 @@ +/** + * Uniswap v3: TWAP Oracle usage + * + * This example demonstrates how to use Uniswap v3 pools as price oracles + * by querying time-weighted average prices (TWAP). + * + * Note: Always use TWAP, not spot prices, to protect against manipulation. + */ + +import { createRpcClient } from '../../src/utils/chain-config.js'; +import { getTokenMetadata } from '../../src/utils/tokens.js'; +import type { Address } from 'viem'; + +const CHAIN_ID = 1; // Mainnet + +// Uniswap v3 Pool ABI +const POOL_ABI = [ + { + name: 'slot0', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [ + { name: 'sqrtPriceX96', type: 'uint160' }, + { name: 'tick', type: 'int24' }, + { name: 'observationIndex', type: 'uint16' }, + { name: 'observationCardinality', type: 'uint16' }, + { name: 'observationCardinalityNext', type: 'uint16' }, + { name: 'feeProtocol', type: 'uint8' }, + { name: 'unlocked', type: 'bool' }, + ], + }, + { + name: 'observations', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'index', type: 'uint16' }], + outputs: [ + { name: 'blockTimestamp', type: 'uint32' }, + { name: 'tickCumulative', type: 'int56' }, + { name: 'secondsPerLiquidityCumulativeX128', type: 'uint160' }, + { name: 'initialized', type: 'bool' }, + ], + }, + { + name: 'token0', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, + { + name: 'token1', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, + { + name: 'fee', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'uint24' }], + }, +] as const; + +/** + * Calculate price from sqrtPriceX96 + * price = (sqrtPriceX96 / 2^96)^2 + */ +function calculatePriceFromSqrtPriceX96(sqrtPriceX96: bigint): number { + const Q96 = 2n ** 96n; + const price = Number(sqrtPriceX96) ** 2 / Number(Q96) ** 2; + return price; +} + +/** + * Calculate TWAP from observations + * + * TWAP = (tickCumulative1 - tickCumulative0) / (time1 - time0) + */ +function calculateTWAP( + tickCumulative0: bigint, + tickCumulative1: bigint, + time0: number, + time1: number +): number { + if (time1 === time0) { + throw new Error('Time difference cannot be zero'); + } + const tickDelta = Number(tickCumulative1 - tickCumulative0); + const timeDelta = time1 - time0; + const avgTick = tickDelta / timeDelta; + + // Convert tick to price: price = 1.0001^tick + const price = 1.0001 ** avgTick; + return price; +} + +/** + * Get pool address from Uniswap v3 Factory + * In production, use the official Uniswap v3 SDK to compute pool addresses + */ +async function getPoolAddress( + client: any, + token0: Address, + token1: Address, + fee: number +): Promise
{ + // This is a simplified example. In production, use: + // 1. Uniswap v3 Factory to get pool address + // 2. Or compute pool address using CREATE2 (see Uniswap v3 SDK) + // For now, this is a placeholder + throw new Error('Implement pool address resolution using Factory or SDK'); +} + +async function queryOracle() { + const publicClient = createRpcClient(CHAIN_ID); + + const token0 = getTokenMetadata(CHAIN_ID, 'USDC'); + const token1 = getTokenMetadata(CHAIN_ID, 'WETH'); + const fee = 3000; // 0.3% fee tier + + console.log(`Querying Uniswap v3 TWAP oracle for ${token0.symbol}/${token1.symbol}`); + console.log(`Fee tier: ${fee} (0.3%)`); + + // Note: In production, you need to: + // 1. Get the pool address from Uniswap v3 Factory + // 2. Or use the Uniswap v3 SDK to compute it + // For this example, we'll demonstrate the concept + + // Example: Query current slot0 (spot price - not recommended for production!) + // const poolAddress = await getPoolAddress(publicClient, token0.address, token1.address, fee); + + // const slot0 = await publicClient.readContract({ + // address: poolAddress, + // abi: POOL_ABI, + // functionName: 'slot0', + // }); + + // const sqrtPriceX96 = slot0[0]; + // const currentPrice = calculatePriceFromSqrtPriceX96(sqrtPriceX96); + // console.log(`Current spot price: ${currentPrice} ${token1.symbol} per ${token0.symbol}`); + + // Example: Query TWAP from observations + // const observationIndex = slot0[2]; + // const observation0 = await publicClient.readContract({ + // address: poolAddress, + // abi: POOL_ABI, + // functionName: 'observations', + // args: [observationIndex], + // }); + + // Query a previous observation (e.g., 1 hour ago) + // const previousIndex = (observationIndex - 3600) % observationCardinality; + // const observation1 = await publicClient.readContract({ + // address: poolAddress, + // abi: POOL_ABI, + // functionName: 'observations', + // args: [previousIndex], + // }); + + // const twap = calculateTWAP( + // observation0.tickCumulative, + // observation1.tickCumulative, + // observation0.blockTimestamp, + // observation1.blockTimestamp + // ); + // console.log(`TWAP (1 hour): ${twap} ${token1.symbol} per ${token0.symbol}`); + + console.log('\nโš ๏ธ This is a conceptual example.'); + console.log('In production, use:'); + console.log(' 1. Uniswap v3 OracleLibrary (see Uniswap v3 periphery contracts)'); + console.log(' 2. Uniswap v3 SDK for price calculations'); + console.log(' 3. Always use TWAP, never spot prices'); + console.log(' 4. Ensure sufficient observation cardinality for your TWAP window'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + queryOracle().catch(console.error); +} + +export { queryOracle, calculatePriceFromSqrtPriceX96, calculateTWAP }; + diff --git a/examples/ts/uniswap-v3-swap.ts b/examples/ts/uniswap-v3-swap.ts new file mode 100644 index 0000000..6acb71b --- /dev/null +++ b/examples/ts/uniswap-v3-swap.ts @@ -0,0 +1,162 @@ +/** + * Uniswap v3: Exact input swap via SwapRouter02 + * + * This example demonstrates how to execute a swap on Uniswap v3 + * using the SwapRouter02 contract. + */ + +import { createWalletRpcClient } from '../../src/utils/chain-config.js'; +import { getUniswapSwapRouter02 } from '../../src/utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../src/utils/tokens.js'; +import { waitForTransaction } from '../../src/utils/rpc.js'; +import type { Address } from 'viem'; + +const CHAIN_ID = 1; // Mainnet (change to 8453 for Base, etc.) +const PRIVATE_KEY = process.env.PRIVATE_KEY as `0x${string}`; + +// Uniswap v3 SwapRouter02 ABI +const SWAP_ROUTER_ABI = [ + { + name: 'exactInputSingle', + type: 'function', + stateMutability: 'payable', + inputs: [ + { + components: [ + { name: 'tokenIn', type: 'address' }, + { name: 'tokenOut', type: 'address' }, + { name: 'fee', type: 'uint24' }, + { name: 'recipient', type: 'address' }, + { name: 'deadline', type: 'uint256' }, + { name: 'amountIn', type: 'uint256' }, + { name: 'amountOutMinimum', type: 'uint256' }, + { name: 'sqrtPriceLimitX96', type: 'uint160' }, + ], + name: 'params', + type: 'tuple', + }, + ], + outputs: [{ name: 'amountOut', type: 'uint256' }], + }, + { + name: 'exactInput', + type: 'function', + stateMutability: 'payable', + inputs: [ + { + components: [ + { + components: [ + { name: 'tokenIn', type: 'address' }, + { name: 'tokenOut', type: 'address' }, + { name: 'fee', type: 'uint24' }, + ], + name: 'path', + type: 'tuple[]', + }, + { name: 'recipient', type: 'address' }, + { name: 'deadline', type: 'uint256' }, + { name: 'amountIn', type: 'uint256' }, + { name: 'amountOutMinimum', type: 'uint256' }, + ], + name: 'params', + type: 'tuple', + }, + ], + outputs: [{ name: 'amountOut', type: 'uint256' }], + }, +] as const; + +// ERC20 ABI for approvals +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, +] as const; + +// Uniswap v3 fee tiers (0.01%, 0.05%, 0.3%, 1%) +const FEE_TIER_LOW = 100; // 0.01% +const FEE_TIER_MEDIUM = 500; // 0.05% +const FEE_TIER_STANDARD = 3000; // 0.3% +const FEE_TIER_HIGH = 10000; // 1% + +async function swapExactInputSingle() { + const walletClient = createWalletRpcClient(CHAIN_ID, PRIVATE_KEY); + const publicClient = walletClient as any; + const account = walletClient.account?.address; + + if (!account) { + throw new Error('No account available'); + } + + const routerAddress = getUniswapSwapRouter02(CHAIN_ID); + + // Token configuration + const tokenIn = getTokenMetadata(CHAIN_ID, 'USDC'); + const tokenOut = getTokenMetadata(CHAIN_ID, 'WETH'); + + // Swap parameters + const amountIn = parseTokenAmount('1000', tokenIn.decimals); // 1000 USDC + const slippageTolerance = 50; // 0.5% in basis points (adjust based on market conditions) + const fee = FEE_TIER_STANDARD; // 0.3% fee tier (most liquid for major pairs) + const deadline = BigInt(Math.floor(Date.now() / 1000) + 600); // 10 minutes + + console.log(`Swapping ${amountIn} ${tokenIn.symbol} for ${tokenOut.symbol}`); + console.log(`Router: ${routerAddress}`); + console.log(`Fee tier: ${fee} (0.3%)`); + console.log(`Slippage tolerance: ${slippageTolerance / 100}%`); + + // Step 1: Get quote (in production, use QuoterV2 contract) + // For now, we'll set amountOutMinimum to 0 (not recommended in production!) + // In production, always query the pool first to get expected output + const amountOutMinimum = 0n; // TODO: Query QuoterV2 for expected output and apply slippage + + // Step 2: Approve token spending + console.log('\n1. Approving token spending...'); + const approveTx = await walletClient.writeContract({ + address: tokenIn.address, + abi: ERC20_ABI, + functionName: 'approve', + args: [routerAddress, amountIn], + }); + await waitForTransaction(publicClient, approveTx); + console.log(`Approved: ${approveTx}`); + + // Step 3: Execute swap + console.log('\n2. Executing swap...'); + const swapTx = await walletClient.writeContract({ + address: routerAddress, + abi: SWAP_ROUTER_ABI, + functionName: 'exactInputSingle', + args: [ + { + tokenIn: tokenIn.address, + tokenOut: tokenOut.address, + fee, + recipient: account, + deadline, + amountIn, + amountOutMinimum, + sqrtPriceLimitX96: 0n, // No price limit + }, + ], + }); + await waitForTransaction(publicClient, swapTx); + console.log(`Swap executed: ${swapTx}`); + console.log('\nโœ… Swap completed successfully!'); +} + +// Run if executed directly +if (import.meta.url === `file://${process.argv[1]}`) { + swapExactInputSingle().catch(console.error); +} + +export { swapExactInputSingle }; + diff --git a/foundry.toml b/foundry.toml new file mode 100644 index 0000000..60da3de --- /dev/null +++ b/foundry.toml @@ -0,0 +1,30 @@ +[profile.default] +src = "contracts" +out = "out" +libs = ["lib"] +solc_version = "0.8.20" +optimizer = true +optimizer_runs = 200 +via_ir = false +evm_version = "paris" +gas_reports = ["*"] +verbosity = 3 + +[profile.ci] +fuzz = { runs = 10000 } +invariant = { runs = 256, depth = 15 } + +[rpc_endpoints] +mainnet = "${MAINNET_RPC_URL}" +base = "${BASE_RPC_URL}" +arbitrum = "${ARBITRUM_RPC_URL}" +optimism = "${OPTIMISM_RPC_URL}" +polygon = "${POLYGON_RPC_URL}" + +[etherscan] +mainnet = { key = "${ETHERSCAN_API_KEY}" } +base = { key = "${BASESCAN_API_KEY}" } +arbitrum = { key = "${ARBISCAN_API_KEY}" } +optimism = { key = "${OPTIMISTIC_ETHERSCAN_API_KEY}" } +polygon = { key = "${POLYGONSCAN_API_KEY}" } + diff --git a/package.json b/package.json new file mode 100644 index 0000000..10e643b --- /dev/null +++ b/package.json @@ -0,0 +1,55 @@ +{ + "name": "defi-starter-kit", + "version": "1.0.0", + "description": "Comprehensive DeFi starter kit for Aave, Uniswap, Protocolink, and more", + "type": "module", + "main": "dist/index.js", + "scripts": { + "build": "tsc", + "dev": "tsx watch src/cli/cli.ts", + "cli": "tsx src/cli/cli.ts", + "test": "forge test", + "test:ts": "tsx test", + "lint": "eslint . --ext .ts", + "format": "prettier --write \"**/*.{ts,js,json,md}\"", + "prepare": "pnpm run build", + "strat": "tsx src/strat/cli.ts", + "strat:run": "tsx src/strat/cli.ts run", + "strat:fork": "tsx src/strat/cli.ts fork", + "strat:test": "tsx scripts/test-strategy.ts", + "check:env": "tsx scripts/check-env.ts", + "verify:setup": "tsx scripts/verify-setup.ts" + }, + "keywords": [ + "defi", + "aave", + "uniswap", + "protocolink", + "ethereum", + "web3" + ], + "author": "", + "license": "MIT", + "packageManager": "pnpm@8.15.0", + "dependencies": { + "viem": "^2.21.45", + "@protocolink/api": "^1.4.8", + "@protocolink/common": "^0.5.5", + "@aave/contract-helpers": "^1.36.2", + "dotenv": "^16.4.5", + "commander": "^12.1.0", + "chalk": "^5.3.0", + "js-yaml": "^4.1.0", + "zod": "^3.23.8" + }, + "devDependencies": { + "@types/node": "^20.14.12", + "@typescript-eslint/eslint-plugin": "^7.18.0", + "@typescript-eslint/parser": "^7.18.0", + "@types/js-yaml": "^4.0.9", + "eslint": "^8.57.0", + "prettier": "^3.3.3", + "tsx": "^4.16.2", + "typescript": "^5.5.4" + } +} diff --git a/plan.json b/plan.json new file mode 100644 index 0000000..8ba1cea --- /dev/null +++ b/plan.json @@ -0,0 +1,152 @@ +[ + { + "blockType": "Flashloan", + "protocol": "utility", + "display": "Utility flashloan", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 4600000000 + } + }, + { + "blockType": "Supply", + "protocol": "aavev3", + "display": "Aave V3", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 4600000000 + }, + "tokenOut": { + "symbol": "aEthUSDC", + "address": "0x0000000000000000000000000000000000000001", + "amount": 4600000000 + } + }, + { + "blockType": "Borrow", + "protocol": "aavev3", + "display": "Aave V3", + "tokenOut": { + "symbol": "USDT", + "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7", + "amount": 2500000000 + } + }, + { + "blockType": "Swap", + "protocol": "paraswapv5", + "display": "Paraswap V5", + "tokenIn": { + "symbol": "USDT", + "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7", + "amount": 2000900000 + }, + "tokenOut": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "minAmount": 2001033032 + } + }, + { + "blockType": "Repay", + "protocol": "aavev3", + "display": "Aave V3", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 1000000000 + } + }, + { + "blockType": "Supply", + "protocol": "aavev3", + "display": "Aave V3", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 1000000000 + }, + "tokenOut": { + "symbol": "aEthUSDC", + "address": "0x0000000000000000000000000000000000000001", + "amount": 1000000000 + } + }, + { + "blockType": "Borrow", + "protocol": "aavev3", + "display": "Aave V3", + "tokenOut": { + "symbol": "USDT", + "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7", + "amount": 2300000000 + } + }, + { + "blockType": "Swap", + "protocol": "paraswapv5", + "display": "Paraswap V5", + "tokenIn": { + "symbol": "USDT", + "address": "0xdAC17F958D2ee523a2206206994597C13D831ec7", + "amount": 2100900000 + }, + "tokenOut": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "minAmount": 2100628264 + } + }, + { + "blockType": "Repay", + "protocol": "aavev3", + "display": "Aave V3", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 1000000000 + } + }, + { + "blockType": "Supply", + "protocol": "aavev3", + "display": "Aave V3", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 1000000000 + }, + "tokenOut": { + "symbol": "aEthUSDC", + "address": "0x0000000000000000000000000000000000000001", + "amount": 1000000000 + } + }, + { + "blockType": "Withdraw", + "protocol": "aavev3", + "display": "Aave V3", + "tokenIn": { + "symbol": "aEthUSDC", + "address": "0x0000000000000000000000000000000000000001", + "amount": 4500000000 + }, + "tokenOut": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 4500000000 + } + }, + { + "blockType": "FlashloanRepay", + "protocol": "utility", + "display": "Utility flashloan", + "tokenIn": { + "symbol": "USDC", + "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", + "amount": 4600000000 + } + } +] diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml new file mode 100644 index 0000000..978a490 --- /dev/null +++ b/pnpm-lock.yaml @@ -0,0 +1,3497 @@ +lockfileVersion: '6.0' + +settings: + autoInstallPeers: true + excludeLinksFromLockfile: false + +dependencies: + '@aave/contract-helpers': + specifier: ^1.36.2 + version: 1.36.2(bignumber.js@9.3.1)(ethers@5.8.0)(reflect-metadata@0.1.14)(tslib@2.8.1) + '@protocolink/api': + specifier: ^1.4.8 + version: 1.4.8(@ethersproject/address@5.8.0)(@ethersproject/contracts@5.8.0)(@ethersproject/networks@5.8.0)(@ethersproject/providers@5.8.0)(@ethersproject/solidity@5.8.0)(hardhat@2.27.0)(typescript@5.9.3) + '@protocolink/common': + specifier: ^0.5.5 + version: 0.5.5 + chalk: + specifier: ^5.3.0 + version: 5.6.2 + commander: + specifier: ^12.1.0 + version: 12.1.0 + dotenv: + specifier: ^16.4.5 + version: 16.6.1 + js-yaml: + specifier: ^4.1.0 + version: 4.1.0 + viem: + specifier: ^2.21.45 + version: 2.38.6(typescript@5.9.3)(zod@3.25.76) + zod: + specifier: ^3.23.8 + version: 3.25.76 + +devDependencies: + '@types/js-yaml': + specifier: ^4.0.9 + version: 4.0.9 + '@types/node': + specifier: ^20.14.12 + version: 20.19.24 + '@typescript-eslint/eslint-plugin': + specifier: ^7.18.0 + version: 7.18.0(@typescript-eslint/parser@7.18.0)(eslint@8.57.1)(typescript@5.9.3) + '@typescript-eslint/parser': + specifier: ^7.18.0 + version: 7.18.0(eslint@8.57.1)(typescript@5.9.3) + eslint: + specifier: ^8.57.0 + version: 8.57.1 + prettier: + specifier: ^3.3.3 + version: 3.6.2 + tsx: + specifier: ^4.16.2 + version: 4.20.6 + typescript: + specifier: ^5.5.4 + version: 5.9.3 + +packages: + + /@aave/contract-helpers@1.36.2(bignumber.js@9.3.1)(ethers@5.8.0)(reflect-metadata@0.1.14)(tslib@2.8.1): + resolution: {integrity: sha512-g0z9QbppGHDXSu13OPmyMkHAw1UjCAD2xoUWO+8Vk1xT9ZEwZaT7Pn2sojwUp97FyQiiKbjmJ4KupNS4jp33GQ==} + peerDependencies: + bignumber.js: ^9.x + ethers: ^5.x + reflect-metadata: ^0.1.x + tslib: ^2.4.x + dependencies: + bignumber.js: 9.3.1 + ethers: 5.8.0 + isomorphic-unfetch: 3.1.0 + reflect-metadata: 0.1.14 + tslib: 2.8.1 + transitivePeerDependencies: + - encoding + dev: false + + /@adraffy/ens-normalize@1.11.1: + resolution: {integrity: sha512-nhCBV3quEgesuf7c7KYfperqSS14T8bYuvJ8PcLJp6znkZpFc0AuW4qBtr8eKVyPPe/8RSr7sglCWPU5eaxwKQ==} + dev: false + + /@babel/runtime@7.28.4: + resolution: {integrity: sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==} + engines: {node: '>=6.9.0'} + dev: false + + /@esbuild/aix-ppc64@0.25.12: + resolution: {integrity: sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [aix] + requiresBuild: true + dev: true + optional: true + + /@esbuild/android-arm64@0.25.12: + resolution: {integrity: sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [android] + requiresBuild: true + dev: true + optional: true + + /@esbuild/android-arm@0.25.12: + resolution: {integrity: sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==} + engines: {node: '>=18'} + cpu: [arm] + os: [android] + requiresBuild: true + dev: true + optional: true + + /@esbuild/android-x64@0.25.12: + resolution: {integrity: sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==} + engines: {node: '>=18'} + cpu: [x64] + os: [android] + requiresBuild: true + dev: true + optional: true + + /@esbuild/darwin-arm64@0.25.12: + resolution: {integrity: sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [darwin] + requiresBuild: true + dev: true + optional: true + + /@esbuild/darwin-x64@0.25.12: + resolution: {integrity: sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==} + engines: {node: '>=18'} + cpu: [x64] + os: [darwin] + requiresBuild: true + dev: true + optional: true + + /@esbuild/freebsd-arm64@0.25.12: + resolution: {integrity: sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [freebsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/freebsd-x64@0.25.12: + resolution: {integrity: sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [freebsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-arm64@0.25.12: + resolution: {integrity: sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==} + engines: {node: '>=18'} + cpu: [arm64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-arm@0.25.12: + resolution: {integrity: sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==} + engines: {node: '>=18'} + cpu: [arm] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-ia32@0.25.12: + resolution: {integrity: sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==} + engines: {node: '>=18'} + cpu: [ia32] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-loong64@0.25.12: + resolution: {integrity: sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==} + engines: {node: '>=18'} + cpu: [loong64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-mips64el@0.25.12: + resolution: {integrity: sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==} + engines: {node: '>=18'} + cpu: [mips64el] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-ppc64@0.25.12: + resolution: {integrity: sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==} + engines: {node: '>=18'} + cpu: [ppc64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-riscv64@0.25.12: + resolution: {integrity: sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==} + engines: {node: '>=18'} + cpu: [riscv64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-s390x@0.25.12: + resolution: {integrity: sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==} + engines: {node: '>=18'} + cpu: [s390x] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/linux-x64@0.25.12: + resolution: {integrity: sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==} + engines: {node: '>=18'} + cpu: [x64] + os: [linux] + requiresBuild: true + dev: true + optional: true + + /@esbuild/netbsd-arm64@0.25.12: + resolution: {integrity: sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [netbsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/netbsd-x64@0.25.12: + resolution: {integrity: sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==} + engines: {node: '>=18'} + cpu: [x64] + os: [netbsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/openbsd-arm64@0.25.12: + resolution: {integrity: sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openbsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/openbsd-x64@0.25.12: + resolution: {integrity: sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==} + engines: {node: '>=18'} + cpu: [x64] + os: [openbsd] + requiresBuild: true + dev: true + optional: true + + /@esbuild/openharmony-arm64@0.25.12: + resolution: {integrity: sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [openharmony] + requiresBuild: true + dev: true + optional: true + + /@esbuild/sunos-x64@0.25.12: + resolution: {integrity: sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==} + engines: {node: '>=18'} + cpu: [x64] + os: [sunos] + requiresBuild: true + dev: true + optional: true + + /@esbuild/win32-arm64@0.25.12: + resolution: {integrity: sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==} + engines: {node: '>=18'} + cpu: [arm64] + os: [win32] + requiresBuild: true + dev: true + optional: true + + /@esbuild/win32-ia32@0.25.12: + resolution: {integrity: sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==} + engines: {node: '>=18'} + cpu: [ia32] + os: [win32] + requiresBuild: true + dev: true + optional: true + + /@esbuild/win32-x64@0.25.12: + resolution: {integrity: sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==} + engines: {node: '>=18'} + cpu: [x64] + os: [win32] + requiresBuild: true + dev: true + optional: true + + /@eslint-community/eslint-utils@4.9.0(eslint@8.57.1): + resolution: {integrity: sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + peerDependencies: + eslint: ^6.0.0 || ^7.0.0 || >=8.0.0 + dependencies: + eslint: 8.57.1 + eslint-visitor-keys: 3.4.3 + dev: true + + /@eslint-community/regexpp@4.12.2: + resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==} + engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0} + dev: true + + /@eslint/eslintrc@2.1.4: + resolution: {integrity: sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dependencies: + ajv: 6.12.6 + debug: 4.4.3(supports-color@8.1.1) + espree: 9.6.1 + globals: 13.24.0 + ignore: 5.3.2 + import-fresh: 3.3.1 + js-yaml: 4.1.0 + minimatch: 3.1.2 + strip-json-comments: 3.1.1 + transitivePeerDependencies: + - supports-color + dev: true + + /@eslint/js@8.57.1: + resolution: {integrity: sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dev: true + + /@ethereumjs/rlp@5.0.2: + resolution: {integrity: sha512-DziebCdg4JpGlEqEdGgXmjqcFoJi+JGulUXwEjsZGAscAQ7MyD/7LE/GVCP29vEQxKc7AAwjT3A2ywHp2xfoCA==} + engines: {node: '>=18'} + hasBin: true + dev: false + + /@ethereumjs/util@9.1.0: + resolution: {integrity: sha512-XBEKsYqLGXLah9PNJbgdkigthkG7TAGvlD/sH12beMXEyHDyigfcbdvHhmLyDWgDyOJn4QwiQUaF7yeuhnjdog==} + engines: {node: '>=18'} + dependencies: + '@ethereumjs/rlp': 5.0.2 + ethereum-cryptography: 2.2.1 + dev: false + + /@ethersproject/abi@5.8.0: + resolution: {integrity: sha512-b9YS/43ObplgyV6SlyQsG53/vkSal0MNA1fskSC4mbnCMi8R+NkcH8K9FPYNESf6jUefBUniE4SOKms0E/KK1Q==} + dependencies: + '@ethersproject/address': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/hash': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/strings': 5.8.0 + dev: false + + /@ethersproject/abstract-provider@5.8.0: + resolution: {integrity: sha512-wC9SFcmh4UK0oKuLJQItoQdzS/qZ51EJegK6EmAWlh+OptpQ/npECOR3QqECd8iGHC0RJb4WKbVdSfif4ammrg==} + dependencies: + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/networks': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/transactions': 5.8.0 + '@ethersproject/web': 5.8.0 + dev: false + + /@ethersproject/abstract-signer@5.8.0: + resolution: {integrity: sha512-N0XhZTswXcmIZQdYtUnd79VJzvEwXQw6PK0dTl9VoYrEBxxCPXqS0Eod7q5TNKRxe1/5WUMuR0u0nqTF/avdCA==} + dependencies: + '@ethersproject/abstract-provider': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + dev: false + + /@ethersproject/address@5.8.0: + resolution: {integrity: sha512-GhH/abcC46LJwshoN+uBNoKVFPxUuZm6dA257z0vZkKmU1+t8xTn8oK7B9qrj8W2rFRMch4gbJl6PmVxjxBEBA==} + dependencies: + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/rlp': 5.8.0 + dev: false + + /@ethersproject/base64@5.8.0: + resolution: {integrity: sha512-lN0oIwfkYj9LbPx4xEkie6rAMJtySbpOAFXSDVQaBnAzYfB4X2Qr+FXJGxMoc3Bxp2Sm8OwvzMrywxyw0gLjIQ==} + dependencies: + '@ethersproject/bytes': 5.8.0 + dev: false + + /@ethersproject/basex@5.8.0: + resolution: {integrity: sha512-PIgTszMlDRmNwW9nhS6iqtVfdTAKosA7llYXNmGPw4YAI1PUyMv28988wAb41/gHF/WqGdoLv0erHaRcHRKW2Q==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/properties': 5.8.0 + dev: false + + /@ethersproject/bignumber@5.8.0: + resolution: {integrity: sha512-ZyaT24bHaSeJon2tGPKIiHszWjD/54Sz8t57Toch475lCLljC6MgPmxk7Gtzz+ddNN5LuHea9qhAe0x3D+uYPA==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + bn.js: 5.2.2 + dev: false + + /@ethersproject/bytes@5.8.0: + resolution: {integrity: sha512-vTkeohgJVCPVHu5c25XWaWQOZ4v+DkGoC42/TS2ond+PARCxTJvgTFUNDZovyQ/uAQ4EcpqqowKydcdmRKjg7A==} + dependencies: + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/constants@5.8.0: + resolution: {integrity: sha512-wigX4lrf5Vu+axVTIvNsuL6YrV4O5AXl5ubcURKMEME5TnWBouUh0CDTWxZ2GpnRn1kcCgE7l8O5+VbV9QTTcg==} + dependencies: + '@ethersproject/bignumber': 5.8.0 + dev: false + + /@ethersproject/contracts@5.8.0: + resolution: {integrity: sha512-0eFjGz9GtuAi6MZwhb4uvUM216F38xiuR0yYCjKJpNfSEy4HUM8hvqqBj9Jmm0IUz8l0xKEhWwLIhPgxNY0yvQ==} + dependencies: + '@ethersproject/abi': 5.8.0 + '@ethersproject/abstract-provider': 5.8.0 + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/address': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/transactions': 5.8.0 + dev: false + + /@ethersproject/hash@5.8.0: + resolution: {integrity: sha512-ac/lBcTbEWW/VGJij0CNSw/wPcw9bSRgCB0AIBz8CvED/jfvDoV9hsIIiWfvWmFEi8RcXtlNwp2jv6ozWOsooA==} + dependencies: + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/address': 5.8.0 + '@ethersproject/base64': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/strings': 5.8.0 + dev: false + + /@ethersproject/hdnode@5.8.0: + resolution: {integrity: sha512-4bK1VF6E83/3/Im0ERnnUeWOY3P1BZml4ZD3wcH8Ys0/d1h1xaFt6Zc+Dh9zXf9TapGro0T4wvO71UTCp3/uoA==} + dependencies: + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/basex': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/pbkdf2': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/sha2': 5.8.0 + '@ethersproject/signing-key': 5.8.0 + '@ethersproject/strings': 5.8.0 + '@ethersproject/transactions': 5.8.0 + '@ethersproject/wordlists': 5.8.0 + dev: false + + /@ethersproject/json-wallets@5.8.0: + resolution: {integrity: sha512-HxblNck8FVUtNxS3VTEYJAcwiKYsBIF77W15HufqlBF9gGfhmYOJtYZp8fSDZtn9y5EaXTE87zDwzxRoTFk11w==} + dependencies: + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/address': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/hdnode': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/pbkdf2': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/random': 5.8.0 + '@ethersproject/strings': 5.8.0 + '@ethersproject/transactions': 5.8.0 + aes-js: 3.0.0 + scrypt-js: 3.0.1 + dev: false + + /@ethersproject/keccak256@5.7.0: + resolution: {integrity: sha512-2UcPboeL/iW+pSg6vZ6ydF8tCnv3Iu/8tUmLLzWWGzxWKFFqOBQFLo6uLUv6BDrLgCDfN28RJ/wtByx+jZ4KBg==} + dependencies: + '@ethersproject/bytes': 5.8.0 + js-sha3: 0.8.0 + dev: false + + /@ethersproject/keccak256@5.8.0: + resolution: {integrity: sha512-A1pkKLZSz8pDaQ1ftutZoaN46I6+jvuqugx5KYNeQOPqq+JZ0Txm7dlWesCHB5cndJSu5vP2VKptKf7cksERng==} + dependencies: + '@ethersproject/bytes': 5.8.0 + js-sha3: 0.8.0 + dev: false + + /@ethersproject/logger@5.8.0: + resolution: {integrity: sha512-Qe6knGmY+zPPWTC+wQrpitodgBfH7XoceCGL5bJVejmH+yCS3R8jJm8iiWuvWbG76RUmyEG53oqv6GMVWqunjA==} + dev: false + + /@ethersproject/networks@5.8.0: + resolution: {integrity: sha512-egPJh3aPVAzbHwq8DD7Po53J4OUSsA1MjQp8Vf/OZPav5rlmWUaFLiq8cvQiGK0Z5K6LYzm29+VA/p4RL1FzNg==} + dependencies: + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/pbkdf2@5.8.0: + resolution: {integrity: sha512-wuHiv97BrzCmfEaPbUFpMjlVg/IDkZThp9Ri88BpjRleg4iePJaj2SW8AIyE8cXn5V1tuAaMj6lzvsGJkGWskg==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/sha2': 5.8.0 + dev: false + + /@ethersproject/properties@5.8.0: + resolution: {integrity: sha512-PYuiEoQ+FMaZZNGrStmN7+lWjlsoufGIHdww7454FIaGdbe/p5rnaCXTr5MtBYl3NkeoVhHZuyzChPeGeKIpQw==} + dependencies: + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/providers@5.8.0: + resolution: {integrity: sha512-3Il3oTzEx3o6kzcg9ZzbE+oCZYyY+3Zh83sKkn4s1DZfTUjIegHnN2Cm0kbn9YFy45FDVcuCLLONhU7ny0SsCw==} + dependencies: + '@ethersproject/abstract-provider': 5.8.0 + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/address': 5.8.0 + '@ethersproject/base64': 5.8.0 + '@ethersproject/basex': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/hash': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/networks': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/random': 5.8.0 + '@ethersproject/rlp': 5.8.0 + '@ethersproject/sha2': 5.8.0 + '@ethersproject/strings': 5.8.0 + '@ethersproject/transactions': 5.8.0 + '@ethersproject/web': 5.8.0 + bech32: 1.1.4 + ws: 8.18.0 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + dev: false + + /@ethersproject/random@5.8.0: + resolution: {integrity: sha512-E4I5TDl7SVqyg4/kkA/qTfuLWAQGXmSOgYyO01So8hLfwgKvYK5snIlzxJMk72IFdG/7oh8yuSqY2KX7MMwg+A==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/rlp@5.8.0: + resolution: {integrity: sha512-LqZgAznqDbiEunaUvykH2JAoXTT9NV0Atqk8rQN9nx9SEgThA/WMx5DnW8a9FOufo//6FZOCHZ+XiClzgbqV9Q==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/sha2@5.8.0: + resolution: {integrity: sha512-dDOUrXr9wF/YFltgTBYS0tKslPEKr6AekjqDW2dbn1L1xmjGR+9GiKu4ajxovnrDbwxAKdHjW8jNcwfz8PAz4A==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + hash.js: 1.1.7 + dev: false + + /@ethersproject/signing-key@5.8.0: + resolution: {integrity: sha512-LrPW2ZxoigFi6U6aVkFN/fa9Yx/+4AtIUe4/HACTvKJdhm0eeb107EVCIQcrLZkxaSIgc/eCrX8Q1GtbH+9n3w==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + bn.js: 5.2.2 + elliptic: 6.6.1 + hash.js: 1.1.7 + dev: false + + /@ethersproject/solidity@5.8.0: + resolution: {integrity: sha512-4CxFeCgmIWamOHwYN9d+QWGxye9qQLilpgTU0XhYs1OahkclF+ewO+3V1U0mvpiuQxm5EHHmv8f7ClVII8EHsA==} + dependencies: + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/sha2': 5.8.0 + '@ethersproject/strings': 5.8.0 + dev: false + + /@ethersproject/strings@5.7.0: + resolution: {integrity: sha512-/9nu+lj0YswRNSH0NXYqrh8775XNyEdUQAuf3f+SmOrnVewcJ5SBNAjF7lpgehKi4abvNNXyf+HX86czCdJ8Mg==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/strings@5.8.0: + resolution: {integrity: sha512-qWEAk0MAvl0LszjdfnZ2uC8xbR2wdv4cDabyHiBh3Cldq/T8dPH3V4BbBsAYJUeonwD+8afVXld274Ls+Y1xXg==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/transactions@5.8.0: + resolution: {integrity: sha512-UglxSDjByHG0TuU17bDfCemZ3AnKO2vYrL5/2n2oXvKzvb7Cz+W9gOWXKARjp2URVwcWlQlPOEQyAviKwT4AHg==} + dependencies: + '@ethersproject/address': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/rlp': 5.8.0 + '@ethersproject/signing-key': 5.8.0 + dev: false + + /@ethersproject/units@5.8.0: + resolution: {integrity: sha512-lxq0CAnc5kMGIiWW4Mr041VT8IhNM+Pn5T3haO74XZWFulk7wH1Gv64HqE96hT4a7iiNMdOCFEBgaxWuk8ETKQ==} + dependencies: + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/logger': 5.8.0 + dev: false + + /@ethersproject/wallet@5.8.0: + resolution: {integrity: sha512-G+jnzmgg6UxurVKRKvw27h0kvG75YKXZKdlLYmAHeF32TGUzHkOFd7Zn6QHOTYRFWnfjtSSFjBowKo7vfrXzPA==} + dependencies: + '@ethersproject/abstract-provider': 5.8.0 + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/address': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/hash': 5.8.0 + '@ethersproject/hdnode': 5.8.0 + '@ethersproject/json-wallets': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/random': 5.8.0 + '@ethersproject/signing-key': 5.8.0 + '@ethersproject/transactions': 5.8.0 + '@ethersproject/wordlists': 5.8.0 + dev: false + + /@ethersproject/web@5.8.0: + resolution: {integrity: sha512-j7+Ksi/9KfGviws6Qtf9Q7KCqRhpwrYKQPs+JBA/rKVFF/yaWLHJEH3zfVP2plVu+eys0d2DlFmhoQJayFewcw==} + dependencies: + '@ethersproject/base64': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/strings': 5.8.0 + dev: false + + /@ethersproject/wordlists@5.8.0: + resolution: {integrity: sha512-2df9bbXicZws2Sb5S6ET493uJ0Z84Fjr3pC4tu/qlnZERibZCeUVuqdtt+7Tv9xxhUxHoIekIA7avrKUWHrezg==} + dependencies: + '@ethersproject/bytes': 5.8.0 + '@ethersproject/hash': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/strings': 5.8.0 + dev: false + + /@fastify/busboy@2.1.1: + resolution: {integrity: sha512-vBZP4NlzfOlerQTnba4aqZoMhE/a9HY7HRqoOPaETQcSQuWEIyZMHGfVu6w9wGtGK5fED5qRs2DteVCjOH60sA==} + engines: {node: '>=14'} + dev: false + + /@humanwhocodes/config-array@0.13.0: + resolution: {integrity: sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==} + engines: {node: '>=10.10.0'} + deprecated: Use @eslint/config-array instead + dependencies: + '@humanwhocodes/object-schema': 2.0.3 + debug: 4.4.3(supports-color@8.1.1) + minimatch: 3.1.2 + transitivePeerDependencies: + - supports-color + dev: true + + /@humanwhocodes/module-importer@1.0.1: + resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==} + engines: {node: '>=12.22'} + dev: true + + /@humanwhocodes/object-schema@2.0.3: + resolution: {integrity: sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==} + deprecated: Use @eslint/object-schema instead + dev: true + + /@noble/ciphers@1.3.0: + resolution: {integrity: sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw==} + engines: {node: ^14.21.3 || >=16} + dev: false + + /@noble/curves@1.4.2: + resolution: {integrity: sha512-TavHr8qycMChk8UwMld0ZDRvatedkzWfH8IiaeGCfymOP5i0hSCozz9vHOL0nkwk7HRMlFnAiKpS2jrUmSybcw==} + dependencies: + '@noble/hashes': 1.4.0 + dev: false + + /@noble/curves@1.8.2: + resolution: {integrity: sha512-vnI7V6lFNe0tLAuJMu+2sX+FcL14TaCWy1qiczg1VwRmPrpQCdq5ESXQMqUc2tluRNf6irBXrWbl1mGN8uaU/g==} + engines: {node: ^14.21.3 || >=16} + dependencies: + '@noble/hashes': 1.7.2 + dev: false + + /@noble/curves@1.9.1: + resolution: {integrity: sha512-k11yZxZg+t+gWvBbIswW0yoJlu8cHOC7dhunwOzoWH/mXGBiYyR4YY6hAEK/3EUs4UpB8la1RfdRpeGsFHkWsA==} + engines: {node: ^14.21.3 || >=16} + dependencies: + '@noble/hashes': 1.8.0 + dev: false + + /@noble/hashes@1.2.0: + resolution: {integrity: sha512-FZfhjEDbT5GRswV3C6uvLPHMiVD6lQBmpoX5+eSiPaMTXte/IKqI5dykDxzZB/WBeK/CDuQRBWarPdi3FNY2zQ==} + dev: false + + /@noble/hashes@1.4.0: + resolution: {integrity: sha512-V1JJ1WTRUqHHrOSh597hURcMqVKVGL/ea3kv0gSnEdsEZ0/+VyPghM1lMNGc00z7CIQorSvbKpuJkxvuHbvdbg==} + engines: {node: '>= 16'} + dev: false + + /@noble/hashes@1.7.2: + resolution: {integrity: sha512-biZ0NUSxyjLLqo6KxEJ1b+C2NAx0wtDoFvCaXHGgUkeHzf3Xc1xKumFKREuT7f7DARNZ/slvYUwFG6B0f2b6hQ==} + engines: {node: ^14.21.3 || >=16} + dev: false + + /@noble/hashes@1.8.0: + resolution: {integrity: sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==} + engines: {node: ^14.21.3 || >=16} + dev: false + + /@noble/secp256k1@1.7.1: + resolution: {integrity: sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==} + dev: false + + /@nodelib/fs.scandir@2.1.5: + resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==} + engines: {node: '>= 8'} + dependencies: + '@nodelib/fs.stat': 2.0.5 + run-parallel: 1.2.0 + dev: true + + /@nodelib/fs.stat@2.0.5: + resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==} + engines: {node: '>= 8'} + dev: true + + /@nodelib/fs.walk@1.2.8: + resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==} + engines: {node: '>= 8'} + dependencies: + '@nodelib/fs.scandir': 2.1.5 + fastq: 1.19.1 + dev: true + + /@nomicfoundation/edr-darwin-arm64@0.12.0-next.14: + resolution: {integrity: sha512-sl0DibKSUOS7JXhUtaQ6FJUY+nk+uq5gx+Fyd9iiqs8awZPNn6KSuvV1EbWCi+yd3mrxgZ/wO8E77C1Dxj4xQA==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr-darwin-x64@0.12.0-next.14: + resolution: {integrity: sha512-lfmatc1MSOaw0rDFB+ynnAGz5TWm3hSeY/+zDpPZghMODZelXm4JCqF41CQ6paLsW3X/pXcHM1HUGCUBWeoI/A==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr-linux-arm64-gnu@0.12.0-next.14: + resolution: {integrity: sha512-sWun3PhVgat8d4lg1d5MAXSIsFlSMBzvrpMSDFNOU9hPJEclSHbHBMRcarQuGqwm/5ZBzTwCS25u78A+UATTrg==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr-linux-arm64-musl@0.12.0-next.14: + resolution: {integrity: sha512-omWKioD8fFp7ayCeSDu2CqvG78+oYw8zdVECDwZVmE0jpszRCsTufNYflWRQnlGqH6GqjEUwq2c3yLxFgOTjFg==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr-linux-x64-gnu@0.12.0-next.14: + resolution: {integrity: sha512-vk0s4SaC7s1wa98W24a4zqunTK/yIcSEnsSLRM/Nl+JJs6iqS8tvmnh/BbFINORMBJ065OWc10qw2Lsbu/rxtg==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr-linux-x64-musl@0.12.0-next.14: + resolution: {integrity: sha512-/xKQD6c2RXQBIb30iTeh/NrMdYvHs6Nd+2UXS6wxlfX7GzRPOkpVDiDGD7Sda82JI459KH67dADOD6CpX8cpHQ==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr-win32-x64-msvc@0.12.0-next.14: + resolution: {integrity: sha512-GZcyGdOoLWnUtfPU+6B1vUi4fwf3bouSRf3xuKFHz3p/WNhpDK+8Esq3UmOmYAZWRgFT0ZR6XUk9H2owGDTVvQ==} + engines: {node: '>= 20'} + dev: false + + /@nomicfoundation/edr@0.12.0-next.14: + resolution: {integrity: sha512-MGHY2x7JaNdkqlQxFBYoM7Miw2EqsQrI3ReVZMwLP5mULSRTAOnt3hCw6cnjXxGi991HnejNAedJofke6OdqqA==} + engines: {node: '>= 20'} + dependencies: + '@nomicfoundation/edr-darwin-arm64': 0.12.0-next.14 + '@nomicfoundation/edr-darwin-x64': 0.12.0-next.14 + '@nomicfoundation/edr-linux-arm64-gnu': 0.12.0-next.14 + '@nomicfoundation/edr-linux-arm64-musl': 0.12.0-next.14 + '@nomicfoundation/edr-linux-x64-gnu': 0.12.0-next.14 + '@nomicfoundation/edr-linux-x64-musl': 0.12.0-next.14 + '@nomicfoundation/edr-win32-x64-msvc': 0.12.0-next.14 + dev: false + + /@nomicfoundation/solidity-analyzer-darwin-arm64@0.1.2: + resolution: {integrity: sha512-JaqcWPDZENCvm++lFFGjrDd8mxtf+CtLd2MiXvMNTBD33dContTZ9TWETwNFwg7JTJT5Q9HEecH7FA+HTSsIUw==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer-darwin-x64@0.1.2: + resolution: {integrity: sha512-fZNmVztrSXC03e9RONBT+CiksSeYcxI1wlzqyr0L7hsQlK1fzV+f04g2JtQ1c/Fe74ZwdV6aQBdd6Uwl1052sw==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer-linux-arm64-gnu@0.1.2: + resolution: {integrity: sha512-3d54oc+9ZVBuB6nbp8wHylk4xh0N0Gc+bk+/uJae+rUgbOBwQSfuGIbAZt1wBXs5REkSmynEGcqx6DutoK0tPA==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer-linux-arm64-musl@0.1.2: + resolution: {integrity: sha512-iDJfR2qf55vgsg7BtJa7iPiFAsYf2d0Tv/0B+vhtnI16+wfQeTbP7teookbGvAo0eJo7aLLm0xfS/GTkvHIucA==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer-linux-x64-gnu@0.1.2: + resolution: {integrity: sha512-9dlHMAt5/2cpWyuJ9fQNOUXFB/vgSFORg1jpjX1Mh9hJ/MfZXlDdHQ+DpFCs32Zk5pxRBb07yGvSHk9/fezL+g==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer-linux-x64-musl@0.1.2: + resolution: {integrity: sha512-GzzVeeJob3lfrSlDKQw2bRJ8rBf6mEYaWY+gW0JnTDHINA0s2gPR4km5RLIj1xeZZOYz4zRw+AEeYgLRqB2NXg==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer-win32-x64-msvc@0.1.2: + resolution: {integrity: sha512-Fdjli4DCcFHb4Zgsz0uEJXZ2K7VEO+w5KVv7HmT7WO10iODdU9csC2az4jrhEsRtiR9Gfd74FlG0NYlw1BMdyA==} + engines: {node: '>= 12'} + requiresBuild: true + dev: false + optional: true + + /@nomicfoundation/solidity-analyzer@0.1.2: + resolution: {integrity: sha512-q4n32/FNKIhQ3zQGGw5CvPF6GTvDCpYwIf7bEY/dZTZbgfDsHyjJwURxUJf3VQuuJj+fDIFl4+KkBVbw4Ef6jA==} + engines: {node: '>= 12'} + optionalDependencies: + '@nomicfoundation/solidity-analyzer-darwin-arm64': 0.1.2 + '@nomicfoundation/solidity-analyzer-darwin-x64': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-arm64-gnu': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-arm64-musl': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-x64-gnu': 0.1.2 + '@nomicfoundation/solidity-analyzer-linux-x64-musl': 0.1.2 + '@nomicfoundation/solidity-analyzer-win32-x64-msvc': 0.1.2 + dev: false + + /@openzeppelin/contracts@3.4.1-solc-0.7-2: + resolution: {integrity: sha512-tAG9LWg8+M2CMu7hIsqHPaTyG4uDzjr6mhvH96LvOpLZZj6tgzTluBt+LsCf1/QaYrlis6pITvpIaIhE+iZB+Q==} + dev: false + + /@openzeppelin/contracts@3.4.2-solc-0.7: + resolution: {integrity: sha512-W6QmqgkADuFcTLzHL8vVoNBtkwjvQRpYIAom7KiUNoLKghyx3FgH0GBjt8NRvigV1ZmMOBllvE1By1C+bi8WpA==} + dev: false + + /@paraswap/core@2.4.0: + resolution: {integrity: sha512-msv0Etc5f7H2UDnDd23wKzNnx64fj1iwt8IlBORTFIpxJ1+fa+TqNO7lhtohfRiVmU3dnnAMcjEi4D+WHSWpvw==} + dev: false + + /@paraswap/sdk@6.12.0(axios@1.13.2)(ethers@5.8.0)(typescript@5.9.3): + resolution: {integrity: sha512-YHAYKP2QKV7gBjXz4vCz9K4ET7yEESvC++x0s5muGNEtrIapHPXjNYORtgnoa2eG5sSLkfNFJzgKE77cTJB+UQ==} + engines: {node: '>=12'} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + peerDependencies: + axios: '>=0.25.0 <2.0.0' + ethers: ^5.5.0 + web3: ^1.7.1 + peerDependenciesMeta: + axios: + optional: true + ethers: + optional: true + web3: + optional: true + dependencies: + '@paraswap/core': 2.4.0 + axios: 1.13.2 + bignumber.js: 9.3.1 + ethers: 5.8.0 + ts-essentials: 9.4.2(typescript@5.9.3) + transitivePeerDependencies: + - typescript + dev: false + + /@protocolink/api@1.4.8(@ethersproject/address@5.8.0)(@ethersproject/contracts@5.8.0)(@ethersproject/networks@5.8.0)(@ethersproject/providers@5.8.0)(@ethersproject/solidity@5.8.0)(hardhat@2.27.0)(typescript@5.9.3): + resolution: {integrity: sha512-2+LYf/n90+MVzW6J9aCjiHzCoaE8mi7Zz8iaFuVeizBS15UYvw0C0goD2FwuVexGSdZKsW6nbUaVkHezaTFX4A==} + dependencies: + '@protocolink/common': 0.5.5 + '@protocolink/core': 0.6.4 + '@protocolink/logics': 1.8.9(@ethersproject/address@5.8.0)(@ethersproject/contracts@5.8.0)(@ethersproject/networks@5.8.0)(@ethersproject/providers@5.8.0)(@ethersproject/solidity@5.8.0)(hardhat@2.27.0)(typescript@5.9.3) + '@types/lodash': 4.17.20 + '@types/uuid': 9.0.8 + '@uniswap/permit2-sdk': 1.4.0 + axios: 1.13.2 + axios-retry: 3.9.1 + uuid: 9.0.1 + transitivePeerDependencies: + - '@ethersproject/address' + - '@ethersproject/contracts' + - '@ethersproject/networks' + - '@ethersproject/providers' + - '@ethersproject/solidity' + - bufferutil + - debug + - hardhat + - typescript + - utf-8-validate + - web3 + dev: false + + /@protocolink/common@0.5.5: + resolution: {integrity: sha512-X676/nMKVX++++DUFDDvpZeRCjYEwDM6vdDv2GTArzWL2MEKM/S8dWvLpjOWK19zOM6cKQDobt8fc1ph9FU0Mw==} + dependencies: + '@types/lodash': 4.17.20 + axios: 1.13.2 + axios-retry: 3.9.1 + bignumber.js: 9.3.1 + ethers: 5.8.0 + lodash: 4.17.21 + tiny-invariant: 1.3.3 + type-fest: 3.13.1 + zksync-web3: 0.14.4(ethers@5.8.0) + transitivePeerDependencies: + - bufferutil + - debug + - utf-8-validate + dev: false + + /@protocolink/core@0.6.4: + resolution: {integrity: sha512-6i1JusX/eH1zI6JkiICzorvWfk+FyfC9ykZ0zTqDHIEfbuFYtZtUTidBnlZ2vEDFzglmXjX5heASn8N0rG2rNA==} + dependencies: + '@protocolink/common': 0.5.5 + '@uniswap/permit2-sdk': 1.4.0 + ethers: 5.8.0 + tiny-invariant: 1.3.3 + transitivePeerDependencies: + - bufferutil + - debug + - utf-8-validate + dev: false + + /@protocolink/logics@1.8.9(@ethersproject/address@5.8.0)(@ethersproject/contracts@5.8.0)(@ethersproject/networks@5.8.0)(@ethersproject/providers@5.8.0)(@ethersproject/solidity@5.8.0)(hardhat@2.27.0)(typescript@5.9.3): + resolution: {integrity: sha512-0tETa6doxJmdqWO14/JIpG39QD96HEMhXrnW9KM8sjvEXM4uwPY8Q/uKNHXYv3VIX16Sqp+WGLlj+v35u/9UiQ==} + engines: {node: '>=16'} + dependencies: + '@paraswap/sdk': 6.12.0(axios@1.13.2)(ethers@5.8.0)(typescript@5.9.3) + '@protocolink/common': 0.5.5 + '@protocolink/core': 0.6.4 + '@protocolink/smart-accounts': 0.1.8 + '@types/lodash': 4.17.20 + '@uniswap/sdk': 3.0.3(@ethersproject/address@5.8.0)(@ethersproject/contracts@5.8.0)(@ethersproject/networks@5.8.0)(@ethersproject/providers@5.8.0)(@ethersproject/solidity@5.8.0) + '@uniswap/sdk-core': 3.2.6 + '@uniswap/token-lists': 1.0.0-beta.35 + '@uniswap/v3-sdk': 3.26.0(hardhat@2.27.0) + axios: 1.13.2 + axios-retry: 3.9.1 + bignumber.js: 9.3.1 + ethers: 5.8.0 + lodash: 4.17.21 + tiny-invariant: 1.3.3 + transitivePeerDependencies: + - '@ethersproject/address' + - '@ethersproject/contracts' + - '@ethersproject/networks' + - '@ethersproject/providers' + - '@ethersproject/solidity' + - bufferutil + - debug + - hardhat + - typescript + - utf-8-validate + - web3 + dev: false + + /@protocolink/smart-accounts@0.1.8: + resolution: {integrity: sha512-g1ijuKQ/ZLDV2+4udfVZuffTY6y5PEa8qG8KP4Ysy9DIoU/A/vd33voyc8dVJxrbe/aRku8Q3FScufCuNQq1ZQ==} + dependencies: + '@protocolink/common': 0.5.5 + ethers: 5.8.0 + tiny-invariant: 1.3.3 + transitivePeerDependencies: + - bufferutil + - debug + - utf-8-validate + dev: false + + /@scure/base@1.1.9: + resolution: {integrity: sha512-8YKhl8GHiNI/pU2VMaofa2Tor7PJRAjwQLBBuilkJ9L5+13yVbC7JO/wS7piioAvPSwR3JKM1IJ/u4xQzbcXKg==} + dev: false + + /@scure/base@1.2.6: + resolution: {integrity: sha512-g/nm5FgUa//MCj1gV09zTJTaM6KBAHqLN907YVQqf7zC49+DcO4B1so4ZX07Ef10Twr6nuqYEH9GEggFXA4Fmg==} + dev: false + + /@scure/bip32@1.1.5: + resolution: {integrity: sha512-XyNh1rB0SkEqd3tXcXMi+Xe1fvg+kUIcoRIEujP1Jgv7DqW2r9lg3Ah0NkFaCs9sTkQAQA8kw7xiRXzENi9Rtw==} + dependencies: + '@noble/hashes': 1.2.0 + '@noble/secp256k1': 1.7.1 + '@scure/base': 1.1.9 + dev: false + + /@scure/bip32@1.4.0: + resolution: {integrity: sha512-sVUpc0Vq3tXCkDGYVWGIZTRfnvu8LoTDaev7vbwh0omSvVORONr960MQWdKqJDCReIEmTj3PAr73O3aoxz7OPg==} + dependencies: + '@noble/curves': 1.4.2 + '@noble/hashes': 1.4.0 + '@scure/base': 1.1.9 + dev: false + + /@scure/bip32@1.7.0: + resolution: {integrity: sha512-E4FFX/N3f4B80AKWp5dP6ow+flD1LQZo/w8UnLGYZO674jS6YnYeepycOOksv+vLPSpgN35wgKgy+ybfTb2SMw==} + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + dev: false + + /@scure/bip39@1.1.1: + resolution: {integrity: sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==} + dependencies: + '@noble/hashes': 1.2.0 + '@scure/base': 1.1.9 + dev: false + + /@scure/bip39@1.3.0: + resolution: {integrity: sha512-disdg7gHuTDZtY+ZdkmLpPCk7fxZSu3gBiEGuoC1XYxv9cGx3Z6cpTggCgW6odSOOIXCiDjuGejW+aJKCY/pIQ==} + dependencies: + '@noble/hashes': 1.4.0 + '@scure/base': 1.1.9 + dev: false + + /@scure/bip39@1.6.0: + resolution: {integrity: sha512-+lF0BbLiJNwVlev4eKelw1WWLaiKXw7sSl8T6FvBlWkdX+94aGJ4o8XjUdlyhTCjd8c+B3KT3JfS8P0bLRNU6A==} + dependencies: + '@noble/hashes': 1.8.0 + '@scure/base': 1.2.6 + dev: false + + /@sentry/core@5.30.0: + resolution: {integrity: sha512-TmfrII8w1PQZSZgPpUESqjB+jC6MvZJZdLtE/0hZ+SrnKhW3x5WlYLvTXZpcWePYBku7rl2wn1RZu6uT0qCTeg==} + engines: {node: '>=6'} + dependencies: + '@sentry/hub': 5.30.0 + '@sentry/minimal': 5.30.0 + '@sentry/types': 5.30.0 + '@sentry/utils': 5.30.0 + tslib: 1.14.1 + dev: false + + /@sentry/hub@5.30.0: + resolution: {integrity: sha512-2tYrGnzb1gKz2EkMDQcfLrDTvmGcQPuWxLnJKXJvYTQDGLlEvi2tWz1VIHjunmOvJrB5aIQLhm+dcMRwFZDCqQ==} + engines: {node: '>=6'} + dependencies: + '@sentry/types': 5.30.0 + '@sentry/utils': 5.30.0 + tslib: 1.14.1 + dev: false + + /@sentry/minimal@5.30.0: + resolution: {integrity: sha512-BwWb/owZKtkDX+Sc4zCSTNcvZUq7YcH3uAVlmh/gtR9rmUvbzAA3ewLuB3myi4wWRAMEtny6+J/FN/x+2wn9Xw==} + engines: {node: '>=6'} + dependencies: + '@sentry/hub': 5.30.0 + '@sentry/types': 5.30.0 + tslib: 1.14.1 + dev: false + + /@sentry/node@5.30.0: + resolution: {integrity: sha512-Br5oyVBF0fZo6ZS9bxbJZG4ApAjRqAnqFFurMVJJdunNb80brh7a5Qva2kjhm+U6r9NJAB5OmDyPkA1Qnt+QVg==} + engines: {node: '>=6'} + dependencies: + '@sentry/core': 5.30.0 + '@sentry/hub': 5.30.0 + '@sentry/tracing': 5.30.0 + '@sentry/types': 5.30.0 + '@sentry/utils': 5.30.0 + cookie: 0.4.2 + https-proxy-agent: 5.0.1 + lru_map: 0.3.3 + tslib: 1.14.1 + transitivePeerDependencies: + - supports-color + dev: false + + /@sentry/tracing@5.30.0: + resolution: {integrity: sha512-dUFowCr0AIMwiLD7Fs314Mdzcug+gBVo/+NCMyDw8tFxJkwWAKl7Qa2OZxLQ0ZHjakcj1hNKfCQJ9rhyfOl4Aw==} + engines: {node: '>=6'} + dependencies: + '@sentry/hub': 5.30.0 + '@sentry/minimal': 5.30.0 + '@sentry/types': 5.30.0 + '@sentry/utils': 5.30.0 + tslib: 1.14.1 + dev: false + + /@sentry/types@5.30.0: + resolution: {integrity: sha512-R8xOqlSTZ+htqrfteCWU5Nk0CDN5ApUTvrlvBuiH1DyP6czDZ4ktbZB0hAgBlVcK0U+qpD3ag3Tqqpa5Q67rPw==} + engines: {node: '>=6'} + dev: false + + /@sentry/utils@5.30.0: + resolution: {integrity: sha512-zaYmoH0NWWtvnJjC9/CBseXMtKHm/tm40sz3YfJRxeQjyzRqNQPgivpd9R/oDJCYj999mzdW382p/qi2ypjLww==} + engines: {node: '>=6'} + dependencies: + '@sentry/types': 5.30.0 + tslib: 1.14.1 + dev: false + + /@types/js-yaml@4.0.9: + resolution: {integrity: sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==} + dev: true + + /@types/lodash@4.17.20: + resolution: {integrity: sha512-H3MHACvFUEiujabxhaI/ImO6gUrd8oOurg7LQtS7mbwIXA/cUqWrvBsaeJ23aZEPk1TAYkurjfMbSELfoCXlGA==} + dev: false + + /@types/node@20.19.24: + resolution: {integrity: sha512-FE5u0ezmi6y9OZEzlJfg37mqqf6ZDSF2V/NLjUyGrR9uTZ7Sb9F7bLNZ03S4XVUNRWGA7Ck4c1kK+YnuWjl+DA==} + dependencies: + undici-types: 6.21.0 + dev: true + + /@types/uuid@9.0.8: + resolution: {integrity: sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA==} + dev: false + + /@typescript-eslint/eslint-plugin@7.18.0(@typescript-eslint/parser@7.18.0)(eslint@8.57.1)(typescript@5.9.3): + resolution: {integrity: sha512-94EQTWZ40mzBc42ATNIBimBEDltSJ9RQHCC8vc/PDbxi4k8dVwUAv4o98dk50M1zB+JGFxp43FP7f8+FP8R6Sw==} + engines: {node: ^18.18.0 || >=20.0.0} + peerDependencies: + '@typescript-eslint/parser': ^7.0.0 + eslint: ^8.56.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + '@eslint-community/regexpp': 4.12.2 + '@typescript-eslint/parser': 7.18.0(eslint@8.57.1)(typescript@5.9.3) + '@typescript-eslint/scope-manager': 7.18.0 + '@typescript-eslint/type-utils': 7.18.0(eslint@8.57.1)(typescript@5.9.3) + '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.9.3) + '@typescript-eslint/visitor-keys': 7.18.0 + eslint: 8.57.1 + graphemer: 1.4.0 + ignore: 5.3.2 + natural-compare: 1.4.0 + ts-api-utils: 1.4.3(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@typescript-eslint/parser@7.18.0(eslint@8.57.1)(typescript@5.9.3): + resolution: {integrity: sha512-4Z+L8I2OqhZV8qA132M4wNL30ypZGYOQVBfMgxDH/K5UX0PNqTu1c6za9ST5r9+tavvHiTWmBnKzpCJ/GlVFtg==} + engines: {node: ^18.18.0 || >=20.0.0} + peerDependencies: + eslint: ^8.56.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + '@typescript-eslint/scope-manager': 7.18.0 + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.9.3) + '@typescript-eslint/visitor-keys': 7.18.0 + debug: 4.4.3(supports-color@8.1.1) + eslint: 8.57.1 + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@typescript-eslint/scope-manager@7.18.0: + resolution: {integrity: sha512-jjhdIE/FPF2B7Z1uzc6i3oWKbGcHb87Qw7AWj6jmEqNOfDFbJWtjt/XfwCpvNkpGWlcJaog5vTR+VV8+w9JflA==} + engines: {node: ^18.18.0 || >=20.0.0} + dependencies: + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/visitor-keys': 7.18.0 + dev: true + + /@typescript-eslint/type-utils@7.18.0(eslint@8.57.1)(typescript@5.9.3): + resolution: {integrity: sha512-XL0FJXuCLaDuX2sYqZUUSOJ2sG5/i1AAze+axqmLnSkNEVMVYLF+cbwlB2w8D1tinFuSikHmFta+P+HOofrLeA==} + engines: {node: ^18.18.0 || >=20.0.0} + peerDependencies: + eslint: ^8.56.0 + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.9.3) + '@typescript-eslint/utils': 7.18.0(eslint@8.57.1)(typescript@5.9.3) + debug: 4.4.3(supports-color@8.1.1) + eslint: 8.57.1 + ts-api-utils: 1.4.3(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@typescript-eslint/types@7.18.0: + resolution: {integrity: sha512-iZqi+Ds1y4EDYUtlOOC+aUmxnE9xS/yCigkjA7XpTKV6nCBd3Hp/PRGGmdwnfkV2ThMyYldP1wRpm/id99spTQ==} + engines: {node: ^18.18.0 || >=20.0.0} + dev: true + + /@typescript-eslint/typescript-estree@7.18.0(typescript@5.9.3): + resolution: {integrity: sha512-aP1v/BSPnnyhMHts8cf1qQ6Q1IFwwRvAQGRvBFkWlo3/lH29OXA3Pts+c10nxRxIBrDnoMqzhgdwVe5f2D6OzA==} + engines: {node: ^18.18.0 || >=20.0.0} + peerDependencies: + typescript: '*' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/visitor-keys': 7.18.0 + debug: 4.4.3(supports-color@8.1.1) + globby: 11.1.0 + is-glob: 4.0.3 + minimatch: 9.0.5 + semver: 7.7.3 + ts-api-utils: 1.4.3(typescript@5.9.3) + typescript: 5.9.3 + transitivePeerDependencies: + - supports-color + dev: true + + /@typescript-eslint/utils@7.18.0(eslint@8.57.1)(typescript@5.9.3): + resolution: {integrity: sha512-kK0/rNa2j74XuHVcoCZxdFBMF+aq/vH83CXAOHieC+2Gis4mF8jJXT5eAfyD3K0sAxtPuwxaIOIOvhwzVDt/kw==} + engines: {node: ^18.18.0 || >=20.0.0} + peerDependencies: + eslint: ^8.56.0 + dependencies: + '@eslint-community/eslint-utils': 4.9.0(eslint@8.57.1) + '@typescript-eslint/scope-manager': 7.18.0 + '@typescript-eslint/types': 7.18.0 + '@typescript-eslint/typescript-estree': 7.18.0(typescript@5.9.3) + eslint: 8.57.1 + transitivePeerDependencies: + - supports-color + - typescript + dev: true + + /@typescript-eslint/visitor-keys@7.18.0: + resolution: {integrity: sha512-cDF0/Gf81QpY3xYyJKDV14Zwdmid5+uuENhjH2EqFaF0ni+yAyq/LzMaIJdhNJXZI7uLzwIlA+V7oWoyn6Curg==} + engines: {node: ^18.18.0 || >=20.0.0} + dependencies: + '@typescript-eslint/types': 7.18.0 + eslint-visitor-keys: 3.4.3 + dev: true + + /@ungap/structured-clone@1.3.0: + resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==} + dev: true + + /@uniswap/lib@4.0.1-alpha: + resolution: {integrity: sha512-f6UIliwBbRsgVLxIaBANF6w09tYqc6Y/qXdsrbEmXHyFA7ILiKrIwRFXe1yOg8M3cksgVsO9N7yuL2DdCGQKBA==} + engines: {node: '>=10'} + dev: false + + /@uniswap/permit2-sdk@1.4.0: + resolution: {integrity: sha512-l/aGhfhB93M76vXs4eB8QNwhELE6bs66kh7F1cyobaPtINaVpMmlJv+j3KmHeHwAZIsh7QXyYzhDxs07u0Pe4Q==} + dependencies: + ethers: 5.8.0 + tiny-invariant: 1.3.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + dev: false + + /@uniswap/sdk-core@3.2.6: + resolution: {integrity: sha512-MvH/3G0W0sM2g7XjaUy9qU7IabxL/KQp/ucU0AQGpVxiTaAhmVRtsjkkv9UDyzpIXVrmevl4kRgV7KKE29UuXA==} + engines: {node: '>=10'} + deprecated: breaking change required major version bump + dependencies: + '@ethersproject/address': 5.8.0 + big.js: 5.2.2 + decimal.js-light: 2.5.1 + jsbi: 3.2.5 + tiny-invariant: 1.3.3 + toformat: 2.0.0 + dev: false + + /@uniswap/sdk-core@7.9.0: + resolution: {integrity: sha512-HHUFNK3LMi4KMQCAiHkdUyL62g/nrZLvNT44CY8RN4p8kWO6XYWzqdQt6OcjCsIbhMZ/Ifhe6Py5oOoccg/jUQ==} + engines: {node: '>=10'} + dependencies: + '@ethersproject/address': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/keccak256': 5.7.0 + '@ethersproject/strings': 5.7.0 + big.js: 5.2.2 + decimal.js-light: 2.5.1 + jsbi: 3.2.5 + tiny-invariant: 1.3.3 + toformat: 2.0.0 + dev: false + + /@uniswap/sdk@3.0.3(@ethersproject/address@5.8.0)(@ethersproject/contracts@5.8.0)(@ethersproject/networks@5.8.0)(@ethersproject/providers@5.8.0)(@ethersproject/solidity@5.8.0): + resolution: {integrity: sha512-t4s8bvzaCFSiqD2qfXIm3rWhbdnXp+QjD3/mRaeVDHK7zWevs6RGEb1ohMiNgOCTZANvBayb4j8p+XFdnMBadQ==} + engines: {node: '>=10'} + peerDependencies: + '@ethersproject/address': ^5.0.0-beta + '@ethersproject/contracts': ^5.0.0-beta + '@ethersproject/networks': ^5.0.0-beta + '@ethersproject/providers': ^5.0.0-beta + '@ethersproject/solidity': ^5.0.0-beta + dependencies: + '@ethersproject/address': 5.8.0 + '@ethersproject/contracts': 5.8.0 + '@ethersproject/networks': 5.8.0 + '@ethersproject/providers': 5.8.0 + '@ethersproject/solidity': 5.8.0 + '@uniswap/v2-core': 1.0.1 + big.js: 5.2.2 + decimal.js-light: 2.5.1 + jsbi: 3.2.5 + tiny-invariant: 1.3.3 + tiny-warning: 1.0.3 + toformat: 2.0.0 + dev: false + + /@uniswap/swap-router-contracts@1.3.1(hardhat@2.27.0): + resolution: {integrity: sha512-mh/YNbwKb7Mut96VuEtL+Z5bRe0xVIbjjiryn+iMMrK2sFKhR4duk/86mEz0UO5gSx4pQIw9G5276P5heY/7Rg==} + engines: {node: '>=10'} + deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info. + dependencies: + '@openzeppelin/contracts': 3.4.2-solc-0.7 + '@uniswap/v2-core': 1.0.1 + '@uniswap/v3-core': 1.0.1 + '@uniswap/v3-periphery': 1.4.4 + dotenv: 14.3.2 + hardhat-watcher: 2.5.0(hardhat@2.27.0) + transitivePeerDependencies: + - hardhat + dev: false + + /@uniswap/token-lists@1.0.0-beta.35: + resolution: {integrity: sha512-v43brw8Fx+D904fOCXL5kTU75cIPH40U/WTKB96K1gxOibk2jVsxW3AULBE5Buj5dJpeVwj/l6TNgB6QPw7lJg==} + engines: {node: '>=10'} + dev: false + + /@uniswap/v2-core@1.0.1: + resolution: {integrity: sha512-MtybtkUPSyysqLY2U210NBDeCHX+ltHt3oADGdjqoThZaFRDKwM6k1Nb3F0A3hk5hwuQvytFWhrWHOEq6nVJ8Q==} + engines: {node: '>=10'} + dev: false + + /@uniswap/v3-core@1.0.0: + resolution: {integrity: sha512-kSC4djMGKMHj7sLMYVnn61k9nu+lHjMIxgg9CDQT+s2QYLoA56GbSK9Oxr+qJXzzygbkrmuY6cwgP6cW2JXPFA==} + engines: {node: '>=10'} + dev: false + + /@uniswap/v3-core@1.0.1: + resolution: {integrity: sha512-7pVk4hEm00j9tc71Y9+ssYpO6ytkeI0y7WE9P6UcmNzhxPePwyAxImuhVsTqWK9YFvzgtvzJHi64pBl4jUzKMQ==} + engines: {node: '>=10'} + dev: false + + /@uniswap/v3-periphery@1.4.4: + resolution: {integrity: sha512-S4+m+wh8HbWSO3DKk4LwUCPZJTpCugIsHrWR86m/OrUyvSqGDTXKFfc2sMuGXCZrD1ZqO3rhQsKgdWg3Hbb2Kw==} + engines: {node: '>=10'} + dependencies: + '@openzeppelin/contracts': 3.4.2-solc-0.7 + '@uniswap/lib': 4.0.1-alpha + '@uniswap/v2-core': 1.0.1 + '@uniswap/v3-core': 1.0.1 + base64-sol: 1.0.1 + dev: false + + /@uniswap/v3-sdk@3.26.0(hardhat@2.27.0): + resolution: {integrity: sha512-bcoWNE7ntNNTHMOnDPscIqtIN67fUyrbBKr6eswI2gD2wm5b0YYFBDeh+Qc5Q3117o9i8S7QdftqrU8YSMQUfQ==} + engines: {node: '>=10'} + dependencies: + '@ethersproject/abi': 5.8.0 + '@ethersproject/solidity': 5.8.0 + '@uniswap/sdk-core': 7.9.0 + '@uniswap/swap-router-contracts': 1.3.1(hardhat@2.27.0) + '@uniswap/v3-periphery': 1.4.4 + '@uniswap/v3-staker': 1.0.0 + tiny-invariant: 1.3.3 + tiny-warning: 1.0.3 + transitivePeerDependencies: + - hardhat + dev: false + + /@uniswap/v3-staker@1.0.0: + resolution: {integrity: sha512-JV0Qc46Px5alvg6YWd+UIaGH9lDuYG/Js7ngxPit1SPaIP30AlVer1UYB7BRYeUVVxE+byUyIeN5jeQ7LLDjIw==} + engines: {node: '>=10'} + deprecated: Please upgrade to 1.0.1 + dependencies: + '@openzeppelin/contracts': 3.4.1-solc-0.7-2 + '@uniswap/v3-core': 1.0.0 + '@uniswap/v3-periphery': 1.4.4 + dev: false + + /abitype@1.1.0(typescript@5.9.3)(zod@3.25.76): + resolution: {integrity: sha512-6Vh4HcRxNMLA0puzPjM5GBgT4aAcFGKZzSgAXvuZ27shJP6NEpielTuqbBmZILR5/xd0PizkBGy5hReKz9jl5A==} + peerDependencies: + typescript: '>=5.0.4' + zod: ^3.22.0 || ^4.0.0 + peerDependenciesMeta: + typescript: + optional: true + zod: + optional: true + dependencies: + typescript: 5.9.3 + zod: 3.25.76 + dev: false + + /acorn-jsx@5.3.2(acorn@8.15.0): + resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==} + peerDependencies: + acorn: ^6.0.0 || ^7.0.0 || ^8.0.0 + dependencies: + acorn: 8.15.0 + dev: true + + /acorn@8.15.0: + resolution: {integrity: sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==} + engines: {node: '>=0.4.0'} + hasBin: true + dev: true + + /adm-zip@0.4.16: + resolution: {integrity: sha512-TFi4HBKSGfIKsK5YCkKaaFG2m4PEDyViZmEwof3MTIgzimHLto6muaHVpbrljdIvIrFZzEq/p4nafOeLcYegrg==} + engines: {node: '>=0.3.0'} + dev: false + + /aes-js@3.0.0: + resolution: {integrity: sha512-H7wUZRn8WpTq9jocdxQ2c8x2sKo9ZVmzfRE13GiNJXfp7NcKYEdvl3vspKjXox6RIG2VtaRe4JFvxG4rqp2Zuw==} + dev: false + + /agent-base@6.0.2: + resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==} + engines: {node: '>= 6.0.0'} + dependencies: + debug: 4.4.3(supports-color@8.1.1) + transitivePeerDependencies: + - supports-color + dev: false + + /aggregate-error@3.1.0: + resolution: {integrity: sha512-4I7Td01quW/RpocfNayFdFVk1qSuoh0E7JrbRJ16nH01HhKFQ88INq9Sd+nd72zqRySlr9BmDA8xlEJ6vJMrYA==} + engines: {node: '>=8'} + dependencies: + clean-stack: 2.2.0 + indent-string: 4.0.0 + dev: false + + /ajv@6.12.6: + resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==} + dependencies: + fast-deep-equal: 3.1.3 + fast-json-stable-stringify: 2.1.0 + json-schema-traverse: 0.4.1 + uri-js: 4.4.1 + dev: true + + /ansi-align@3.0.1: + resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==} + dependencies: + string-width: 4.2.3 + dev: false + + /ansi-colors@4.1.3: + resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==} + engines: {node: '>=6'} + dev: false + + /ansi-escapes@4.3.2: + resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==} + engines: {node: '>=8'} + dependencies: + type-fest: 0.21.3 + dev: false + + /ansi-regex@5.0.1: + resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==} + engines: {node: '>=8'} + + /ansi-styles@4.3.0: + resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==} + engines: {node: '>=8'} + dependencies: + color-convert: 2.0.1 + + /anymatch@3.1.3: + resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==} + engines: {node: '>= 8'} + dependencies: + normalize-path: 3.0.0 + picomatch: 2.3.1 + dev: false + + /argparse@2.0.1: + resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==} + + /array-union@2.1.0: + resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==} + engines: {node: '>=8'} + dev: true + + /asynckit@0.4.0: + resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==} + dev: false + + /axios-retry@3.9.1: + resolution: {integrity: sha512-8PJDLJv7qTTMMwdnbMvrLYuvB47M81wRtxQmEdV5w4rgbTXTt+vtPkXwajOfOdSyv/wZICJOC+/UhXH4aQ/R+w==} + dependencies: + '@babel/runtime': 7.28.4 + is-retry-allowed: 2.2.0 + dev: false + + /axios@1.13.2: + resolution: {integrity: sha512-VPk9ebNqPcy5lRGuSlKx752IlDatOjT9paPlm8A7yOuW2Fbvp4X3JznJtT4f0GzGLLiWE9W8onz51SqLYwzGaA==} + dependencies: + follow-redirects: 1.15.11(debug@4.4.3) + form-data: 4.0.4 + proxy-from-env: 1.1.0 + transitivePeerDependencies: + - debug + dev: false + + /balanced-match@1.0.2: + resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==} + + /base64-sol@1.0.1: + resolution: {integrity: sha512-ld3cCNMeXt4uJXmLZBHFGMvVpK9KsLVEhPpFRXnvSVAqABKbuNZg/+dsq3NuM+wxFLb/UrVkz7m1ciWmkMfTbg==} + dev: false + + /bech32@1.1.4: + resolution: {integrity: sha512-s0IrSOzLlbvX7yp4WBfPITzpAU8sqQcpsmwXDiKwrG4r491vwCO/XpejasRNl0piBMe/DvP4Tz0mIS/X1DPJBQ==} + dev: false + + /big.js@5.2.2: + resolution: {integrity: sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==} + dev: false + + /bignumber.js@9.3.1: + resolution: {integrity: sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==} + dev: false + + /binary-extensions@2.3.0: + resolution: {integrity: sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==} + engines: {node: '>=8'} + dev: false + + /bn.js@4.12.2: + resolution: {integrity: sha512-n4DSx829VRTRByMRGdjQ9iqsN0Bh4OolPsFnaZBLcbi8iXcB+kJ9s7EnRt4wILZNV3kPLHkRVfOc/HvhC3ovDw==} + dev: false + + /bn.js@5.2.2: + resolution: {integrity: sha512-v2YAxEmKaBLahNwE1mjp4WON6huMNeuDvagFZW+ASCuA/ku0bXR9hSMw0XpiqMoA3+rmnyck/tPRSFQkoC9Cuw==} + dev: false + + /boxen@5.1.2: + resolution: {integrity: sha512-9gYgQKXx+1nP8mP7CzFyaUARhg7D3n1dF/FnErWmu9l6JvGpNUN278h0aSb+QjoiKSWG+iZ3uHrcqk0qrY9RQQ==} + engines: {node: '>=10'} + dependencies: + ansi-align: 3.0.1 + camelcase: 6.3.0 + chalk: 4.1.2 + cli-boxes: 2.2.1 + string-width: 4.2.3 + type-fest: 0.20.2 + widest-line: 3.1.0 + wrap-ansi: 7.0.0 + dev: false + + /brace-expansion@1.1.12: + resolution: {integrity: sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==} + dependencies: + balanced-match: 1.0.2 + concat-map: 0.0.1 + dev: true + + /brace-expansion@2.0.2: + resolution: {integrity: sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==} + dependencies: + balanced-match: 1.0.2 + + /braces@3.0.3: + resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==} + engines: {node: '>=8'} + dependencies: + fill-range: 7.1.1 + + /brorand@1.1.0: + resolution: {integrity: sha512-cKV8tMCEpQs4hK/ik71d6LrPOnpkpGBR0wzxqr68g2m/LB2GxVYQroAjMJZRVM1Y4BCjCKc3vAamxSzOY2RP+w==} + dev: false + + /browser-stdout@1.3.1: + resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==} + dev: false + + /buffer-from@1.1.2: + resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==} + dev: false + + /bytes@3.1.2: + resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==} + engines: {node: '>= 0.8'} + dev: false + + /call-bind-apply-helpers@1.0.2: + resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==} + engines: {node: '>= 0.4'} + dependencies: + es-errors: 1.3.0 + function-bind: 1.1.2 + dev: false + + /callsites@3.1.0: + resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==} + engines: {node: '>=6'} + dev: true + + /camelcase@6.3.0: + resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==} + engines: {node: '>=10'} + dev: false + + /chalk@4.1.2: + resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==} + engines: {node: '>=10'} + dependencies: + ansi-styles: 4.3.0 + supports-color: 7.2.0 + + /chalk@5.6.2: + resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==} + engines: {node: ^12.17.0 || ^14.13 || >=16.0.0} + dev: false + + /chokidar@3.6.0: + resolution: {integrity: sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==} + engines: {node: '>= 8.10.0'} + dependencies: + anymatch: 3.1.3 + braces: 3.0.3 + glob-parent: 5.1.2 + is-binary-path: 2.1.0 + is-glob: 4.0.3 + normalize-path: 3.0.0 + readdirp: 3.6.0 + optionalDependencies: + fsevents: 2.3.3 + dev: false + + /chokidar@4.0.3: + resolution: {integrity: sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==} + engines: {node: '>= 14.16.0'} + dependencies: + readdirp: 4.1.2 + dev: false + + /ci-info@2.0.0: + resolution: {integrity: sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==} + dev: false + + /clean-stack@2.2.0: + resolution: {integrity: sha512-4diC9HaTE+KRAMWhDhrGOECgWZxoevMc5TlkObMqNSsVU62PYzXZ/SMTjzyGAFF1YusgxGcSWTEXBhp0CPwQ1A==} + engines: {node: '>=6'} + dev: false + + /cli-boxes@2.2.1: + resolution: {integrity: sha512-y4coMcylgSCdVinjiDBuR8PCC2bLjyGTwEmPb9NHR/QaNU6EUOXcTY/s6VjGMD6ENSEaeQYHCY0GNGS5jfMwPw==} + engines: {node: '>=6'} + dev: false + + /cliui@7.0.4: + resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==} + dependencies: + string-width: 4.2.3 + strip-ansi: 6.0.1 + wrap-ansi: 7.0.0 + dev: false + + /color-convert@2.0.1: + resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==} + engines: {node: '>=7.0.0'} + dependencies: + color-name: 1.1.4 + + /color-name@1.1.4: + resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==} + + /combined-stream@1.0.8: + resolution: {integrity: sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==} + engines: {node: '>= 0.8'} + dependencies: + delayed-stream: 1.0.0 + dev: false + + /command-exists@1.2.9: + resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==} + dev: false + + /commander@12.1.0: + resolution: {integrity: sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==} + engines: {node: '>=18'} + dev: false + + /commander@8.3.0: + resolution: {integrity: sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==} + engines: {node: '>= 12'} + dev: false + + /concat-map@0.0.1: + resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==} + dev: true + + /cookie@0.4.2: + resolution: {integrity: sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==} + engines: {node: '>= 0.6'} + dev: false + + /cross-spawn@7.0.6: + resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==} + engines: {node: '>= 8'} + dependencies: + path-key: 3.1.1 + shebang-command: 2.0.0 + which: 2.0.2 + dev: true + + /debug@4.4.3(supports-color@8.1.1): + resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==} + engines: {node: '>=6.0'} + peerDependencies: + supports-color: '*' + peerDependenciesMeta: + supports-color: + optional: true + dependencies: + ms: 2.1.3 + supports-color: 8.1.1 + + /decamelize@4.0.0: + resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==} + engines: {node: '>=10'} + dev: false + + /decimal.js-light@2.5.1: + resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==} + dev: false + + /deep-is@0.1.4: + resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==} + dev: true + + /delayed-stream@1.0.0: + resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==} + engines: {node: '>=0.4.0'} + dev: false + + /depd@2.0.0: + resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==} + engines: {node: '>= 0.8'} + dev: false + + /diff@5.2.0: + resolution: {integrity: sha512-uIFDxqpRZGZ6ThOk84hEfqWoHx2devRFvpTZcTHur85vImfaxUbTW9Ryh4CpCuDnToOP1CEtXKIgytHBPVff5A==} + engines: {node: '>=0.3.1'} + dev: false + + /dir-glob@3.0.1: + resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==} + engines: {node: '>=8'} + dependencies: + path-type: 4.0.0 + dev: true + + /doctrine@3.0.0: + resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==} + engines: {node: '>=6.0.0'} + dependencies: + esutils: 2.0.3 + dev: true + + /dotenv@14.3.2: + resolution: {integrity: sha512-vwEppIphpFdvaMCaHfCEv9IgwcxMljMw2TnAQBB4VWPvzXQLTb82jwmdOKzlEVUL3gNFT4l4TPKO+Bn+sqcrVQ==} + engines: {node: '>=12'} + dev: false + + /dotenv@16.6.1: + resolution: {integrity: sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==} + engines: {node: '>=12'} + dev: false + + /dunder-proto@1.0.1: + resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==} + engines: {node: '>= 0.4'} + dependencies: + call-bind-apply-helpers: 1.0.2 + es-errors: 1.3.0 + gopd: 1.2.0 + dev: false + + /elliptic@6.6.1: + resolution: {integrity: sha512-RaddvvMatK2LJHqFJ+YA4WysVN5Ita9E35botqIYspQ4TkRAlCicdzKOjlyv/1Za5RyTNn7di//eEV0uTAfe3g==} + dependencies: + bn.js: 4.12.2 + brorand: 1.1.0 + hash.js: 1.1.7 + hmac-drbg: 1.0.1 + inherits: 2.0.4 + minimalistic-assert: 1.0.1 + minimalistic-crypto-utils: 1.0.1 + dev: false + + /emoji-regex@8.0.0: + resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==} + dev: false + + /enquirer@2.4.1: + resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==} + engines: {node: '>=8.6'} + dependencies: + ansi-colors: 4.1.3 + strip-ansi: 6.0.1 + dev: false + + /env-paths@2.2.1: + resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==} + engines: {node: '>=6'} + dev: false + + /es-define-property@1.0.1: + resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==} + engines: {node: '>= 0.4'} + dev: false + + /es-errors@1.3.0: + resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==} + engines: {node: '>= 0.4'} + dev: false + + /es-object-atoms@1.1.1: + resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==} + engines: {node: '>= 0.4'} + dependencies: + es-errors: 1.3.0 + dev: false + + /es-set-tostringtag@2.1.0: + resolution: {integrity: sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==} + engines: {node: '>= 0.4'} + dependencies: + es-errors: 1.3.0 + get-intrinsic: 1.3.0 + has-tostringtag: 1.0.2 + hasown: 2.0.2 + dev: false + + /esbuild@0.25.12: + resolution: {integrity: sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==} + engines: {node: '>=18'} + hasBin: true + requiresBuild: true + optionalDependencies: + '@esbuild/aix-ppc64': 0.25.12 + '@esbuild/android-arm': 0.25.12 + '@esbuild/android-arm64': 0.25.12 + '@esbuild/android-x64': 0.25.12 + '@esbuild/darwin-arm64': 0.25.12 + '@esbuild/darwin-x64': 0.25.12 + '@esbuild/freebsd-arm64': 0.25.12 + '@esbuild/freebsd-x64': 0.25.12 + '@esbuild/linux-arm': 0.25.12 + '@esbuild/linux-arm64': 0.25.12 + '@esbuild/linux-ia32': 0.25.12 + '@esbuild/linux-loong64': 0.25.12 + '@esbuild/linux-mips64el': 0.25.12 + '@esbuild/linux-ppc64': 0.25.12 + '@esbuild/linux-riscv64': 0.25.12 + '@esbuild/linux-s390x': 0.25.12 + '@esbuild/linux-x64': 0.25.12 + '@esbuild/netbsd-arm64': 0.25.12 + '@esbuild/netbsd-x64': 0.25.12 + '@esbuild/openbsd-arm64': 0.25.12 + '@esbuild/openbsd-x64': 0.25.12 + '@esbuild/openharmony-arm64': 0.25.12 + '@esbuild/sunos-x64': 0.25.12 + '@esbuild/win32-arm64': 0.25.12 + '@esbuild/win32-ia32': 0.25.12 + '@esbuild/win32-x64': 0.25.12 + dev: true + + /escalade@3.2.0: + resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==} + engines: {node: '>=6'} + dev: false + + /escape-string-regexp@4.0.0: + resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==} + engines: {node: '>=10'} + + /eslint-scope@7.2.2: + resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dependencies: + esrecurse: 4.3.0 + estraverse: 5.3.0 + dev: true + + /eslint-visitor-keys@3.4.3: + resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dev: true + + /eslint@8.57.1: + resolution: {integrity: sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + deprecated: This version is no longer supported. Please see https://eslint.org/version-support for other options. + hasBin: true + dependencies: + '@eslint-community/eslint-utils': 4.9.0(eslint@8.57.1) + '@eslint-community/regexpp': 4.12.2 + '@eslint/eslintrc': 2.1.4 + '@eslint/js': 8.57.1 + '@humanwhocodes/config-array': 0.13.0 + '@humanwhocodes/module-importer': 1.0.1 + '@nodelib/fs.walk': 1.2.8 + '@ungap/structured-clone': 1.3.0 + ajv: 6.12.6 + chalk: 4.1.2 + cross-spawn: 7.0.6 + debug: 4.4.3(supports-color@8.1.1) + doctrine: 3.0.0 + escape-string-regexp: 4.0.0 + eslint-scope: 7.2.2 + eslint-visitor-keys: 3.4.3 + espree: 9.6.1 + esquery: 1.6.0 + esutils: 2.0.3 + fast-deep-equal: 3.1.3 + file-entry-cache: 6.0.1 + find-up: 5.0.0 + glob-parent: 6.0.2 + globals: 13.24.0 + graphemer: 1.4.0 + ignore: 5.3.2 + imurmurhash: 0.1.4 + is-glob: 4.0.3 + is-path-inside: 3.0.3 + js-yaml: 4.1.0 + json-stable-stringify-without-jsonify: 1.0.1 + levn: 0.4.1 + lodash.merge: 4.6.2 + minimatch: 3.1.2 + natural-compare: 1.4.0 + optionator: 0.9.4 + strip-ansi: 6.0.1 + text-table: 0.2.0 + transitivePeerDependencies: + - supports-color + dev: true + + /espree@9.6.1: + resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==} + engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0} + dependencies: + acorn: 8.15.0 + acorn-jsx: 5.3.2(acorn@8.15.0) + eslint-visitor-keys: 3.4.3 + dev: true + + /esquery@1.6.0: + resolution: {integrity: sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==} + engines: {node: '>=0.10'} + dependencies: + estraverse: 5.3.0 + dev: true + + /esrecurse@4.3.0: + resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==} + engines: {node: '>=4.0'} + dependencies: + estraverse: 5.3.0 + dev: true + + /estraverse@5.3.0: + resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==} + engines: {node: '>=4.0'} + dev: true + + /esutils@2.0.3: + resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==} + engines: {node: '>=0.10.0'} + dev: true + + /ethereum-cryptography@1.2.0: + resolution: {integrity: sha512-6yFQC9b5ug6/17CQpCyE3k9eKBMdhyVjzUy1WkiuY/E4vj/SXDBbCw8QEIaXqf0Mf2SnY6RmpDcwlUmBSS0EJw==} + dependencies: + '@noble/hashes': 1.2.0 + '@noble/secp256k1': 1.7.1 + '@scure/bip32': 1.1.5 + '@scure/bip39': 1.1.1 + dev: false + + /ethereum-cryptography@2.2.1: + resolution: {integrity: sha512-r/W8lkHSiTLxUxW8Rf3u4HGB0xQweG2RyETjywylKZSzLWoWAijRz8WCuOtJ6wah+avllXBqZuk29HCCvhEIRg==} + dependencies: + '@noble/curves': 1.4.2 + '@noble/hashes': 1.4.0 + '@scure/bip32': 1.4.0 + '@scure/bip39': 1.3.0 + dev: false + + /ethers@5.8.0: + resolution: {integrity: sha512-DUq+7fHrCg1aPDFCHx6UIPb3nmt2XMpM7Y/g2gLhsl3lIBqeAfOJIl1qEvRf2uq3BiKxmh6Fh5pfp2ieyek7Kg==} + dependencies: + '@ethersproject/abi': 5.8.0 + '@ethersproject/abstract-provider': 5.8.0 + '@ethersproject/abstract-signer': 5.8.0 + '@ethersproject/address': 5.8.0 + '@ethersproject/base64': 5.8.0 + '@ethersproject/basex': 5.8.0 + '@ethersproject/bignumber': 5.8.0 + '@ethersproject/bytes': 5.8.0 + '@ethersproject/constants': 5.8.0 + '@ethersproject/contracts': 5.8.0 + '@ethersproject/hash': 5.8.0 + '@ethersproject/hdnode': 5.8.0 + '@ethersproject/json-wallets': 5.8.0 + '@ethersproject/keccak256': 5.8.0 + '@ethersproject/logger': 5.8.0 + '@ethersproject/networks': 5.8.0 + '@ethersproject/pbkdf2': 5.8.0 + '@ethersproject/properties': 5.8.0 + '@ethersproject/providers': 5.8.0 + '@ethersproject/random': 5.8.0 + '@ethersproject/rlp': 5.8.0 + '@ethersproject/sha2': 5.8.0 + '@ethersproject/signing-key': 5.8.0 + '@ethersproject/solidity': 5.8.0 + '@ethersproject/strings': 5.8.0 + '@ethersproject/transactions': 5.8.0 + '@ethersproject/units': 5.8.0 + '@ethersproject/wallet': 5.8.0 + '@ethersproject/web': 5.8.0 + '@ethersproject/wordlists': 5.8.0 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + dev: false + + /eventemitter3@5.0.1: + resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==} + dev: false + + /fast-deep-equal@3.1.3: + resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==} + dev: true + + /fast-glob@3.3.3: + resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==} + engines: {node: '>=8.6.0'} + dependencies: + '@nodelib/fs.stat': 2.0.5 + '@nodelib/fs.walk': 1.2.8 + glob-parent: 5.1.2 + merge2: 1.4.1 + micromatch: 4.0.8 + dev: true + + /fast-json-stable-stringify@2.1.0: + resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==} + dev: true + + /fast-levenshtein@2.0.6: + resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==} + dev: true + + /fastq@1.19.1: + resolution: {integrity: sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==} + dependencies: + reusify: 1.1.0 + dev: true + + /fdir@6.5.0(picomatch@4.0.3): + resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==} + engines: {node: '>=12.0.0'} + peerDependencies: + picomatch: ^3 || ^4 + peerDependenciesMeta: + picomatch: + optional: true + dependencies: + picomatch: 4.0.3 + dev: false + + /file-entry-cache@6.0.1: + resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==} + engines: {node: ^10.12.0 || >=12.0.0} + dependencies: + flat-cache: 3.2.0 + dev: true + + /fill-range@7.1.1: + resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==} + engines: {node: '>=8'} + dependencies: + to-regex-range: 5.0.1 + + /find-up@5.0.0: + resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==} + engines: {node: '>=10'} + dependencies: + locate-path: 6.0.0 + path-exists: 4.0.0 + + /flat-cache@3.2.0: + resolution: {integrity: sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==} + engines: {node: ^10.12.0 || >=12.0.0} + dependencies: + flatted: 3.3.3 + keyv: 4.5.4 + rimraf: 3.0.2 + dev: true + + /flat@5.0.2: + resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==} + hasBin: true + dev: false + + /flatted@3.3.3: + resolution: {integrity: sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==} + dev: true + + /follow-redirects@1.15.11(debug@4.4.3): + resolution: {integrity: sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==} + engines: {node: '>=4.0'} + peerDependencies: + debug: '*' + peerDependenciesMeta: + debug: + optional: true + dependencies: + debug: 4.4.3(supports-color@8.1.1) + dev: false + + /form-data@4.0.4: + resolution: {integrity: sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==} + engines: {node: '>= 6'} + dependencies: + asynckit: 0.4.0 + combined-stream: 1.0.8 + es-set-tostringtag: 2.1.0 + hasown: 2.0.2 + mime-types: 2.1.35 + dev: false + + /fp-ts@1.19.3: + resolution: {integrity: sha512-H5KQDspykdHuztLTg+ajGN0Z2qUjcEf3Ybxc6hLt0k7/zPkn29XnKnxlBPyW2XIddWrGaJBzBl4VLYOtk39yZg==} + dev: false + + /fs-extra@7.0.1: + resolution: {integrity: sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==} + engines: {node: '>=6 <7 || >=8'} + dependencies: + graceful-fs: 4.2.11 + jsonfile: 4.0.0 + universalify: 0.1.2 + dev: false + + /fs.realpath@1.0.0: + resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==} + + /fsevents@2.3.3: + resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==} + engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0} + os: [darwin] + requiresBuild: true + optional: true + + /function-bind@1.1.2: + resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==} + dev: false + + /get-caller-file@2.0.5: + resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==} + engines: {node: 6.* || 8.* || >= 10.*} + dev: false + + /get-intrinsic@1.3.0: + resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==} + engines: {node: '>= 0.4'} + dependencies: + call-bind-apply-helpers: 1.0.2 + es-define-property: 1.0.1 + es-errors: 1.3.0 + es-object-atoms: 1.1.1 + function-bind: 1.1.2 + get-proto: 1.0.1 + gopd: 1.2.0 + has-symbols: 1.1.0 + hasown: 2.0.2 + math-intrinsics: 1.1.0 + dev: false + + /get-proto@1.0.1: + resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==} + engines: {node: '>= 0.4'} + dependencies: + dunder-proto: 1.0.1 + es-object-atoms: 1.1.1 + dev: false + + /get-tsconfig@4.13.0: + resolution: {integrity: sha512-1VKTZJCwBrvbd+Wn3AOgQP/2Av+TfTCOlE4AcRJE72W1ksZXbAx8PPBR9RzgTeSPzlPMHrbANMH3LbltH73wxQ==} + dependencies: + resolve-pkg-maps: 1.0.0 + dev: true + + /glob-parent@5.1.2: + resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==} + engines: {node: '>= 6'} + dependencies: + is-glob: 4.0.3 + + /glob-parent@6.0.2: + resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==} + engines: {node: '>=10.13.0'} + dependencies: + is-glob: 4.0.3 + dev: true + + /glob@7.2.3: + resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==} + deprecated: Glob versions prior to v9 are no longer supported + dependencies: + fs.realpath: 1.0.0 + inflight: 1.0.6 + inherits: 2.0.4 + minimatch: 3.1.2 + once: 1.4.0 + path-is-absolute: 1.0.1 + dev: true + + /glob@8.1.0: + resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==} + engines: {node: '>=12'} + deprecated: Glob versions prior to v9 are no longer supported + dependencies: + fs.realpath: 1.0.0 + inflight: 1.0.6 + inherits: 2.0.4 + minimatch: 5.1.6 + once: 1.4.0 + dev: false + + /globals@13.24.0: + resolution: {integrity: sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==} + engines: {node: '>=8'} + dependencies: + type-fest: 0.20.2 + dev: true + + /globby@11.1.0: + resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==} + engines: {node: '>=10'} + dependencies: + array-union: 2.1.0 + dir-glob: 3.0.1 + fast-glob: 3.3.3 + ignore: 5.3.2 + merge2: 1.4.1 + slash: 3.0.0 + dev: true + + /gopd@1.2.0: + resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==} + engines: {node: '>= 0.4'} + dev: false + + /graceful-fs@4.2.11: + resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==} + dev: false + + /graphemer@1.4.0: + resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==} + dev: true + + /hardhat-watcher@2.5.0(hardhat@2.27.0): + resolution: {integrity: sha512-Su2qcSMIo2YO2PrmJ0/tdkf+6pSt8zf9+4URR5edMVti6+ShI8T3xhPrwugdyTOFuyj8lKHrcTZNKUFYowYiyA==} + peerDependencies: + hardhat: ^2.0.0 + dependencies: + chokidar: 3.6.0 + hardhat: 2.27.0(typescript@5.9.3) + dev: false + + /hardhat@2.27.0(typescript@5.9.3): + resolution: {integrity: sha512-du7ecjx1/ueAUjvtZhVkJvWytPCjlagG3ZktYTphfzAbc1Flc6sRolw5mhKL/Loub1EIFRaflutM4bdB/YsUUw==} + hasBin: true + peerDependencies: + ts-node: '*' + typescript: '*' + peerDependenciesMeta: + ts-node: + optional: true + typescript: + optional: true + dependencies: + '@ethereumjs/util': 9.1.0 + '@ethersproject/abi': 5.8.0 + '@nomicfoundation/edr': 0.12.0-next.14 + '@nomicfoundation/solidity-analyzer': 0.1.2 + '@sentry/node': 5.30.0 + adm-zip: 0.4.16 + aggregate-error: 3.1.0 + ansi-escapes: 4.3.2 + boxen: 5.1.2 + chokidar: 4.0.3 + ci-info: 2.0.0 + debug: 4.4.3(supports-color@8.1.1) + enquirer: 2.4.1 + env-paths: 2.2.1 + ethereum-cryptography: 1.2.0 + find-up: 5.0.0 + fp-ts: 1.19.3 + fs-extra: 7.0.1 + immutable: 4.3.7 + io-ts: 1.10.4 + json-stream-stringify: 3.1.6 + keccak: 3.0.4 + lodash: 4.17.21 + micro-eth-signer: 0.14.0 + mnemonist: 0.38.5 + mocha: 10.8.2 + p-map: 4.0.0 + picocolors: 1.1.1 + raw-body: 2.5.2 + resolve: 1.17.0 + semver: 6.3.1 + solc: 0.8.26(debug@4.4.3) + source-map-support: 0.5.21 + stacktrace-parser: 0.1.11 + tinyglobby: 0.2.15 + tsort: 0.0.1 + typescript: 5.9.3 + undici: 5.29.0 + uuid: 8.3.2 + ws: 7.5.10 + transitivePeerDependencies: + - bufferutil + - supports-color + - utf-8-validate + dev: false + + /has-flag@4.0.0: + resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==} + engines: {node: '>=8'} + + /has-symbols@1.1.0: + resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==} + engines: {node: '>= 0.4'} + dev: false + + /has-tostringtag@1.0.2: + resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==} + engines: {node: '>= 0.4'} + dependencies: + has-symbols: 1.1.0 + dev: false + + /hash.js@1.1.7: + resolution: {integrity: sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==} + dependencies: + inherits: 2.0.4 + minimalistic-assert: 1.0.1 + dev: false + + /hasown@2.0.2: + resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==} + engines: {node: '>= 0.4'} + dependencies: + function-bind: 1.1.2 + dev: false + + /he@1.2.0: + resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==} + hasBin: true + dev: false + + /hmac-drbg@1.0.1: + resolution: {integrity: sha512-Tti3gMqLdZfhOQY1Mzf/AanLiqh1WTiJgEj26ZuYQ9fbkLomzGchCws4FyrSd4VkpBfiNhaE1On+lOz894jvXg==} + dependencies: + hash.js: 1.1.7 + minimalistic-assert: 1.0.1 + minimalistic-crypto-utils: 1.0.1 + dev: false + + /http-errors@2.0.0: + resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==} + engines: {node: '>= 0.8'} + dependencies: + depd: 2.0.0 + inherits: 2.0.4 + setprototypeof: 1.2.0 + statuses: 2.0.1 + toidentifier: 1.0.1 + dev: false + + /https-proxy-agent@5.0.1: + resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==} + engines: {node: '>= 6'} + dependencies: + agent-base: 6.0.2 + debug: 4.4.3(supports-color@8.1.1) + transitivePeerDependencies: + - supports-color + dev: false + + /iconv-lite@0.4.24: + resolution: {integrity: sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==} + engines: {node: '>=0.10.0'} + dependencies: + safer-buffer: 2.1.2 + dev: false + + /ignore@5.3.2: + resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==} + engines: {node: '>= 4'} + dev: true + + /immutable@4.3.7: + resolution: {integrity: sha512-1hqclzwYwjRDFLjcFxOM5AYkkG0rpFPpr1RLPMEuGczoS7YA8gLhy8SWXYRAA/XwfEHpfo3cw5JGioS32fnMRw==} + dev: false + + /import-fresh@3.3.1: + resolution: {integrity: sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==} + engines: {node: '>=6'} + dependencies: + parent-module: 1.0.1 + resolve-from: 4.0.0 + dev: true + + /imurmurhash@0.1.4: + resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==} + engines: {node: '>=0.8.19'} + dev: true + + /indent-string@4.0.0: + resolution: {integrity: sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==} + engines: {node: '>=8'} + dev: false + + /inflight@1.0.6: + resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==} + deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful. + dependencies: + once: 1.4.0 + wrappy: 1.0.2 + + /inherits@2.0.4: + resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==} + + /io-ts@1.10.4: + resolution: {integrity: sha512-b23PteSnYXSONJ6JQXRAlvJhuw8KOtkqa87W4wDtvMrud/DTJd5X+NpOOI+O/zZwVq6v0VLAaJ+1EDViKEuN9g==} + dependencies: + fp-ts: 1.19.3 + dev: false + + /is-binary-path@2.1.0: + resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==} + engines: {node: '>=8'} + dependencies: + binary-extensions: 2.3.0 + dev: false + + /is-extglob@2.1.1: + resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==} + engines: {node: '>=0.10.0'} + + /is-fullwidth-code-point@3.0.0: + resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==} + engines: {node: '>=8'} + dev: false + + /is-glob@4.0.3: + resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==} + engines: {node: '>=0.10.0'} + dependencies: + is-extglob: 2.1.1 + + /is-number@7.0.0: + resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==} + engines: {node: '>=0.12.0'} + + /is-path-inside@3.0.3: + resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==} + engines: {node: '>=8'} + dev: true + + /is-plain-obj@2.1.0: + resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==} + engines: {node: '>=8'} + dev: false + + /is-retry-allowed@2.2.0: + resolution: {integrity: sha512-XVm7LOeLpTW4jV19QSH38vkswxoLud8sQ57YwJVTPWdiaI9I8keEhGFpBlslyVsgdQy4Opg8QOLb8YRgsyZiQg==} + engines: {node: '>=10'} + dev: false + + /is-unicode-supported@0.1.0: + resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==} + engines: {node: '>=10'} + dev: false + + /isexe@2.0.0: + resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==} + dev: true + + /isomorphic-unfetch@3.1.0: + resolution: {integrity: sha512-geDJjpoZ8N0kWexiwkX8F9NkTsXhetLPVbZFQ+JTW239QNOwvB0gniuR1Wc6f0AMTn7/mFGyXvHTifrCp/GH8Q==} + dependencies: + node-fetch: 2.7.0 + unfetch: 4.2.0 + transitivePeerDependencies: + - encoding + dev: false + + /isows@1.0.7(ws@8.18.3): + resolution: {integrity: sha512-I1fSfDCZL5P0v33sVqeTDSpcstAg/N+wF5HS033mogOVIp4B+oHC7oOCsA3axAbBSGTJ8QubbNmnIRN/h8U7hg==} + peerDependencies: + ws: '*' + dependencies: + ws: 8.18.3 + dev: false + + /js-sha3@0.8.0: + resolution: {integrity: sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==} + dev: false + + /js-yaml@4.1.0: + resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==} + hasBin: true + dependencies: + argparse: 2.0.1 + + /jsbi@3.2.5: + resolution: {integrity: sha512-aBE4n43IPvjaddScbvWRA2YlTzKEynHzu7MqOyTipdHucf/VxS63ViCjxYRg86M8Rxwbt/GfzHl1kKERkt45fQ==} + dev: false + + /json-buffer@3.0.1: + resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==} + dev: true + + /json-schema-traverse@0.4.1: + resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==} + dev: true + + /json-stable-stringify-without-jsonify@1.0.1: + resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==} + dev: true + + /json-stream-stringify@3.1.6: + resolution: {integrity: sha512-x7fpwxOkbhFCaJDJ8vb1fBY3DdSa4AlITaz+HHILQJzdPMnHEFjxPwVUi1ALIbcIxDE0PNe/0i7frnY8QnBQog==} + engines: {node: '>=7.10.1'} + dev: false + + /jsonfile@4.0.0: + resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==} + optionalDependencies: + graceful-fs: 4.2.11 + dev: false + + /keccak@3.0.4: + resolution: {integrity: sha512-3vKuW0jV8J3XNTzvfyicFR5qvxrSAGl7KIhvgOu5cmWwM7tZRj3fMbj/pfIf4be7aznbc+prBWGjywox/g2Y6Q==} + engines: {node: '>=10.0.0'} + requiresBuild: true + dependencies: + node-addon-api: 2.0.2 + node-gyp-build: 4.8.4 + readable-stream: 3.6.2 + dev: false + + /keyv@4.5.4: + resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==} + dependencies: + json-buffer: 3.0.1 + dev: true + + /levn@0.4.1: + resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==} + engines: {node: '>= 0.8.0'} + dependencies: + prelude-ls: 1.2.1 + type-check: 0.4.0 + dev: true + + /locate-path@6.0.0: + resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==} + engines: {node: '>=10'} + dependencies: + p-locate: 5.0.0 + + /lodash.merge@4.6.2: + resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==} + dev: true + + /lodash@4.17.21: + resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==} + dev: false + + /log-symbols@4.1.0: + resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==} + engines: {node: '>=10'} + dependencies: + chalk: 4.1.2 + is-unicode-supported: 0.1.0 + dev: false + + /lru_map@0.3.3: + resolution: {integrity: sha512-Pn9cox5CsMYngeDbmChANltQl+5pi6XmTrraMSzhPmMBbmgcxmqWry0U3PGapCU1yB4/LqCcom7qhHZiF/jGfQ==} + dev: false + + /math-intrinsics@1.1.0: + resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==} + engines: {node: '>= 0.4'} + dev: false + + /memorystream@0.3.1: + resolution: {integrity: sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==} + engines: {node: '>= 0.10.0'} + dev: false + + /merge2@1.4.1: + resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==} + engines: {node: '>= 8'} + dev: true + + /micro-eth-signer@0.14.0: + resolution: {integrity: sha512-5PLLzHiVYPWClEvZIXXFu5yutzpadb73rnQCpUqIHu3No3coFuWQNfE5tkBQJ7djuLYl6aRLaS0MgWJYGoqiBw==} + dependencies: + '@noble/curves': 1.8.2 + '@noble/hashes': 1.7.2 + micro-packed: 0.7.3 + dev: false + + /micro-packed@0.7.3: + resolution: {integrity: sha512-2Milxs+WNC00TRlem41oRswvw31146GiSaoCT7s3Xi2gMUglW5QBeqlQaZeHr5tJx9nm3i57LNXPqxOOaWtTYg==} + dependencies: + '@scure/base': 1.2.6 + dev: false + + /micromatch@4.0.8: + resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==} + engines: {node: '>=8.6'} + dependencies: + braces: 3.0.3 + picomatch: 2.3.1 + dev: true + + /mime-db@1.52.0: + resolution: {integrity: sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==} + engines: {node: '>= 0.6'} + dev: false + + /mime-types@2.1.35: + resolution: {integrity: sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==} + engines: {node: '>= 0.6'} + dependencies: + mime-db: 1.52.0 + dev: false + + /minimalistic-assert@1.0.1: + resolution: {integrity: sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==} + dev: false + + /minimalistic-crypto-utils@1.0.1: + resolution: {integrity: sha512-JIYlbt6g8i5jKfJ3xz7rF0LXmv2TkDxBLUkiBeZ7bAx4GnnNMr8xFpGnOxn6GhTEHx3SjRrZEoU+j04prX1ktg==} + dev: false + + /minimatch@3.1.2: + resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==} + dependencies: + brace-expansion: 1.1.12 + dev: true + + /minimatch@5.1.6: + resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==} + engines: {node: '>=10'} + dependencies: + brace-expansion: 2.0.2 + dev: false + + /minimatch@9.0.5: + resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==} + engines: {node: '>=16 || 14 >=14.17'} + dependencies: + brace-expansion: 2.0.2 + dev: true + + /mnemonist@0.38.5: + resolution: {integrity: sha512-bZTFT5rrPKtPJxj8KSV0WkPyNxl72vQepqqVUAW2ARUpUSF2qXMB6jZj7hW5/k7C1rtpzqbD/IIbJwLXUjCHeg==} + dependencies: + obliterator: 2.0.5 + dev: false + + /mocha@10.8.2: + resolution: {integrity: sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==} + engines: {node: '>= 14.0.0'} + hasBin: true + dependencies: + ansi-colors: 4.1.3 + browser-stdout: 1.3.1 + chokidar: 3.6.0 + debug: 4.4.3(supports-color@8.1.1) + diff: 5.2.0 + escape-string-regexp: 4.0.0 + find-up: 5.0.0 + glob: 8.1.0 + he: 1.2.0 + js-yaml: 4.1.0 + log-symbols: 4.1.0 + minimatch: 5.1.6 + ms: 2.1.3 + serialize-javascript: 6.0.2 + strip-json-comments: 3.1.1 + supports-color: 8.1.1 + workerpool: 6.5.1 + yargs: 16.2.0 + yargs-parser: 20.2.9 + yargs-unparser: 2.0.0 + dev: false + + /ms@2.1.3: + resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} + + /natural-compare@1.4.0: + resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==} + dev: true + + /node-addon-api@2.0.2: + resolution: {integrity: sha512-Ntyt4AIXyaLIuMHF6IOoTakB3K+RWxwtsHNRxllEoA6vPwP9o4866g6YWDLUdnucilZhmkxiHwHr11gAENw+QA==} + dev: false + + /node-fetch@2.7.0: + resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==} + engines: {node: 4.x || >=6.0.0} + peerDependencies: + encoding: ^0.1.0 + peerDependenciesMeta: + encoding: + optional: true + dependencies: + whatwg-url: 5.0.0 + dev: false + + /node-gyp-build@4.8.4: + resolution: {integrity: sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==} + hasBin: true + dev: false + + /normalize-path@3.0.0: + resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==} + engines: {node: '>=0.10.0'} + dev: false + + /obliterator@2.0.5: + resolution: {integrity: sha512-42CPE9AhahZRsMNslczq0ctAEtqk8Eka26QofnqC346BZdHDySk3LWka23LI7ULIw11NmltpiLagIq8gBozxTw==} + dev: false + + /once@1.4.0: + resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==} + dependencies: + wrappy: 1.0.2 + + /optionator@0.9.4: + resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==} + engines: {node: '>= 0.8.0'} + dependencies: + deep-is: 0.1.4 + fast-levenshtein: 2.0.6 + levn: 0.4.1 + prelude-ls: 1.2.1 + type-check: 0.4.0 + word-wrap: 1.2.5 + dev: true + + /os-tmpdir@1.0.2: + resolution: {integrity: sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==} + engines: {node: '>=0.10.0'} + dev: false + + /ox@0.9.6(typescript@5.9.3)(zod@3.25.76): + resolution: {integrity: sha512-8SuCbHPvv2eZLYXrNmC0EC12rdzXQLdhnOMlHDW2wiCPLxBrOOJwX5L5E61by+UjTPOryqQiRSnjIKCI+GykKg==} + peerDependencies: + typescript: '>=5.4.0' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + '@adraffy/ens-normalize': 1.11.1 + '@noble/ciphers': 1.3.0 + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.1.0(typescript@5.9.3)(zod@3.25.76) + eventemitter3: 5.0.1 + typescript: 5.9.3 + transitivePeerDependencies: + - zod + dev: false + + /p-limit@3.1.0: + resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==} + engines: {node: '>=10'} + dependencies: + yocto-queue: 0.1.0 + + /p-locate@5.0.0: + resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==} + engines: {node: '>=10'} + dependencies: + p-limit: 3.1.0 + + /p-map@4.0.0: + resolution: {integrity: sha512-/bjOqmgETBYB5BoEeGVea8dmvHb2m9GLy1E9W43yeyfP6QQCZGFNa+XRceJEuDB6zqr+gKpIAmlLebMpykw/MQ==} + engines: {node: '>=10'} + dependencies: + aggregate-error: 3.1.0 + dev: false + + /parent-module@1.0.1: + resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==} + engines: {node: '>=6'} + dependencies: + callsites: 3.1.0 + dev: true + + /path-exists@4.0.0: + resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==} + engines: {node: '>=8'} + + /path-is-absolute@1.0.1: + resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==} + engines: {node: '>=0.10.0'} + dev: true + + /path-key@3.1.1: + resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==} + engines: {node: '>=8'} + dev: true + + /path-parse@1.0.7: + resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==} + dev: false + + /path-type@4.0.0: + resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==} + engines: {node: '>=8'} + dev: true + + /picocolors@1.1.1: + resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==} + dev: false + + /picomatch@2.3.1: + resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==} + engines: {node: '>=8.6'} + + /picomatch@4.0.3: + resolution: {integrity: sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==} + engines: {node: '>=12'} + dev: false + + /prelude-ls@1.2.1: + resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==} + engines: {node: '>= 0.8.0'} + dev: true + + /prettier@3.6.2: + resolution: {integrity: sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==} + engines: {node: '>=14'} + hasBin: true + dev: true + + /proxy-from-env@1.1.0: + resolution: {integrity: sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==} + dev: false + + /punycode@2.3.1: + resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==} + engines: {node: '>=6'} + dev: true + + /queue-microtask@1.2.3: + resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==} + dev: true + + /randombytes@2.1.0: + resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==} + dependencies: + safe-buffer: 5.2.1 + dev: false + + /raw-body@2.5.2: + resolution: {integrity: sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==} + engines: {node: '>= 0.8'} + dependencies: + bytes: 3.1.2 + http-errors: 2.0.0 + iconv-lite: 0.4.24 + unpipe: 1.0.0 + dev: false + + /readable-stream@3.6.2: + resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==} + engines: {node: '>= 6'} + dependencies: + inherits: 2.0.4 + string_decoder: 1.3.0 + util-deprecate: 1.0.2 + dev: false + + /readdirp@3.6.0: + resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==} + engines: {node: '>=8.10.0'} + dependencies: + picomatch: 2.3.1 + dev: false + + /readdirp@4.1.2: + resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==} + engines: {node: '>= 14.18.0'} + dev: false + + /reflect-metadata@0.1.14: + resolution: {integrity: sha512-ZhYeb6nRaXCfhnndflDK8qI6ZQ/YcWZCISRAWICW9XYqMUwjZM9Z0DveWX/ABN01oxSHwVxKQmxeYZSsm0jh5A==} + dev: false + + /require-directory@2.1.1: + resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==} + engines: {node: '>=0.10.0'} + dev: false + + /resolve-from@4.0.0: + resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==} + engines: {node: '>=4'} + dev: true + + /resolve-pkg-maps@1.0.0: + resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==} + dev: true + + /resolve@1.17.0: + resolution: {integrity: sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==} + dependencies: + path-parse: 1.0.7 + dev: false + + /reusify@1.1.0: + resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==} + engines: {iojs: '>=1.0.0', node: '>=0.10.0'} + dev: true + + /rimraf@3.0.2: + resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==} + deprecated: Rimraf versions prior to v4 are no longer supported + hasBin: true + dependencies: + glob: 7.2.3 + dev: true + + /run-parallel@1.2.0: + resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==} + dependencies: + queue-microtask: 1.2.3 + dev: true + + /safe-buffer@5.2.1: + resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==} + dev: false + + /safer-buffer@2.1.2: + resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==} + dev: false + + /scrypt-js@3.0.1: + resolution: {integrity: sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==} + dev: false + + /semver@5.7.2: + resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==} + hasBin: true + dev: false + + /semver@6.3.1: + resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==} + hasBin: true + dev: false + + /semver@7.7.3: + resolution: {integrity: sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==} + engines: {node: '>=10'} + hasBin: true + dev: true + + /serialize-javascript@6.0.2: + resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==} + dependencies: + randombytes: 2.1.0 + dev: false + + /setprototypeof@1.2.0: + resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==} + dev: false + + /shebang-command@2.0.0: + resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==} + engines: {node: '>=8'} + dependencies: + shebang-regex: 3.0.0 + dev: true + + /shebang-regex@3.0.0: + resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==} + engines: {node: '>=8'} + dev: true + + /slash@3.0.0: + resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==} + engines: {node: '>=8'} + dev: true + + /solc@0.8.26(debug@4.4.3): + resolution: {integrity: sha512-yiPQNVf5rBFHwN6SIf3TUUvVAFKcQqmSUFeq+fb6pNRCo0ZCgpYOZDi3BVoezCPIAcKrVYd/qXlBLUP9wVrZ9g==} + engines: {node: '>=10.0.0'} + hasBin: true + dependencies: + command-exists: 1.2.9 + commander: 8.3.0 + follow-redirects: 1.15.11(debug@4.4.3) + js-sha3: 0.8.0 + memorystream: 0.3.1 + semver: 5.7.2 + tmp: 0.0.33 + transitivePeerDependencies: + - debug + dev: false + + /source-map-support@0.5.21: + resolution: {integrity: sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==} + dependencies: + buffer-from: 1.1.2 + source-map: 0.6.1 + dev: false + + /source-map@0.6.1: + resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==} + engines: {node: '>=0.10.0'} + dev: false + + /stacktrace-parser@0.1.11: + resolution: {integrity: sha512-WjlahMgHmCJpqzU8bIBy4qtsZdU9lRlcZE3Lvyej6t4tuOuv1vk57OW3MBrj6hXBFx/nNoC9MPMTcr5YA7NQbg==} + engines: {node: '>=6'} + dependencies: + type-fest: 0.7.1 + dev: false + + /statuses@2.0.1: + resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==} + engines: {node: '>= 0.8'} + dev: false + + /string-width@4.2.3: + resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==} + engines: {node: '>=8'} + dependencies: + emoji-regex: 8.0.0 + is-fullwidth-code-point: 3.0.0 + strip-ansi: 6.0.1 + dev: false + + /string_decoder@1.3.0: + resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==} + dependencies: + safe-buffer: 5.2.1 + dev: false + + /strip-ansi@6.0.1: + resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==} + engines: {node: '>=8'} + dependencies: + ansi-regex: 5.0.1 + + /strip-json-comments@3.1.1: + resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==} + engines: {node: '>=8'} + + /supports-color@7.2.0: + resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==} + engines: {node: '>=8'} + dependencies: + has-flag: 4.0.0 + + /supports-color@8.1.1: + resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==} + engines: {node: '>=10'} + dependencies: + has-flag: 4.0.0 + + /text-table@0.2.0: + resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==} + dev: true + + /tiny-invariant@1.3.3: + resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==} + dev: false + + /tiny-warning@1.0.3: + resolution: {integrity: sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==} + dev: false + + /tinyglobby@0.2.15: + resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==} + engines: {node: '>=12.0.0'} + dependencies: + fdir: 6.5.0(picomatch@4.0.3) + picomatch: 4.0.3 + dev: false + + /tmp@0.0.33: + resolution: {integrity: sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==} + engines: {node: '>=0.6.0'} + dependencies: + os-tmpdir: 1.0.2 + dev: false + + /to-regex-range@5.0.1: + resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==} + engines: {node: '>=8.0'} + dependencies: + is-number: 7.0.0 + + /toformat@2.0.0: + resolution: {integrity: sha512-03SWBVop6nU8bpyZCx7SodpYznbZF5R4ljwNLBcTQzKOD9xuihRo/psX58llS1BMFhhAI08H3luot5GoXJz2pQ==} + dev: false + + /toidentifier@1.0.1: + resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==} + engines: {node: '>=0.6'} + dev: false + + /tr46@0.0.3: + resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==} + dev: false + + /ts-api-utils@1.4.3(typescript@5.9.3): + resolution: {integrity: sha512-i3eMG77UTMD0hZhgRS562pv83RC6ukSAC2GMNWc+9dieh/+jDM5u5YG+NHX6VNDRHQcHwmsTHctP9LhbC3WxVw==} + engines: {node: '>=16'} + peerDependencies: + typescript: '>=4.2.0' + dependencies: + typescript: 5.9.3 + dev: true + + /ts-essentials@9.4.2(typescript@5.9.3): + resolution: {integrity: sha512-mB/cDhOvD7pg3YCLk2rOtejHjjdSi9in/IBYE13S+8WA5FBSraYf4V/ws55uvs0IvQ/l0wBOlXy5yBNZ9Bl8ZQ==} + peerDependencies: + typescript: '>=4.1.0' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + typescript: 5.9.3 + dev: false + + /tslib@1.14.1: + resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==} + dev: false + + /tslib@2.8.1: + resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==} + dev: false + + /tsort@0.0.1: + resolution: {integrity: sha512-Tyrf5mxF8Ofs1tNoxA13lFeZ2Zrbd6cKbuH3V+MQ5sb6DtBj5FjrXVsRWT8YvNAQTqNoz66dz1WsbigI22aEnw==} + dev: false + + /tsx@4.20.6: + resolution: {integrity: sha512-ytQKuwgmrrkDTFP4LjR0ToE2nqgy886GpvRSpU0JAnrdBYppuY5rLkRUYPU1yCryb24SsKBTL/hlDQAEFVwtZg==} + engines: {node: '>=18.0.0'} + hasBin: true + dependencies: + esbuild: 0.25.12 + get-tsconfig: 4.13.0 + optionalDependencies: + fsevents: 2.3.3 + dev: true + + /type-check@0.4.0: + resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==} + engines: {node: '>= 0.8.0'} + dependencies: + prelude-ls: 1.2.1 + dev: true + + /type-fest@0.20.2: + resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==} + engines: {node: '>=10'} + + /type-fest@0.21.3: + resolution: {integrity: sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==} + engines: {node: '>=10'} + dev: false + + /type-fest@0.7.1: + resolution: {integrity: sha512-Ne2YiiGN8bmrmJJEuTWTLJR32nh/JdL1+PSicowtNb0WFpn59GK8/lfD61bVtzguz7b3PBt74nxpv/Pw5po5Rg==} + engines: {node: '>=8'} + dev: false + + /type-fest@3.13.1: + resolution: {integrity: sha512-tLq3bSNx+xSpwvAJnzrK0Ep5CLNWjvFTOp71URMaAEWBfRb9nnJiBoUe0tF8bI4ZFO3omgBR6NvnbzVUT3Ly4g==} + engines: {node: '>=14.16'} + dev: false + + /typescript@5.9.3: + resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==} + engines: {node: '>=14.17'} + hasBin: true + + /undici-types@6.21.0: + resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==} + dev: true + + /undici@5.29.0: + resolution: {integrity: sha512-raqeBD6NQK4SkWhQzeYKd1KmIG6dllBOTt55Rmkt4HtI9mwdWtJljnrXjAFUBLTSN67HWrOIZ3EPF4kjUw80Bg==} + engines: {node: '>=14.0'} + dependencies: + '@fastify/busboy': 2.1.1 + dev: false + + /unfetch@4.2.0: + resolution: {integrity: sha512-F9p7yYCn6cIW9El1zi0HI6vqpeIvBsr3dSuRO6Xuppb1u5rXpCPmMvLSyECLhybr9isec8Ohl0hPekMVrEinDA==} + dev: false + + /universalify@0.1.2: + resolution: {integrity: sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==} + engines: {node: '>= 4.0.0'} + dev: false + + /unpipe@1.0.0: + resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==} + engines: {node: '>= 0.8'} + dev: false + + /uri-js@4.4.1: + resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==} + dependencies: + punycode: 2.3.1 + dev: true + + /util-deprecate@1.0.2: + resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==} + dev: false + + /uuid@8.3.2: + resolution: {integrity: sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==} + hasBin: true + dev: false + + /uuid@9.0.1: + resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==} + hasBin: true + dev: false + + /viem@2.38.6(typescript@5.9.3)(zod@3.25.76): + resolution: {integrity: sha512-aqO6P52LPXRjdnP6rl5Buab65sYa4cZ6Cpn+k4OLOzVJhGIK8onTVoKMFMT04YjDfyDICa/DZyV9HmvLDgcjkw==} + peerDependencies: + typescript: '>=5.0.4' + peerDependenciesMeta: + typescript: + optional: true + dependencies: + '@noble/curves': 1.9.1 + '@noble/hashes': 1.8.0 + '@scure/bip32': 1.7.0 + '@scure/bip39': 1.6.0 + abitype: 1.1.0(typescript@5.9.3)(zod@3.25.76) + isows: 1.0.7(ws@8.18.3) + ox: 0.9.6(typescript@5.9.3)(zod@3.25.76) + typescript: 5.9.3 + ws: 8.18.3 + transitivePeerDependencies: + - bufferutil + - utf-8-validate + - zod + dev: false + + /webidl-conversions@3.0.1: + resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==} + dev: false + + /whatwg-url@5.0.0: + resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==} + dependencies: + tr46: 0.0.3 + webidl-conversions: 3.0.1 + dev: false + + /which@2.0.2: + resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==} + engines: {node: '>= 8'} + hasBin: true + dependencies: + isexe: 2.0.0 + dev: true + + /widest-line@3.1.0: + resolution: {integrity: sha512-NsmoXalsWVDMGupxZ5R08ka9flZjjiLvHVAWYOKtiKM8ujtZWr9cRffak+uSE48+Ob8ObalXpwyeUiyDD6QFgg==} + engines: {node: '>=8'} + dependencies: + string-width: 4.2.3 + dev: false + + /word-wrap@1.2.5: + resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==} + engines: {node: '>=0.10.0'} + dev: true + + /workerpool@6.5.1: + resolution: {integrity: sha512-Fs4dNYcsdpYSAfVxhnl1L5zTksjvOJxtC5hzMNl+1t9B8hTJTdKDyZ5ju7ztgPy+ft9tBFXoOlDNiOT9WUXZlA==} + dev: false + + /wrap-ansi@7.0.0: + resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==} + engines: {node: '>=10'} + dependencies: + ansi-styles: 4.3.0 + string-width: 4.2.3 + strip-ansi: 6.0.1 + dev: false + + /wrappy@1.0.2: + resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==} + + /ws@7.5.10: + resolution: {integrity: sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==} + engines: {node: '>=8.3.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ^5.0.2 + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + dev: false + + /ws@8.18.0: + resolution: {integrity: sha512-8VbfWfHLbbwu3+N6OKsOMpBdT4kXPDDB9cJk2bJ6mh9ucxdlnNvH1e+roYkKmN9Nxw2yjz7VzeO9oOz2zJ04Pw==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + dev: false + + /ws@8.18.3: + resolution: {integrity: sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==} + engines: {node: '>=10.0.0'} + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: '>=5.0.2' + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + dev: false + + /y18n@5.0.8: + resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==} + engines: {node: '>=10'} + dev: false + + /yargs-parser@20.2.9: + resolution: {integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==} + engines: {node: '>=10'} + dev: false + + /yargs-unparser@2.0.0: + resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==} + engines: {node: '>=10'} + dependencies: + camelcase: 6.3.0 + decamelize: 4.0.0 + flat: 5.0.2 + is-plain-obj: 2.1.0 + dev: false + + /yargs@16.2.0: + resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==} + engines: {node: '>=10'} + dependencies: + cliui: 7.0.4 + escalade: 3.2.0 + get-caller-file: 2.0.5 + require-directory: 2.1.1 + string-width: 4.2.3 + y18n: 5.0.8 + yargs-parser: 20.2.9 + dev: false + + /yocto-queue@0.1.0: + resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==} + engines: {node: '>=10'} + + /zksync-web3@0.14.4(ethers@5.8.0): + resolution: {integrity: sha512-kYehMD/S6Uhe1g434UnaMN+sBr9nQm23Ywn0EUP5BfQCsbjcr3ORuS68PosZw8xUTu3pac7G6YMSnNHk+fwzvg==} + deprecated: This package has been deprecated in favor of zksync-ethers@5.0.0 + peerDependencies: + ethers: ^5.7.0 + dependencies: + ethers: 5.8.0 + dev: false + + /zod@3.25.76: + resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==} + dev: false diff --git a/scenarios/README.md b/scenarios/README.md new file mode 100644 index 0000000..077462e --- /dev/null +++ b/scenarios/README.md @@ -0,0 +1,190 @@ +# ๐Ÿ“‹ DeFi Strategy Testing Scenarios + +This directory contains example scenarios for testing DeFi strategies using the DeFi Strategy Testing CLI. + +--- + +## ๐Ÿ“š Example Scenarios + +### ๐Ÿฆ Aave v3 + +#### ๐Ÿ“ˆ Leveraged Long Strategy +**File**: `leveraged-long.yml` + +A leveraged long strategy using Aave v3: +- โœ… Supplies WETH as collateral +- โœ… Borrows USDC +- โœ… Swaps USDC to WETH to increase exposure +- โœ… Validates health factor remains safe + +#### ๐Ÿ’ฅ Liquidation Drill +**File**: `liquidation-drill.yml` + +Tests liquidation scenarios: +- โœ… Sets up a position near liquidation threshold +- โœ… Applies oracle shock +- โœ… Validates health factor drops below 1.0 +- โœ… Repays debt to recover + +### ๐Ÿ›๏ธ Compound v3 + +#### ๐Ÿ’ฐ Supply and Borrow +**File**: `supply-borrow.yml` + +Basic Compound v3 supply and borrow: +- โœ… Supplies WETH as collateral +- โœ… Borrows USDC (base asset) +- โœ… Validates borrow balance +- โœ… Repays part of debt + +--- + +## ๐Ÿš€ Running Scenarios + +### Basic Run + +```bash +# Run a scenario +pnpm run strat:run scenarios/aave/leveraged-long.yml +``` + +### With Custom Network + +```bash +# Run with custom network +pnpm run strat:run scenarios/aave/leveraged-long.yml --network base +``` + +### Generate Reports + +```bash +# Generate JSON and HTML reports +pnpm run strat:run scenarios/aave/leveraged-long.yml \ + --report out/run.json \ + --html out/report.html +``` + +--- + +## ๐Ÿ“ Scenario Format + +Scenarios are defined in YAML or JSON format: + +```yaml +version: 1 +network: mainnet +protocols: [aave-v3, uniswap-v3] + +assumptions: + baseCurrency: USD + slippageBps: 30 + minHealthFactor: 1.05 + +accounts: + trader: + funded: + - token: WETH + amount: "5" + +steps: + - name: Supply WETH + action: aave-v3.supply + args: + asset: WETH + amount: "5" + onBehalfOf: $accounts.trader + assert: + - aave-v3.healthFactor >= 1.5 +``` + +--- + +## ๐Ÿ”Œ Supported Actions + +### ๐Ÿฆ Aave v3 + +| Action | Description | +|--------|-------------| +| `aave-v3.supply` | Supply assets to Aave | +| `aave-v3.withdraw` | Withdraw assets from Aave | +| `aave-v3.borrow` | Borrow assets from Aave | +| `aave-v3.repay` | Repay borrowed assets | +| `aave-v3.flashLoanSimple` | Execute a flash loan | + +### ๐Ÿ›๏ธ Compound v3 + +| Action | Description | +|--------|-------------| +| `compound-v3.supply` | Supply collateral to Compound v3 | +| `compound-v3.withdraw` | Withdraw collateral or base asset | +| `compound-v3.borrow` | Borrow base asset (withdraws base asset) | +| `compound-v3.repay` | Repay debt (supplies base asset) | + +### ๐Ÿ”„ Uniswap v3 + +| Action | Description | +|--------|-------------| +| `uniswap-v3.exactInputSingle` | Execute an exact input swap | +| `uniswap-v3.exactOutputSingle` | Execute an exact output swap | + +### ๐Ÿ’ฐ ERC20 + +| Action | Description | +|--------|-------------| +| `erc20.approve` | Approve token spending | + +### ๐Ÿ’ฅ Failure Injection + +| Action | Description | +|--------|-------------| +| `failure.oracleShock` | Inject an oracle price shock | +| `failure.timeTravel` | Advance time | +| `failure.setTimestamp` | Set block timestamp | +| `failure.liquidityShock` | Move liquidity | +| `failure.setBaseFee` | Set gas price | +| `failure.pauseReserve` | Pause a reserve (Aave) | +| `failure.capExhaustion` | Simulate cap exhaustion | + +--- + +## โœ… Assertions + +Assertions can be added to any step: + +```yaml +steps: + - name: Check health factor + action: assert + args: + expression: "aave-v3.healthFactor >= 1.05" +``` + +### Supported Assertion Formats + +| Format | Example | Description | +|--------|---------|-------------| +| Protocol views | `aave-v3.healthFactor >= 1.05` | Compare protocol view values | +| Comparisons | `>=`, `<=`, `>`, `<`, `==`, `!=` | Standard comparison operators | + +--- + +## ๐ŸŒ Network Support + +| Network | Chain ID | Status | +|---------|----------|--------| +| Ethereum Mainnet | 1 | โœ… | +| Base | 8453 | โœ… | +| Arbitrum One | 42161 | โœ… | +| Optimism | 10 | โœ… | +| Polygon | 137 | โœ… | + +> ๐Ÿ’ก Or use chain IDs directly: `--network 1` for mainnet. + +--- + +## ๐Ÿ“– Next Steps + +- ๐Ÿ“š Read the [Strategy Testing Guide](../docs/STRATEGY_TESTING.md) for comprehensive documentation +- ๐ŸŽฏ Explore example scenarios in this directory +- ๐Ÿงช Try running scenarios with different parameters +- ๐Ÿ’ฅ Experiment with failure injection scenarios diff --git a/scenarios/aave/leveraged-long.yml b/scenarios/aave/leveraged-long.yml new file mode 100644 index 0000000..7d1ac9f --- /dev/null +++ b/scenarios/aave/leveraged-long.yml @@ -0,0 +1,61 @@ +version: 1 +network: mainnet +protocols: [aave-v3, uniswap-v3] + +assumptions: + baseCurrency: USD + slippageBps: 30 + minHealthFactor: 1.05 + +accounts: + trader: + funded: + - token: WETH + amount: "5" + +steps: + - name: Approve WETH to Aave Pool + action: erc20.approve + args: + token: WETH + spender: aave-v3:Pool + amount: "max" + + - name: Supply WETH + action: aave-v3.supply + args: + asset: WETH + amount: "5" + onBehalfOf: $accounts.trader + assert: + - aave-v3.healthFactor >= 1.5 + + - name: Borrow USDC + action: aave-v3.borrow + args: + asset: USDC + amount: "6000" + rateMode: variable + + - name: Swap USDC->WETH (hedge) + action: uniswap-v3.exactInputSingle + args: + tokenIn: USDC + tokenOut: WETH + fee: 500 + amountIn: "3000" + + - name: Supply additional WETH + action: aave-v3.supply + args: + asset: WETH + amount: "max" + onBehalfOf: $accounts.trader + assert: + - aave-v3.healthFactor >= 1.2 + + - name: Check final health factor + action: assert + args: + expression: "aave-v3.healthFactor >= 1.05" + diff --git a/scenarios/aave/liquidation-drill.yml b/scenarios/aave/liquidation-drill.yml new file mode 100644 index 0000000..dc749a6 --- /dev/null +++ b/scenarios/aave/liquidation-drill.yml @@ -0,0 +1,64 @@ +version: 1 +network: mainnet +protocols: [aave-v3] + +assumptions: + baseCurrency: USD + minHealthFactor: 1.05 + +accounts: + trader: + funded: + - token: WETH + amount: "10" + +steps: + - name: Approve WETH to Aave Pool + action: erc20.approve + args: + token: WETH + spender: aave-v3:Pool + amount: "max" + + - name: Supply WETH + action: aave-v3.supply + args: + asset: WETH + amount: "10" + onBehalfOf: $accounts.trader + assert: + - aave-v3.healthFactor >= 1.5 + + - name: Borrow USDC near limit + action: aave-v3.borrow + args: + asset: USDC + amount: "12000" + rateMode: variable + assert: + - aave-v3.healthFactor >= 1.1 + + - name: Oracle shock (-12% WETH) + action: failure.oracleShock + args: + feed: CHAINLINK_WETH_USD + pctDelta: -12 + + - name: Check HF after shock + action: assert + args: + expression: "aave-v3.healthFactor < 1.0" + # This should pass - HF should be below 1.0 after shock + + - name: Repay part of debt + action: aave-v3.repay + args: + asset: USDC + amount: "1500" + rateMode: variable + + - name: Check HF after repay + action: assert + args: + expression: "aave-v3.healthFactor >= 1.0" + diff --git a/scenarios/compound3/supply-borrow.yml b/scenarios/compound3/supply-borrow.yml new file mode 100644 index 0000000..f6c6a42 --- /dev/null +++ b/scenarios/compound3/supply-borrow.yml @@ -0,0 +1,43 @@ +version: 1 +network: mainnet +protocols: [compound-v3] + +assumptions: + baseCurrency: USD + minHealthFactor: 1.05 + +accounts: + trader: + funded: + - token: WETH + amount: "2" + +steps: + - name: Approve WETH to Compound Comet + action: erc20.approve + args: + token: WETH + spender: compound-v3:comet + amount: "max" + + - name: Supply WETH as collateral + action: compound-v3.supply + args: + asset: WETH + amount: "2" + + - name: Borrow USDC (withdraw base asset) + action: compound-v3.borrow + args: + amount: "3000" + + - name: Check borrow balance + action: assert + args: + expression: "compound-v3.borrowBalance > 0" + + - name: Repay part of debt + action: compound-v3.repay + args: + amount: "1000" + diff --git a/scripts/check-env.ts b/scripts/check-env.ts new file mode 100644 index 0000000..4db81d3 --- /dev/null +++ b/scripts/check-env.ts @@ -0,0 +1,156 @@ +#!/usr/bin/env tsx + +/** + * Environment Variable Checker + * + * This script checks that all required environment variables are set + * and validates RPC URLs are accessible. + * + * Usage: + * tsx scripts/check-env.ts + */ + +// Load environment variables FIRST +import dotenv from 'dotenv'; +dotenv.config(); + +import { createPublicClient, http } from 'viem'; +import { mainnet, base, arbitrum, optimism, polygon } from 'viem/chains'; +import chalk from 'chalk'; + +interface EnvCheck { + name: string; + value: string | undefined; + required: boolean; + valid: boolean; + error?: string; +} + +async function checkRpcUrl(name: string, url: string | undefined, chain: any): Promise { + const check: EnvCheck = { + name, + value: url ? (url.length > 50 ? `${url.substring(0, 30)}...${url.substring(url.length - 10)}` : url) : undefined, + required: false, + valid: false, + }; + + if (!url) { + check.error = 'Not set (using default or will fail)'; + return check; + } + + if (url.includes('YOUR_KEY') || url.includes('YOUR_INFURA_KEY')) { + check.error = 'Contains placeholder - please set a real RPC URL'; + return check; + } + + try { + const client = createPublicClient({ + chain, + transport: http(url, { timeout: 5000 }), + }); + + const blockNumber = await client.getBlockNumber(); + check.valid = true; + check.error = `โœ“ Connected (block: ${blockNumber})`; + } catch (error: any) { + check.error = `Connection failed: ${error.message}`; + } + + return check; +} + +async function main() { + console.log(chalk.blue('='.repeat(60))); + console.log(chalk.blue('Environment Variable Checker')); + console.log(chalk.blue('='.repeat(60))); + console.log(''); + + const checks: EnvCheck[] = []; + + // Check RPC URLs + console.log(chalk.yellow('Checking RPC URLs...')); + console.log(''); + + checks.push(await checkRpcUrl('MAINNET_RPC_URL', process.env.MAINNET_RPC_URL, mainnet)); + checks.push(await checkRpcUrl('BASE_RPC_URL', process.env.BASE_RPC_URL, base)); + checks.push(await checkRpcUrl('ARBITRUM_RPC_URL', process.env.ARBITRUM_RPC_URL, arbitrum)); + checks.push(await checkRpcUrl('OPTIMISM_RPC_URL', process.env.OPTIMISM_RPC_URL, optimism)); + checks.push(await checkRpcUrl('POLYGON_RPC_URL', process.env.POLYGON_RPC_URL, polygon)); + + // Check other variables + console.log(chalk.yellow('Checking other environment variables...')); + console.log(''); + + const privateKey = process.env.PRIVATE_KEY; + checks.push({ + name: 'PRIVATE_KEY', + value: privateKey ? '***' + privateKey.slice(-4) : undefined, + required: false, + valid: !!privateKey, + error: privateKey ? 'โœ“ Set (not shown for security)' : 'Not set (optional, only needed for mainnet transactions)', + }); + + // Print results + console.log(chalk.blue('='.repeat(60))); + console.log(chalk.blue('Results')); + console.log(chalk.blue('='.repeat(60))); + console.log(''); + + let hasErrors = false; + let hasWarnings = false; + + for (const check of checks) { + const status = check.valid ? chalk.green('โœ“') : (check.required ? chalk.red('โœ—') : chalk.yellow('โš ')); + const name = chalk.bold(check.name); + const value = check.value ? chalk.gray(`(${check.value})`) : ''; + const error = check.error ? ` - ${check.error}` : ''; + + console.log(`${status} ${name} ${value}${error}`); + + if (!check.valid) { + if (check.required) { + hasErrors = true; + } else { + hasWarnings = true; + } + } + + // Check for placeholder values + if (check.value && (check.value.includes('YOUR_KEY') || check.value.includes('YOUR_INFURA_KEY'))) { + hasWarnings = true; + console.log(chalk.yellow(` โš  Contains placeholder - please set a real value`)); + } + } + + console.log(''); + console.log(chalk.blue('='.repeat(60))); + + if (hasErrors) { + console.log(chalk.red('โœ— Some required checks failed')); + console.log(''); + console.log('Please:'); + console.log(' 1. Copy .env.example to .env'); + console.log(' 2. Fill in your RPC URLs'); + console.log(' 3. Run this script again to verify'); + process.exit(1); + } else if (hasWarnings) { + console.log(chalk.yellow('โš  Some checks have warnings')); + console.log(''); + console.log('Recommendations:'); + console.log(' - Set RPC URLs in .env file for better performance'); + console.log(' - Replace placeholder values with real RPC URLs'); + console.log(' - Check RPC provider settings if connections fail'); + console.log(''); + console.log('You can still run tests, but they may fail if RPC URLs are not properly configured.'); + } else { + console.log(chalk.green('โœ“ All checks passed!')); + console.log(''); + console.log('You can now run:'); + console.log(' - pnpm run strat run scenarios/aave/leveraged-long.yml'); + console.log(' - pnpm run strat:test'); + } +} + +main().catch(console.error); + diff --git a/scripts/install-foundry-deps.sh b/scripts/install-foundry-deps.sh new file mode 100755 index 0000000..c5f683f --- /dev/null +++ b/scripts/install-foundry-deps.sh @@ -0,0 +1,16 @@ +#!/usr/bin/env bash + +# Install Foundry dependencies (OpenZeppelin, etc.) + +set -euo pipefail + +echo "Installing Foundry dependencies..." + +# Install forge-std +forge install foundry-rs/forge-std --no-commit + +# Install OpenZeppelin contracts +forge install OpenZeppelin/openzeppelin-contracts --no-commit + +echo "Foundry dependencies installed successfully!" + diff --git a/scripts/test-strategy.ts b/scripts/test-strategy.ts new file mode 100644 index 0000000..b171033 --- /dev/null +++ b/scripts/test-strategy.ts @@ -0,0 +1,182 @@ +#!/usr/bin/env tsx + +/** + * Test script for DeFi strategy testing + * + * This script can be used to test the strategy framework with a real fork + * + * Usage: + * tsx scripts/test-strategy.ts + * + * Environment variables: + * MAINNET_RPC_URL - RPC URL for mainnet fork (required) + * TEST_SCENARIO - Path to scenario file (default: scenarios/aave/leveraged-long.yml) + * TEST_NETWORK - Network name (default: mainnet) + */ + +// Load environment variables FIRST, before any other imports that might use them +import dotenv from 'dotenv'; +dotenv.config(); + +import { readFileSync } from 'fs'; +import { join } from 'path'; +import { ForkOrchestrator } from '../src/strat/core/fork-orchestrator.js'; +import { ScenarioRunner } from '../src/strat/core/scenario-runner.js'; +import { loadScenario } from '../src/strat/dsl/scenario-loader.js'; +import { AaveV3Adapter } from '../src/strat/adapters/aave-v3-adapter.js'; +import { UniswapV3Adapter } from '../src/strat/adapters/uniswap-v3-adapter.js'; +import { CompoundV3Adapter } from '../src/strat/adapters/compound-v3-adapter.js'; +import { Erc20Adapter } from '../src/strat/adapters/erc20-adapter.js'; +import { FailureInjector } from '../src/strat/core/failure-injector.js'; +import { JsonReporter } from '../src/strat/reporters/json-reporter.js'; +import { HtmlReporter } from '../src/strat/reporters/html-reporter.js'; +import { getNetwork } from '../src/strat/config/networks.js'; +import type { ProtocolAdapter } from '../src/strat/types.js'; + +async function main() { + const scenarioPath = process.env.TEST_SCENARIO || 'scenarios/aave/leveraged-long.yml'; + const networkName = process.env.TEST_NETWORK || 'mainnet'; + + // Get RPC URL from env - try network-specific first, then MAINNET_RPC_URL + const networkEnvVar = `${networkName.toUpperCase()}_RPC_URL`; + let rpcUrl = process.env[networkEnvVar] || process.env.MAINNET_RPC_URL; + + if (!rpcUrl) { + console.error('ERROR: RPC URL not found'); + console.error(` Please set ${networkEnvVar} or MAINNET_RPC_URL in your .env file`); + console.error(' Or create .env from .env.example and fill in your RPC URLs'); + process.exit(1); + } + + if (rpcUrl.includes('YOUR_KEY') || rpcUrl.includes('YOUR_INFURA_KEY')) { + console.error('ERROR: RPC URL contains placeholder'); + console.error(' Please set a real RPC URL in your .env file'); + console.error(` Current: ${rpcUrl.substring(0, 50)}...`); + process.exit(1); + } + + console.log('='.repeat(60)); + console.log('DeFi Strategy Testing - Test Script'); + console.log('='.repeat(60)); + console.log(`Scenario: ${scenarioPath}`); + console.log(`Network: ${networkName}`); + console.log(`RPC: ${rpcUrl.substring(0, 30)}...`); + console.log(''); + + try { + // Load scenario + console.log('Loading scenario...'); + const scenario = loadScenario(scenarioPath); + console.log(`โœ“ Loaded scenario with ${scenario.steps.length} steps`); + + // Setup network + const network = getNetwork(networkName); + network.rpcUrl = rpcUrl; + + // Start fork + console.log('Starting fork...'); + const fork = new ForkOrchestrator(network, rpcUrl); + await fork.start(); + console.log('โœ“ Fork started'); + + // Register adapters + console.log('Registering adapters...'); + const adapters = new Map(); + adapters.set('erc20', new Erc20Adapter()); + adapters.set('aave-v3', new AaveV3Adapter()); + adapters.set('uniswap-v3', new UniswapV3Adapter()); + adapters.set('compound-v3', new CompoundV3Adapter()); + + // Register failure injector + const failureInjector = new FailureInjector(fork); + adapters.set('failure', { + name: 'failure', + discover: async () => ({}), + actions: { + oracleShock: (ctx, args) => failureInjector.oracleShock(ctx, args), + timeTravel: (ctx, args) => failureInjector.timeTravel(ctx, args), + setTimestamp: (ctx, args) => failureInjector.setTimestamp(ctx, args), + liquidityShock: (ctx, args) => failureInjector.liquidityShock(ctx, args), + setBaseFee: (ctx, args) => failureInjector.setBaseFee(ctx, args), + pauseReserve: (ctx, args) => failureInjector.pauseReserve(ctx, args), + capExhaustion: (ctx, args) => failureInjector.capExhaustion(ctx, args), + }, + views: {}, + }); + console.log('โœ“ Adapters registered'); + + // Create snapshot + console.log('Creating snapshot...'); + const snapshotId = await fork.snapshot('test_start'); + console.log(`โœ“ Snapshot created: ${snapshotId}`); + + // Run scenario + console.log(''); + console.log('Running scenario...'); + console.log('-'.repeat(60)); + const runner = new ScenarioRunner(fork, adapters, network); + const report = await runner.run(scenario); + console.log('-'.repeat(60)); + + // Print summary + console.log(''); + console.log('='.repeat(60)); + console.log('Run Summary'); + console.log('='.repeat(60)); + console.log(`Status: ${report.passed ? 'โœ“ PASSED' : 'โœ— FAILED'}`); + console.log(`Steps: ${report.steps.length}`); + console.log(`Duration: ${((report.endTime! - report.startTime) / 1000).toFixed(2)}s`); + console.log(`Total Gas: ${report.metadata.totalGas.toString()}`); + if (report.error) { + console.log(`Error: ${report.error}`); + } + + // Generate reports + const outputDir = 'out'; + const timestamp = Date.now(); + const jsonPath = join(outputDir, `test-run-${timestamp}.json`); + const htmlPath = join(outputDir, `test-report-${timestamp}.html`); + + console.log(''); + console.log('Generating reports...'); + JsonReporter.generate(report, jsonPath); + HtmlReporter.generate(report, htmlPath); + console.log(`โœ“ JSON report: ${jsonPath}`); + console.log(`โœ“ HTML report: ${htmlPath}`); + + // Print step details + console.log(''); + console.log('Step Results:'); + for (const step of report.steps) { + const status = step.result.success ? 'โœ“' : 'โœ—'; + const duration = (step.duration / 1000).toFixed(2); + console.log(` ${status} ${step.stepName} (${duration}s)`); + if (!step.result.success) { + console.log(` Error: ${step.result.error}`); + } + if (step.assertions && step.assertions.length > 0) { + const passed = step.assertions.filter(a => a.passed).length; + const total = step.assertions.length; + console.log(` Assertions: ${passed}/${total} passed`); + } + } + + // Cleanup + await fork.revert(snapshotId); + await fork.stop(); + + console.log(''); + console.log('='.repeat(60)); + console.log('Test completed'); + + process.exit(report.passed ? 0 : 1); + } catch (error: any) { + console.error(''); + console.error('ERROR:', error.message); + console.error(error.stack); + process.exit(1); + } +} + +main(); + diff --git a/scripts/verify-env.ts b/scripts/verify-env.ts new file mode 100644 index 0000000..3cac77f --- /dev/null +++ b/scripts/verify-env.ts @@ -0,0 +1,72 @@ +#!/usr/bin/env tsx + +/** + * Quick verification that environment variables are being loaded correctly + * + * Usage: + * tsx scripts/verify-env.ts + */ + +// Load dotenv FIRST +import dotenv from 'dotenv'; +dotenv.config(); + +console.log('Environment Variable Verification'); +console.log('='.repeat(50)); + +// Check if dotenv loaded the .env file +const envFile = dotenv.config(); +if (envFile.error) { + console.log('โš  .env file not found (this is okay if using system env vars)'); +} else { + console.log('โœ“ .env file loaded'); +} + +console.log(''); + +// Check RPC URLs +const rpcUrls = { + 'MAINNET_RPC_URL': process.env.MAINNET_RPC_URL, + 'BASE_RPC_URL': process.env.BASE_RPC_URL, + 'ARBITRUM_RPC_URL': process.env.ARBITRUM_RPC_URL, + 'OPTIMISM_RPC_URL': process.env.OPTIMISM_RPC_URL, + 'POLYGON_RPC_URL': process.env.POLYGON_RPC_URL, +}; + +console.log('RPC URLs:'); +for (const [key, value] of Object.entries(rpcUrls)) { + if (value) { + const display = value.length > 50 + ? `${value.substring(0, 30)}...${value.substring(value.length - 10)}` + : value; + const hasPlaceholder = value.includes('YOUR_KEY') || value.includes('YOUR_INFURA_KEY'); + console.log(` ${key}: ${hasPlaceholder ? 'โš  PLACEHOLDER' : 'โœ“'} ${display}`); + } else { + console.log(` ${key}: โœ— Not set`); + } +} + +console.log(''); + +// Check other vars +if (process.env.PRIVATE_KEY) { + console.log('PRIVATE_KEY: โœ“ Set (not shown)'); +} else { + console.log('PRIVATE_KEY: โœ— Not set (optional)'); +} + +console.log(''); +console.log('='.repeat(50)); + +// Test network loading +try { + // This will import networks.ts which should use the env vars + const { getNetwork } = await import('../src/strat/config/networks.js'); + const network = getNetwork('mainnet'); + console.log(`Network config test: โœ“ Loaded (RPC: ${network.rpcUrl.substring(0, 30)}...)`); +} catch (error: any) { + console.log(`Network config test: โœ— Failed - ${error.message}`); +} + +console.log(''); + diff --git a/scripts/verify-setup.ts b/scripts/verify-setup.ts new file mode 100644 index 0000000..2266ffa --- /dev/null +++ b/scripts/verify-setup.ts @@ -0,0 +1,169 @@ +#!/usr/bin/env tsx + +/** + * Comprehensive Setup Verification Script + * + * Verifies that all scripts are properly configured with environment variables + * and that connections work correctly. + * + * Usage: + * tsx scripts/verify-setup.ts + */ + +// Load dotenv FIRST +import dotenv from 'dotenv'; +dotenv.config(); + +import { existsSync } from 'fs'; +import { join } from 'path'; +import chalk from 'chalk'; + +async function main() { + console.log(chalk.blue('='.repeat(70))); + console.log(chalk.blue('DeFi Strategy Testing Framework - Setup Verification')); + console.log(chalk.blue('='.repeat(70))); + console.log(''); + + let allGood = true; + + // Check .env file + console.log(chalk.yellow('1. Checking .env file...')); + if (existsSync('.env')) { + console.log(chalk.green(' โœ“ .env file exists')); + } else { + console.log(chalk.yellow(' โš  .env file not found')); + console.log(chalk.yellow(' Create it from .env.example: cp .env.example .env')); + allGood = false; + } + console.log(''); + + // Check .env.example + console.log(chalk.yellow('2. Checking .env.example...')); + if (existsSync('.env.example')) { + console.log(chalk.green(' โœ“ .env.example exists')); + } else { + console.log(chalk.red(' โœ— .env.example not found')); + allGood = false; + } + console.log(''); + + // Check environment variables + console.log(chalk.yellow('3. Checking environment variables...')); + const requiredVars = ['MAINNET_RPC_URL']; + const optionalVars = ['BASE_RPC_URL', 'ARBITRUM_RPC_URL', 'OPTIMISM_RPC_URL', 'POLYGON_RPC_URL', 'PRIVATE_KEY']; + + for (const varName of requiredVars) { + const value = process.env[varName]; + if (value && !value.includes('YOUR_KEY') && !value.includes('YOUR_INFURA_KEY')) { + console.log(chalk.green(` โœ“ ${varName} is set`)); + } else { + console.log(chalk.red(` โœ— ${varName} is not properly configured`)); + allGood = false; + } + } + + for (const varName of optionalVars) { + const value = process.env[varName]; + if (value && !value.includes('YOUR_KEY') && !value.includes('YOUR_INFURA_KEY')) { + console.log(chalk.green(` โœ“ ${varName} is set`)); + } else if (value) { + console.log(chalk.yellow(` โš  ${varName} contains placeholder`)); + } else { + console.log(chalk.gray(` - ${varName} not set (optional)`)); + } + } + console.log(''); + + // Check scripts load dotenv + console.log(chalk.yellow('4. Checking scripts load dotenv...')); + const scripts = [ + 'src/strat/cli.ts', + 'src/cli/cli.ts', + 'scripts/test-strategy.ts', + ]; + + for (const script of scripts) { + if (existsSync(script)) { + // Read first few lines to check for dotenv + const fs = await import('fs'); + const content = fs.readFileSync(script, 'utf-8'); + const lines = content.split('\n').slice(0, 20); + const hasDotenv = lines.some(line => + line.includes('dotenv') && (line.includes('import') || line.includes('require')) + ); + const dotenvConfigLine = lines.findIndex(line => line.includes('dotenv.config()')); + const firstNonDotenvImport = lines.findIndex(line => + line.includes('import') && !line.includes('dotenv') && !line.trim().startsWith('//') + ); + const dotenvBeforeImports = dotenvConfigLine !== -1 && + (firstNonDotenvImport === -1 || dotenvConfigLine < firstNonDotenvImport); + + if (hasDotenv && dotenvBeforeImports) { + console.log(chalk.green(` โœ“ ${script} loads dotenv correctly`)); + } else if (hasDotenv) { + console.log(chalk.yellow(` โš  ${script} loads dotenv but may be after other imports`)); + } else { + console.log(chalk.red(` โœ— ${script} does not load dotenv`)); + allGood = false; + } + } + } + console.log(''); + + // Check network config + console.log(chalk.yellow('5. Checking network configuration...')); + try { + const { getNetwork } = await import('../src/strat/config/networks.js'); + const network = getNetwork('mainnet'); + if (network.rpcUrl && !network.rpcUrl.includes('YOUR_KEY')) { + console.log(chalk.green(` โœ“ Network config loads correctly`)); + console.log(chalk.gray(` Mainnet RPC: ${network.rpcUrl.substring(0, 50)}...`)); + } else { + console.log(chalk.yellow(` โš  Network config has placeholder RPC URL`)); + } + } catch (error: any) { + console.log(chalk.red(` โœ— Network config error: ${error.message}`)); + allGood = false; + } + console.log(''); + + // Check scenario files + console.log(chalk.yellow('6. Checking scenario files...')); + const scenarios = [ + 'scenarios/aave/leveraged-long.yml', + 'scenarios/aave/liquidation-drill.yml', + 'scenarios/compound3/supply-borrow.yml', + ]; + + for (const scenario of scenarios) { + if (existsSync(scenario)) { + console.log(chalk.green(` โœ“ ${scenario} exists`)); + } else { + console.log(chalk.yellow(` โš  ${scenario} not found`)); + } + } + console.log(''); + + // Summary + console.log(chalk.blue('='.repeat(70))); + if (allGood) { + console.log(chalk.green('โœ“ Setup verification passed!')); + console.log(''); + console.log('Next steps:'); + console.log(' 1. Run environment check: pnpm run check:env'); + console.log(' 2. Test a scenario: pnpm run strat:test'); + console.log(' 3. Run a scenario: pnpm run strat run scenarios/aave/leveraged-long.yml'); + } else { + console.log(chalk.yellow('โš  Setup verification found some issues')); + console.log(''); + console.log('Please:'); + console.log(' 1. Create .env file: cp .env.example .env'); + console.log(' 2. Fill in your RPC URLs in .env'); + console.log(' 3. Run: pnpm run check:env'); + process.exit(1); + } + console.log(''); +} + +main().catch(console.error); + diff --git a/src/cli/cli.ts b/src/cli/cli.ts new file mode 100644 index 0000000..d25150a --- /dev/null +++ b/src/cli/cli.ts @@ -0,0 +1,204 @@ +#!/usr/bin/env node + +/** + * DeFi Starter Kit CLI + * + * Commands: + * - build-plan: Generate transaction plan + * - execute: Execute plan via Protocolink + * - simulate: Simulate transaction + * - quote: Get quotes for operations + */ + +// Load environment variables FIRST, before any other imports that might use them +import dotenv from 'dotenv'; +dotenv.config(); + +import { Command } from 'commander'; +import { readFileSync, writeFileSync } from 'fs'; +import { join } from 'path'; +import * as api from '@protocolink/api'; +import * as common from '@protocolink/common'; +import { createWalletRpcClient, createRpcClient } from '../utils/chain-config.js'; +import { getProtocolinkRouter } from '../utils/addresses.js'; +import { waitForTransaction } from '../utils/rpc.js'; +import chalk from 'chalk'; + +const program = new Command(); + +program + .name('defi-cli') + .description('DeFi Starter Kit CLI for multi-protocol transactions') + .version('1.0.0'); + +// Build plan command +program + .command('build-plan') + .description('Generate a transaction plan from a JSON configuration') + .option('-c, --chain ', 'Chain ID (1=mainnet, 8453=base, etc.)', '1') + .option('-o, --output ', 'Output file for plan', 'plan.json') + .option('-i, --input ', 'Input file with plan configuration', 'plan-config.json') + .action(async (options) => { + try { + const chainId = parseInt(options.chain); + console.log(chalk.blue(`Building plan for chain ${chainId}...`)); + + // Read input configuration + let config; + try { + const configData = readFileSync(options.input, 'utf-8'); + config = JSON.parse(configData); + } catch (error) { + console.error(chalk.red(`Error reading input file: ${error}`)); + console.log(chalk.yellow('Creating default plan structure...')); + config = { + operations: [ + { type: 'supply', protocol: 'aavev3', token: 'USDC', amount: '1000' }, + { type: 'borrow', protocol: 'aavev3', token: 'USDT', amount: '500' }, + ], + }; + } + + // Build plan (simplified - in production, use Protocolink API) + const plan = { + chainId, + operations: config.operations || [], + timestamp: Date.now(), + }; + + // Write plan to file + writeFileSync(options.output, JSON.stringify(plan, null, 2)); + console.log(chalk.green(`Plan written to ${options.output}`)); + } catch (error) { + console.error(chalk.red(`Error building plan: ${error}`)); + process.exit(1); + } + }); + +// Quote command +program + .command('quote') + .description('Get quotes for DeFi operations') + .option('-c, --chain ', 'Chain ID', '1') + .option('-p, --protocol ', 'Protocol (aavev3, uniswapv3, etc.)', 'uniswapv3') + .option('-t, --type ', 'Operation type (swap, supply, borrow)', 'swap') + .option('-i, --token-in ', 'Input token symbol', 'USDC') + .option('-o, --token-out ', 'Output token symbol', 'WETH') + .option('-a, --amount ', 'Amount', '1000') + .action(async (options) => { + try { + const chainId = parseInt(options.chain) as common.ChainId; + console.log(chalk.blue(`Getting quote for ${options.protocol} ${options.type}...`)); + + // Token definitions (simplified - use proper token resolution in production) + const tokens: Record = { + USDC: { + chainId, + address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', + decimals: 6, + symbol: 'USDC', + name: 'USD Coin', + }, + WETH: { + chainId, + address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', + decimals: 18, + symbol: 'WETH', + name: 'Wrapped Ether', + }, + }; + + if (options.protocol === 'uniswapv3' && options.type === 'swap') { + const quotation = await api.protocols.uniswapv3.getSwapTokenQuotation(chainId, { + input: { token: tokens[options.tokenIn], amount: options.amount }, + tokenOut: tokens[options.tokenOut], + slippage: 100, // 1% slippage + }); + + console.log(chalk.green(`Quote:`)); + console.log(` Input: ${quotation.input.amount} ${quotation.input.token.symbol}`); + console.log(` Output: ${quotation.output.amount} ${quotation.output.token.symbol}`); + } else if (options.protocol === 'aavev3' && options.type === 'supply') { + const quotation = await api.protocols.aavev3.getSupplyQuotation(chainId, { + input: { token: tokens[options.tokenIn], amount: options.amount }, + }); + + console.log(chalk.green(`Quote:`)); + console.log(` Input: ${quotation.input.amount} ${quotation.input.token.symbol}`); + console.log(` Output: ${quotation.output.amount} ${quotation.output.token.symbol}`); + } else { + console.log(chalk.yellow('Unsupported protocol/type combination')); + } + } catch (error) { + console.error(chalk.red(`Error getting quote: ${error}`)); + process.exit(1); + } + }); + +// Execute command +program + .command('execute') + .description('Execute a transaction plan via Protocolink') + .option('-c, --chain ', 'Chain ID', '1') + .option('-p, --plan ', 'Plan file', 'plan.json') + .option('--dry-run', 'Simulate without executing', false) + .action(async (options) => { + try { + const chainId = parseInt(options.chain) as common.ChainId; + const privateKey = process.env.PRIVATE_KEY as `0x${string}`; + + if (!privateKey) { + throw new Error('PRIVATE_KEY environment variable not set'); + } + + // Read plan + const planData = readFileSync(options.plan, 'utf-8'); + const plan = JSON.parse(planData); + + console.log(chalk.blue(`Executing plan on chain ${chainId}...`)); + + if (options.dryRun) { + console.log(chalk.yellow('Dry run mode - simulating transaction...')); + // Simulate transaction + console.log(chalk.green('Simulation complete')); + } else { + const walletClient = createWalletRpcClient(chainId, privateKey); + const publicClient = walletClient as any; + + // Build Protocolink route from plan + // This is simplified - in production, convert plan to Protocolink logics + console.log(chalk.yellow('Plan execution not fully implemented')); + console.log(chalk.yellow('Use Protocolink SDK directly for production')); + } + } catch (error) { + console.error(chalk.red(`Error executing plan: ${error}`)); + process.exit(1); + } + }); + +// Simulate command +program + .command('simulate') + .description('Simulate a transaction without executing') + .option('-c, --chain ', 'Chain ID', '1') + .option('-p, --plan ', 'Plan file', 'plan.json') + .action(async (options) => { + try { + const chainId = parseInt(options.chain); + console.log(chalk.blue(`Simulating plan on chain ${chainId}...`)); + + // Read plan + const planData = readFileSync(options.plan, 'utf-8'); + const plan = JSON.parse(planData); + + console.log(chalk.green('Simulation complete')); + console.log(chalk.yellow('Note: Full simulation requires Tenderly or similar service')); + } catch (error) { + console.error(chalk.red(`Error simulating: ${error}`)); + process.exit(1); + } + }); + +// Parse arguments +program.parse(); + diff --git a/src/cli/index.ts b/src/cli/index.ts new file mode 100644 index 0000000..cb73d58 --- /dev/null +++ b/src/cli/index.ts @@ -0,0 +1,2 @@ +export {}; + diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..416a5fe --- /dev/null +++ b/src/index.ts @@ -0,0 +1,9 @@ +// Main exports for the DeFi Starter Kit + +export * from './utils/chain-config.js'; +export * from './utils/addresses.js'; +export * from './utils/tokens.js'; +export * from './utils/permit2.js'; +export * from './utils/encoding.js'; +export * from './utils/rpc.js'; + diff --git a/src/strat/adapters/aave-v3-adapter.ts b/src/strat/adapters/aave-v3-adapter.ts new file mode 100644 index 0000000..943a00a --- /dev/null +++ b/src/strat/adapters/aave-v3-adapter.ts @@ -0,0 +1,459 @@ +import type { + ProtocolAdapter, + StepContext, + StepResult, + ViewContext, + RuntimeAddresses, + Network, +} from '../types.js'; +import { getChainConfig } from '../../utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../utils/tokens.js'; +import type { Address } from 'viem'; +import { formatUnits, parseUnits, maxUint256 } from 'viem'; + +/** + * Aave v3 Protocol Adapter + * Implements Aave v3 operations: supply, withdraw, borrow, repay, flash loans + */ + +// Aave Pool ABI +const POOL_ABI = [ + { + name: 'supply', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'onBehalfOf', type: 'address' }, + { name: 'referralCode', type: 'uint16' }, + ], + outputs: [], + }, + { + name: 'withdraw', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'to', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'borrow', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'interestRateMode', type: 'uint256' }, + { name: 'referralCode', type: 'uint16' }, + { name: 'onBehalfOf', type: 'address' }, + ], + outputs: [], + }, + { + name: 'repay', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'rateMode', type: 'uint256' }, + { name: 'onBehalfOf', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'flashLoanSimple', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'receiverAddress', type: 'address' }, + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + { name: 'params', type: 'bytes' }, + { name: 'referralCode', type: 'uint16' }, + ], + outputs: [], + }, + { + name: 'flashLoan', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'receiverAddress', type: 'address' }, + { name: 'assets', type: 'address[]' }, + { name: 'amounts', type: 'uint256[]' }, + { name: 'modes', type: 'uint256[]' }, + { name: 'onBehalfOf', type: 'address' }, + { name: 'params', type: 'bytes' }, + { name: 'referralCode', type: 'uint16' }, + ], + outputs: [], + }, + { + name: 'getUserAccountData', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'user', type: 'address' }], + outputs: [ + { name: 'totalCollateralBase', type: 'uint256' }, + { name: 'totalDebtBase', type: 'uint256' }, + { name: 'availableBorrowsBase', type: 'uint256' }, + { name: 'currentLiquidationThreshold', type: 'uint256' }, + { name: 'ltv', type: 'uint256' }, + { name: 'healthFactor', type: 'uint256' }, + { name: 'eModeCategoryId', type: 'uint8' }, + ], + }, +] as const; + +// ERC20 ABI +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'allowance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'owner', type: 'address' }, + { name: 'spender', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +export class AaveV3Adapter implements ProtocolAdapter { + name = 'aave-v3'; + + async discover(network: Network): Promise { + const config = getChainConfig(network.chainId); + return { + pool: config.aave.pool, + addressesProvider: config.aave.poolAddressesProvider, + }; + } + + actions = { + supply: async (ctx: StepContext, args: any): Promise => { + const { asset, amount, onBehalfOf } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = this.parseAmount(amount, assetAddress, ctx.network.chainId); + const userAddress = this.resolveAddress(onBehalfOf || '$accounts.trader', ctx); + + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + // Approve if needed + await this.ensureApproval( + ctx, + assetAddress, + poolAddress, + amountValue + ); + + // Execute supply + const hash = await ctx.walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'supply', + args: [assetAddress, amountValue, userAddress, 0], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + withdraw: async (ctx: StepContext, args: any): Promise => { + const { asset, amount, to } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = amount === 'max' + ? maxUint256 + : this.parseAmount(amount, assetAddress, ctx.network.chainId); + const toAddress = this.resolveAddress(to || '$accounts.trader', ctx); + + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + const hash = await ctx.walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'withdraw', + args: [assetAddress, amountValue, toAddress], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + borrow: async (ctx: StepContext, args: any): Promise => { + const { asset, amount, rateMode, onBehalfOf } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = this.parseAmount(amount, assetAddress, ctx.network.chainId); + const userAddress = this.resolveAddress(onBehalfOf || '$accounts.trader', ctx); + const rateModeValue = rateMode === 'variable' ? 2n : 1n; // 2 = variable, 1 = stable (deprecated) + + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + const hash = await ctx.walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'borrow', + args: [assetAddress, amountValue, rateModeValue, 0, userAddress], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + repay: async (ctx: StepContext, args: any): Promise => { + const { asset, amount, rateMode, onBehalfOf } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = amount === 'max' + ? maxUint256 + : this.parseAmount(amount, assetAddress, ctx.network.chainId); + const userAddress = this.resolveAddress(onBehalfOf || '$accounts.trader', ctx); + const rateModeValue = rateMode === 'variable' ? 2n : 1n; + + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + // Approve if needed + await this.ensureApproval( + ctx, + assetAddress, + poolAddress, + amountValue + ); + + const hash = await ctx.walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'repay', + args: [assetAddress, amountValue, rateModeValue, userAddress], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + flashLoanSimple: async (ctx: StepContext, args: any): Promise => { + const { asset, amount, receiverAddress, params } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = this.parseAmount(amount, assetAddress, ctx.network.chainId); + const receiver = this.resolveAddress(receiverAddress, ctx); + const paramsBytes = params ? (typeof params === 'string' ? params as `0x${string}` : '0x') : '0x'; + + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + const hash = await ctx.walletClient.writeContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'flashLoanSimple', + args: [receiver, assetAddress, amountValue, paramsBytes, 0], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + }; + + views = { + healthFactor: async (ctx: ViewContext): Promise => { + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + const traderAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + if (!traderAddress) { + throw new Error('Trader account not found'); + } + + const data = await ctx.publicClient.readContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'getUserAccountData', + args: [traderAddress], + }); + + // Health factor is stored as uint256 with 18 decimals + return Number(formatUnits(data[5], 18)); + }, + + userAccountData: async (ctx: ViewContext): Promise => { + const poolAddress = ctx.addresses['aave-v3']?.pool; + if (!poolAddress) { + throw new Error('Aave pool address not found'); + } + + const traderAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + if (!traderAddress) { + throw new Error('Trader account not found'); + } + + const data = await ctx.publicClient.readContract({ + address: poolAddress, + abi: POOL_ABI, + functionName: 'getUserAccountData', + args: [traderAddress], + }); + + return { + totalCollateralBase: data[0], + totalDebtBase: data[1], + availableBorrowsBase: data[2], + currentLiquidationThreshold: data[3], + ltv: data[4], + healthFactor: Number(formatUnits(data[5], 18)), + eModeCategoryId: data[6], + }; + }, + }; + + invariants = [ + async (ctx: StepContext): Promise => { + // Default invariant: health factor should be >= 1 (unless expecting failure) + const hf = await this.views.healthFactor({ + network: ctx.network, + publicClient: ctx.publicClient, + accounts: ctx.accounts, + addresses: ctx.addresses, + variables: ctx.variables, + }); + + if (hf < 1.0 && hf > 0) { + console.warn(`Health factor is below 1.0: ${hf}`); + } + }, + ]; + + private resolveToken(symbol: string, chainId: number): Address { + try { + const token = getTokenMetadata(chainId, symbol as any); + return token.address; + } catch { + // Try as address directly + return symbol as Address; + } + } + + private parseAmount(amount: string, tokenAddress: Address, chainId: number): bigint { + if (amount === 'max') { + return maxUint256; + } + + try { + const token = getTokenMetadata(chainId, tokenAddress as any); + return parseTokenAmount(amount, token.decimals); + } catch { + // Assume 18 decimals if token not found + return parseUnits(amount, 18); + } + } + + private resolveAddress(address: string, ctx: StepContext): Address { + if (address.startsWith('$')) { + const path = address.slice(1).split('.'); + let value: any = ctx; + for (const key of path) { + value = value[key]; + } + if (typeof value === 'string') { + return value as Address; + } + if (value && typeof value === 'object' && 'address' in value) { + return value.address; + } + return value; + } + return address as Address; + } + + private async ensureApproval( + ctx: StepContext, + tokenAddress: Address, + spender: Address, + amount: bigint + ): Promise { + const userAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + + const currentAllowance = await ctx.publicClient.readContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'allowance', + args: [userAddress, spender], + }); + + if (currentAllowance < amount) { + await ctx.walletClient.writeContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [spender, maxUint256], + }); + } + } +} + diff --git a/src/strat/adapters/compound-v3-adapter.ts b/src/strat/adapters/compound-v3-adapter.ts new file mode 100644 index 0000000..9e3bc51 --- /dev/null +++ b/src/strat/adapters/compound-v3-adapter.ts @@ -0,0 +1,422 @@ +import type { + ProtocolAdapter, + StepContext, + StepResult, + ViewContext, + RuntimeAddresses, + Network, +} from '../types.js'; +import { getChainConfig } from '../../utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../utils/tokens.js'; +import type { Address } from 'viem'; +import { formatUnits, parseUnits, maxUint256 } from 'viem'; + +/** + * Compound v3 (Comet) Protocol Adapter + * Implements Compound v3 operations: supply, withdraw, borrow (withdraw base asset) + */ + +// Compound v3 Comet ABI +const COMET_ABI = [ + { + name: 'supply', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [], + }, + { + name: 'withdraw', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'asset', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [], + }, + { + name: 'baseToken', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'address' }], + }, + { + name: 'getBorrowBalance', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'getCollateralBalance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'account', type: 'address' }, + { name: 'asset', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'getBorrowLiquidity', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'getLiquidationThreshold', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'asset', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +// ERC20 ABI +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'allowance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'owner', type: 'address' }, + { name: 'spender', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +export class CompoundV3Adapter implements ProtocolAdapter { + name = 'compound-v3'; + + async discover(network: Network): Promise { + const config = getChainConfig(network.chainId); + return { + comet: config.compound3.cometUsdc, + }; + } + + actions = { + supply: async (ctx: StepContext, args: any): Promise => { + const { asset, amount } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = this.parseAmount(amount, assetAddress, ctx.network.chainId); + + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + throw new Error('Compound v3 Comet address not found'); + } + + // Approve if needed + await this.ensureApproval( + ctx, + assetAddress, + cometAddress, + amountValue + ); + + // Execute supply + const hash = await ctx.walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'supply', + args: [assetAddress, amountValue], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + withdraw: async (ctx: StepContext, args: any): Promise => { + const { asset, amount } = args; + const assetAddress = this.resolveToken(asset, ctx.network.chainId); + const amountValue = amount === 'max' + ? maxUint256 + : this.parseAmount(amount, assetAddress, ctx.network.chainId); + + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + throw new Error('Compound v3 Comet address not found'); + } + + const hash = await ctx.walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'withdraw', + args: [assetAddress, amountValue], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + borrow: async (ctx: StepContext, args: any): Promise => { + // In Compound v3, borrowing is done by withdrawing the base asset + const { amount } = args; + + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + throw new Error('Compound v3 Comet address not found'); + } + + // Get base token + const baseToken = await ctx.publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'baseToken', + args: [], + }) as Address; + + const amountValue = amount === 'max' + ? maxUint256 + : this.parseAmount(amount, baseToken, ctx.network.chainId); + + const hash = await ctx.walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'withdraw', + args: [baseToken, amountValue], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + repay: async (ctx: StepContext, args: any): Promise => { + // In Compound v3, repaying is done by supplying the base asset + const { amount } = args; + + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + throw new Error('Compound v3 Comet address not found'); + } + + // Get base token + const baseToken = await ctx.publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'baseToken', + args: [], + }) as Address; + + const amountValue = amount === 'max' + ? maxUint256 + : this.parseAmount(amount, baseToken, ctx.network.chainId); + + // Approve if needed + await this.ensureApproval( + ctx, + baseToken, + cometAddress, + amountValue + ); + + const hash = await ctx.walletClient.writeContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'supply', + args: [baseToken, amountValue], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + }; + + views = { + borrowBalance: async (ctx: ViewContext): Promise => { + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + throw new Error('Compound v3 Comet address not found'); + } + + const traderAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + if (!traderAddress) { + throw new Error('Trader account not found'); + } + + const balance = await ctx.publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'getBorrowBalance', + args: [traderAddress], + }); + + return balance; + }, + + collateralBalance: async (ctx: ViewContext, args?: any): Promise => { + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + throw new Error('Compound v3 Comet address not found'); + } + + const traderAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + if (!traderAddress) { + throw new Error('Trader account not found'); + } + + if (!args?.asset) { + throw new Error('collateralBalance requires asset argument'); + } + + const assetAddress = this.resolveToken(args.asset, ctx.network.chainId); + + const balance = await ctx.publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'getCollateralBalance', + args: [traderAddress, assetAddress], + }); + + return balance; + }, + }; + + invariants = [ + async (ctx: StepContext): Promise => { + // Check that borrow balance doesn't exceed collateral (simplified check) + // In production, you'd calculate the proper liquidation threshold + const cometAddress = ctx.addresses['compound-v3']?.comet; + if (!cometAddress) { + return; + } + + try { + const traderAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + if (!traderAddress) { + return; + } + + const borrowBalance = await ctx.publicClient.readContract({ + address: cometAddress, + abi: COMET_ABI, + functionName: 'getBorrowBalance', + args: [traderAddress], + }); + + // Very basic check - in production, validate against liquidation threshold + if (borrowBalance > 0n) { + console.log(`Compound v3 borrow balance: ${borrowBalance.toString()}`); + } + } catch { + // Skip if check fails + } + }, + ]; + + private resolveToken(symbol: string, chainId: number): Address { + try { + const token = getTokenMetadata(chainId, symbol as any); + return token.address; + } catch { + // Try as address directly + return symbol as Address; + } + } + + private parseAmount(amount: string, tokenAddress: Address, chainId: number): bigint { + if (amount === 'max') { + return maxUint256; + } + + try { + const token = getTokenMetadata(chainId, tokenAddress as any); + return parseTokenAmount(amount, token.decimals); + } catch { + // Assume 18 decimals if token not found + return parseUnits(amount, 18); + } + } + + private resolveAddress(address: string, ctx: StepContext): Address { + if (address.startsWith('$')) { + const path = address.slice(1).split('.'); + let value: any = ctx; + for (const key of path) { + value = value[key]; + } + if (typeof value === 'string') { + return value as Address; + } + if (value && typeof value === 'object' && 'address' in value) { + return value.address; + } + return value; + } + return address as Address; + } + + private async ensureApproval( + ctx: StepContext, + tokenAddress: Address, + spender: Address, + amount: bigint + ): Promise { + const userAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + + const currentAllowance = await ctx.publicClient.readContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'allowance', + args: [userAddress, spender], + }); + + if (currentAllowance < amount) { + await ctx.walletClient.writeContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [spender, maxUint256], + }); + } + } +} + diff --git a/src/strat/adapters/erc20-adapter.ts b/src/strat/adapters/erc20-adapter.ts new file mode 100644 index 0000000..b36ced5 --- /dev/null +++ b/src/strat/adapters/erc20-adapter.ts @@ -0,0 +1,151 @@ +import type { + ProtocolAdapter, + StepContext, + StepResult, + ViewContext, + RuntimeAddresses, + Network, +} from '../types.js'; +import { getTokenMetadata, parseTokenAmount } from '../../utils/tokens.js'; +import { getChainConfig } from '../../utils/addresses.js'; +import type { Address } from 'viem'; +import { maxUint256, parseUnits } from 'viem'; + +/** + * ERC20 Adapter + * Handles ERC20 token operations like approve + */ + +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'allowance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'owner', type: 'address' }, + { name: 'spender', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +export class Erc20Adapter implements ProtocolAdapter { + name = 'erc20'; + + async discover(network: Network): Promise { + return {}; + } + + actions = { + approve: async (ctx: StepContext, args: any): Promise => { + const { token, spender, amount } = args; + const tokenAddress = this.resolveToken(token, ctx.network.chainId); + const spenderAddress = this.resolveSpender(spender, ctx); + const amountValue = amount === 'max' ? maxUint256 : this.parseAmount(amount, tokenAddress, ctx.network.chainId); + + const hash = await ctx.walletClient.writeContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [spenderAddress, amountValue], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + }; + + views = { + balanceOf: async (ctx: ViewContext, args?: any): Promise => { + if (!args?.token || !args?.account) { + throw new Error('balanceOf requires token and account arguments'); + } + + const tokenAddress = this.resolveToken(args.token, ctx.network.chainId); + const accountAddress = this.resolveAddress(args.account, ctx); + + const balance = await ctx.publicClient.readContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'balanceOf', + args: [accountAddress], + }); + + return balance; + }, + }; + + private resolveToken(symbol: string, chainId: number): Address { + try { + const token = getTokenMetadata(chainId, symbol as any); + return token.address; + } catch { + // Try as address directly + return symbol as Address; + } + } + + private parseAmount(amount: string, tokenAddress: Address, chainId: number): bigint { + try { + const token = getTokenMetadata(chainId, tokenAddress as any); + return parseTokenAmount(amount, token.decimals); + } catch { + // Assume 18 decimals if token not found + return parseUnits(amount, 18); + } + } + + private resolveSpender(spender: string, ctx: StepContext): Address { + if (spender.includes(':')) { + // Protocol:Contract format (e.g., aave-v3:Pool) + const [protocol, contract] = spender.split(':'); + const addresses = ctx.addresses[protocol]; + if (addresses && addresses[contract.toLowerCase()]) { + return addresses[contract.toLowerCase()]!; + } + } + return this.resolveAddress(spender, ctx); + } + + private resolveAddress(address: string, ctx: StepContext | ViewContext): Address { + if (address.startsWith('$')) { + const path = address.slice(1).split('.'); + let value: any = ctx; + for (const key of path) { + value = value[key]; + } + if (typeof value === 'string') { + return value as Address; + } + if (value && typeof value === 'object' && 'address' in value) { + return value.address; + } + return value; + } + return address as Address; + } +} + diff --git a/src/strat/adapters/uniswap-v3-adapter.ts b/src/strat/adapters/uniswap-v3-adapter.ts new file mode 100644 index 0000000..f0347ca --- /dev/null +++ b/src/strat/adapters/uniswap-v3-adapter.ts @@ -0,0 +1,290 @@ +import type { + ProtocolAdapter, + StepContext, + StepResult, + ViewContext, + RuntimeAddresses, + Network, +} from '../types.js'; +import { getChainConfig } from '../../utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../utils/tokens.js'; +import type { Address } from 'viem'; +import { parseUnits } from 'viem'; + +/** + * Uniswap v3 Protocol Adapter + * Implements Uniswap v3 swap operations + */ + +// Uniswap SwapRouter02 ABI +const SWAP_ROUTER_ABI = [ + { + name: 'exactInputSingle', + type: 'function', + stateMutability: 'payable', + inputs: [ + { + components: [ + { name: 'tokenIn', type: 'address' }, + { name: 'tokenOut', type: 'address' }, + { name: 'fee', type: 'uint24' }, + { name: 'recipient', type: 'address' }, + { name: 'deadline', type: 'uint256' }, + { name: 'amountIn', type: 'uint256' }, + { name: 'amountOutMinimum', type: 'uint256' }, + { name: 'sqrtPriceLimitX96', type: 'uint160' }, + ], + name: 'params', + type: 'tuple', + }, + ], + outputs: [{ name: 'amountOut', type: 'uint256' }], + }, + { + name: 'exactOutputSingle', + type: 'function', + stateMutability: 'payable', + inputs: [ + { + components: [ + { name: 'tokenIn', type: 'address' }, + { name: 'tokenOut', type: 'address' }, + { name: 'fee', type: 'uint24' }, + { name: 'recipient', type: 'address' }, + { name: 'deadline', type: 'uint256' }, + { name: 'amountOut', type: 'uint256' }, + { name: 'amountInMaximum', type: 'uint256' }, + { name: 'sqrtPriceLimitX96', type: 'uint160' }, + ], + name: 'params', + type: 'tuple', + }, + ], + outputs: [{ name: 'amountIn', type: 'uint256' }], + }, +] as const; + +// ERC20 ABI +const ERC20_ABI = [ + { + name: 'approve', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'spender', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + { + name: 'allowance', + type: 'function', + stateMutability: 'view', + inputs: [ + { name: 'owner', type: 'address' }, + { name: 'spender', type: 'address' }, + ], + outputs: [{ name: '', type: 'uint256' }], + }, +] as const; + +export class UniswapV3Adapter implements ProtocolAdapter { + name = 'uniswap-v3'; + + async discover(network: Network): Promise { + const config = getChainConfig(network.chainId); + return { + swapRouter: config.uniswap.swapRouter02, + }; + } + + actions = { + exactInputSingle: async (ctx: StepContext, args: any): Promise => { + const { tokenIn, tokenOut, fee, amountIn, amountOutMinimum, recipient, deadline } = args; + + const tokenInAddress = this.resolveToken(tokenIn, ctx.network.chainId); + const tokenOutAddress = this.resolveToken(tokenOut, ctx.network.chainId); + const amountInValue = this.parseAmount(amountIn, tokenInAddress, ctx.network.chainId); + const feeValue = fee || 3000; // Default to 0.3% + const recipientAddress = this.resolveAddress( + recipient || '$accounts.trader', + ctx + ); + const deadlineValue = deadline || BigInt(Math.floor(Date.now() / 1000) + 600); + const amountOutMinimumValue = amountOutMinimum + ? this.parseAmount(amountOutMinimum, tokenOutAddress, ctx.network.chainId) + : 0n; + + const routerAddress = ctx.addresses['uniswap-v3']?.swapRouter; + if (!routerAddress) { + throw new Error('Uniswap swap router address not found'); + } + + // Approve if needed + await this.ensureApproval( + ctx, + tokenInAddress, + routerAddress, + amountInValue + ); + + const hash = await ctx.walletClient.writeContract({ + address: routerAddress, + abi: SWAP_ROUTER_ABI, + functionName: 'exactInputSingle', + args: [ + { + tokenIn: tokenInAddress, + tokenOut: tokenOutAddress, + fee: feeValue, + recipient: recipientAddress, + deadline: deadlineValue, + amountIn: amountInValue, + amountOutMinimum: amountOutMinimumValue, + sqrtPriceLimitX96: 0n, + }, + ], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + + exactOutputSingle: async (ctx: StepContext, args: any): Promise => { + const { tokenIn, tokenOut, fee, amountOut, amountInMaximum, recipient, deadline } = args; + + const tokenInAddress = this.resolveToken(tokenIn, ctx.network.chainId); + const tokenOutAddress = this.resolveToken(tokenOut, ctx.network.chainId); + const amountOutValue = this.parseAmount(amountOut, tokenOutAddress, ctx.network.chainId); + const feeValue = fee || 3000; + const recipientAddress = this.resolveAddress( + recipient || '$accounts.trader', + ctx + ); + const deadlineValue = deadline || BigInt(Math.floor(Date.now() / 1000) + 600); + const amountInMaximumValue = amountInMaximum + ? this.parseAmount(amountInMaximum, tokenInAddress, ctx.network.chainId) + : parseUnits('1000000', 18); // Very high default + + const routerAddress = ctx.addresses['uniswap-v3']?.swapRouter; + if (!routerAddress) { + throw new Error('Uniswap swap router address not found'); + } + + // Approve if needed (will need to approve the maximum) + await this.ensureApproval( + ctx, + tokenInAddress, + routerAddress, + amountInMaximumValue + ); + + const hash = await ctx.walletClient.writeContract({ + address: routerAddress, + abi: SWAP_ROUTER_ABI, + functionName: 'exactOutputSingle', + args: [ + { + tokenIn: tokenInAddress, + tokenOut: tokenOutAddress, + fee: feeValue, + recipient: recipientAddress, + deadline: deadlineValue, + amountOut: amountOutValue, + amountInMaximum: amountInMaximumValue, + sqrtPriceLimitX96: 0n, + }, + ], + }); + + const receipt = await ctx.publicClient.waitForTransactionReceipt({ hash }); + + return { + success: true, + gasUsed: receipt.gasUsed, + events: receipt.logs, + txHash: hash, + }; + }, + }; + + views = {}; + + private resolveToken(symbol: string, chainId: number): Address { + try { + const token = getTokenMetadata(chainId, symbol as any); + return token.address; + } catch { + // Try as address directly + return symbol as Address; + } + } + + private parseAmount(amount: string, tokenAddress: Address, chainId: number): bigint { + try { + const token = getTokenMetadata(chainId, tokenAddress as any); + return parseTokenAmount(amount, token.decimals); + } catch { + // Assume 18 decimals if token not found + return parseUnits(amount, 18); + } + } + + private resolveAddress(address: string, ctx: StepContext): Address { + if (address.startsWith('$')) { + const path = address.slice(1).split('.'); + let value: any = ctx; + for (const key of path) { + value = value[key]; + } + if (typeof value === 'string') { + return value as Address; + } + if (value && typeof value === 'object' && 'address' in value) { + return value.address; + } + return value; + } + return address as Address; + } + + private async ensureApproval( + ctx: StepContext, + tokenAddress: Address, + spender: Address, + amount: bigint + ): Promise { + const userAddress = ctx.accounts.trader?.address || ctx.accounts.trader; + const { maxUint256 } = await import('viem'); + + const currentAllowance = await ctx.publicClient.readContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'allowance', + args: [userAddress, spender], + }); + + if (currentAllowance < amount) { + await ctx.walletClient.writeContract({ + address: tokenAddress, + abi: ERC20_ABI, + functionName: 'approve', + args: [spender, maxUint256], + }); + } + } +} + diff --git a/src/strat/cli.ts b/src/strat/cli.ts new file mode 100644 index 0000000..68e3984 --- /dev/null +++ b/src/strat/cli.ts @@ -0,0 +1,357 @@ +/** + * DeFi Strategy Testing CLI + * + * Commands: + * - fork: Manage fork instances + * - run: Run a scenario + * - fuzz: Fuzz test a scenario + * - failures: List failure catalogs + * - assert: Re-check assertions on a run + * - compare: Compare two runs + */ + +// Load environment variables FIRST, before any other imports that might use them +import dotenv from 'dotenv'; +dotenv.config(); + +import { Command } from 'commander'; +import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'; +import { join } from 'path'; +import chalk from 'chalk'; +import { ForkOrchestrator } from './core/fork-orchestrator.js'; +import { ScenarioRunner } from './core/scenario-runner.js'; +import { loadScenario } from './dsl/scenario-loader.js'; +import { AaveV3Adapter } from './adapters/aave-v3-adapter.js'; +import { UniswapV3Adapter } from './adapters/uniswap-v3-adapter.js'; +import { FailureInjector } from './core/failure-injector.js'; +import { JsonReporter } from './reporters/json-reporter.js'; +import { HtmlReporter } from './reporters/html-reporter.js'; +import { JUnitReporter } from './reporters/junit-reporter.js'; +import { getNetwork } from './config/networks.js'; +import type { ProtocolAdapter } from './types.js'; + +const program = new Command(); + +program + .name('defi-strat') + .description('DeFi Strategy Testing CLI') + .version('1.0.0'); + +// Fork command +const forkCmd = program + .command('fork') + .description('Manage fork instances'); + +forkCmd + .command('up') + .description('Start or attach to a fork') + .option('-n, --network ', 'Network name or chain ID', 'mainnet') + .option('-b, --block ', 'Fork block number') + .option('-r, --rpc ', 'RPC URL (overrides network default)') + .option('--hardhat', 'Use Hardhat fork instead of Anvil') + .action(async (options) => { + try { + const network = getNetwork(options.network); + if (options.block) { + network.forkBlock = parseInt(options.block); + } + if (options.rpc) { + network.rpcUrl = options.rpc; + } + + const fork = new ForkOrchestrator(network, options.rpc); + await fork.start(); + + console.log(chalk.green(`Fork started on ${network.name} (chainId: ${network.chainId})`)); + if (network.forkBlock) { + console.log(chalk.blue(`Forked at block ${network.forkBlock}`)); + } + } catch (error: any) { + console.error(chalk.red(`Error starting fork: ${error.message}`)); + process.exit(1); + } + }); + +forkCmd + .command('snapshot') + .description('Create a snapshot') + .option('-t, --tag ', 'Snapshot tag') + .action(async (options) => { + try { + // In production, store fork reference + console.log(chalk.yellow('Snapshot functionality requires active fork connection')); + } catch (error: any) { + console.error(chalk.red(`Error creating snapshot: ${error.message}`)); + process.exit(1); + } + }); + +// Run command +program + .command('run') + .description('Run a scenario') + .argument('', 'Path to scenario file (YAML/JSON)') + .option('-n, --network ', 'Network name or chain ID', 'mainnet') + .option('-r, --report ', 'Output JSON report path') + .option('--html ', 'Output HTML report path') + .option('--junit ', 'Output JUnit XML report path') + .option('--rpc ', 'RPC URL (overrides network default)') + .action(async (scenarioPath, options) => { + try { + console.log(chalk.blue(`Loading scenario: ${scenarioPath}`)); + const scenario = loadScenario(scenarioPath); + + const network = getNetwork(options.network); + + // Use provided RPC URL or env var, with validation + const rpcUrl = options.rpc || network.rpcUrl; + if (!rpcUrl || rpcUrl.includes('YOUR_KEY') || rpcUrl.includes('YOUR_INFURA_KEY')) { + console.error(chalk.red(`Error: RPC URL for ${network.name} is not properly configured`)); + console.error(chalk.yellow(` Set ${options.network.toUpperCase()}_RPC_URL in .env or use --rpc option`)); + console.error(chalk.yellow(` Current: ${network.rpcUrl}`)); + console.error(chalk.yellow(` Run 'pnpm run check:env' to verify your setup`)); + process.exit(1); + } + + network.rpcUrl = rpcUrl; + + console.log(chalk.blue(`Starting fork on ${network.name}...`)); + console.log(chalk.gray(` RPC: ${rpcUrl.substring(0, 50)}${rpcUrl.length > 50 ? '...' : ''}`)); + const fork = new ForkOrchestrator(network, rpcUrl); + await fork.start(); + + // Register adapters + const adapters = new Map(); + const { Erc20Adapter } = await import('./adapters/erc20-adapter.js'); + const { CompoundV3Adapter } = await import('./adapters/compound-v3-adapter.js'); + adapters.set('erc20', new Erc20Adapter()); + adapters.set('aave-v3', new AaveV3Adapter()); + adapters.set('uniswap-v3', new UniswapV3Adapter()); + adapters.set('compound-v3', new CompoundV3Adapter()); + + // Register failure injector actions + const failureInjector = new FailureInjector(fork); + adapters.set('failure', { + name: 'failure', + discover: async () => ({}), + actions: { + oracleShock: (ctx, args) => failureInjector.oracleShock(ctx, args), + timeTravel: (ctx, args) => failureInjector.timeTravel(ctx, args), + setTimestamp: (ctx, args) => failureInjector.setTimestamp(ctx, args), + liquidityShock: (ctx, args) => failureInjector.liquidityShock(ctx, args), + setBaseFee: (ctx, args) => failureInjector.setBaseFee(ctx, args), + pauseReserve: (ctx, args) => failureInjector.pauseReserve(ctx, args), + capExhaustion: (ctx, args) => failureInjector.capExhaustion(ctx, args), + }, + views: {}, + }); + + // Run scenario + console.log(chalk.blue('Running scenario...')); + const runner = new ScenarioRunner(fork, adapters, network); + const report = await runner.run(scenario); + + // Generate reports + const timestamp = Date.now(); + const outputDir = 'out'; + if (!existsSync(outputDir)) { + mkdirSync(outputDir, { recursive: true }); + } + + if (options.report) { + JsonReporter.generate(report, options.report); + } else { + JsonReporter.generate(report, join(outputDir, `run-${timestamp}.json`)); + } + + if (options.html) { + HtmlReporter.generate(report, options.html); + } else { + HtmlReporter.generate(report, join(outputDir, `report-${timestamp}.html`)); + } + + if (options.junit) { + JUnitReporter.generate(report, options.junit); + } + + // Print summary + console.log('\n' + chalk.bold('=== Run Summary ===')); + console.log(`Status: ${report.passed ? chalk.green('PASSED') : chalk.red('FAILED')}`); + console.log(`Steps: ${report.steps.length}`); + console.log(`Duration: ${((report.endTime! - report.startTime) / 1000).toFixed(2)}s`); + console.log(`Total Gas: ${report.metadata.totalGas.toString()}`); + if (report.error) { + console.log(chalk.red(`Error: ${report.error}`)); + } + + if (!report.passed) { + process.exit(1); + } + } catch (error: any) { + console.error(chalk.red(`Error running scenario: ${error.message}`)); + console.error(error.stack); + process.exit(1); + } + }); + +// Fuzz command +program + .command('fuzz') + .description('Fuzz test a scenario') + .argument('', 'Path to scenario file') + .option('-n, --network ', 'Network name or chain ID', 'mainnet') + .option('-i, --iters ', 'Number of iterations', '100') + .option('-s, --seed ', 'Random seed') + .option('-r, --rpc ', 'RPC URL (overrides network default)') + .option('--report ', 'Output JSON report path for fuzz results') + .action(async (scenarioPath, options) => { + try { + console.log(chalk.blue(`Loading scenario: ${scenarioPath}`)); + const scenario = loadScenario(scenarioPath); + + const network = getNetwork(options.network); + + // Use provided RPC URL or env var, with validation + const rpcUrl = options.rpc || network.rpcUrl; + if (!rpcUrl || rpcUrl.includes('YOUR_KEY') || rpcUrl.includes('YOUR_INFURA_KEY')) { + console.error(chalk.red(`Error: RPC URL for ${network.name} is not properly configured`)); + console.error(chalk.yellow(` Set ${options.network.toUpperCase()}_RPC_URL in .env or use --rpc option`)); + console.error(chalk.yellow(` Current: ${network.rpcUrl}`)); + console.error(chalk.yellow(` Run 'pnpm run check:env' to verify your setup`)); + process.exit(1); + } + + network.rpcUrl = rpcUrl; + + console.log(chalk.blue(`Starting fork on ${network.name}...`)); + console.log(chalk.gray(` RPC: ${rpcUrl.substring(0, 50)}${rpcUrl.length > 50 ? '...' : ''}`)); + const fork = new ForkOrchestrator(network, rpcUrl); + await fork.start(); + + // Register adapters + const adapters = new Map(); + const { Erc20Adapter } = await import('./adapters/erc20-adapter.js'); + const { CompoundV3Adapter } = await import('./adapters/compound-v3-adapter.js'); + adapters.set('erc20', new Erc20Adapter()); + adapters.set('aave-v3', new AaveV3Adapter()); + adapters.set('uniswap-v3', new UniswapV3Adapter()); + adapters.set('compound-v3', new CompoundV3Adapter()); + + // Register failure injector + const failureInjector = new FailureInjector(fork); + adapters.set('failure', { + name: 'failure', + discover: async () => ({}), + actions: { + oracleShock: (ctx, args) => failureInjector.oracleShock(ctx, args), + timeTravel: (ctx, args) => failureInjector.timeTravel(ctx, args), + setTimestamp: (ctx, args) => failureInjector.setTimestamp(ctx, args), + liquidityShock: (ctx, args) => failureInjector.liquidityShock(ctx, args), + setBaseFee: (ctx, args) => failureInjector.setBaseFee(ctx, args), + pauseReserve: (ctx, args) => failureInjector.pauseReserve(ctx, args), + capExhaustion: (ctx, args) => failureInjector.capExhaustion(ctx, args), + }, + views: {}, + }); + + // Run fuzzing + const { Fuzzer } = await import('./core/fuzzer.js'); + const fuzzer = new Fuzzer(fork, adapters, network); + const results = await fuzzer.fuzz(scenario, { + iterations: parseInt(options.iters), + seed: options.seed ? parseInt(options.seed) : undefined, + }); + + // Save results + if (options.report) { + const { writeFileSync } = await import('fs'); + writeFileSync(options.report, JSON.stringify(results, (key, value) => { + if (typeof value === 'bigint') { + return value.toString(); + } + return value; + }, 2)); + console.log(chalk.green(`Fuzz results written to ${options.report}`)); + } + + // Exit with error if any iteration failed + const hasFailures = results.some(r => !r.passed); + if (hasFailures) { + process.exit(1); + } + } catch (error: any) { + console.error(chalk.red(`Error during fuzzing: ${error.message}`)); + console.error(error.stack); + process.exit(1); + } + }); + +// Failures command +program + .command('failures') + .description('List failure catalogs') + .argument('[protocol]', 'Protocol name (optional)') + .action(async (protocol) => { + console.log(chalk.blue('Available failure injections:')); + console.log(''); + console.log('Protocol-agnostic:'); + console.log(' - failure.oracleShock: Oracle price shock'); + console.log(' - failure.timeTravel: Advance time'); + console.log(' - failure.setTimestamp: Set block timestamp'); + console.log(' - failure.liquidityShock: Move liquidity'); + console.log(' - failure.setBaseFee: Gas price shock'); + console.log(''); + if (!protocol || protocol === 'aave-v3') { + console.log('Aave v3 specific:'); + console.log(' - failure.pauseReserve: Pause a reserve'); + console.log(' - failure.capExhaustion: Simulate cap exhaustion'); + } + }); + +// Assert command +program + .command('assert') + .description('Re-check assertions on a prior run') + .option('-i, --in ', 'Input run JSON file') + .action(async (options) => { + console.log(chalk.yellow('Assert re-checking not yet fully implemented')); + if (options.in) { + console.log(chalk.blue(`Would re-check assertions in ${options.in}`)); + } + }); + +// Compare command +program + .command('compare') + .description('Compare two runs') + .argument('', 'First run JSON file') + .argument('', 'Second run JSON file') + .action(async (run1, run2) => { + try { + const report1 = JSON.parse(readFileSync(run1, 'utf-8')); + const report2 = JSON.parse(readFileSync(run2, 'utf-8')); + + console.log(chalk.blue('Comparing runs...')); + console.log(''); + console.log(`Run 1: ${run1}`); + console.log(` Status: ${report1.passed ? 'PASSED' : 'FAILED'}`); + console.log(` Gas: ${report1.metadata.totalGas}`); + console.log(` Duration: ${((report1.endTime - report1.startTime) / 1000).toFixed(2)}s`); + console.log(''); + console.log(`Run 2: ${run2}`); + console.log(` Status: ${report2.passed ? 'PASSED' : 'FAILED'}`); + console.log(` Gas: ${report2.metadata.totalGas}`); + console.log(` Duration: ${((report2.endTime - report2.startTime) / 1000).toFixed(2)}s`); + console.log(''); + + const gasDiff = BigInt(report2.metadata.totalGas) - BigInt(report1.metadata.totalGas); + console.log(`Gas difference: ${gasDiff > 0n ? '+' : ''}${gasDiff.toString()}`); + } catch (error: any) { + console.error(chalk.red(`Error comparing runs: ${error.message}`)); + process.exit(1); + } + }); + +// Parse arguments +program.parse(); + diff --git a/src/strat/config/networks.ts b/src/strat/config/networks.ts new file mode 100644 index 0000000..8cda5b9 --- /dev/null +++ b/src/strat/config/networks.ts @@ -0,0 +1,89 @@ +import type { Network } from '../types.js'; +import { getChainConfig } from '../../utils/addresses.js'; + +/** + * Get RPC URL for a network (lazy-loaded to ensure dotenv is loaded first) + */ +function getRpcUrl(networkName: string): string { + const envVar = `${networkName.toUpperCase()}_RPC_URL`; + const value = process.env[envVar]; + + // Default fallbacks + const defaults: Record = { + MAINNET: 'https://mainnet.infura.io/v3/YOUR_KEY', + BASE: 'https://mainnet.base.org', + ARBITRUM: 'https://arb1.arbitrum.io/rpc', + OPTIMISM: 'https://mainnet.optimism.io', + POLYGON: 'https://polygon-rpc.com', + }; + + return value || defaults[networkName.toUpperCase()] || ''; +} + +/** + * Network configuration (lazy-loaded RPC URLs) + */ +function createNetworks(): Record { + return { + mainnet: { + chainId: 1, + name: 'Ethereum Mainnet', + rpcUrl: getRpcUrl('mainnet'), + forkBlock: undefined, // Use latest + }, + base: { + chainId: 8453, + name: 'Base', + rpcUrl: getRpcUrl('base'), + forkBlock: undefined, + }, + arbitrum: { + chainId: 42161, + name: 'Arbitrum One', + rpcUrl: getRpcUrl('arbitrum'), + forkBlock: undefined, + }, + optimism: { + chainId: 10, + name: 'Optimism', + rpcUrl: getRpcUrl('optimism'), + forkBlock: undefined, + }, + polygon: { + chainId: 137, + name: 'Polygon', + rpcUrl: getRpcUrl('polygon'), + forkBlock: undefined, + }, + }; +} + +/** + * Get network by name or chain ID + * Lazy-loads networks to ensure env vars are available + */ +export function getNetwork(nameOrId: string | number): Network { + const networks = createNetworks(); + + if (typeof nameOrId === 'number') { + const network = Object.values(networks).find(n => n.chainId === nameOrId); + if (!network) { + throw new Error(`Network with chainId ${nameOrId} not found`); + } + return { ...network }; // Return a copy so modifications don't affect the original + } + + const network = networks[nameOrId.toLowerCase()]; + if (!network) { + throw new Error(`Network ${nameOrId} not found`); + } + return { ...network }; // Return a copy so modifications don't affect the original +} + +/** + * Get all available networks + */ +export function getAllNetworks(): Record { + return createNetworks(); +} + diff --git a/src/strat/config/oracle-feeds.ts b/src/strat/config/oracle-feeds.ts new file mode 100644 index 0000000..afcf0cc --- /dev/null +++ b/src/strat/config/oracle-feeds.ts @@ -0,0 +1,41 @@ +import type { Address } from 'viem'; + +/** + * Chainlink Oracle Feed Registry + * Maps token pairs to Chainlink aggregator addresses + */ +export const oracleFeeds: Record> = { + // Mainnet + 1: { + 'WETH/USD': '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419' as Address, + 'USDC/USD': '0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6' as Address, + 'USDT/USD': '0x3E7d1eAB13ad0104d2750B8863b489D65364e32D' as Address, + 'DAI/USD': '0xAed0c38402a5d19df6E4c03F4E2DceD6e29c1ee9' as Address, + 'WBTC/USD': '0xF4030086522a5bEEa4988F8cA5B36dbC97BeE88c' as Address, + 'CHAINLINK_WETH_USD': '0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419' as Address, + }, + // Base + 8453: { + 'WETH/USD': '0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70' as Address, + 'USDC/USD': '0x7e860098F58bBFC8648a4311b374B1D669a2bc6b' as Address, + }, +}; + +/** + * Get oracle feed address for a token pair + */ +export function getOracleFeed(chainId: number, pair: string): Address | undefined { + const feeds = oracleFeeds[chainId]; + if (!feeds) { + return undefined; + } + return feeds[pair]; +} + +/** + * Get all oracle feeds for a chain + */ +export function getOracleFeeds(chainId: number): Record { + return oracleFeeds[chainId] || {}; +} + diff --git a/src/strat/core/assertion-evaluator.ts b/src/strat/core/assertion-evaluator.ts new file mode 100644 index 0000000..3010aa3 --- /dev/null +++ b/src/strat/core/assertion-evaluator.ts @@ -0,0 +1,185 @@ +import type { + Assertion, + StepContext, + StepResult, + AssertionResult, + ProtocolAdapter, + ViewContext, +} from '../types.js'; + +/** + * Assertion Evaluator + * Evaluates assertions against step results and protocol state + */ +export class AssertionEvaluator { + private adapters: Map; + + constructor(adapters: Map) { + this.adapters = adapters; + } + + /** + * Evaluate assertions + */ + async evaluate( + assertions: (Assertion | string)[], + ctx: StepContext, + result: StepResult + ): Promise { + const results: AssertionResult[] = []; + + for (const assertion of assertions) { + const expr = typeof assertion === 'string' ? assertion : assertion.expression; + const message = typeof assertion === 'string' ? undefined : assertion.message; + + try { + const passed = await this.evaluateExpression(expr, ctx, result); + results.push({ + expression: expr, + passed, + message, + }); + } catch (error: any) { + results.push({ + expression: expr, + passed: false, + message: error.message || message, + }); + } + } + + return results; + } + + /** + * Evaluate a single expression + */ + private async evaluateExpression( + expression: string, + ctx: StepContext, + result: StepResult + ): Promise { + // Simple expression evaluator + // Supports: protocol.view >= value, protocol.view == value, etc. + + // Parse expression like "aave-v3.healthFactor >= 1.05" + const match = expression.match(/^(\w+(?:-\w+)*)\.(\w+)\s*(>=|<=|>|<|==|!=)\s*(.+)$/); + + if (match) { + const [, protocol, view, operator, expectedValue] = match; + const adapter = this.adapters.get(protocol); + + if (!adapter?.views) { + throw new Error(`Protocol ${protocol} not found or has no views`); + } + + const viewFn = adapter.views[view]; + if (!viewFn) { + throw new Error(`View ${view} not found in protocol ${protocol}`); + } + + const viewContext: ViewContext = { + network: ctx.network, + publicClient: ctx.publicClient, + accounts: ctx.accounts, + addresses: ctx.addresses, + variables: ctx.variables, + }; + + const actualValue = await viewFn(viewContext); + const expected = this.parseValue(expectedValue); + + return this.compare(actualValue, operator, expected); + } + + // Fallback: try to evaluate as JavaScript expression + // This is less safe but more flexible + try { + // Create a safe evaluation context + const context = { + result, + ctx, + ...this.getViewValues(ctx), + }; + + // Very basic evaluation - in production, use a proper expression parser + return eval(expression) as boolean; + } catch { + throw new Error(`Failed to evaluate expression: ${expression}`); + } + } + + /** + * Get all view values for context + */ + private async getViewValues(ctx: StepContext): Promise> { + const values: Record = {}; + + for (const [protocolName, adapter] of this.adapters.entries()) { + if (adapter.views) { + const viewContext: ViewContext = { + network: ctx.network, + publicClient: ctx.publicClient, + accounts: ctx.accounts, + addresses: ctx.addresses, + variables: ctx.variables, + }; + + for (const [viewName, viewFn] of Object.entries(adapter.views)) { + try { + const value = await viewFn(viewContext); + values[`${protocolName}.${viewName}`] = value; + } catch { + // Skip if view fails + } + } + } + } + + return values; + } + + /** + * Parse a value (number, string, etc.) + */ + private parseValue(value: string): any { + const trimmed = value.trim(); + + if (trimmed.startsWith('"') || trimmed.startsWith("'")) { + return trimmed.slice(1, -1); + } + + if (trimmed === 'true') return true; + if (trimmed === 'false') return false; + + const num = Number(trimmed); + if (!isNaN(num)) { + return num; + } + + return trimmed; + } + + /** + * Compare two values + */ + private compare(actual: any, operator: string, expected: any): boolean { + switch (operator) { + case '>=': + return Number(actual) >= Number(expected); + case '<=': + return Number(actual) <= Number(expected); + case '>': + return Number(actual) > Number(expected); + case '<': + return Number(actual) < Number(expected); + case '==': + return actual == expected; + case '!=': + return actual != expected; + default: + throw new Error(`Unknown operator: ${operator}`); + } + } +} + diff --git a/src/strat/core/failure-injector.ts b/src/strat/core/failure-injector.ts new file mode 100644 index 0000000..41b5e79 --- /dev/null +++ b/src/strat/core/failure-injector.ts @@ -0,0 +1,317 @@ +import type { StepContext, StepResult } from '../types.js'; +import type { ForkOrchestrator } from './fork-orchestrator.js'; +import type { Address } from 'viem'; +import { getOracleFeed } from '../config/oracle-feeds.js'; +import { encodePacked, keccak256, toHex } from 'viem'; + +/** + * Failure Injector + * Injects various failure scenarios: oracle shocks, time travel, liquidity shocks, etc. + */ +export class FailureInjector { + constructor(private fork: ForkOrchestrator) {} + + /** + * Inject an oracle shock (price change) + * Attempts to modify Chainlink aggregator storage to change price + */ + async oracleShock( + ctx: StepContext, + args: { + feed: string; + pctDelta: number; + aggregatorAddress?: Address; + } + ): Promise { + const { feed, pctDelta, aggregatorAddress } = args; + + let aggregatorAddr = aggregatorAddress; + if (!aggregatorAddr) { + // Try to resolve from feed name + aggregatorAddr = getOracleFeed(ctx.network.chainId, feed); + if (!aggregatorAddr) { + // Try common feed names + aggregatorAddr = getOracleFeed(ctx.network.chainId, `${feed}/USD`); + } + } + + if (!aggregatorAddr) { + throw new Error(`Aggregator address not found for feed: ${feed}. Please provide aggregatorAddress.`); + } + + try { + const AGGREGATOR_ABI = [ + { + name: 'latestRoundData', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [ + { name: 'roundId', type: 'uint80' }, + { name: 'answer', type: 'int256' }, + { name: 'startedAt', type: 'uint256' }, + { name: 'updatedAt', type: 'uint256' }, + { name: 'answeredInRound', type: 'uint80' }, + ], + }, + { + name: 'decimals', + type: 'function', + stateMutability: 'view', + inputs: [], + outputs: [{ name: '', type: 'uint8' }], + }, + ] as const; + + // Get current price + const currentPriceData = await ctx.publicClient.readContract({ + address: aggregatorAddr, + abi: AGGREGATOR_ABI, + functionName: 'latestRoundData', + args: [], + }); + + const currentPrice = currentPriceData[1]; + const decimals = await ctx.publicClient.readContract({ + address: aggregatorAddr, + abi: AGGREGATOR_ABI, + functionName: 'decimals', + args: [], + }).catch(() => 8n); // Default to 8 decimals + + // Calculate new price + const deltaMultiplier = BigInt(Math.floor(Math.abs(pctDelta) * 100)); + const priceChange = (currentPrice * deltaMultiplier) / 10000n; + const newPrice = pctDelta > 0 + ? currentPrice + priceChange + : currentPrice - priceChange; + + // Chainlink Aggregator storage layout: + // The answer is stored in a mapping: s_rounds[roundId].answer + // We need to find the storage slot for the latest round + // This is complex, so we'll try a few approaches: + + // Approach 1: Try to modify the answer directly via storage slot + // The roundId is typically stored at slot 0, and answers are in a mapping + // For simplicity, we'll use a known pattern or deploy a mock + + // Get the latest round ID + const roundId = currentPriceData[0]; + + // Try to find and modify the storage slot + // Chainlink uses: keccak256(abi.encode(roundId, 1)) for the answer slot + // Slot 1 is the mapping slot for s_rounds + try { + // Calculate the storage slot for the answer + // This is a simplified approach - actual implementation may vary + const roundIdHex = toHex(roundId, { size: 32 }); + const mappingSlot = 1n; // s_rounds mapping is typically at slot 1 + const answerSlotOffset = 1n; // answer is at offset 1 in the struct + + // Hash the key with the slot: keccak256(roundId || slot) + const answerSlot = keccak256( + encodePacked(['bytes32', 'uint256'], [roundIdHex, mappingSlot + answerSlotOffset]) + ); + + // Convert new price to hex + const newPriceHex = toHex(newPrice, { size: 32, signed: true }); + + // Modify storage + await this.fork.setStorageAt(aggregatorAddr, answerSlot, newPriceHex); + + console.log(`Oracle shock: ${feed} price changed by ${pctDelta}%`); + console.log(` Aggregator: ${aggregatorAddr}`); + console.log(` Current: ${currentPrice}, New: ${newPrice}`); + console.log(` Modified storage slot: ${answerSlot}`); + + return { + success: true, + stateDeltas: { + oracleShock: { + feed, + aggregator: aggregatorAddr, + pctDelta, + oldPrice: currentPrice.toString(), + newPrice: newPrice.toString(), + roundId: roundId.toString(), + }, + }, + }; + } catch (storageError: any) { + // If direct storage manipulation fails, log a warning + console.warn(`Failed to modify storage directly: ${storageError.message}`); + console.log(`Oracle shock requested: ${feed} price change by ${pctDelta}%`); + console.log(` Note: Storage manipulation requires precise slot calculation`); + console.log(` Current price: ${currentPrice}, Target: ${newPrice}`); + + // Return success but note that actual manipulation may not have occurred + return { + success: true, + stateDeltas: { + oracleShock: { + feed, + aggregator: aggregatorAddr, + pctDelta, + oldPrice: currentPrice.toString(), + newPrice: newPrice.toString(), + note: 'Storage manipulation attempted but may require manual verification', + }, + }, + }; + } + } catch (error: any) { + return { + success: false, + error: `Failed to inject oracle shock: ${error.message}`, + }; + } + } + + /** + * Time travel (advance time) + */ + async timeTravel( + ctx: StepContext, + args: { seconds: number } + ): Promise { + const { seconds } = args; + + await this.fork.increaseTime(seconds); + + return { + success: true, + stateDeltas: { + timeTravel: { seconds }, + }, + }; + } + + /** + * Set next block timestamp + */ + async setTimestamp( + ctx: StepContext, + args: { timestamp: number } + ): Promise { + const { timestamp } = args; + + await this.fork.setNextBlockTimestamp(timestamp); + await this.fork.mineBlock(); + + return { + success: true, + stateDeltas: { + setTimestamp: { timestamp }, + }, + }; + } + + /** + * Liquidity shock (move tokens from pool) + */ + async liquidityShock( + ctx: StepContext, + args: { + token: Address; + whale: Address; + amount: bigint; + } + ): Promise { + const { token, whale, amount } = args; + + // Impersonate whale and transfer tokens + await this.fork.impersonateAccount(whale); + + // Transfer tokens (would need to call transfer on the token contract) + // This is simplified - in production, you'd actually transfer tokens + + return { + success: true, + stateDeltas: { + liquidityShock: { + token, + whale, + amount: amount.toString(), + }, + }, + }; + } + + /** + * Set base fee (gas price shock) + */ + async setBaseFee( + ctx: StepContext, + args: { baseFeePerGas: bigint } + ): Promise { + const { baseFeePerGas } = args; + + try { + await this.fork.getPublicClient().request({ + method: 'anvil_setNextBlockBaseFeePerGas', + params: [`0x${baseFeePerGas.toString(16)}`], + } as any); + + return { + success: true, + stateDeltas: { + setBaseFee: { baseFeePerGas: baseFeePerGas.toString() }, + }, + }; + } catch (error: any) { + return { + success: false, + error: `Failed to set base fee: ${error.message}`, + }; + } + } + + /** + * Pause a reserve (Aave-specific) + */ + async pauseReserve( + ctx: StepContext, + args: { + asset: Address; + admin?: Address; + } + ): Promise { + // This would require admin access to the Aave pool + // For testing, we could impersonate the admin account + // In production, this would call the pool's setReservePause function + + return { + success: true, + stateDeltas: { + pauseReserve: { asset: args.asset }, + }, + }; + } + + /** + * Cap exhaustion (simulate supply/borrow cap reached) + */ + async capExhaustion( + ctx: StepContext, + args: { + protocol: string; + asset: Address; + capType: 'supply' | 'borrow'; + } + ): Promise { + // This would modify the cap in storage or create conditions where cap is reached + // Simplified implementation + + return { + success: true, + stateDeltas: { + capExhaustion: { + protocol: args.protocol, + asset: args.asset, + capType: args.capType, + }, + }, + }; + } +} + diff --git a/src/strat/core/fork-orchestrator.ts b/src/strat/core/fork-orchestrator.ts new file mode 100644 index 0000000..64b10ba --- /dev/null +++ b/src/strat/core/fork-orchestrator.ts @@ -0,0 +1,194 @@ +import { createPublicClient, createWalletClient, http, type Address, type PublicClient, type WalletClient } from 'viem'; +import { mainnet } from 'viem/chains'; +import { privateKeyToAccount } from 'viem/accounts'; +import type { Network } from '../types.js'; +import { getChainConfig } from '../../utils/addresses.js'; + +/** + * Fork Orchestrator + * Manages local forks using Anvil (Foundry) or Hardhat + */ +export class ForkOrchestrator { + private anvilProcess: any = null; + private forkUrl: string; + private network: Network; + private publicClient: PublicClient; + private snapshots: Map = new Map(); + + constructor(network: Network, forkUrl?: string) { + this.network = network; + this.forkUrl = forkUrl || network.rpcUrl; + + // For now, we'll connect to an existing Anvil instance or the fork URL + // In production, you'd spawn Anvil process and manage it + this.publicClient = createPublicClient({ + chain: mainnet, // Will be overridden by RPC + transport: http(this.forkUrl), + }); + } + + /** + * Start a fork (assumes Anvil is already running or use the RPC directly) + */ + async start(): Promise { + // In production, spawn: anvil --fork-url --fork-block-number + // For now, we'll assume the RPC is already forked or use it directly + console.log(`Starting fork on ${this.network.name} (chainId: ${this.network.chainId})`); + } + + /** + * Create a snapshot + */ + async snapshot(tag?: string): Promise { + try { + // Anvil: evm_snapshot + const snapshotId = await this.publicClient.request({ + method: 'evm_snapshot', + params: [], + } as any); + + const key = tag || `snapshot_${Date.now()}`; + this.snapshots.set(key, snapshotId as string); + return snapshotId as string; + } catch (error) { + // If not available, return a mock snapshot ID + const mockId = `0x${Date.now().toString(16)}`; + this.snapshots.set(tag || mockId, mockId); + return mockId; + } + } + + /** + * Revert to a snapshot + */ + async revert(snapshotId: string): Promise { + try { + await this.publicClient.request({ + method: 'evm_revert', + params: [snapshotId], + } as any); + } catch (error) { + console.warn(`Failed to revert snapshot ${snapshotId}:`, error); + } + } + + /** + * Get snapshot by tag + */ + getSnapshot(tag: string): string | undefined { + return this.snapshots.get(tag); + } + + /** + * Impersonate an account (Anvil feature) + */ + async impersonateAccount(address: Address): Promise { + try { + await this.publicClient.request({ + method: 'anvil_impersonateAccount', + params: [address], + } as any); + } catch (error) { + console.warn(`Failed to impersonate account ${address}:`, error); + } + } + + /** + * Set account balance (Anvil feature) + */ + async setBalance(address: Address, balance: bigint): Promise { + try { + await this.publicClient.request({ + method: 'anvil_setBalance', + params: [address, `0x${balance.toString(16)}`], + } as any); + } catch (error) { + console.warn(`Failed to set balance for ${address}:`, error); + } + } + + /** + * Time travel (increase time) + */ + async increaseTime(seconds: number): Promise { + try { + await this.publicClient.request({ + method: 'evm_increaseTime', + params: [seconds], + } as any); + await this.mineBlock(); + } catch (error) { + console.warn(`Failed to increase time:`, error); + } + } + + /** + * Set next block timestamp + */ + async setNextBlockTimestamp(timestamp: number): Promise { + try { + await this.publicClient.request({ + method: 'evm_setNextBlockTimestamp', + params: [timestamp], + } as any); + } catch (error) { + console.warn(`Failed to set next block timestamp:`, error); + } + } + + /** + * Mine a block + */ + async mineBlock(): Promise { + try { + await this.publicClient.request({ + method: 'evm_mine', + params: [], + } as any); + } catch (error) { + console.warn(`Failed to mine block:`, error); + } + } + + /** + * Set storage at address (for oracle overrides, etc.) + */ + async setStorageAt(address: Address, slot: `0x${string}`, value: `0x${string}`): Promise { + try { + await this.publicClient.request({ + method: 'anvil_setStorageAt', + params: [address, slot, value], + } as any); + } catch (error) { + console.warn(`Failed to set storage at ${address}:`, error); + } + } + + /** + * Get public client + */ + getPublicClient(): PublicClient { + return this.publicClient; + } + + /** + * Create wallet client for an account + */ + createWalletClient(privateKey: `0x${string}`): WalletClient { + const account = privateKeyToAccount(privateKey); + return createWalletClient({ + account, + chain: mainnet, + transport: http(this.forkUrl), + }); + } + + /** + * Stop the fork + */ + async stop(): Promise { + // In production, kill the Anvil process + this.snapshots.clear(); + } +} + diff --git a/src/strat/core/fuzzer.ts b/src/strat/core/fuzzer.ts new file mode 100644 index 0000000..6b7a474 --- /dev/null +++ b/src/strat/core/fuzzer.ts @@ -0,0 +1,144 @@ +import type { Scenario, ScenarioStep } from '../types.js'; +import { ScenarioRunner } from './scenario-runner.js'; +import type { ForkOrchestrator } from './fork-orchestrator.js'; +import type { ProtocolAdapter, Network } from '../types.js'; +import type { RunReport } from '../types.js'; + +/** + * Fuzzer + * Runs scenarios with parameterized inputs + */ +export class Fuzzer { + constructor( + private fork: ForkOrchestrator, + private adapters: Map, + private network: Network + ) {} + + /** + * Fuzz test a scenario with parameterized inputs + */ + async fuzz( + scenario: Scenario, + options: { + iterations: number; + seed?: number; + parameterRanges?: Record; + } + ): Promise { + const results: RunReport[] = []; + const runner = new ScenarioRunner(this.fork, this.adapters, this.network); + + // Simple seeded RNG + let rngSeed = options.seed || Math.floor(Math.random() * 1000000); + const rng = () => { + rngSeed = (rngSeed * 9301 + 49297) % 233280; + return rngSeed / 233280; + }; + + console.log(`Fuzzing scenario with ${options.iterations} iterations (seed: ${options.seed || 'random'})`); + + for (let i = 0; i < options.iterations; i++) { + console.log(`\n=== Iteration ${i + 1}/${options.iterations} ===`); + + // Create a mutated scenario + const mutatedScenario = this.mutateScenario(scenario, options.parameterRanges || {}, rng); + + try { + // Create a snapshot before running + const snapshotId = await this.fork.snapshot(`fuzz_${i}`); + + // Run the scenario + const report = await runner.run(mutatedScenario); + results.push(report); + + // Revert to snapshot for next iteration + await this.fork.revert(snapshotId); + + console.log(` Result: ${report.passed ? 'PASSED' : 'FAILED'}`); + if (!report.passed) { + console.log(` Error: ${report.error}`); + } + } catch (error: any) { + console.error(` Error in iteration ${i + 1}: ${error.message}`); + // Continue with next iteration + } + } + + // Summary + const passed = results.filter(r => r.passed).length; + const failed = results.filter(r => !r.passed).length; + console.log(`\n=== Fuzzing Summary ===`); + console.log(`Total iterations: ${options.iterations}`); + console.log(`Passed: ${passed}`); + console.log(`Failed: ${failed}`); + console.log(`Success rate: ${((passed / options.iterations) * 100).toFixed(2)}%`); + + return results; + } + + /** + * Mutate a scenario with random parameter values + */ + private mutateScenario( + scenario: Scenario, + parameterRanges: Record, + rng: () => number + ): Scenario { + const mutated = JSON.parse(JSON.stringify(scenario)) as Scenario; + + // Mutate step arguments + for (const step of mutated.steps) { + this.mutateStep(step, parameterRanges, rng); + } + + return mutated; + } + + /** + * Mutate a single step + */ + private mutateStep( + step: ScenarioStep, + parameterRanges: Record, + rng: () => number + ): void { + // Mutate amount parameters + if (step.args.amount && typeof step.args.amount === 'string') { + const amountNum = parseFloat(step.args.amount); + if (!isNaN(amountNum)) { + // Apply random variation (ยฑ20%) + const variation = (rng() - 0.5) * 0.4; // -0.2 to 0.2 + const newAmount = amountNum * (1 + variation); + step.args.amount = newAmount.toFixed(6); + } + } + + // Mutate percentage-based parameters + if (step.args.pctDelta !== undefined && typeof step.args.pctDelta === 'number') { + if (parameterRanges.pctDelta) { + const { min, max, step: stepSize } = parameterRanges.pctDelta; + const range = max - min; + const steps = stepSize ? Math.floor(range / stepSize) : 100; + const randomStep = Math.floor(rng() * steps); + step.args.pctDelta = min + (stepSize || (range / steps)) * randomStep; + } else { + // Default: vary between -20% and 20% + step.args.pctDelta = (rng() - 0.5) * 40; + } + } + + // Mutate fee parameters (for Uniswap) + if (step.args.fee !== undefined && typeof step.args.fee === 'number') { + const fees = [100, 500, 3000, 10000]; // Common Uniswap fees + step.args.fee = fees[Math.floor(rng() * fees.length)]; + } + + // Mutate slippage + if (step.args.slippageBps !== undefined && typeof step.args.slippageBps === 'number') { + // Vary slippage between 10 and 100 bps (0.1% to 1%) + step.args.slippageBps = Math.floor(10 + rng() * 90); + } + } +} + diff --git a/src/strat/core/scenario-runner.ts b/src/strat/core/scenario-runner.ts new file mode 100644 index 0000000..e2eb6bd --- /dev/null +++ b/src/strat/core/scenario-runner.ts @@ -0,0 +1,382 @@ +import type { + Scenario, + ScenarioStep, + StepContext, + StepResult, + RunReport, + StepReport, + AssertionResult, + ProtocolAdapter, + Network, + ViewContext, +} from '../types.js'; +import { ForkOrchestrator } from './fork-orchestrator.js'; +import { AssertionEvaluator } from './assertion-evaluator.js'; +import { getChainConfig } from '../../utils/addresses.js'; +import { getTokenMetadata, parseTokenAmount } from '../../utils/tokens.js'; +import { createAccountFromPrivateKey } from '../../utils/chain-config.js'; +import { privateKeyToAccount } from 'viem/accounts'; +import { encodeFunctionData } from 'viem'; +import type { Address } from 'viem'; + +/** + * Scenario Runner + * Executes scenarios step by step, handles assertions, and collects results + */ +export class ScenarioRunner { + private fork: ForkOrchestrator; + private adapters: Map; + private assertionEvaluator: AssertionEvaluator; + private network: Network; + + constructor( + fork: ForkOrchestrator, + adapters: Map, + network: Network + ) { + this.fork = fork; + this.adapters = adapters; + this.network = network; + this.assertionEvaluator = new AssertionEvaluator(this.adapters); + } + + /** + * Run a scenario + */ + async run(scenario: Scenario): Promise { + const startTime = Date.now(); + const stepReports: StepReport[] = []; + let passed = true; + let error: string | undefined; + + // Setup accounts + const accounts = await this.setupAccounts(scenario); + const addresses: Record = {}; + + // Discover protocol addresses + for (const protocolName of scenario.protocols) { + const adapter = this.adapters.get(protocolName); + if (adapter) { + addresses[protocolName] = await adapter.discover(this.network); + } + } + + try { + // Fund accounts + await this.fundAccounts(scenario, accounts); + + // Execute steps + for (let i = 0; i < scenario.steps.length; i++) { + const step = scenario.steps[i]; + + if (step.skip) { + continue; + } + + const traderAccount = accounts.trader || accounts[Object.keys(accounts)[0]]; + if (!traderAccount?.privateKey) { + throw new Error('No trader account with private key found'); + } + + const stepContext: StepContext = { + network: this.network, + publicClient: this.fork.getPublicClient(), + walletClient: this.fork.createWalletClient(traderAccount.privateKey), + accounts: Object.fromEntries( + Object.entries(accounts).map(([k, v]) => [k, v.address]) + ) as Record, + addresses, + snapshots: this.fork['snapshots'], + stepIndex: i, + stepName: step.name, + variables: {}, + }; + + const stepStartTime = Date.now(); + + try { + // Execute step + const result = await this.executeStep(step, stepContext); + + // Evaluate assertions + const assertions = step.assert + ? await this.assertionEvaluator.evaluate( + step.assert, + stepContext, + result + ) + : []; + + // Check if any assertion failed + const stepPassed = result.success && assertions.every(a => a.passed); + if (!stepPassed) { + passed = false; + } + + // Run protocol invariants + if (step.action.includes('.')) { + const [protocolName] = step.action.split('.'); + const adapter = this.adapters.get(protocolName); + if (adapter?.invariants) { + for (const invariant of adapter.invariants) { + try { + await invariant(stepContext); + } catch (err) { + console.warn(`Invariant check failed:`, err); + passed = false; + } + } + } + } + + const stepEndTime = Date.now(); + stepReports.push({ + stepIndex: i, + stepName: step.name, + action: step.action, + args: step.args, + result, + assertions, + startTime: stepStartTime, + endTime: stepEndTime, + duration: stepEndTime - stepStartTime, + }); + + if (!result.success) { + error = result.error || `Step ${i} (${step.name}) failed`; + if (step.expectRevert) { + // Expected revert, so this is actually success + passed = true; + } else { + break; + } + } + } catch (err: any) { + const stepEndTime = Date.now(); + stepReports.push({ + stepIndex: i, + stepName: step.name, + action: step.action, + args: step.args, + result: { + success: false, + error: err.message, + }, + assertions: [], + startTime: stepStartTime, + endTime: stepEndTime, + duration: stepEndTime - stepStartTime, + }); + + if (!step.expectRevert) { + passed = false; + error = err.message; + break; + } + } + } + } catch (err: any) { + passed = false; + error = err.message; + } + + const endTime = Date.now(); + const totalGas = stepReports.reduce( + (sum, report) => sum + (report.result.gasUsed || 0n), + 0n + ); + + return { + scenario, + network: this.network, + startTime, + endTime, + steps: stepReports, + passed, + error, + metadata: { + totalGas, + slowestStep: stepReports.reduce((slowest, report) => + report.duration > (slowest?.duration || 0) ? report : slowest + )?.stepName, + }, + }; + } + + /** + * Setup accounts from scenario + */ + private async setupAccounts(scenario: Scenario): Promise> { + const accounts: Record = {}; + + for (const [name, config] of Object.entries(scenario.accounts)) { + if (config.address) { + accounts[name] = { address: config.address as Address }; + } else if (config.privateKey) { + const account = privateKeyToAccount(config.privateKey as `0x${string}`); + accounts[name] = { address: account.address, privateKey: config.privateKey }; + } else { + // Generate a new account + const privateKey = `0x${Array.from({ length: 64 }, () => + Math.floor(Math.random() * 16).toString(16) + ).join('')}` as `0x${string}`; + const account = privateKeyToAccount(privateKey); + accounts[name] = { address: account.address, privateKey }; + } + } + + return accounts; + } + + /** + * Fund accounts with tokens via whale impersonation + */ + private async fundAccounts( + scenario: Scenario, + accounts: Record + ): Promise { + const publicClient = this.fork.getPublicClient(); + const { getWhaleAddress } = await import('./whale-registry.js'); + + const ERC20_ABI = [ + { + name: 'transfer', + type: 'function', + stateMutability: 'nonpayable', + inputs: [ + { name: 'to', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + outputs: [{ name: '', type: 'bool' }], + }, + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + ] as const; + + for (const [name, config] of Object.entries(scenario.accounts)) { + if (config.funded) { + const account = accounts[name]; + + // Set ETH balance (for gas) + await this.fork.setBalance(account.address, 100n * 10n ** 18n); + console.log(`Set ETH balance for ${name}: ${account.address}`); + + // Fund with tokens via whale impersonation + for (const fund of config.funded) { + const token = getTokenMetadata(this.network.chainId, fund.token as any); + const amount = parseTokenAmount(fund.amount, token.decimals); + + console.log(`Funding ${name} with ${fund.amount} ${fund.token}...`); + + // Find whale address + const whaleAddress = getWhaleAddress(this.network.chainId, fund.token); + + if (!whaleAddress) { + console.warn(`No whale found for ${fund.token} on chain ${this.network.chainId}`); + console.warn(` Account ${name} will need to be funded manually or via another method`); + continue; + } + + try { + // Check whale balance + const whaleBalance = await publicClient.readContract({ + address: token.address, + abi: ERC20_ABI, + functionName: 'balanceOf', + args: [whaleAddress], + }); + + if (whaleBalance < amount) { + console.warn(`Whale ${whaleAddress} has insufficient balance: ${whaleBalance} < ${amount}`); + console.warn(` Attempting transfer anyway (may fail on fork)`); + } + + // Impersonate whale + await this.fork.impersonateAccount(whaleAddress); + console.log(` Impersonating whale: ${whaleAddress}`); + + // Transfer tokens using sendTransaction with impersonated account + try { + // Use the public client's request method to send a transaction as the impersonated account + const data = encodeFunctionData({ + abi: ERC20_ABI, + functionName: 'transfer', + args: [account.address, amount], + }); + + const hash = await publicClient.request({ + method: 'eth_sendTransaction', + params: [{ + from: whaleAddress, + to: token.address, + data, + }], + } as any); + + // Wait for transaction + await publicClient.waitForTransactionReceipt({ hash: hash as `0x${string}` }); + console.log(` โœ“ Transferred ${fund.amount} ${fund.token} to ${account.address}`); + } catch (transferError: any) { + // If transfer fails, try setting storage directly (for testing) + console.warn(` Transfer failed: ${transferError.message}`); + console.warn(` This is expected on some forks - tokens may need manual funding`); + } + + // Verify balance + const newBalance = await publicClient.readContract({ + address: token.address, + abi: ERC20_ABI, + functionName: 'balanceOf', + args: [account.address], + }); + + console.log(` Final balance: ${newBalance.toString()}`); + } catch (error: any) { + console.warn(`Failed to fund ${name} with ${fund.token}: ${error.message}`); + } + } + } + } + } + + /** + * Execute a single step + */ + private async executeStep( + step: ScenarioStep, + ctx: StepContext + ): Promise { + if (step.action.includes('.')) { + const [protocol, action] = step.action.split('.'); + const adapter = this.adapters.get(protocol); + + if (!adapter) { + throw new Error(`Unknown protocol: ${protocol}`); + } + + const actionFn = adapter.actions[action]; + if (!actionFn) { + throw new Error(`Unknown action: ${protocol}.${action}`); + } + + return await actionFn(ctx, step.args); + } + + // Built-in actions + switch (step.action) { + case 'assert': + return { + success: true, + stateDeltas: {}, + }; + default: + throw new Error(`Unknown action: ${step.action}`); + } + } +} + diff --git a/src/strat/core/whale-registry.ts b/src/strat/core/whale-registry.ts new file mode 100644 index 0000000..bffcb8f --- /dev/null +++ b/src/strat/core/whale-registry.ts @@ -0,0 +1,41 @@ +import type { Address } from 'viem'; + +/** + * Whale Registry + * Known whale addresses with large token balances for funding test accounts + */ + +export const WHALE_REGISTRY: Record> = { + // Mainnet + 1: { + WETH: '0x2fEb1512183545f48f6b9C5b4EbfCaF49CfCa6F3' as Address, // Binance hot wallet + USDC: '0x55FE002aefF02F77364de339a1292923A15844B8' as Address, // Circle + USDT: '0x5754284f345afc66a98fbB0a0Afe71e0F007B949' as Address, // Tether Treasury + DAI: '0x5d38b4e4783e34e2301a2a36c39a03c45798c4dd' as Address, // MakerDAO + WBTC: '0x28C6c06298d514Db089934071355E5743bf21d60' as Address, // Binance + }, + // Base + 8453: { + WETH: '0x4200000000000000000000000000000000000006' as Address, // WETH on Base + USDC: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' as Address, // USDC on Base + }, +}; + +/** + * Get whale address for a token + */ +export function getWhaleAddress(chainId: number, token: string): Address | undefined { + const whales = WHALE_REGISTRY[chainId]; + if (!whales) { + return undefined; + } + return whales[token.toUpperCase()]; +} + +/** + * Get all whales for a chain + */ +export function getWhales(chainId: number): Record { + return WHALE_REGISTRY[chainId] || {}; +} + diff --git a/src/strat/dsl/scenario-loader.ts b/src/strat/dsl/scenario-loader.ts new file mode 100644 index 0000000..f6f9424 --- /dev/null +++ b/src/strat/dsl/scenario-loader.ts @@ -0,0 +1,82 @@ +import { readFileSync } from 'fs'; +import { load } from 'js-yaml'; +import type { Scenario } from '../types.js'; +import { z } from 'zod'; + +/** + * DSL Parser + * Loads and validates scenario files (YAML/JSON) + */ + +const ScenarioSchema = z.object({ + version: z.number(), + network: z.union([z.string(), z.number()]), + protocols: z.array(z.string()), + assumptions: z.object({ + baseCurrency: z.string().optional(), + slippageBps: z.number().optional(), + minHealthFactor: z.number().optional(), + }).optional(), + accounts: z.record(z.object({ + funded: z.array(z.object({ + token: z.string(), + amount: z.string(), + })).optional(), + address: z.string().optional(), + privateKey: z.string().optional(), + })), + steps: z.array(z.object({ + name: z.string(), + action: z.string(), + args: z.record(z.any()), + assert: z.union([ + z.array(z.string()), + z.array(z.object({ + expression: z.string(), + message: z.string().optional(), + })), + ]).optional(), + expectRevert: z.boolean().optional(), + skip: z.boolean().optional(), + })), +}); + +/** + * Load a scenario from a file + */ +export function loadScenario(filePath: string): Scenario { + const content = readFileSync(filePath, 'utf-8'); + + let data: any; + if (filePath.endsWith('.yaml') || filePath.endsWith('.yml')) { + data = load(content); + } else if (filePath.endsWith('.json')) { + data = JSON.parse(content); + } else { + throw new Error(`Unsupported file format: ${filePath}`); + } + + // Validate using Zod + const validated = ScenarioSchema.parse(data); + + return validated as Scenario; +} + +/** + * Validate a scenario object + */ +export function validateScenario(scenario: any): scenario is Scenario { + try { + ScenarioSchema.parse(scenario); + return true; + } catch (error) { + if (error instanceof z.ZodError) { + console.error('Scenario validation errors:'); + error.errors.forEach(err => { + console.error(` ${err.path.join('.')}: ${err.message}`); + }); + } + return false; + } +} + diff --git a/src/strat/index.ts b/src/strat/index.ts new file mode 100644 index 0000000..15b1106 --- /dev/null +++ b/src/strat/index.ts @@ -0,0 +1,24 @@ +/** + * DeFi Strategy Testing Framework + * + * Main exports for the strategy testing system + */ + +export * from './types.js'; +export * from './core/fork-orchestrator.js'; +export * from './core/scenario-runner.js'; +export * from './core/assertion-evaluator.js'; +export * from './core/failure-injector.js'; +export * from './adapters/aave-v3-adapter.js'; +export * from './adapters/uniswap-v3-adapter.js'; +export * from './adapters/compound-v3-adapter.js'; +export * from './adapters/erc20-adapter.js'; +export * from './core/fuzzer.js'; +export * from './core/whale-registry.js'; +export * from './dsl/scenario-loader.js'; +export * from './reporters/json-reporter.js'; +export * from './reporters/html-reporter.js'; +export * from './reporters/junit-reporter.js'; +export * from './config/networks.js'; +export * from './config/oracle-feeds.js'; + diff --git a/src/strat/reporters/html-reporter.ts b/src/strat/reporters/html-reporter.ts new file mode 100644 index 0000000..a707833 --- /dev/null +++ b/src/strat/reporters/html-reporter.ts @@ -0,0 +1,267 @@ +import { writeFileSync } from 'fs'; +import type { RunReport } from '../types.js'; + +/** + * HTML Reporter + * Generates human-readable HTML reports + */ +export class HtmlReporter { + /** + * Generate an HTML report + */ + static generate(report: RunReport, outputPath: string): void { + const html = this.render(report); + writeFileSync(outputPath, html, 'utf-8'); + console.log(`HTML report written to ${outputPath}`); + } + + private static render(report: RunReport): string { + const duration = report.endTime ? (report.endTime - report.startTime) / 1000 : 0; + const totalGas = report.metadata.totalGas.toString(); + + return ` + + + + + DeFi Strategy Test Report + + + +
+
+

DeFi Strategy Test Report

+
+ ${report.passed ? 'โœ“ PASSED' : 'โœ— FAILED'} +
+
+ +
+
+

Network

+
${report.network.name}
+
+
+

Steps

+
${report.steps.length}
+
+
+

Duration

+
${duration.toFixed(2)}s
+
+
+

Total Gas

+
${this.formatGas(totalGas)}
+
+
+ + ${report.error ? ` +
+ Error: ${this.escapeHtml(report.error)} +
+ ` : ''} + +
+

Steps

+ ${report.steps.map((step, idx) => this.renderStep(step, idx)).join('')} +
+
+ +`; + } + + private static renderStep(step: any, idx: number): string { + const duration = (step.duration / 1000).toFixed(2); + const gasUsed = step.result.gasUsed?.toString() || '0'; + + return ` +
+
+
+
Step ${step.stepIndex + 1}: ${this.escapeHtml(step.stepName)}
+
${this.escapeHtml(step.action)}
+
+
+
Gas: ${this.formatGas(gasUsed)}
+
Duration: ${duration}s
+
+
+ +
+ ${step.result.success ? 'โœ“ Success' : `โœ— Failed: ${this.escapeHtml(step.result.error || 'Unknown error')}`} + ${step.result.txHash ? `
Tx: ${step.result.txHash}
` : ''} +
+ + ${step.assertions && step.assertions.length > 0 ? ` +
+

Assertions

+ ${step.assertions.map((assert: any) => ` +
+ ${assert.passed ? 'โœ“' : 'โœ—'} ${this.escapeHtml(assert.expression)} + ${assert.message ? `
${this.escapeHtml(assert.message)}
` : ''} +
+ `).join('')} +
+ ` : ''} + +
+ View Args + 
${JSON.stringify(step.args, null, 2)}
+
+
+ `; + } + + private static formatGas(gas: string): string { + const num = BigInt(gas); + if (num > 1000000n) { + return `${(Number(num) / 1000000).toFixed(2)}M`; + } else if (num > 1000n) { + return `${(Number(num) / 1000).toFixed(2)}K`; + } + return num.toString(); + } + + private static escapeHtml(text: string): string { + const map: Record = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + }; + return text.replace(/[&<>"']/g, m => map[m]); + } +} + diff --git a/src/strat/reporters/json-reporter.ts b/src/strat/reporters/json-reporter.ts new file mode 100644 index 0000000..ecc750d --- /dev/null +++ b/src/strat/reporters/json-reporter.ts @@ -0,0 +1,25 @@ +import { writeFileSync } from 'fs'; +import type { RunReport } from '../types.js'; + +/** + * JSON Reporter + * Generates machine-readable JSON reports + */ +export class JsonReporter { + /** + * Generate a JSON report + */ + static generate(report: RunReport, outputPath: string): void { + const json = JSON.stringify(report, (key, value) => { + // Convert bigint to string for JSON serialization + if (typeof value === 'bigint') { + return value.toString(); + } + return value; + }, 2); + + writeFileSync(outputPath, json, 'utf-8'); + console.log(`JSON report written to ${outputPath}`); + } +} + diff --git a/src/strat/reporters/junit-reporter.ts b/src/strat/reporters/junit-reporter.ts new file mode 100644 index 0000000..afdf0be --- /dev/null +++ b/src/strat/reporters/junit-reporter.ts @@ -0,0 +1,62 @@ +import { writeFileSync } from 'fs'; +import type { RunReport } from '../types.js'; +import { escapeXml } from './utils.js'; + +/** + * JUnit Reporter + * Generates JUnit XML format for CI integration + */ +export class JUnitReporter { + /** + * Generate a JUnit XML report + */ + static generate(report: RunReport, outputPath: string): void { + const duration = report.endTime ? (report.endTime - report.startTime) / 1000 : 0; + const failures = report.steps.filter(s => !s.result.success).length; + const tests = report.steps.length; + + const xml = ` + + + ${report.steps.map((step, idx) => this.renderTestCase(step, idx)).join('\n')} + +`; + + writeFileSync(outputPath, xml, 'utf-8'); + console.log(`JUnit XML report written to ${outputPath}`); + } + + private static renderTestCase(step: any, idx: number): string { + const duration = (step.duration / 1000).toFixed(3); + const className = escapeXml(step.action); + const testName = escapeXml(step.stepName); + + if (!step.result.success) { + const errorMessage = escapeXml(step.result.error || 'Step failed'); + return ` + ${errorMessage} + `; + } + + // Check assertions + const failedAssertions = step.assertions?.filter((a: any) => !a.passed) || []; + if (failedAssertions.length > 0) { + const assertionMessages = failedAssertions + .map((a: any) => `${a.expression}: ${a.message || 'Failed'}`) + .join('; '); + return ` + ${escapeXml(assertionMessages)} + `; + } + + return ` `; + } +} + diff --git a/src/strat/reporters/utils.ts b/src/strat/reporters/utils.ts new file mode 100644 index 0000000..5d52fdc --- /dev/null +++ b/src/strat/reporters/utils.ts @@ -0,0 +1,13 @@ +/** + * Utility functions for reporters + */ + +export function escapeXml(text: string): string { + return text + .replace(/&/g, '&') + .replace(//g, '>') + .replace(/"/g, '"') + .replace(/'/g, '''); +} + diff --git a/src/strat/types.ts b/src/strat/types.ts new file mode 100644 index 0000000..8481fa3 --- /dev/null +++ b/src/strat/types.ts @@ -0,0 +1,139 @@ +import type { Address, PublicClient, WalletClient } from 'viem'; +import type { ChainConfig } from '../../config/types.js'; + +/** + * Core types for DeFi strategy testing + */ + +export interface Network { + chainId: number; + name: string; + rpcUrl: string; + forkBlock?: number; +} + +export interface RuntimeAddresses { + pool?: Address; + addressesProvider?: Address; + dataProvider?: Address; + priceOracle?: Address; + swapRouter?: Address; + [key: string]: Address | undefined; +} + +export interface StepContext { + network: Network; + publicClient: PublicClient; + walletClient: WalletClient; + accounts: Record; + addresses: Record; + snapshots: Map; + stepIndex: number; + stepName: string; + variables: Record; +} + +export interface StepResult { + success: boolean; + gasUsed?: bigint; + events?: any[]; + tokenDeltas?: Record; + stateDeltas?: Record; + error?: string; + txHash?: Address; +} + +export interface ViewContext { + network: Network; + publicClient: PublicClient; + accounts: Record; + addresses: Record; + variables: Record; +} + +export interface ProtocolAdapter { + name: string; + discover(network: Network): Promise; + actions: Record Promise>; + invariants?: Array<(ctx: StepContext) => Promise>; + views?: Record Promise>; +} + +export interface Scenario { + version: number; + network: string | number; + protocols: string[]; + assumptions?: { + baseCurrency?: string; + slippageBps?: number; + minHealthFactor?: number; + [key: string]: any; + }; + accounts: Record; + address?: Address; + privateKey?: string; + }>; + steps: ScenarioStep[]; +} + +export interface ScenarioStep { + name: string; + action: string; + args: Record; + assert?: Array; + expectRevert?: boolean; + skip?: boolean; +} + +export interface Assertion { + expression: string; + message?: string; +} + +export interface RunReport { + scenario: Scenario; + network: Network; + startTime: number; + endTime?: number; + steps: StepReport[]; + passed: boolean; + error?: string; + metadata: { + totalGas: bigint; + slowestStep?: string; + riskNotes?: string[]; + }; +} + +export interface StepReport { + stepIndex: number; + stepName: string; + action: string; + args: Record; + result: StepResult; + assertions: AssertionResult[]; + startTime: number; + endTime: number; + duration: number; +} + +export interface AssertionResult { + expression: string; + passed: boolean; + message?: string; + value?: any; +} + +export interface FailureCatalog { + protocol: string; + failures: FailureDefinition[]; +} + +export interface FailureDefinition { + name: string; + description: string; + action: string; + params: Record; +} + diff --git a/src/utils/addresses.ts b/src/utils/addresses.ts new file mode 100644 index 0000000..3c9ed8b --- /dev/null +++ b/src/utils/addresses.ts @@ -0,0 +1,39 @@ +import { getChainConfig as getChainConfigFromAddresses } from '../../config/addresses.js'; +import type { ChainConfig } from '../../config/types.js'; + +export function getAavePoolAddress(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).aave.pool; +} + +export function getAavePoolAddressesProvider(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).aave.poolAddressesProvider; +} + +export function getUniswapSwapRouter02(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).uniswap.swapRouter02; +} + +export function getUniswapUniversalRouter(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).uniswap.universalRouter; +} + +export function getPermit2Address(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).uniswap.permit2; +} + +export function getProtocolinkRouter(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).protocolink.router; +} + +export function getCompound3Comet(chainId: number): `0x${string}` { + return getChainConfigFromAddresses(chainId).compound3.cometUsdc; +} + +export function getTokenAddress(chainId: number, token: 'WETH' | 'USDC' | 'USDT' | 'DAI' | 'WBTC'): `0x${string}` { + return getChainConfigFromAddresses(chainId).tokens[token]; +} + +// Export getChainConfig for use in strat modules +export function getChainConfig(chainId: number): ChainConfig { + return getChainConfigFromAddresses(chainId); +} diff --git a/src/utils/chain-config.ts b/src/utils/chain-config.ts new file mode 100644 index 0000000..5bcd344 --- /dev/null +++ b/src/utils/chain-config.ts @@ -0,0 +1,57 @@ +import { getChainConfig } from '../../config/addresses.js'; +import type { ChainConfig } from '../../config/types.js'; +import { http, createPublicClient, createWalletClient, type PublicClient, type WalletClient } from 'viem'; +import { mainnet, base, arbitrum, optimism, polygon } from 'viem/chains'; +import type { PrivateKeyAccount } from 'viem/accounts'; +import { privateKeyToAccount } from 'viem/accounts'; + +const viemChains = { + 1: mainnet, + 8453: base, + 42161: arbitrum, + 10: optimism, + 137: polygon, +}; + +export function loadChainConfig(chainId: number): ChainConfig { + return getChainConfig(chainId); +} + +export function getViemChain(chainId: number) { + const chain = viemChains[chainId as keyof typeof viemChains]; + if (!chain) { + throw new Error(`Unsupported chain ID: ${chainId}`); + } + return chain; +} + +export function createRpcClient(chainId: number, rpcUrl?: string): PublicClient { + const config = loadChainConfig(chainId); + const viemChain = getViemChain(chainId); + + return createPublicClient({ + chain: viemChain, + transport: http(rpcUrl || config.rpcUrl), + }); +} + +export function createWalletRpcClient( + chainId: number, + privateKey: `0x${string}`, + rpcUrl?: string +): WalletClient { + const config = loadChainConfig(chainId); + const viemChain = getViemChain(chainId); + const account = privateKeyToAccount(privateKey); + + return createWalletClient({ + account, + chain: viemChain, + transport: http(rpcUrl || config.rpcUrl), + }); +} + +export function createAccountFromPrivateKey(privateKey: `0x${string}`): PrivateKeyAccount { + return privateKeyToAccount(privateKey); +} + diff --git a/src/utils/encoding.ts b/src/utils/encoding.ts new file mode 100644 index 0000000..9bf0b3e --- /dev/null +++ b/src/utils/encoding.ts @@ -0,0 +1,60 @@ +import { encodeAbiParameters, parseAbiParameters, type Hex } from 'viem'; + +export function encodeSwapParams(params: { + tokenIn: `0x${string}`; + tokenOut: `0x${string}`; + fee: number; + recipient: `0x${string}`; + deadline: bigint; + amountIn: bigint; + amountOutMinimum: bigint; + sqrtPriceLimitX96: bigint; +}): Hex { + return encodeAbiParameters( + parseAbiParameters('(address,address,uint24,address,uint256,uint256,uint256,uint160)'), + [ + [ + params.tokenIn, + params.tokenOut, + params.fee, + params.recipient, + params.deadline, + params.amountIn, + params.amountOutMinimum, + params.sqrtPriceLimitX96, + ], + ] + ); +} + +export function encodeAaveSupplyParams(params: { + asset: `0x${string}`; + amount: bigint; + onBehalfOf: `0x${string}`; + referralCode: number; +}): Hex { + return encodeAbiParameters( + parseAbiParameters('address,uint256,address,uint16'), + [params.asset, params.amount, params.onBehalfOf, params.referralCode] + ); +} + +export function encodeAaveBorrowParams(params: { + asset: `0x${string}`; + amount: bigint; + interestRateMode: number; + referralCode: number; + onBehalfOf: `0x${string}`; +}): Hex { + return encodeAbiParameters( + parseAbiParameters('address,uint256,uint256,uint16,address'), + [ + params.asset, + params.amount, + params.interestRateMode, + params.referralCode, + params.onBehalfOf, + ] + ); +} + diff --git a/src/utils/permit2.ts b/src/utils/permit2.ts new file mode 100644 index 0000000..ae5db10 --- /dev/null +++ b/src/utils/permit2.ts @@ -0,0 +1,63 @@ +import type { Address } from 'viem'; +import { getPermit2Address } from './addresses.js'; + +export interface Permit2Signature { + token: Address; + amount: bigint; + expiration: bigint; + nonce: bigint; + spender: Address; +} + +export interface Permit2TransferDetails { + to: Address; + requestedAmount: bigint; +} + +export interface Permit2PermitTransferFrom { + permitted: { + token: Address; + amount: bigint; + }; + nonce: bigint; + deadline: bigint; +} + +export interface Permit2SignatureTransfer { + permitted: Permit2PermitTransferFrom['permitted']; + spender: Address; + nonce: bigint; + deadline: bigint; +} + +export function getPermit2Domain(chainId: number): { + name: string; + chainId: number; + verifyingContract: Address; +} { + return { + name: 'Permit2', + chainId, + verifyingContract: getPermit2Address(chainId), + }; +} + +export function getPermit2TransferTypes() { + return { + PermitTransferFrom: [ + { name: 'permitted', type: 'TokenPermissions' }, + { name: 'spender', type: 'address' }, + { name: 'nonce', type: 'uint256' }, + { name: 'deadline', type: 'uint256' }, + ], + TokenPermissions: [ + { name: 'token', type: 'address' }, + { name: 'amount', type: 'uint256' }, + ], + }; +} + +export function createPermit2Deadline(secondsFromNow: number = 3600): bigint { + return BigInt(Math.floor(Date.now() / 1000) + secondsFromNow); +} + diff --git a/src/utils/rpc.ts b/src/utils/rpc.ts new file mode 100644 index 0000000..37917a7 --- /dev/null +++ b/src/utils/rpc.ts @@ -0,0 +1,42 @@ +import { createRpcClient, createWalletRpcClient } from './chain-config.js'; +import type { PublicClient, WalletClient } from 'viem'; + +export { createRpcClient, createWalletRpcClient }; + +export async function getBalance( + client: PublicClient, + address: `0x${string}` +): Promise { + return await client.getBalance({ address }); +} + +export async function getTokenBalance( + client: PublicClient, + token: `0x${string}`, + address: `0x${string}` +): Promise { + const balance = await client.readContract({ + address: token, + abi: [ + { + name: 'balanceOf', + type: 'function', + stateMutability: 'view', + inputs: [{ name: 'account', type: 'address' }], + outputs: [{ name: '', type: 'uint256' }], + }, + ], + functionName: 'balanceOf', + args: [address], + }); + return balance as bigint; +} + +export async function waitForTransaction( + client: PublicClient, + hash: `0x${string}`, + confirmations: number = 1 +): Promise { + await client.waitForTransactionReceipt({ hash, confirmations }); +} + diff --git a/src/utils/tokens.ts b/src/utils/tokens.ts new file mode 100644 index 0000000..f3a06c2 --- /dev/null +++ b/src/utils/tokens.ts @@ -0,0 +1,59 @@ +import type { TokenMetadata } from '../../config/types.js'; +import { getChainConfig as getChainConfigFromAddresses } from '../../config/addresses.js'; + +const TOKEN_DECIMALS: Record = { + WETH: 18, + USDC: 6, + USDT: 6, + DAI: 18, + WBTC: 8, +}; + +const TOKEN_NAMES: Record = { + WETH: 'Wrapped Ether', + USDC: 'USD Coin', + USDT: 'Tether USD', + DAI: 'Dai Stablecoin', + WBTC: 'Wrapped Bitcoin', +}; + +export function getTokenMetadata( + chainId: number, + symbol: 'WETH' | 'USDC' | 'USDT' | 'DAI' | 'WBTC' +): TokenMetadata { + const config = getChainConfigFromAddresses(chainId); + const address = config.tokens[symbol]; + + return { + chainId, + address, + decimals: TOKEN_DECIMALS[symbol], + symbol, + name: TOKEN_NAMES[symbol], + }; +} + +export function parseTokenAmount(amount: string, decimals: number): bigint { + const [integerPart, decimalPart = ''] = amount.split('.'); + const paddedDecimal = decimalPart.padEnd(decimals, '0').slice(0, decimals); + return BigInt(integerPart + paddedDecimal); +} + +export function formatTokenAmount(amount: bigint, decimals: number): string { + const divisor = BigInt(10 ** decimals); + const quotient = amount / divisor; + const remainder = amount % divisor; + + if (remainder === 0n) { + return quotient.toString(); + } + + const remainderStr = remainder.toString().padStart(decimals, '0'); + const trimmed = remainderStr.replace(/0+$/, ''); + return `${quotient}.${trimmed}`; +} + +export function getTokenDecimals(symbol: string): number { + return TOKEN_DECIMALS[symbol] || 18; +} + diff --git a/test/Aave.test.sol b/test/Aave.test.sol new file mode 100644 index 0000000..e366605 --- /dev/null +++ b/test/Aave.test.sol @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "forge-std/Test.sol"; +import "../contracts/examples/AaveSupplyBorrow.sol"; +import "../contracts/examples/AaveFlashLoanReceiver.sol"; +import "../contracts/interfaces/IAavePool.sol"; +import "../contracts/interfaces/IERC20.sol"; + +contract AaveTest is Test { + AaveSupplyBorrow public aaveSupplyBorrow; + AaveFlashLoanReceiver public flashLoanReceiver; + + // Mainnet addresses + address constant AAVE_POOL = 0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2; + address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; + address constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; + address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; + + uint256 mainnetFork; + + function setUp() public { + // Fork mainnet at a recent block + mainnetFork = vm.createFork(vm.envString("MAINNET_RPC_URL")); + vm.selectFork(mainnetFork); + + // Deploy contracts + aaveSupplyBorrow = new AaveSupplyBorrow(AAVE_POOL); + flashLoanReceiver = new AaveFlashLoanReceiver(AAVE_POOL); + } + + function testSupplyAndBorrow() public { + // Setup: Get some USDC from a whale + address whale = 0x47ac0Fb4F2D84898e4D9E7b4DaB3C24507a6D503; // USDC whale + uint256 supplyAmount = 1000 * 10**6; // 1000 USDC + uint256 borrowAmount = 500 * 10**6; // 500 USDT + + // Impersonate whale and transfer USDC to test contract + vm.startPrank(whale); + IERC20(USDC).transfer(address(this), supplyAmount); + vm.stopPrank(); + + // Approve and supply + IERC20(USDC).approve(address(aaveSupplyBorrow), supplyAmount); + aaveSupplyBorrow.supplyAndBorrow(USDC, supplyAmount, USDT, borrowAmount); + + // Check balances + uint256 usdtBalance = IERC20(USDT).balanceOf(address(this)); + assertGt(usdtBalance, 0, "Should have borrowed USDT"); + } + + function testFlashLoanSimple() public { + uint256 flashLoanAmount = 10000 * 10**6; // 10,000 USDC + + // Execute flash loan + flashLoanReceiver.flashLoanSimple(USDC, flashLoanAmount, ""); + + // Flash loan should complete successfully (repaid in executeOperation) + assertTrue(true, "Flash loan completed"); + } + + function testFlashLoanMulti() public { + address[] memory assets = new address[](2); + assets[0] = USDC; + assets[1] = USDT; + + uint256[] memory amounts = new uint256[](2); + amounts[0] = 10000 * 10**6; // 10,000 USDC + amounts[1] = 5000 * 10**6; // 5,000 USDT + + uint256[] memory modes = new uint256[](2); + modes[0] = 0; // No debt + modes[1] = 0; // No debt + + // Execute multi-asset flash loan + flashLoanReceiver.flashLoan(assets, amounts, modes, ""); + + // Flash loan should complete successfully + assertTrue(true, "Multi-asset flash loan completed"); + } +} + diff --git a/test/Protocolink.test.sol b/test/Protocolink.test.sol new file mode 100644 index 0000000..5f41ac0 --- /dev/null +++ b/test/Protocolink.test.sol @@ -0,0 +1,42 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "forge-std/Test.sol"; +import "../contracts/examples/ProtocolinkExecutor.sol"; +import "../contracts/interfaces/IERC20.sol"; + +contract ProtocolinkTest is Test { + ProtocolinkExecutor public executor; + + // Mainnet addresses (update with actual Protocolink Router address) + address constant PROTOCOLINK_ROUTER = 0xf7b10d603907658F690Da534E9b7dbC4dAB3E2D6; + address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; + + uint256 mainnetFork; + + function setUp() public { + // Fork mainnet + mainnetFork = vm.createFork(vm.envString("MAINNET_RPC_URL")); + vm.selectFork(mainnetFork); + + // Deploy contract + executor = new ProtocolinkExecutor(PROTOCOLINK_ROUTER); + } + + function testExecuteRoute() public { + // This is a placeholder test + // In production, you would: + // 1. Build a Protocolink route (e.g., swap + supply) + // 2. Encode it as bytes + // 3. Execute via executor.executeRoute() + + // Example: Empty route data (will fail, but demonstrates structure) + bytes memory routeData = ""; + + // Note: Actual implementation would require building proper Protocolink route data + // This is a conceptual test structure + // vm.expectRevert(); + // executor.executeRoute(routeData); + } +} + diff --git a/test/Uniswap.test.sol b/test/Uniswap.test.sol new file mode 100644 index 0000000..8ec5d80 --- /dev/null +++ b/test/Uniswap.test.sol @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import "forge-std/Test.sol"; +import "../contracts/examples/UniswapV3Swap.sol"; +import "../contracts/interfaces/IERC20.sol"; + +contract UniswapTest is Test { + UniswapV3Swap public uniswapSwap; + + // Mainnet addresses + address constant SWAP_ROUTER = 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45; + address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; + address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; + + uint256 mainnetFork; + + function setUp() public { + // Fork mainnet + mainnetFork = vm.createFork(vm.envString("MAINNET_RPC_URL")); + vm.selectFork(mainnetFork); + + // Deploy contract + uniswapSwap = new UniswapV3Swap(SWAP_ROUTER); + } + + function testSwapExactInputSingle() public { + // Setup: Get some USDC from a whale + address whale = 0x47ac0Fb4F2D84898e4D9E7b4DaB3C24507a6D503; // USDC whale + uint256 amountIn = 1000 * 10**6; // 1000 USDC + uint24 fee = 3000; // 0.3% fee tier + uint256 deadline = block.timestamp + 600; // 10 minutes + + // Impersonate whale and transfer USDC to test contract + vm.startPrank(whale); + IERC20(USDC).transfer(address(this), amountIn); + vm.stopPrank(); + + // Record initial WETH balance + uint256 initialWETH = IERC20(WETH).balanceOf(address(this)); + + // Approve and swap + IERC20(USDC).approve(address(uniswapSwap), amountIn); + uint256 amountOut = uniswapSwap.swapExactInputSingle( + USDC, + WETH, + fee, + amountIn, + 0, // No slippage protection for test + deadline + ); + + // Check that we received WETH + uint256 finalWETH = IERC20(WETH).balanceOf(address(this)); + assertGt(finalWETH, initialWETH, "Should have received WETH"); + assertGt(amountOut, 0, "Should have output amount"); + } +} + diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..92c59bc --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,28 @@ +{ + "compilerOptions": { + "target": "ES2022", + "module": "ESNext", + "lib": ["ES2022"], + "moduleResolution": "bundler", + "resolveJsonModule": true, + "allowJs": true, + "outDir": "./dist", + "rootDir": "./", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "declaration": true, + "declarationMap": true, + "sourceMap": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noImplicitReturns": true, + "noFallthroughCasesInSwitch": true, + "allowSyntheticDefaultImports": true, + "types": ["node"] + }, + "include": ["src/**/*", "examples/**/*", "config/**/*"], + "exclude": ["node_modules", "dist", "test", "contracts"] +} +