@eco-incorp/sauce 0.99.0

package/sdk/src/skills/olympus.md

@@ -0,0 +1,46 @@
+# Olympus DAO
+
+Decentralized reserve currency protocol. OHM staking and bonding mechanism with protocol-owned liquidity and treasury management.
+
+## Category
+
+staking | Chains: Ethereum
+
+## Key Operations
+
+- **stake**: Stake OHM tokens
+- **unstake**: Unstake OHM tokens
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/olympus";
+```
+
+## SauceScript Examples
+
+```typescript
+// Stake OHM
+import { StakingABI as IStaking } from "./abis";
+
+function main(stakingAddress: Address, to: Address, amount: Uint256): Uint256 {
+  const staking = IStaking.at(stakingAddress);
+  return staking.stake(to, amount, 1, 1);
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | ohm      | `0x64aa3364F17a4D01c6f1751Fd97C2BD3D7e7f1D5` |
+| Ethereum | staking  | `0xB63cac384247597756545b500253ff8E607a8020` |
+
+## ABI Methods
+
+- `stake(address,uint256,bool,bool)` - Stake OHM
+- `unstake(address,uint256,bool,bool)` - Unstake OHM
+
+## Notes
+
+- Protocol-owned liquidity model. Rebase mechanism for staking rewards.

package/sdk/src/skills/oneinch.md

@@ -0,0 +1,63 @@
+# 1inch
+
+Leading DEX aggregator that finds optimal swap routes across multiple liquidity sources. Supports limit orders and Fusion mode for gasless swaps.
+
+## Category
+
+aggregator | Chains: Ethereum, Arbitrum, Optimism, Base, Polygon, BSC, Avalanche
+
+## Key Operations
+
+- **unoswap**: Single-source optimized swap via AggregationRouter
+- **swap**: Multi-source aggregated swap with custom routing
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/oneinch";
+```
+
+## SauceScript Examples
+
+```typescript
+// Unoswap (single-source swap)
+import { AggregationRouterV6ABI as IAggregationRouterV6 } from "./abis";
+function main(
+  routerAddress: Address,
+  srcToken: Address,
+  amount: Uint256,
+  minReturn: Uint256,
+): Uint256 {
+  const router = IAggregationRouterV6.at(routerAddress);
+  return router.unoswap(srcToken, amount, minReturn, []);
+}
+```
+
+## Key Addresses
+
+| Chain     | Contract            | Address                                      |
+| --------- | ------------------- | -------------------------------------------- |
+| Ethereum  | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+| Arbitrum  | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+| Optimism  | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+| Base      | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+| Polygon   | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+| BSC       | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+| Avalanche | aggregationRouterV6 | `0x111111125421cA6dc452d289314280a0f8842A65` |
+
+## ABI Methods
+
+### AggregationRouterV6ABI
+
+- `swap(address,tuple,bytes)` - Multi-source swap. Params: executor, desc (SwapDescription tuple: srcToken, dstToken, srcReceiver, dstReceiver, amount, minReturnAmount, flags), data (executor calldata). Payable. Returns (returnAmount, spentAmount)
+  - SwapDescription tuple: `{ srcToken, dstToken, srcReceiver, dstReceiver, amount, minReturnAmount, flags }`
+- `unoswap(address,uint256,uint256,uint256[])` - Single-source optimized swap. Params: srcToken, amount, minReturn, pools (encoded pool addresses with direction flags). Payable. Returns returnAmount
+
+## Notes
+
+- Same contract address across all 7 chains
+- V6 router is the latest version
+- unoswap is gas-efficient for single-pool swaps; swap handles complex multi-hop routes
+- pools[] in unoswap encodes pool addresses with swap direction in high bits
+- Fusion mode enables gasless swaps via order matching (off-chain, not in ABI)
+- Approve srcToken to aggregationRouterV6 before swapping

package/sdk/src/skills/openocean.md

@@ -0,0 +1,86 @@
+# OpenOcean
+
+Cross-chain DEX aggregator providing optimal swap routing across multiple DEXes and chains.
+
+## Category
+
+aggregator | Chains: Ethereum, Arbitrum, Optimism, BSC, Polygon, Avalanche, Fantom
+
+## Key Operations
+
+- **swap**: Execute aggregated swap via OpenOcean Exchange
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/openocean";
+```
+
+## SauceScript Examples
+
+```typescript
+// Swap via OpenOcean
+import { OpenOceanExchangeV2ABI as IOpenOceanExchange } from "./abis";
+function main(
+  exchangeAddress: Address,
+  caller: Address,
+  srcToken: Address,
+  dstToken: Address,
+  srcReceiver: Address,
+  dstReceiver: Address,
+  amount: Uint256,
+  minReturnAmount: Uint256,
+  guaranteedAmount: Uint256,
+  referrer: Address,
+  calls: bytes,
+): Uint256 {
+  const exchange = IOpenOceanExchange.at(exchangeAddress);
+  return exchange.swap(
+    caller,
+    {
+      srcToken: srcToken,
+      dstToken: dstToken,
+      srcReceiver: srcReceiver,
+      dstReceiver: dstReceiver,
+      amount: amount,
+      minReturnAmount: minReturnAmount,
+      guaranteedAmount: guaranteedAmount,
+      flags: 0,
+      referrer: referrer,
+      permit: 0x00,
+    },
+    calls,
+  );
+}
+```
+
+## Key Addresses
+
+| Chain     | Contract   | Address                                      |
+| --------- | ---------- | -------------------------------------------- |
+| Ethereum  | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+| Arbitrum  | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+| Optimism  | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+| BSC       | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+| Polygon   | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+| Avalanche | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+| Fantom    | exchangeV2 | `0x6352a56caadC4F1E25CD6c75970Fa768A3304e64` |
+
+## ABI Methods
+
+### OpenOceanExchangeV2ABI
+
+- `swap(address,tuple,bytes)` - Execute aggregated swap. Payable. Params: caller (msg.sender or executor), desc (SwapDescription tuple), calls (encoded swap calldata). Returns returnAmount
+  - SwapDescription tuple: `{ srcToken, dstToken, srcReceiver, dstReceiver, amount, minReturnAmount, guaranteedAmount, flags, referrer, permit }`
+  - `srcReceiver` - address that receives srcToken from caller
+  - `dstReceiver` - address that receives output tokens
+  - `guaranteedAmount` - guaranteed minimum output (can differ from minReturnAmount)
+  - `flags` - swap behavior flags (0 for default)
+  - `permit` - EIP-2612 permit data (0x00 if pre-approved)
+
+## Notes
+
+- TVL: $200M+. Same contract address across all 7 supported chains
+- Route computation via OpenOcean API - calls parameter comes from API response
+- Approve srcToken to exchangeV2 before swapping
+- caller is typically msg.sender; srcReceiver receives tokens from the caller

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

@@ -0,0 +1,81 @@
+# Optimism Native Bridge
+
+Official Optimism L1StandardBridge for depositing ETH and ERC-20 tokens from Ethereum to Optimism. OP Stack architecture with 7-day withdrawal finality.
+
+## Category
+
+native L2 bridge | Direction: L1 to L2 (Ethereum to Optimism) | Chains: Ethereum (1), Optimism (10)
+
+## SauceScript Functions
+
+### depositETH
+
+Deposit ETH from Ethereum L1 to Optimism L2.
+
+```typescript
+import { OptimismL1StandardBridgeABI 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 Optimism L2.
+
+```typescript
+import { OptimismL1StandardBridgeABI 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 Optimism 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 | `0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1` |
+| Optimism | l2StandardBridge | `0x4200000000000000000000000000000000000010` |
+
+## ABI Reference
+
+### OptimismL1StandardBridgeABI
+
+- `depositETH(uint32 _minGasLimit, bytes _extraData)` [payable] - Deposit ETH to your own address on L2. Amount = msg.value
+- `depositERC20(address _l1Token, address _l2Token, uint256 _amount, uint32 _minGasLimit, bytes _extraData)` - Deposit ERC-20 tokens to your own address on L2
+- `depositETHTo(address _to, uint32 _minGasLimit, bytes _extraData)` [payable] - Deposit ETH to a specific recipient on L2
+- `depositERC20To(address _l1Token, address _l2Token, address _to, uint256 _amount, uint32 _minGasLimit, bytes _extraData)` - Deposit ERC-20 tokens to a specific recipient on L2
+
+## Notes
+
+- **L1 to L2 only** via this contract. For L2 to L1 withdrawals, use the L2StandardBridge on Optimism (takes 7 days)
+- OP Stack architecture -- same pattern used by Base, Mode, Zora, and other OP chains
+- `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 Optimism -- incorrect L2 token address will cause deposit to fail
+- Canonical bridge -- no third-party risk, secured by the Optimism rollup itself
+- L2StandardBridge is at a predefined address: `0x4200000000000000000000000000000000000010`
+- Audited

package/sdk/src/skills/opyn.md

@@ -0,0 +1,70 @@
+# Opyn
+
+DeFi options protocol known for Squeeth (squared ETH), a power perpetual that provides leveraged ETH exposure without liquidations.
+
+## Category
+
+options | Chains: Ethereum
+
+## Key Operations
+
+- **burnSqueeth**: Burn oSQTH to close/reduce a squeeth position
+- **withdrawCollateral**: Withdraw ETH collateral from a vault
+- **mintSqueeth**: Mint oSQTH (open squeeth position) by depositing ETH collateral
+- **deposit**: Deposit additional ETH collateral to an existing vault
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/opyn";
+```
+
+## SauceScript Examples
+
+```typescript
+// Burn Squeeth to reduce position
+import { ControllerABI as IController } from "./abis";
+function main(
+  controllerAddress: Address,
+  vaultId: Uint256,
+  amount: Uint256,
+  withdrawAmount: Uint256,
+): Uint256 {
+  const controller = IController.at(controllerAddress);
+  controller.burnPowerPerpAmount(vaultId, amount, withdrawAmount);
+  return 1;
+}
+
+// Withdraw collateral from vault
+import { ControllerABI as IController } from "./abis";
+function main(controllerAddress: Address, vaultId: Uint256, amount: Uint256): Uint256 {
+  const controller = IController.at(controllerAddress);
+  controller.withdraw(vaultId, amount);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract   | Address                                      |
+| -------- | ---------- | -------------------------------------------- |
+| Ethereum | controller | `0x64187ae08781B09368e6253F9E94951243A493D5` |
+| Ethereum | oSQTH      | `0xf1B99e3E573A1a9C5E6B2Ce818b617F0E664E86B` |
+
+## ABI Methods
+
+### ControllerABI
+
+- `mintPowerPerpAmount(uint256,uint256,uint256)` - Mint oSQTH. Params: vaultId (0 to create new), powerPerpAmount (oSQTH to mint), uniTokenId (Uniswap LP NFT as collateral, 0 for ETH). Payable (send ETH as collateral). Returns (vaultId, wPowerPerpAmount)
+- `burnPowerPerpAmount(uint256,uint256,uint256)` - Burn oSQTH to close position. Params: vaultId, powerPerpAmount (oSQTH to burn), withdrawAmount (ETH collateral to withdraw)
+- `deposit(uint256)` - Deposit additional ETH collateral. Params: vaultId. Payable (ETH sent = deposit amount)
+- `withdraw(uint256,uint256)` - Withdraw ETH collateral. Params: vaultId, amount (ETH to withdraw)
+
+## Notes
+
+- Squeeth = squared ETH exposure (ETH^2), providing leveraged upside without liquidations
+- Funding rate applies instead of liquidations - long positions pay short positions
+- oSQTH is the ERC-20 power perpetual token
+- Vaults hold ETH collateral backing minted oSQTH
+- vaultId=0 in mintPowerPerpAmount creates a new vault
+- Can use Uniswap V3 LP NFTs as collateral via uniTokenId parameter

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

@@ -0,0 +1,151 @@
+# PancakeSwap V2
+
+The most popular DEX on BNB Chain using the constant product AMM model (x*y=k). Forked from Uniswap V2 with additional features like yield farming and lottery. Expanded to 6 chains.
+
+## Category
+
+dex | Chains: BSC, Ethereum, Arbitrum, Base, Linea, opBNB
+
+## Key Operations
+
+- **swap**: Swap exact input tokens through a routing path
+- **addLiquidity**: Deposit two tokens to mint CAKE-LP tokens
+- **removeLiquidity**: Burn LP tokens to withdraw underlying tokens
+
+## SDK Usage
+
+```typescript
+import {
+  protocolInfo,
+  deployments,
+  sauceFunctions,
+} from "@eco-incorp/sauce/protocols/pancakeswap-v2";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { PancakeSwapV2RouterABI 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`: PancakeSwap V2 Router for the target chain
+- `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 { PancakeSwapV2RouterABI 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,
+  );
+}
+```
+
+- `amountADesired` / `amountBDesired`: Ideal deposit amounts (router adjusts to maintain ratio)
+- `amountAMin` / `amountBMin`: Minimum deposits (slippage protection)
+- Both tokens must be approved to the router
+
+### removeLiquidity
+
+```typescript
+import { PancakeSwapV2RouterABI 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,
+  );
+}
+```
+
+- `liquidity`: Amount of LP tokens to burn
+- LP token must be approved to the router
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| BSC      | Factory  | `0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73` |
+| BSC      | Router   | `0x10ED43C718714eb63d5aA57B78B54704E256024E` |
+| Ethereum | Factory  | `0x1097053Fd2ea711dad45caCcc45EfF7548fCB362` |
+| Ethereum | Router   | `0xEfF92A263d31888d860bD50809A8D171709b7b1c` |
+| Arbitrum | Factory  | `0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E` |
+| Arbitrum | Router   | `0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb` |
+| Base     | Factory  | `0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E` |
+| Base     | Router   | `0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb` |
+| Linea    | Factory  | `0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E` |
+| Linea    | Router   | `0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb` |
+| opBNB    | Factory  | `0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E` |
+| opBNB    | Router   | `0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb` |
+
+## ABI Methods
+
+### PancakeSwapV2RouterABI
+
+- `swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) -> uint256[] amounts` - Swap exact input along path
+- `swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) -> uint256[] amounts` - Swap to get exact output
+- `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
+- `getAmountsOut(uint256 amountIn, address[] path) -> uint256[] amounts` - Quote output amounts (view)
+
+### PancakeSwapV2FactoryABI
+
+- `getPair(address tokenA, address tokenB) -> address pair` - Look up pair address (view)
+- `createPair(address tokenA, address tokenB) -> address pair` - Create a new pair
+
+## Notes
+
+- Same Uniswap V2 interface; 0.25% fee per swap (0.17% to LPs, 0.03% to treasury, 0.05% to CAKE buyback)
+- BSC Router address differs from other chains (BSC was the original deployment)
+- Arbitrum, Base, Linea, and opBNB share the same Factory and Router addresses
+- LP tokens can be staked in MasterChef for CAKE rewards
+- PancakeSwap is the default choice for BSC trading; use PancakeSwap V3 for concentrated liquidity

