@eco-incorp/sauce 0.99.0

package/sdk/src/skills/arbitrum-bridge.md

@@ -0,0 +1,64 @@
+# Arbitrum Native Bridge
+
+Official Arbitrum L1-L2 gateway bridge. Routes tokens through the canonical Arbitrum rollup bridge with 7-day withdrawal finality.
+
+## Category
+
+native L2 bridge | Direction: L1 to L2 (Ethereum to Arbitrum) | Chains: Ethereum (1), Arbitrum (42161)
+
+## SauceScript Functions
+
+### depositToL2
+
+Deposit ERC-20 tokens from Ethereum L1 to Arbitrum L2 via the Gateway Router.
+
+```typescript
+import { ArbitrumL1GatewayRouterABI as IL1GatewayRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  token: Address,
+  recipient: Address,
+  amount: Uint256,
+  maxGas: Uint256,
+  gasPriceBid: Uint256,
+): bytes {
+  const router = IL1GatewayRouter.at(routerAddress);
+  return router.outboundTransfer(token, recipient, amount, maxGas, gasPriceBid, 0x00);
+}
+```
+
+- `token`: L1 ERC-20 token address to bridge
+- `recipient`: Address to receive tokens on Arbitrum L2
+- `amount`: Amount of tokens to deposit
+- `maxGas`: Maximum L2 gas for the deposit transaction (e.g. 300000). Excess is refunded
+- `gasPriceBid`: L2 gas price bid in wei. Use Arbitrum's `ArbGasInfo.getMinimumGasPrice()` or estimate
+- `_data`: Extra data, typically `0x00` for standard deposits. Used for custom gateway params
+- Requires ERC-20 approval to the appropriate gateway (use `getGateway(token)` to find it)
+- Requires ETH as msg.value to cover L2 execution costs (`maxGas * gasPriceBid + maxSubmissionCost`)
+
+## Deployed Addresses
+
+| Chain    | Contract        | Address                                      |
+| -------- | --------------- | -------------------------------------------- |
+| Ethereum | l1GatewayRouter | `0x72Ce9c846789fdB6fC1f34aC4AD25Dd9ef7031ef` |
+| Arbitrum | l2GatewayRouter | `0x5288c571Fd7aD117beA99bF60FE0846C4E84F933` |
+
+## ABI Reference
+
+### ArbitrumL1GatewayRouterABI
+
+- `outboundTransfer(address _token, address _to, uint256 _amount, uint256 _maxGas, uint256 _gasPriceBid, bytes _data) returns (bytes)` [payable] - Deposit tokens from L1 to L2. Routes to the correct gateway automatically based on the token
+- `getGateway(address _token) returns (address)` - Look up the gateway contract for a specific token (view). Approve tokens to this address, not the router
+
+## Notes
+
+- **L1 to L2 only** via this contract. For L2 to L1 withdrawals, use `ArbSys.sendTxToL1()` on Arbitrum (takes 7 days)
+- The router auto-routes tokens to the correct gateway (standard, custom, or WETH gateway)
+- **Approval target**: approve tokens to the gateway returned by `getGateway(token)`, NOT to the router itself
+- `msg.value` must cover: `maxSubmissionCost + (maxGas * gasPriceBid)` for L2 execution
+- L1 to L2 deposits finalize in ~10-15 minutes (after L1 finality + sequencer inclusion)
+- L2 to L1 withdrawals require 7-day challenge period before funds can be claimed on L1
+- For ETH deposits, send ETH directly to the Arbitrum Delayed Inbox (no token approval needed)
+- Canonical bridge -- no third-party risk, secured by the Arbitrum rollup itself
+- Audited

package/sdk/src/skills/arrakis.md

