@eco-incorp/sauce 0.99.0

package/sdk/src/skills/spookyswap.md

@@ -0,0 +1,126 @@
+# SpookySwap
+
+The largest DEX on Fantom with UniV2-style constant product pools (x*y=k). Features yield farming, cross-chain bridges, and limit orders. The default trading venue on the Fantom network.
+
+## Category
+
+dex | Chains: Fantom
+
+## 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/spookyswap";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { SpookySwapRouterABI 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`: SpookySwap Router on Fantom (`0xa6AD18C2aC47803E193F75c3677b14BF19B94883`)
+- `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 { SpookySwapRouterABI 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 { SpookySwapRouterABI 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                                      |
+| ------ | --------- | -------------------------------------------- |
+| Fantom | V2 Router | `0xa6AD18C2aC47803E193F75c3677b14BF19B94883` |
+
+## ABI Methods
+
+### SpookySwapRouterABI
+
+- `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.2% fee per swap (lower than standard 0.3%)
+- Fantom-only deployment; the dominant DEX on Fantom
+- BOO token is the governance/staking token (stake for xBOO to earn fees)
+- SushiSwap is also deployed on Fantom as an alternative
+- Both tokens must be ERC20-approved to the Router before swap/addLiquidity

package/sdk/src/skills/squid.md

@@ -0,0 +1,71 @@
+# Squid Router
+
+Cross-chain liquidity router built on Axelar. Enables one-click cross-chain swaps combining bridge and DEX operations.
+
+## Category
+
+bridge aggregator | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), BSC (56), Avalanche (43114)
+
+## SauceScript Functions
+
+### bridge
+
+Bridge tokens cross-chain via Squid Router.
+
+```typescript
+import { SquidRouterABI as ISquidRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  token: Address,
+  amount: Uint256,
+  bridgedTokenSymbol: string,
+  destinationChain: string,
+  destinationAddress: string,
+): Uint256 {
+  const router = ISquidRouter.at(routerAddress);
+  router.callBridge(token, amount, bridgedTokenSymbol, destinationChain, destinationAddress, 0x00);
+  return 1;
+}
+```
+
+- `token`: ERC-20 token address to bridge on source chain
+- `amount`: Amount of tokens to bridge
+- `bridgedTokenSymbol`: Symbol of the bridged token on Axelar (e.g. "axlUSDC", "WETH")
+- `destinationChain`: Axelar chain name string (e.g. "ethereum", "arbitrum", "Polygon")
+- `destinationAddress`: Recipient address on the destination chain (as string)
+- `payload`: Optional calldata to execute on destination. `0x00` for simple transfers
+- Requires ERC-20 approval to the Squid Router
+
+## Deployed Addresses
+
+| Chain     | Contract    | Address                                      |
+| --------- | ----------- | -------------------------------------------- |
+| Ethereum  | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+| Arbitrum  | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+| Optimism  | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+| Base      | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+| Polygon   | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+| BSC       | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+| Avalanche | squidRouter | `0xce16F69375520ab01377ce7B88f5BA8C48F8D666` |
+
+## ABI Reference
+
+### SquidRouterABI
+
+- `bridgeCall(address token, uint256 amount, ISquidMulticall.Call[] calls, string bridgedTokenSymbol, string destinationChain, string destinationAddress)` [payable] - Bridge with pre-bridge swap steps. `calls` is an array of swap operations to execute before bridging
+- `callBridge(address token, uint256 amount, string bridgedTokenSymbol, string destinationChain, string destinationAddress, bytes payload)` [payable] - Simple bridge without pre-bridge swaps. `payload` is optional calldata for destination execution
+
+ISquidMulticall.Call tuple: `(uint8 callType, address target, uint256 value, bytes callData, bytes payload)`
+
+## Notes
+
+- Built on Axelar GMP -- uses Axelar chain name strings for destination (e.g. "ethereum", "arbitrum", "Polygon")
+- `callBridge` for simple token bridges; `bridgeCall` for swap-then-bridge (includes pre-bridge DEX swaps)
+- Same Router address (`0xce16F6...`) deployed across all supported chains
+- `bridgedTokenSymbol` must match the Axelar-registered symbol for the bridged asset
+- The `payload` parameter in `callBridge` enables post-bridge execution on the destination chain
+- `bridgeCall`'s `calls` array allows chaining multiple swap steps before the bridge
+- Requires ERC-20 approval to the Squid Router address
+- Finality: 2-5 minutes (depends on Axelar validator consensus)
+- TVL: $100M+. Audited