package/sdk/src/skills/pancakeswap-v3.md

@@ -0,0 +1,104 @@
+# PancakeSwap V3
+
+Concentrated liquidity AMM on BNB Chain and multiple EVM chains. Built on Uniswap V3 architecture with custom fee tiers and farming integration via the SmartRouter.
+
+## Category
+
+dex | Chains: BSC, Ethereum, Arbitrum, Base, Linea
+
+## Key Operations
+
+- **swap**: Exact input single-hop swap with fee tier selection via SmartRouter
+
+## SDK Usage
+
+```typescript
+import {
+  protocolInfo,
+  deployments,
+  sauceFunctions,
+} from "@eco-incorp/sauce/protocols/pancakeswap-v3";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { PancakeSwapV3SmartRouterABI as ISmartRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenIn: Address,
+  tokenOut: Address,
+  fee: Uint256,
+  amountIn: Uint256,
+  amountOutMin: Uint256,
+  recipient: Address,
+): Uint256 {
+  const router = ISmartRouter.at(routerAddress);
+  return router.exactInputSingle({
+    tokenIn: tokenIn,
+    tokenOut: tokenOut,
+    fee: fee,
+    recipient: recipient,
+    amountIn: amountIn,
+    amountOutMinimum: amountOutMin,
+    sqrtPriceLimitX96: 0,
+  });
+}
+```
+
+- `routerAddress`: PancakeSwap V3 SmartRouter address for the target chain
+- `tokenIn` / `tokenOut`: Input and output token addresses
+- `fee`: Pool fee tier in hundredths of a bip. Common: `100` (0.01%), `500` (0.05%), `2500` (0.25%), `10000` (1%)
+- `amountIn`: Exact input amount (in wei)
+- `amountOutMin`: Minimum output for slippage protection
+- `recipient`: Address to receive output tokens
+- `sqrtPriceLimitX96`: Set to `0` to accept any price
+- Note: SmartRouter does NOT include a `deadline` param in the struct (unlike Uniswap V3)
+
+## Key Addresses
+
+| Chain    | Contract    | Address                                      |
+| -------- | ----------- | -------------------------------------------- |
+| BSC      | Factory     | `0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865` |
+| BSC      | SmartRouter | `0x13f4EA83D0bd40E75C8222255bc855a974568Dd4` |
+| BSC      | NFPM        | `0x46A15B0b27311cedF172AB29E4f4766fbE7F4364` |
+| Ethereum | Factory     | `0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865` |
+| Ethereum | SmartRouter | `0x13f4EA83D0bd40E75C8222255bc855a974568Dd4` |
+| Ethereum | NFPM        | `0x46A15B0b27311cedF172AB29E4f4766fbE7F4364` |
+| Arbitrum | Factory     | `0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865` |
+| Arbitrum | SmartRouter | `0x32226588378236Fd0c7c4053999F88aC0e5cAc77` |
+| Arbitrum | NFPM        | `0x46A15B0b27311cedF172AB29E4f4766fbE7F4364` |
+| Base     | Factory     | `0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865` |
+| Base     | SmartRouter | `0x678Aa4bF4E210cf2166753e054d5b7c31cc7fa86` |
+| Base     | NFPM        | `0x46A15B0b27311cedF172AB29E4f4766fbE7F4364` |
+| Linea    | Factory     | `0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865` |
+| Linea    | SmartRouter | `0x678Aa4bF4E210cf2166753e054d5b7c31cc7fa86` |
+| Linea    | NFPM        | `0x46A15B0b27311cedF172AB29E4f4766fbE7F4364` |
+
+## ABI Methods
+
+### PancakeSwapV3SmartRouterABI
+
+- `exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) -> uint256 amountOut` - Single-hop swap with exact input amount
+- `exactOutputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96)) -> uint256 amountIn` - Single-hop swap specifying exact output desired
+
+### PancakeSwapV3FactoryABI
+
+- `getPool(address tokenA, address tokenB, uint24 fee) -> address pool` - Look up pool address for token pair and fee tier (view)
+
+### PancakeSwapV3NFPMABI
+
+- `mint(tuple(address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, uint256 amount0Desired, uint256 amount1Desired, uint256 amount0Min, uint256 amount1Min, address recipient, uint256 deadline)) -> (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1)` - Create new concentrated liquidity position NFT
+
+## Notes
+
+- Fee tiers may differ from Uniswap V3; PancakeSwap includes a 2500 (0.25%) tier
+- SmartRouter struct does NOT include `deadline` (unlike Uniswap V3's router)
+- Factory address is the same across all chains; SmartRouter addresses vary
+- NFPM address is consistent across all chains (`0x46A15B...`)
+- Input token must be ERC20-approved to the SmartRouter for swaps
+- Both tokens must be ERC20-approved to the NFPM for minting positions
+- Prefer V3 over V2 for major pairs on BSC for better capital efficiency

package/sdk/src/skills/paraswap.md

@@ -0,0 +1,67 @@
+# ParaSwap
+
+Multi-chain DEX aggregator optimizing swap rates across decentralized exchanges. Supports limit orders and delta algorithm for MEV protection.
+
+## Category
+
+aggregator | Chains: Ethereum, Arbitrum, Optimism, Polygon, BSC, Avalanche, Base
+
+## Key Operations
+
+- **simpleSwap**: Execute a simple single-path swap via Augustus router
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/paraswap";
+```
+
+## SauceScript Examples
+
+```typescript
+// Note: ParaSwap requires off-chain route computation via API before on-chain execution.
+// The simpleSwap function uses complex tuple params populated from API response.
+```
+
+## Key Addresses
+
+| Chain     | Contract   | Address                                      |
+| --------- | ---------- | -------------------------------------------- |
+| Ethereum  | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+| Ethereum  | augustusV6 | `0x6A000F20005980200259B80c5102003040001068` |
+| Arbitrum  | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+| Arbitrum  | augustusV6 | `0x6A000F20005980200259B80c5102003040001068` |
+| Optimism  | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+| Polygon   | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+| BSC       | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+| Avalanche | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+| Base      | augustusV5 | `0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57` |
+
+## ABI Methods
+
+### AugustusV5ABI
+
+- `simpleSwap(tuple)` - Simple single-path swap. Payable. Returns receivedAmount. Tuple params:
+  - `fromToken` (address) - Source token
+  - `toToken` (address) - Destination token
+  - `fromAmount` (uint256) - Input amount
+  - `toAmount` (uint256) - Expected output
+  - `expectedAmount` (uint256) - Expected amount for positive slippage tracking
+  - `callees` (address[]) - DEX contracts to call
+  - `exchangeData` (bytes) - Encoded calldata for each callee
+  - `startIndexes` (uint256[]) - Byte offsets in exchangeData for each callee
+  - `values` (uint256[]) - ETH values for each callee call
+  - `beneficiary` (address) - Recipient of output tokens
+  - `partner` (address) - Partner/referrer address
+  - `feePercent` (uint256) - Fee percentage
+  - `permit` (bytes) - EIP-2612 permit data (empty if pre-approved)
+  - `deadline` (uint256) - Transaction deadline
+  - `uuid` (bytes16) - Unique swap identifier
+
+## Notes
+
+- Augustus V5 and V6 both deployed on all chains
+- Delta algorithm protects against MEV/sandwich attacks
+- Route computation happens off-chain via ParaSwap API - callees/exchangeData come from API
+- Approve srcToken to Augustus contract before swapping
+- V6 is newer but V5 is more widely integrated