@@ -0,0 +1,65 @@
+# Arrakis Finance
+
+Automated liquidity management protocol for Uniswap V3. Provides vaults that actively manage concentrated liquidity positions with rebalancing.
+
+## Category
+
+yield | Chains: Ethereum
+
+## Key Operations
+
+- **addLiquidity**: Add liquidity to an Arrakis vault via router (tuple params)
+- **removeLiquidity**: Remove liquidity from vault via router (tuple params)
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/arrakis";
+```
+
+## SauceScript Examples
+
+```typescript
+// Add liquidity - NOTE: uses tuple params via router
+import { ArrakisRouterABI as IArrakisRouter } from "./abis";
+function main(
+  routerAddress: Address,
+  vault: Address,
+  receiver: Address,
+  amount0Max: Uint256,
+  amount1Max: Uint256,
+): Uint256 {
+  const router = IArrakisRouter.at(routerAddress);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | factory  | `0xEA1aFf9dbFfD1580F6b81A3ad3589E66652dB7D9` |
+| Ethereum | router   | `0x6aC8Bab8B775a03b8B72B2940251432442f61B94` |
+
+## ABI Methods
+
+### ArrakisRouterABI
+
+- `addLiquidity(tuple)` - Add liquidity. Tuple: (amount0Max, amount1Max, amount0Min, amount1Min, amountSharesMin, vault, receiver, gauge). Returns (amount0, amount1, sharesReceived)
+- `removeLiquidity(tuple)` - Remove liquidity. Tuple: (burnAmount, amount0Min, amount1Min, vault, receiver, gauge). Returns (amount0, amount1)
+
+### ArrakisVaultABI
+
+- `totalSupply()` - Total vault shares outstanding
+- `balanceOf(address)` - Query vault share balance
+- `totalUnderlying()` - Total (amount0, amount1) managed by vault
+- `token0()` - First token address
+- `token1()` - Second token address
+
+## Notes
+
+- TVL: $50M+. Manages UniV3 concentrated liquidity positions automatically
+- Both addLiquidity and removeLiquidity take struct/tuple params via the router
+- Approve both token0 and token1 to the router before adding liquidity
+- Vault shares represent proportional ownership of the managed position
+- gauge param can be zero address if not staking in a gauge

package/sdk/src/skills/axelar.md

@@ -0,0 +1,80 @@
+# Axelar
+
+Universal cross-chain communication protocol with decentralized validator set. Supports GMP (General Message Passing) and ITS (Interchain Token Service).
+
+## Category
+
+cross-chain messaging + bridge | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), Avalanche (43114)
+
+## SauceScript Functions
+
+### sendToken
+
+Send tokens cross-chain via the Axelar Gateway.
+
+```typescript
+import { AxelarGatewayABI as IGateway } from "./abis";
+
+function main(
+  gatewayAddress: Address,
+  destinationChain: string,
+  destinationAddress: string,
+  symbol: string,
+  amount: Uint256,
+): Uint256 {
+  const gateway = IGateway.at(gatewayAddress);
+  gateway.sendToken(destinationChain, destinationAddress, symbol, amount);
+  return 1;
+}
+```
+
+- `destinationChain`: Chain name as string (e.g. "ethereum", "arbitrum", "base")
+- `destinationAddress`: Recipient address as string
+- `symbol`: Token symbol as string (e.g. "axlUSDC", "WETH")
+- Requires ERC-20 approval to the Gateway
+
+## Deployed Addresses
+
+| Chain     | Contract   | Address                                      |
+| --------- | ---------- | -------------------------------------------- |
+| Ethereum  | gateway    | `0x4F4495243837681061C4743b74B3eEdf548D56A5` |
+| Ethereum  | gasService | `0x2d5d7d31F671F86C782533cc367F14109a082712` |
+| Ethereum  | its        | `0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C` |
+| Arbitrum  | gateway    | `0xe432150cce91c13a887f7D836923d5597adD8E31` |
+| Arbitrum  | its        | `0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C` |
+| Optimism  | gateway    | `0xe432150cce91c13a887f7D836923d5597adD8E31` |
+| Optimism  | its        | `0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C` |
+| Base      | gateway    | `0xe432150cce91c13a887f7D836923d5597adD8E31` |
+| Base      | its        | `0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C` |
+| Polygon   | gateway    | `0x6f015F16De9fC8791b234eF68D486d2bF203FBA8` |
+| Polygon   | its        | `0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C` |
+| Avalanche | gateway    | `0x5029C0EFf6C34351a0CEc334542cDb22c7928f78` |
+| Avalanche | its        | `0xB5FB4BE02232B1bBA4dC8f81dc24C26980dE9e3C` |
+
+## ABI Reference
+
+### AxelarGatewayABI
+
+- `callContract(string destinationChain, string contractAddress, bytes payload)` - Send arbitrary message to destination contract (GMP)
+- `callContractWithToken(string destinationChain, string contractAddress, bytes payload, string symbol, uint256 amount)` - Send message + tokens together
+- `sendToken(string destinationChain, string destinationAddress, string symbol, uint256 amount)` - Send tokens to destination address
+- `tokenAddresses(string symbol) returns (address)` - Look up token address by symbol (view)
+
+### AxelarGasServiceABI
+
+- `payNativeGasForContractCall(address sender, string destinationChain, string destinationAddress, bytes payload, address refundAddress)` [payable] - Pre-pay gas for GMP execution on destination chain
+
+### AxelarITSABI
+
+- `interchainTransfer(bytes32 tokenId, string destinationChain, bytes destinationAddress, uint256 amount, bytes metadata, uint256 gasValue)` [payable] - Transfer ITS-registered tokens cross-chain
+
+## Notes
+
+- Uses chain name strings for destination (e.g. "ethereum", "arbitrum", "Polygon") -- NOT chain IDs
+- `sendToken`: Simple token transfer. `callContract`: GMP message. `callContractWithToken`: Both
+- GMP calls require pre-paying gas via GasService or including gasValue in ITS calls
+- ITS (Interchain Token Service) enables native cross-chain tokens without wrapping
+- Same ITS address (`0xB5FB...`) across all chains
+- `tokenAddresses(symbol)` to look up the local address of an Axelar-supported token
+- Finality: typically 2-5 minutes depending on source chain
+- TVL: $800M+. Audited