package/sdk/src/skills/stader.md

@@ -0,0 +1,53 @@
+# Stader
+
+Multi-chain liquid staking protocol. ETHx is Stader's non-rebasing liquid staking token for Ethereum.
+
+## Category
+
+liquid-staking | Chains: Ethereum
+
+## Key Operations
+
+- **deposit**: Stake ETH to receive ETHx
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/stader";
+```
+
+## SauceScript Examples
+
+```typescript
+// Stake ETH for ETHx
+import { StakePoolManagerABI as IStakePoolManager } from "./abis";
+function main(stakePoolManagerAddress: Address, receiver: Address): Uint256 {
+  const pool = IStakePoolManager.at(stakePoolManagerAddress);
+  return pool.deposit(receiver);
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract         | Address                                      |
+| -------- | ---------------- | -------------------------------------------- |
+| Ethereum | ETHx             | `0xA35b1B31Ce002FBF2058D22F30f95D405200A15b` |
+| Ethereum | stakePoolManager | `0xcf5EA1b38380f6aF39068375516Daf40Ed70D299` |
+
+## ABI Methods
+
+### StakePoolManagerABI
+
+- `deposit(address)` - Stake ETH (payable), receive ETHx. Param: receiver address. Returns ETHx amount
+- `getExchangeRate()` - Current ETHx/ETH exchange rate
+
+### ETHxABI
+
+- `balanceOf(address)` - Query ETHx balance
+- `approve(address,uint256)` - Approve ETHx spending
+
+## Notes
+
+- TVL: $300M+. ETHx is non-rebasing (value accrues over time)
+- deposit() is payable - send ETH as msg.value, pass receiver address
+- Compatible with EigenLayer restaking (can deposit into stETH/ETHx strategies)

package/sdk/src/skills/stargate.md

@@ -0,0 +1,83 @@
+# Stargate
+
+Omnichain liquidity transport protocol built on LayerZero. Provides native asset bridging with unified liquidity pools.
+
+## Category
+
+bridge | Direction: L2-to-L2, L1-to-L2, L2-to-L1 (any-to-any) | Chains: Ethereum (1), Arbitrum (42161), Base (8453)
+
+## SauceScript Functions
+
+### bridge
+
+Send tokens cross-chain via Stargate pool using LayerZero messaging.
+
+```typescript
+import { StargatePoolABI as IStargatePool } from "./abis";
+
+function main(
+  poolAddress: Address,
+  dstEid: Uint256,
+  recipient: Uint256,
+  amount: Uint256,
+  minAmount: Uint256,
+): {
+  msgReceipt: { guid: Uint256; nonce: Uint256; fee: { nativeFee: Uint256; lzTokenFee: Uint256 } };
+  oftReceipt: { amountSentLD: Uint256; amountReceivedLD: Uint256 };
+} {
+  const pool = IStargatePool.at(poolAddress);
+  return pool.send(
+    {
+      dstEid: dstEid,
+      to: recipient,
+      amountLD: amount,
+      minAmountLD: minAmount,
+      extraOptions: 0x00,
+      composeMsg: 0x00,
+      oftCmd: 0x00,
+    },
+    { nativeFee: ctx.msgValue(), lzTokenFee: 0 },
+    ctx.msgSender(),
+  );
+}
+```
+
+- `poolAddress`: Token-specific pool (e.g. poolUSDC, poolNative)
+- `dstEid`: LayerZero endpoint ID for destination chain (NOT the EVM chain ID)
+- `recipient`: Destination address as bytes32 (left-padded)
+- `amount`: Amount in token's native decimals (LD = local decimals)
+- `minAmount`: Minimum amount to receive on destination (slippage protection)
+- Requires native token (ETH) for LayerZero messaging fee (sent as msg.value)
+- Requires ERC-20 approval to the pool for non-native tokens
+
+## Deployed Addresses
+
+| Chain    | Contract   | Address                                      |
+| -------- | ---------- | -------------------------------------------- |
+| Ethereum | poolNative | `0x77b2043768d28E9C9aB44E1aBfC95944bcE57931` |
+| Ethereum | poolUSDC   | `0xc026395860Db2d07ee33e05fE50ed7bD583189C7` |
+| Ethereum | poolUSDT   | `0x933597a323Eb81cAe705C5bC29985172fd5A3973` |
+| Arbitrum | poolNative | `0xA45B5130f36CDcA45667738e2a258AB09f4A5f7F` |
+| Arbitrum | poolUSDC   | `0xe8CDF27AcD73a434D661C84887215F7598e7d0d3` |
+| Base     | poolNative | `0xdc181Bd607330aeeBEF6ea62e03e5e1Fb4B6F7C7` |
+| Base     | poolUSDC   | `0x27a16dc786820B16E5c9028b75B99F6f604b5d26` |
+
+## ABI Reference
+
+### StargatePoolABI
+
+- `send(SendParam _sendParam, MessagingFee _fee, address _refundAddress) returns (MessagingReceipt msgReceipt, OFTReceipt oftReceipt)` [payable] - Bridge tokens to destination chain
+- `quoteOFT(SendParam _sendParam) returns (OFTLimit oftLimit)` - Quote bridge limits and fees (view)
+
+SendParam tuple: `(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd)`
+MessagingFee tuple: `(uint256 nativeFee, uint256 lzTokenFee)`
+
+## Notes
+
+- Uses LayerZero endpoint IDs (dstEid) for destination chains, NOT EVM chain IDs
+- Each token has its own pool contract (poolNative for ETH, poolUSDC for USDC, etc.)
+- Native token fees required for LayerZero messaging -- sent as msg.value
+- Unified liquidity pools across chains -- no wrapped tokens, receives native assets
+- Finality depends on LayerZero verification (typically 1-5 minutes)
+- Use `quoteOFT` to get fee estimates before sending
+- TVL: $400M+. Audited

package/sdk/src/skills/superfluid.md

@@ -0,0 +1,97 @@
+# Superfluid
+
+Protocol for real-time finance enabling continuous token streams (per-second payments), distributions, and composable Super Tokens.
+
+## Category
+
+payments | Chains: Ethereum, Polygon, Arbitrum, Optimism, Base
+
+## Key Operations
+
+- **createFlow**: Create a continuous payment stream
+- **updateFlow**: Update the flow rate of an existing stream
+- **deleteFlow**: Stop/delete a payment stream
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/superfluid";
+```
+
+## SauceScript Examples
+
+```typescript
+// Create payment stream
+import { CFAForwarderABI as ICFAForwarder } from "./abis";
+function main(
+  forwarderAddress: Address,
+  token: Address,
+  sender: Address,
+  receiver: Address,
+  flowrate: Uint256,
+): Uint256 {
+  const forwarder = ICFAForwarder.at(forwarderAddress);
+  forwarder.createFlow(token, sender, receiver, flowrate, 0x00);
+  return 1;
+}
+
+// Update flow rate
+import { CFAForwarderABI as ICFAForwarder } from "./abis";
+function main(
+  forwarderAddress: Address,
+  token: Address,
+  sender: Address,
+  receiver: Address,
+  flowrate: Uint256,
+): Uint256 {
+  const forwarder = ICFAForwarder.at(forwarderAddress);
+  forwarder.updateFlow(token, sender, receiver, flowrate, 0x00);
+  return 1;
+}
+
+// Delete payment stream
+import { CFAForwarderABI as ICFAForwarder } from "./abis";
+function main(
+  forwarderAddress: Address,
+  token: Address,
+  sender: Address,
+  receiver: Address,
+): Uint256 {
+  const forwarder = ICFAForwarder.at(forwarderAddress);
+  forwarder.deleteFlow(token, sender, receiver, 0x00);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract     | Address                                      |
+| -------- | ------------ | -------------------------------------------- |
+| Ethereum | host         | `0x3E14dC1b13c488a8d5D310918780c983bD5982E7` |
+| Ethereum | cfaForwarder | `0xcfA132E353cB4E398080B9700609bb008eceB125` |
+| Polygon  | host         | `0x3E14dC1b13c488a8d5D310918780c983bD5982E7` |
+| Polygon  | cfaForwarder | `0xcfA132E353cB4E398080B9700609bb008eceB125` |
+| Arbitrum | host         | `0x3E14dC1b13c488a8d5D310918780c983bD5982E7` |
+| Arbitrum | cfaForwarder | `0xcfA132E353cB4E398080B9700609bb008eceB125` |
+| Optimism | host         | `0x3E14dC1b13c488a8d5D310918780c983bD5982E7` |
+| Optimism | cfaForwarder | `0xcfA132E353cB4E398080B9700609bb008eceB125` |
+| Base     | host         | `0x3E14dC1b13c488a8d5D310918780c983bD5982E7` |
+| Base     | cfaForwarder | `0xcfA132E353cB4E398080B9700609bb008eceB125` |
+
+## ABI Methods
+
+### CFAForwarderABI
+
+- `createFlow(address,address,address,int96,bytes)` - Create stream. Params: token (Super Token), sender, receiver, flowrate (tokens per second as int96), userData (arbitrary bytes, 0x00 for none). Returns bool
+- `updateFlow(address,address,address,int96,bytes)` - Update flow rate. Params: token, sender, receiver, flowrate (new rate), userData. Returns bool
+- `deleteFlow(address,address,address,bytes)` - Delete stream. Params: token, sender, receiver, userData. Returns bool
+
+## Notes
+
+- Flowrate is in tokens per second (int96) - e.g. 1e18 / (30 * 86400) for ~1 token/month
+- Uses Super Tokens - wrapped ERC-20s with streaming capability (wrap before streaming)
+- Same host and cfaForwarder addresses on all 5 chains
+- CFAForwarder is the simplified interface; host is the core protocol contract
+- Streams are continuous - balance updates every second without transactions
+- Sender must maintain sufficient Super Token balance; otherwise stream gets liquidated
+- userData allows passing arbitrary data for composability with other contracts

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

@@ -0,0 +1,154 @@
+# SushiSwap V2
+
+Community-driven fork of Uniswap V2 with additional yield farming features and multi-chain deployment. Identical AMM interface to Uniswap V2 (x*y=k constant product) with broader L2 and alt-chain coverage.
+
+## Category
+
+dex | Chains: Ethereum, Arbitrum, Polygon, BSC, Avalanche, Fantom, Optimism
+
+## Key Operations
+
+- **swap**: Swap exact input tokens through a routing path
+- **addLiquidity**: Deposit two tokens to mint SLP (SushiSwap LP) tokens
+- **removeLiquidity**: Burn SLP tokens to withdraw underlying tokens
+
+## SDK Usage
+
+```typescript
+import {
+  protocolInfo,
+  deployments,
+  sauceFunctions,
+} from "@eco-incorp/sauce/protocols/sushiswap-v2";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { SushiSwapV2RouterABI 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`: SushiSwap Router address for the target chain
+- `path`: Ordered token address array for the swap route (e.g., `[tokenIn, WETH, tokenOut]`)
+- `amountIn`: Exact input token amount (in wei)
+- `amountOutMin`: Minimum output for slippage protection
+- `recipient`: Address to receive output tokens
+
+### addLiquidity
+
+```typescript
+import { SushiSwapV2RouterABI 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,
+  );
+}
+```
+
+- `tokenA` / `tokenB`: Pair token addresses
+- `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 { SushiSwapV2RouterABI 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 SLP tokens to burn
+- SLP token must be approved to the router
+
+## Key Addresses
+
+| Chain     | Contract | Address                                      |
+| --------- | -------- | -------------------------------------------- |
+| Ethereum  | Factory  | `0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac` |
+| Ethereum  | Router   | `0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F` |
+| Arbitrum  | Factory  | `0xc35DADB65012eC5796536bD9864eD8773aBc74C4` |
+| Arbitrum  | Router   | `0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506` |
+| Polygon   | Factory  | `0xc35DADB65012eC5796536bD9864eD8773aBc74C4` |
+| Polygon   | Router   | `0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506` |
+| BSC       | Factory  | `0xc35DADB65012eC5796536bD9864eD8773aBc74C4` |
+| BSC       | Router   | `0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506` |
+| Avalanche | Factory  | `0xc35DADB65012eC5796536bD9864eD8773aBc74C4` |
+| Avalanche | Router   | `0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506` |
+| Fantom    | Factory  | `0xc35DADB65012eC5796536bD9864eD8773aBc74C4` |
+| Fantom    | Router   | `0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506` |
+| Optimism  | Factory  | `0xFbc12984689e5f15626Bad03Ad60160Fe98B303C` |
+| Optimism  | Router   | `0x4C5D5234f232BD2D76B96aA33F5AE4FCF0E4BFAb` |
+
+## ABI Methods
+
+### SushiSwapV2RouterABI
+
+- `swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, uint256 deadline) -> uint256[] amounts` - Swap exact input along path, returns amounts at each hop
+- `swapTokensForExactTokens(uint256 amountOut, uint256 amountInMax, address[] path, address to, uint256 deadline) -> uint256[] amounts` - Swap to get exact output amount
+- `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 SLP tokens
+- `removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB)` - Burn SLP tokens for underlying tokens
+- `getAmountsOut(uint256 amountIn, address[] path) -> uint256[] amounts` - Quote output amounts along path (view)
+
+### SushiSwapV2FactoryABI
+
+- `getPair(address tokenA, address tokenB) -> address pair` - Look up pair address (view)
+- `createPair(address tokenA, address tokenB) -> address pair` - Create a new pair
+
+## Notes
+
+- Interface is identical to Uniswap V2; same 0.3% fee per hop
+- Factory and Router addresses are consistent across Arbitrum, Polygon, BSC, Avalanche, and Fantom
+- SLP tokens can be staked in SushiSwap's MasterChef/MiniChef contracts for SUSHI rewards (not in SDK)
+- Both tokens must be ERC20-approved to the Router before swap/addLiquidity
+- Use SushiSwap when Uniswap V2 is not deployed on the target chain, or when SUSHI farming incentives are active

package/sdk/src/skills/swell.md

@@ -0,0 +1,63 @@
+# Swell
+
+Liquid staking and restaking protocol for Ethereum. Offers swETH for liquid staking and rswETH for liquid restaking via EigenLayer.
+
+## Category
+
+liquid-staking | Chains: Ethereum
+
+## Key Operations
+
+- **stakeSwETH**: Deposit ETH for swETH (liquid staking)
+- **stakeRswETH**: Deposit ETH for rswETH (liquid restaking)
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/swell";
+```
+
+## SauceScript Examples
+
+```typescript
+// Stake ETH for swETH
+import { SwETHABI as ISwETH } from "./abis";
+function main(swethAddress: Address): Uint256 {
+  const sweth = ISwETH.at(swethAddress);
+  return sweth.deposit();
+}
+
+// Stake ETH for rswETH (restaking)
+import { RswETHABI as IRswETH } from "./abis";
+function main(rswethAddress: Address): Uint256 {
+  const rsweth = IRswETH.at(rswethAddress);
+  return rsweth.deposit();
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | swETH    | `0xf951E335afb289353dc249e82926178EaC7DEd78` |
+| Ethereum | rswETH   | `0xFAe103DC9cf190eD75350761e95403b7b8aFa6c0` |
+
+## ABI Methods
+
+### SwETHABI
+
+- `deposit()` - Stake ETH (payable), receive swETH. Returns shares
+- `swETHToETHRate()` - Current swETH/ETH exchange rate
+- `balanceOf(address)` - Query swETH balance
+
+### RswETHABI
+
+- `deposit()` - Stake ETH (payable), receive rswETH. Returns shares
+- `rswETHToETHRate()` - Current rswETH/ETH exchange rate
+- `balanceOf(address)` - Query rswETH balance
+
+## Notes
+
+- TVL: $800M+. Both tokens are non-rebasing (value accrues)
+- swETH = standard liquid staking. rswETH = liquid restaking via EigenLayer
+- Both deposit() functions are payable - send ETH as msg.value