package/sdk/src/skills/balancer-v2.md

@@ -0,0 +1,152 @@
+# Balancer V2
+
+Generalized AMM with weighted pools, single Vault architecture, and flash loans. Supports custom pool types (weighted, stable, linear, composable stable) and multi-token pools with up to 8 tokens per pool.
+
+## Category
+
+dex | Chains: Ethereum, Polygon, Arbitrum, Optimism, Gnosis, Avalanche, Base, BSC
+
+## Key Operations
+
+- **swap**: Execute a single swap through the Vault specifying pool ID and assets
+- **addLiquidity**: Join a pool by depositing tokens via the Vault
+- **removeLiquidity**: Exit a pool by withdrawing tokens via the Vault
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/balancer-v2";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { BalancerV2VaultABI as IVault } from "./abis";
+
+function main(
+  vaultAddress: Address,
+  poolId: Uint256,
+  assetIn: Address,
+  assetOut: Address,
+  amount: Uint256,
+  limit: Uint256,
+  sender: Address,
+  recipient: Address,
+): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  return vault.swap(
+    {
+      poolId: poolId,
+      kind: 0,
+      assetIn: assetIn,
+      assetOut: assetOut,
+      amount: amount,
+      userData: 0x00,
+    },
+    { sender: sender, fromInternalBalance: false, recipient: recipient, toInternalBalance: false },
+    limit,
+    99999999999,
+  );
+}
+```
+
+- `vaultAddress`: The Balancer V2 Vault (same address on ALL chains: `0xBA12222222228d8Ba445958a75a0704d566BF2C8`)
+- `poolId`: bytes32 identifier for the specific pool (encodes pool address + pool type + nonce)
+- `assetIn` / `assetOut`: Token addresses to swap between
+- `amount`: Input amount when `kind=0` (GIVEN_IN) or output amount when `kind=1` (GIVEN_OUT)
+- `limit`: Maximum input (GIVEN_OUT) or minimum output (GIVEN_IN) for slippage protection
+- `sender`: Address providing the input tokens (must have approved the Vault)
+- `recipient`: Address receiving the output tokens
+- `userData`: Extra data for the pool (usually `0x00` for swaps)
+- `fromInternalBalance` / `toInternalBalance`: Use Vault internal balances (set false for standard swaps)
+
+### addLiquidity
+
+```typescript
+import { BalancerV2VaultABI as IVault } from "./abis";
+
+function main(
+  vaultAddress: Address,
+  poolId: Uint256,
+  sender: Address,
+  recipient: Address,
+  userData: bytes,
+): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  vault.joinPool(poolId, sender, recipient, {
+    assets: [],
+    maxAmountsIn: [],
+    userData: userData,
+    fromInternalBalance: false,
+  });
+  return 1;
+}
+```
+
+- `userData`: ABI-encoded join type and amounts. Join types vary by pool kind (e.g., EXACT_TOKENS_IN_FOR_BPT_OUT, TOKEN_IN_FOR_EXACT_BPT_OUT)
+- `assets`: Array of token addresses in the pool (must match pool composition order)
+- `maxAmountsIn`: Maximum amounts to deposit per token (slippage protection)
+
+### removeLiquidity
+
+```typescript
+import { BalancerV2VaultABI as IVault } from "./abis";
+
+function main(
+  vaultAddress: Address,
+  poolId: Uint256,
+  sender: Address,
+  recipient: Address,
+  userData: bytes,
+): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  vault.exitPool(poolId, sender, recipient, {
+    assets: [],
+    minAmountsOut: [],
+    userData: userData,
+    toInternalBalance: false,
+  });
+  return 1;
+}
+```
+
+- `userData`: ABI-encoded exit type and amounts. Exit types: EXACT_BPT_IN_FOR_ONE_TOKEN_OUT, EXACT_BPT_IN_FOR_TOKENS_OUT, BPT_IN_FOR_EXACT_TOKENS_OUT
+- `minAmountsOut`: Minimum amounts to receive per token (slippage protection)
+
+## Key Addresses
+
+| Chain     | Contract | Address                                      |
+| --------- | -------- | -------------------------------------------- |
+| Ethereum  | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| Polygon   | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| Arbitrum  | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| Optimism  | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| Gnosis    | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| Avalanche | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| Base      | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+| BSC       | Vault    | `0xBA12222222228d8Ba445958a75a0704d566BF2C8` |
+
+## ABI Methods
+
+### BalancerV2VaultABI
+
+- `swap(tuple(bytes32 poolId, uint8 kind, address assetIn, address assetOut, uint256 amount, bytes userData), tuple(address sender, bool fromInternalBalance, address recipient, bool toInternalBalance), uint256 limit, uint256 deadline) -> uint256 amountCalculated` - Execute a single swap. `kind`: 0=GIVEN_IN, 1=GIVEN_OUT
+- `batchSwap(uint8 kind, tuple[](bytes32 poolId, uint256 assetInIndex, uint256 assetOutIndex, uint256 amount, bytes userData), address[] assets, tuple(address sender, bool fromInternalBalance, address recipient, bool toInternalBalance), int256[] limits, uint256 deadline) -> int256[] assetDeltas` - Execute multi-hop swap through multiple pools in one transaction
+- `joinPool(bytes32 poolId, address sender, address recipient, tuple(address[] assets, uint256[] maxAmountsIn, bytes userData, bool fromInternalBalance))` - Deposit tokens into a pool
+- `exitPool(bytes32 poolId, address sender, address recipient, tuple(address[] assets, uint256[] minAmountsOut, bytes userData, bool toInternalBalance))` - Withdraw tokens from a pool
+- `flashLoan(address recipient, address[] tokens, uint256[] amounts, bytes userData)` - Flash loan from the Vault (zero fee for Balancer pools)
+- `getPoolTokens(bytes32 poolId) -> (address[] tokens, uint256[] balances, uint256 lastChangeBlock)` - Query pool token composition and balances (view)
+
+## Notes
+
+- Single Vault contract holds ALL pool liquidity (same address `0xBA12...` on every chain)
+- Pools are identified by `bytes32 poolId`, NOT by contract address
+- The Vault model means tokens only need to be approved to ONE contract for all Balancer pools
+- Weighted pools: custom token weights (e.g., 80/20 ETH/USDC); Stable pools: pegged assets; Linear pools: wrapping yield-bearing tokens
+- `batchSwap` is gas-efficient for multi-hop trades since tokens only move between Vault internal accounts
+- Flash loans from Balancer Vault are zero-fee when the swap route stays within Balancer pools
+- Internal balances: users can keep tokens in the Vault to save gas on repeated trades
+- `userData` encoding varies by pool type - check Balancer docs for the specific pool's join/exit types
+- Use Balancer for multi-token pools (3+ tokens), weighted index exposure, or flash loans

package/sdk/src/skills/base-bridge.md

@@ -0,0 +1,81 @@
+# Base Native Bridge
+
+Official Base L1StandardBridge for depositing ETH and ERC-20 tokens from Ethereum to Base. OP Stack architecture with 7-day withdrawal finality.
+
+## Category
+
+native L2 bridge | Direction: L1 to L2 (Ethereum to Base) | Chains: Ethereum (1), Base (8453)
+
+## SauceScript Functions
+
+### depositETH
+
+Deposit ETH from Ethereum L1 to Base L2.
+
+```typescript
+import { BaseL1StandardBridgeABI as IL1StandardBridge } from "./abis";
+
+function main(bridgeAddress: Address): Uint256 {
+  const bridge = IL1StandardBridge.at(bridgeAddress);
+  bridge.depositETH(200000, 0x00);
+  return 1;
+}
+```
+
+- ETH amount is sent as `msg.value`
+- `_minGasLimit`: Minimum gas for the L2 deposit execution (200000 is a safe default)
+- `_extraData`: Optional extra data (typically `0x00`)
+
+### depositERC20
+
+Deposit ERC-20 tokens from Ethereum L1 to Base L2.
+
+```typescript
+import { BaseL1StandardBridgeABI as IL1StandardBridge } from "./abis";
+
+function main(
+  bridgeAddress: Address,
+  l1Token: Address,
+  l2Token: Address,
+  amount: Uint256,
+): Uint256 {
+  const bridge = IL1StandardBridge.at(bridgeAddress);
+  bridge.depositERC20(l1Token, l2Token, amount, 200000, 0x00);
+  return 1;
+}
+```
+
+- `l1Token`: Token address on Ethereum L1
+- `l2Token`: Corresponding token address on Base L2 (must be the official bridged representation)
+- `amount`: Amount of tokens to deposit
+- `_minGasLimit`: Minimum gas for L2 execution (200000 is a safe default)
+- `_extraData`: Optional extra data (typically `0x00`)
+- Requires ERC-20 approval to the L1StandardBridge
+
+## Deployed Addresses
+
+| Chain    | Contract         | Address                                      |
+| -------- | ---------------- | -------------------------------------------- |
+| Ethereum | l1StandardBridge | `0x3154Cf16ccdb4C6d922629664174b904d80F2C35` |
+| Base     | l2StandardBridge | `0x4200000000000000000000000000000000000010` |
+
+## ABI Reference
+
+### BaseL1StandardBridgeABI
+
+- `depositETH(uint32 _minGasLimit, bytes _extraData)` [payable] - Deposit ETH to your own address on Base. Amount = msg.value
+- `depositERC20(address _l1Token, address _l2Token, uint256 _amount, uint32 _minGasLimit, bytes _extraData)` - Deposit ERC-20 tokens to your own address on Base
+- `depositETHTo(address _to, uint32 _minGasLimit, bytes _extraData)` [payable] - Deposit ETH to a specific recipient on Base
+- `depositERC20To(address _l1Token, address _l2Token, address _to, uint256 _amount, uint32 _minGasLimit, bytes _extraData)` - Deposit ERC-20 tokens to a specific recipient on Base
+
+## Notes
+
+- **L1 to L2 only** via this contract. For L2 to L1 withdrawals, use the L2StandardBridge on Base (takes 7 days)
+- OP Stack architecture -- same bridge pattern as Optimism, Mode, Zora
+- `depositETH` / `depositERC20` send to `msg.sender` on L2. Use `depositETHTo` / `depositERC20To` to specify a different recipient
+- L1 to L2 deposits finalize in ~2-5 minutes (after L1 inclusion + sequencer processing)
+- L2 to L1 withdrawals require 7-day challenge period (optimistic rollup security)
+- `_l2Token` must be the official bridged token representation on Base -- incorrect L2 token address will cause deposit to fail
+- Canonical bridge -- no third-party risk, secured by the Base (OP Stack) rollup itself
+- L2StandardBridge is at a predefined address: `0x4200000000000000000000000000000000000010`
+- Audited

package/sdk/src/skills/baseswap.md

@@ -0,0 +1,125 @@
+# BaseSwap
+
+Base-native DEX with UniV2-style constant product pools (x*y=k). Features yield farming, launchpad, and NFT marketplace. A simple and straightforward fork of Uniswap V2 on Base.
+
+## Category
+
+dex | Chains: Base
+
+## Key Operations
+
+- **swap**: Swap exact input tokens through a routing path
+- **addLiquidity**: Deposit two tokens to mint LP tokens
+- **removeLiquidity**: Burn LP tokens to withdraw underlying tokens
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/baseswap";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { BaseSwapRouterABI as IRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  path: Address[],
+  amountIn: Uint256,
+  amountOutMin: Uint256,
+  recipient: Address,
+): Uint256[] {
+  const router = IRouter.at(routerAddress);
+  return router.swapExactTokensForTokens(amountIn, amountOutMin, path, recipient, 99999999999);
+}
+```
+
+- `routerAddress`: BaseSwap V2 Router on Base (`0x327Df1E6de05895d2ab08513aaDD9313Fe505d86`)
+- `path`: Ordered token address array for the swap route
+- `amountIn`: Exact input amount (in wei)
+- `amountOutMin`: Minimum output for slippage protection
+- `recipient`: Address to receive output tokens
+
+### addLiquidity
+
+```typescript
+import { BaseSwapRouterABI as IRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
+  amountADesired: Uint256,
+  amountBDesired: Uint256,
+  amountAMin: Uint256,
+  amountBMin: Uint256,
+  recipient: Address,
+): { amountA: Uint256; amountB: Uint256; liquidity: Uint256 } {
+  const router = IRouter.at(routerAddress);
+  return router.addLiquidity(
+    tokenA,
+    tokenB,
+    amountADesired,
+    amountBDesired,
+    amountAMin,
+    amountBMin,
+    recipient,
+    99999999999,
+  );
+}
+```
+
+- Both tokens must be approved to the router
+
+### removeLiquidity
+
+```typescript
+import { BaseSwapRouterABI as IRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
+  liquidity: Uint256,
+  amountAMin: Uint256,
+  amountBMin: Uint256,
+  recipient: Address,
+): { amountA: Uint256; amountB: Uint256 } {
+  const router = IRouter.at(routerAddress);
+  return router.removeLiquidity(
+    tokenA,
+    tokenB,
+    liquidity,
+    amountAMin,
+    amountBMin,
+    recipient,
+    99999999999,
+  );
+}
+```
+
+- LP token must be approved to the router
+
+## Key Addresses
+
+| Chain | Contract  | Address                                      |
+| ----- | --------- | -------------------------------------------- |
+| Base  | V2 Router | `0x327Df1E6de05895d2ab08513aaDD9313Fe505d86` |
+
+## ABI Methods
+
+### BaseSwapRouterABI
+
+- `swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) -> uint256[] amounts` - Swap exact input along path
+- `addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB, uint256 liquidity)` - Add liquidity and mint LP tokens
+- `removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB)` - Burn LP tokens for underlying
+
+## Notes
+
+- Standard Uniswap V2 fork interface; 0.3% fee per swap
+- Base-only deployment
+- For most Base swaps, Aerodrome has higher liquidity; use BaseSwap for pairs where Aerodrome has less depth or when BSWAP farming rewards are active
+- Both tokens must be ERC20-approved to the Router before swap/addLiquidity

package/sdk/src/skills/beefy.md

@@ -0,0 +1,89 @@
+# Beefy Finance
+
+Multi-chain yield optimizer. Auto-compounds rewards from LP tokens and other yield sources across many chains.
+
+## Category
+
+yield | Chains: Ethereum, BSC, Polygon, Arbitrum, Optimism, Base, Avalanche
+
+## Key Operations
+
+- **deposit**: Deposit want tokens into Beefy vault
+- **depositAll**: Deposit entire balance of want token
+- **withdraw**: Withdraw by specifying share amount
+- **withdrawAll**: Withdraw entire position
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/beefy";
+```
+
+## SauceScript Examples
+
+```typescript
+// Deposit into Beefy vault
+import { BeefyVaultABI as IBeefyVault } from "./abis";
+function main(vaultAddress: Address, amount: Uint256): Uint256 {
+  const vault = IBeefyVault.at(vaultAddress);
+  vault.deposit(amount);
+  return 1;
+}
+
+// Deposit entire balance
+import { BeefyVaultABI as IBeefyVault } from "./abis";
+function main(vaultAddress: Address): Uint256 {
+  const vault = IBeefyVault.at(vaultAddress);
+  vault.depositAll();
+  return 1;
+}
+
+// Withdraw shares
+import { BeefyVaultABI as IBeefyVault } from "./abis";
+function main(vaultAddress: Address, shares: Uint256): Uint256 {
+  const vault = IBeefyVault.at(vaultAddress);
+  vault.withdraw(shares);
+  return 1;
+}
+
+// Withdraw all
+import { BeefyVaultABI as IBeefyVault } from "./abis";
+function main(vaultAddress: Address): Uint256 {
+  const vault = IBeefyVault.at(vaultAddress);
+  vault.withdrawAll();
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain     | Contract | Address                                      |
+| --------- | -------- | -------------------------------------------- |
+| Ethereum  | BIFI     | `0xB1F1ee126e9c96231Cc3d3fAD7C08b4cf873b1f1` |
+| BSC       | BIFI     | `0xCa3F508B8e4Dd382eE878A314789373D80A5190A` |
+| Polygon   | BIFI     | `0xFbdd194376de19a88F4A68671C339563c427310d` |
+| Arbitrum  | BIFI     | `0x99C409E5f62E4bd2AC142f17caFb6810B8F0BAAE` |
+| Optimism  | BIFI     | `0x4E720DD3Ac5CFe1e1fbDE4935f386Bb1C66F4642` |
+| Base      | BIFI     | `0xc55E93C62874D8100dBd2DfE307EDc1036ad5434` |
+| Avalanche | BIFI     | `0xd6070ae98b8069de6B494332d1A1a81B6179D960` |
+
+## ABI Methods
+
+### BeefyVaultABI
+
+- `deposit(uint256)` - Deposit want tokens, receive mooTokens (vault shares)
+- `depositAll()` - Deposit entire want token balance
+- `withdraw(uint256)` - Withdraw by burning shares
+- `withdrawAll()` - Withdraw entire position
+- `getPricePerFullShare()` - Current share price (18 decimals)
+- `balance()` - Total want tokens in vault
+- `balanceOf(address)` - Query mooToken (share) balance
+- `want()` - Address of the underlying want token
+
+## Notes
+
+- TVL: $300M+. Each vault has a unique address per strategy
+- Approve want token to vault before depositing
+- Use want() to discover which token a vault accepts
+- getPricePerFullShare() returns the exchange rate between shares and want tokens
+- Auto-compounds rewards - no manual claiming needed