@eco-incorp/sauce 0.99.4 → 0.99.5

package/sdk/src/skills/lifi.md

@@ -4,13 +4,13 @@ Multi-chain bridge and DEX aggregator via LiFiDiamond proxy. Routes through opti
 
 ## Category
 
-bridge aggregator | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), BSC (56), Avalanche (43114), Gnosis (100), Fantom (250)
+bridge aggregator | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), BSC (56), Avalanche (43114), Gnosis (100), Fantom (250), Arc (5042)
 
 ## SauceScript Functions
 
 ### bridge
 
-Bridge tokens cross-chain via LI.FI Diamond.
+Bridge tokens cross-chain via the LI.FI Diamond's Across V4 facet. Each underlying bridge has its own facet entry point (`startBridgeTokensVia<Bridge>`), with a bridge-specific second struct.
 
 ```typescript
 import { LiFiDiamondABI as ILiFiDiamond } from "./abis";
@@ -19,37 +19,53 @@ function main(
   diamondAddress: Address,
   transactionId: Uint256,
   sendingAsset: Address,
+  receivingAsset: Address,
   receiver: Address,
   amount: Uint256,
+  outputAmount: Uint256,
   destinationChainId: Uint256,
+  quoteTimestamp: Uint256,
+  fillDeadline: Uint256,
 ): Uint256 {
   const lifi = ILiFiDiamond.at(diamondAddress);
-  lifi.startBridgeTokensViaBridge({
-    transactionId: transactionId,
-    bridge: "across",
-    integrator: "sauce",
-    referrer: 0x0000000000000000000000000000000000000000,
-    sendingAssetId: sendingAsset,
-    receiver: receiver,
-    minAmount: amount,
-    destinationChainId: destinationChainId,
-    hasSourceSwaps: false,
-    hasDestinationCall: false,
-  });
+  lifi.startBridgeTokensViaAcrossV4(
+    {
+      transactionId: transactionId,
+      bridge: "acrossV4",
+      integrator: "sauce",
+      referrer: 0x0000000000000000000000000000000000000000,
+      sendingAssetId: sendingAsset,
+      receiver: receiver,
+      minAmount: amount,
+      destinationChainId: destinationChainId,
+      hasSourceSwaps: false,
+      hasDestinationCall: false,
+    },
+    {
+      receiverAddress: receiver,
+      refundAddress: receiver,
+      sendingAssetId: sendingAsset,
+      receivingAssetId: receivingAsset,
+      outputAmount: outputAmount,
+      outputAmountMultiplier: 0,
+      exclusiveRelayer: 0,
+      quoteTimestamp: quoteTimestamp,
+      fillDeadline: fillDeadline,
+      exclusivityParameter: 0,
+      message: "",
+    },
+  );
   return 1;
 }
 ```
 
 - `transactionId`: Unique identifier for tracking this bridge transaction (bytes32)
-- `bridge`: Name of the underlying bridge to use (e.g. "across", "stargate", "hop", "cbridge")
 - `integrator`: Integration partner identifier (e.g. "sauce")
 - `referrer`: Referral address for fee sharing. `address(0)` for none
-- `sendingAssetId`: ERC-20 token address to bridge
-- `receiver`: Recipient address on the destination chain
-- `minAmount`: Minimum amount of tokens to bridge
-- `destinationChainId`: Destination EVM chain ID
-- `hasSourceSwaps`: Set `true` if including pre-bridge swap steps
-- `hasDestinationCall`: Set `true` if including post-bridge execution on destination
+- `sendingAssetId` / `receivingAssetId`: token sent, and token received on the destination
+- `minAmount` / `outputAmount`: amount bridged, and the amount the Across relayer delivers
+- `quoteTimestamp` / `fillDeadline`: the Across quote's timestamp and fill deadline
+- `hasSourceSwaps` / `hasDestinationCall`: `true` only with pre-bridge swaps or a destination call
 - Requires ERC-20 approval to the LiFi Diamond
 
 ## Deployed Addresses
@@ -70,8 +86,10 @@ function main(
 
 ### LiFiDiamondABI
 
-- `startBridgeTokensViaBridge(BridgeData _bridgeData)` [payable] - Start a cross-chain bridge transaction. Routes through the specified underlying bridge
-- `extractBridgeData(bytes data) returns (BridgeData bridgeData)` - Decode bridge data from raw calldata (pure/view)
+- `startBridgeTokensViaAcrossV4(BridgeData _bridgeData, AcrossV4Data _acrossData)` [payable] - Bridge through Across V4 (AcrossFacetV4)
+- `extractBridgeData(bytes data) returns (BridgeData bridgeData)` - Decode bridge data from raw calldata (pure)
+
+AcrossV4Data tuple: `(bytes32 receiverAddress, bytes32 refundAddress, bytes32 sendingAssetId, bytes32 receivingAssetId, uint256 outputAmount, uint128 outputAmountMultiplier, bytes32 exclusiveRelayer, uint32 quoteTimestamp, uint32 fillDeadline, uint32 exclusivityParameter, bytes message)`
 
 BridgeData tuple: `(bytes32 transactionId, string bridge, string integrator, address referrer, address sendingAssetId, address receiver, uint256 minAmount, uint256 destinationChainId, bool hasSourceSwaps, bool hasDestinationCall)`
 

package/sdk/src/skills/liquity-v1.md

@@ -34,7 +34,11 @@ function main(borrowerOpsAddress: Address): Uint256 {
 import { BorrowerOperationsABI as IBorrowerOperations } from "./abis";
 function main(borrowerOpsAddress: Address, amount: Uint256): Uint256 {
   const borrowerOps = IBorrowerOperations.at(borrowerOpsAddress);
-  borrowerOps.repayLUSD(amount);
+  borrowerOps.repayLUSD(
+    amount,
+    0x0000000000000000000000000000000000000000,
+    0x0000000000000000000000000000000000000000,
+  );
   return 1;
 }
 ```
@@ -53,7 +57,7 @@ function main(borrowerOpsAddress: Address, amount: Uint256): Uint256 {
 - `openTrove(uint256,uint256,address,address)` - Open new Trove. Payable (send ETH as collateral). Params: maxFeePercentage (max borrowing fee, e.g. 5e16 = 5%), LUSDAmount (LUSD to borrow), upperHint (sorted troves hint), lowerHint (sorted troves hint)
 - `closeTrove()` - Close Trove. Must repay all LUSD debt first. Returns all ETH collateral
 - `adjustTrove(uint256,uint256,uint256,bool,address,address)` - Adjust Trove. Payable (send ETH to add collateral). Params: maxFeePercentage, collWithdrawal (ETH to withdraw), LUSDChange (LUSD amount to change), isDebtIncrease (true=borrow more, false=repay), upperHint, lowerHint
-- `repayLUSD(uint256)` - Repay LUSD debt. Params: LUSDAmount
+- `repayLUSD(uint256,address,address)` - Repay LUSD debt. Params: LUSDAmount, upperHint, lowerHint (sorted-trove hints; the zero address is valid)
 
 ## Notes
 

package/sdk/src/skills/loader.ts

@@ -1,19 +1,19 @@
-import { readFileSync, readdirSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
+// The skill documents are embedded at build time (`embedded/skills.generated.ts`), so this module
+// reads no filesystem and works in a browser. The `.md` files under `src/skills/` remain the source
+// of truth, and still ship in the package for readers who want the files themselves.
+import { SKILL_DOCUMENTS } from "../embedded/skills.generated.js";
 
-// At runtime this file is at dist/skills/loader.js, so package root is ../..
-// The .md files live at src/skills/ which ships with the package
-const thisDir = dirname(fileURLToPath(import.meta.url));
-const packageRoot = join(thisDir, "..", "..");
-const skillsDir = join(packageRoot, "src", "skills");
+const INDEX = "index";
 
 /**
  * Load the master protocol index skill file.
  * Returns markdown content with all protocols, categories, operations, and chain coverage.
  */
 export function getProtocolIndex(): string {
-  return readFileSync(join(skillsDir, "index.md"), "utf-8");
+  const index = SKILL_DOCUMENTS[INDEX];
+  if (index === undefined) throw new Error("the protocol skill index is not embedded");
+
+  return index;
 }
 
 /**
@@ -21,34 +21,24 @@ export function getProtocolIndex(): string {
  * Returns markdown describing the protocol, its operations,
  * SauceScript examples, contract addresses, and ABI methods.
  *
- * The slug is matched against `listSkillSlugs()` before it ever reaches `join`, so it can only name
- * a skill file this package ships — a caller-supplied path can never escape `skillsDir`. Anything
- * else, including a slug whose file is unreadable, surfaces as the same not-found error.
+ * The slug is matched against `listSkillSlugs()`, so it can only name a skill this package ships;
+ * anything else surfaces as the same not-found error.
  */
 export function getProtocolSkill(slug: string): string {
   if (!listSkillSlugs().includes(slug)) throw unknownSlug(slug);
-  try {
-    return readFileSync(join(skillsDir, `${slug}.md`), "utf-8");
-  } catch {
-    throw unknownSlug(slug);
-  }
+
+  return SKILL_DOCUMENTS[slug]!;
 }
 
 /**
  * List all available protocol skill slugs.
  */
 export function listSkillSlugs(): string[] {
-  return readdirSync(skillsDir)
-    .filter((f) => f.endsWith(".md") && f !== "index.md")
-    .map((f) => f.replace(".md", ""))
+  return Object.keys(SKILL_DOCUMENTS)
+    .filter((slug) => slug !== INDEX)
     .sort();
 }
 
-/**
- * Absolute path to the skills directory (for direct file access).
- */
-export const SKILLS_DIR = skillsDir;
-
 function unknownSlug(slug: string): Error {
   return new Error(
     `No skill file found for protocol "${slug}". Check listSkillSlugs() for valid slugs.`,

package/sdk/src/skills/mantle-meth.md

@@ -20,10 +20,10 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
 
 ```typescript
 // Stake ETH for mETH
-import { METHABI as IMETH } from "./abis";
-function main(methAddress: Address, minMETHAmount: Uint256): Uint256 {
-  const meth = IMETH.at(methAddress);
-  meth.stake(minMETHAmount);
+import { METHStakingABI as IStaking } from "./abis";
+function main(stakingAddress: Address, minMETHAmount: Uint256): Uint256 {
+  const staking = IStaking.at(stakingAddress);
+  staking.stake(minMETHAmount);
   return 1;
 }
 ```
@@ -33,14 +33,22 @@ function main(methAddress: Address, minMETHAmount: Uint256): Uint256 {
 | Chain    | Contract | Address                                      |
 | -------- | -------- | -------------------------------------------- |
 | Ethereum | mETH     | `0xd5F7838F5C461fefF7FE49ea5ebaF7728bB0ADfa` |
+| Ethereum | staking  | `0xe3cBd06D7dadB3F4e6557bAb7EdD924CD1489E8f` |
 
 ## ABI Methods
 
-### METHABI
+### METHStakingABI
+
+The Staking contract (`staking`), not the token.
 
 - `stake(uint256)` - Stake ETH (payable), receive mETH. Param: minMETHAmount for slippage protection
 - `mETHToETH(uint256)` - Convert mETH amount to ETH value
 - `ethToMETH(uint256)` - Convert ETH amount to mETH value
+
+### METHABI
+
+The mETH token (`mETH`).
+
 - `balanceOf(address)` - Query mETH balance
 - `approve(address,uint256)` - Approve mETH spending
 

package/sdk/src/skills/maverick.md

@@ -58,17 +58,17 @@ function main(
 ### MaverickV2RouterABI
 
 - `exactInputSingle(address recipient, address pool, bool tokenAIn, uint256 amountIn, uint256 amountOutMinimum) -> uint256 amountOut` - Swap exact input in a specific pool
-- `exactOutputSingle(address recipient, address pool, bool tokenAIn, uint256 amountOut, uint256 amountInMaximum) -> uint256 amountIn` - Swap to get exact output from a specific pool
+- `exactOutputSingle(address recipient, address pool, bool tokenAIn, uint256 amountOut, uint256 amountInMaximum) -> (uint256 amountIn, uint256 amountOut)` - Swap to get exact output from a specific pool
 
 ### MaverickV2FactoryABI
 
-- `lookup(address tokenA, address tokenB) -> address[] pools` - Look up all available pools for a token pair (view)
+- `lookup(address tokenA, address tokenB, uint256 startIndex, uint256 endIndex) -> address[] pools` - Look up a page of the pools for a token pair (view)
 
 ## Notes
 
 - Uses `tokenAIn` bool instead of separate token addresses to specify swap direction within a pool
 - Pool address must be provided directly (no built-in path routing like Uniswap)
-- Use `factory.lookup(tokenA, tokenB)` to discover available pools for a pair
+- Use `factory.lookup(tokenA, tokenB, 0, n)` to discover available pools for a pair
 - Parameter order is unusual: `recipient` is the FIRST parameter, not the last
 - Maverick's key innovation is directional LP strategies: bins can be configured to move with price in one direction
 - LP modes: Static (like Uniswap V3), Right (follow price up), Left (follow price down), Both (follow both)

package/sdk/src/skills/morpho-blue.md

@@ -4,7 +4,7 @@ Minimal and gas-efficient lending primitive with permissionless market creation.
 
 ## Category
 
-lending | Chains: Ethereum (1), Base (8453)
+lending | Chains: Ethereum (1), Base (8453), Arc (5042)
 
 ## SauceScript Functions
 

package/sdk/src/skills/mux-protocol.md

@@ -8,9 +8,9 @@ perpetuals | Chains: Arbitrum
 
 ## Key Operations
 
-- **addLiquidity**: Add liquidity to MUX pool (receive MLP tokens)
-- **removeLiquidity**: Remove liquidity from pool (burn MLP tokens)
-- **placePositionOrder**: Place a leveraged position order
+- **addLiquidity**: Place an order adding liquidity to the MUX pool (receive MLP tokens)
+- **removeLiquidity**: Place an order removing liquidity (burn MLP tokens)
+- **placePositionOrder3**: Place a leveraged position order
 - **cancelOrder**: Cancel a pending order
 
 ## SDK Usage
@@ -25,20 +25,22 @@ import {
 
 ## SauceScript Examples
 
+Liquidity moves through OrderBook orders that MUX brokers fill; the LiquidityPool's own add/remove functions are callable only by the OrderBook.
+
 ```typescript
-// Add liquidity to MUX pool
-import { LiquidityPoolABI as ILiquidityPool } from "./abis";
-function main(poolAddress: Address, tokenId: Uint256, tokenAmount: Uint256): Uint256 {
-  const pool = ILiquidityPool.at(poolAddress);
-  pool.addLiquidity(tokenId, tokenAmount);
+// Add liquidity: a liquidity order that deposits `rawAmount` of asset `assetId`
+import { OrderBookABI as IOrderBook } from "./abis";
+function main(orderBookAddress: Address, assetId: Uint256, rawAmount: Uint256): Uint256 {
+  const orderBook = IOrderBook.at(orderBookAddress);
+  orderBook.placeLiquidityOrder(assetId, rawAmount, true);
   return 1;
 }
 
-// Remove liquidity from MUX pool
-import { LiquidityPoolABI as ILiquidityPool } from "./abis";
-function main(poolAddress: Address, tokenId: Uint256, mlpAmount: Uint256): Uint256 {
-  const pool = ILiquidityPool.at(poolAddress);
-  pool.removeLiquidity(tokenId, mlpAmount);
+// Remove liquidity: a liquidity order that burns `mlpAmount` MLP for asset `assetId`
+import { OrderBookABI as IOrderBook } from "./abis";
+function main(orderBookAddress: Address, assetId: Uint256, mlpAmount: Uint256): Uint256 {
+  const orderBook = IOrderBook.at(orderBookAddress);
+  orderBook.placeLiquidityOrder(assetId, mlpAmount, false);
   return 1;
 }
 ```
@@ -54,13 +56,15 @@ function main(poolAddress: Address, tokenId: Uint256, mlpAmount: Uint256): Uint2
 
 ### OrderBookABI
 
-- `placePositionOrder(bytes32,uint256,uint256,uint256,uint8,uint8,uint32,bytes32)` - Place leveraged position order. Params: subAccountId (encodes account+collateral+asset+isLong), collateralAmount, size (position size), price, profitTokenId, flags (order type bits), deadline, referralCode. Payable (execution fee)
-- `cancelOrder(uint64)` - Cancel pending order. Params: orderId
+- `placeLiquidityOrder(uint8 assetId, uint96 rawAmount, bool isAdding)` [payable] - Order to add (`isAdding`) or remove liquidity. Adding: approve the asset to the OrderBook first; removing: `rawAmount` is MLP
+- `placePositionOrder3(bytes32 subAccountId, uint96 collateralAmount, uint96 size, uint96 price, uint8 profitTokenId, uint8 flags, uint32 deadline, bytes32 referralCode, (uint96 tpPrice, uint96 slPrice, uint8 tpslProfitTokenId, uint32 tpslDeadline) extra)` [payable] - Place a leveraged position order (with optional TP/SL)
+- `cancelOrder(uint64 orderId)` - Cancel pending order
 
 ### LiquidityPoolABI
 
-- `addLiquidity(uint8,uint256)` - Add liquidity. Params: tokenId (asset index), tokenAmount. Approve token to pool first
-- `removeLiquidity(uint8,uint256)` - Remove liquidity. Params: tokenId (asset to receive), mlpAmount (MLP tokens to burn)
+- `depositCollateral(bytes32 subAccountId, uint256 rawAmount)` - Deposit collateral into a sub-account
+- `getAssetAddress(uint8 assetId) returns (address)` - Token address of an asset id
+- `getSubAccount(bytes32 subAccountId) returns (uint96 collateral, uint96 size, uint32 lastIncreasedTime, uint96 entryPrice, uint128 entryFunding)` - A sub-account's position
 
 ## Notes
 

package/sdk/src/skills/oneinch.md

@@ -27,9 +27,10 @@ function main(
   srcToken: Address,
   amount: Uint256,
   minReturn: Uint256,
+  dex: Uint256,
 ): Uint256 {
   const router = IAggregationRouterV6.at(routerAddress);
-  return router.unoswap(srcToken, amount, minReturn, []);
+  return router.unoswap(srcToken, amount, minReturn, dex);
 }
 ```
 
@@ -51,13 +52,13 @@ function main(
 
 - `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
+- `unoswap(uint256,uint256,uint256,uint256)` - Single-pool optimized swap. Params: token (source token address as uint256), amount, minReturn, dex (pool address packed with protocol and direction flags). 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
+- `dex` in unoswap packs the pool address with its protocol and swap-direction flags in the 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

@@ -32,7 +32,7 @@ function main(
   minReturnAmount: Uint256,
   guaranteedAmount: Uint256,
   referrer: Address,
-  calls: bytes,
+  calls: { target: Uint256; gasLimit: Uint256; value: Uint256; data: bytes }[],
 ): Uint256 {
   const exchange = IOpenOceanExchange.at(exchangeAddress);
   return exchange.swap(
@@ -70,7 +70,7 @@ function main(
 
 ### OpenOceanExchangeV2ABI
 
-- `swap(address,tuple,bytes)` - Execute aggregated swap. Payable. Params: caller (msg.sender or executor), desc (SwapDescription tuple), calls (encoded swap calldata). Returns returnAmount
+- `swap(address,tuple,tuple[])` - Execute aggregated swap. Payable. Params: caller (msg.sender or executor), desc (SwapDescription tuple), calls (CallDescription[]: `(uint256 target, uint256 gasLimit, uint256 value, bytes data)`). 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

package/sdk/src/skills/opyn.md

@@ -56,7 +56,7 @@ function main(controllerAddress: Address, vaultId: Uint256, amount: Uint256): Ui
 ### 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)
+- `burnPowerPerpAmount(uint256,uint256,uint256) returns (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)
 

package/sdk/src/skills/permit2.md

@@ -4,7 +4,7 @@ Universal token approval infrastructure by Uniswap. Provides a single approval c
 
 ## Category
 
-infrastructure | Chains: Ethereum, Arbitrum, Optimism, Base, Polygon, BSC, Avalanche
+infrastructure | Chains: Ethereum, Arbitrum, Optimism, Base, Polygon, BSC, Avalanche, Arc
 
 ## Key Operations
 

package/sdk/src/skills/perpetual-protocol.md

@@ -54,8 +54,8 @@ function main(vaultAddress: Address, token: Address, amount: Uint256): Uint256 {
 
 ### ClearingHouseABI
 
-- `openPosition(address,bool,bool,uint256,uint256,uint256,uint256,bytes32)` - Open leveraged position. Params: baseToken (market), isBaseToQuote (true=short, false=long), isExactInput (true=exact input amount), amount (trade amount), oppositeAmountBound (slippage limit), deadline (tx deadline), sqrtPriceLimitX96 (price limit, 0 for none), referralCode. Returns (base, quote)
-- `closePosition(address,uint256,uint256,uint256,bytes32)` - Close position. Params: baseToken, sqrtPriceLimitX96 (0 for market), oppositeAmountBound (slippage), deadline, referralCode. Returns (base, quote)
+- `openPosition((address,bool,bool,uint256,uint256,uint256,uint160,bytes32))` - Open leveraged position. One params struct: baseToken (market), isBaseToQuote (true=short, false=long), isExactInput (true=exact input amount), amount (trade amount), oppositeAmountBound (slippage limit), deadline (tx deadline), sqrtPriceLimitX96 (price limit, 0 for none), referralCode. Returns (base, quote)
+- `closePosition((address,uint160,uint256,uint256,bytes32))` - Close position. One params struct: baseToken, sqrtPriceLimitX96 (0 for market), oppositeAmountBound (slippage), deadline, referralCode. Returns (base, quote)
 - `getAccountValue(address)` - Get account value. Params: trader. Returns int256 value
 
 ### VaultABI

package/sdk/src/skills/premia.md

@@ -4,7 +4,7 @@ Decentralized options protocol with an AMM-based pricing model and concentrated
 
 ## Category
 
-options | Chains: Arbitrum, Ethereum
+options | Chains: Arbitrum
 
 ## Key Operations
 
@@ -20,41 +20,41 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
 
 ## SauceScript Examples
 
+Premia v3 has one pool contract per market (base, quote, strike, maturity, call/put), deployed by the PoolFactory; its `PoolDeployed` event names each pool. `exercise` and `settle` act on the caller's own position in that pool.
+
 ```typescript
-// Exercise long option
-import { DiamondABI as IDiamond } from "./abis";
-function main(diamondAddress: Address, holder: Address, longTokenId: Uint256): Uint256 {
-  const diamond = IDiamond.at(diamondAddress);
-  return diamond.exercise(holder, longTokenId);
+// Exercise a long position after maturity
+import { DiamondABI as IPool } from "./abis";
+function main(poolAddress: Address): { exerciseValue: Uint256; exerciseFee: Uint256 } {
+  const pool = IPool.at(poolAddress);
+  return pool.exercise();
 }
 
-// Settle short option
-import { DiamondABI as IDiamond } from "./abis";
-function main(diamondAddress: Address, holder: Address, shortTokenId: Uint256): Uint256 {
-  const diamond = IDiamond.at(diamondAddress);
-  return diamond.settle(holder, shortTokenId);
+// Settle a short position after maturity
+import { DiamondABI as IPool } from "./abis";
+function main(poolAddress: Address): Uint256 {
+  const pool = IPool.at(poolAddress);
+  return pool.settle();
 }
 ```
 
 ## Key Addresses
 
-| Chain    | Contract | Address                                      |
-| -------- | -------- | -------------------------------------------- |
-| Arbitrum | diamond  | `0xa079C6B032133b95Cf8b3d273D27eeb6B110a469` |
-| Ethereum | diamond  | `0xc22FAe86443aEed038A4ED887bbA8F5035FD12F0` |
+| Chain    | Contract    | Address                                      |
+| -------- | ----------- | -------------------------------------------- |
+| Arbitrum | poolFactory | `0xAE4fB6622F25f397587F11638dA8CE88C27b5645` |
 
 ## ABI Methods
 
-### DiamondABI
+### DiamondABI (a Premia v3 pool)
 
-- `trade(bytes32,uint256,bool,uint256,address)` - Buy/sell options. Params: poolKey (identifies option market), size (option amount), isBuy (true=buy, false=sell), premiumLimit (max/min premium), referrer. Returns totalPremium
-- `exercise(address,uint256)` - Exercise long option. Params: holder, longTokenId. Returns exerciseValue (profit amount)
-- `settle(address,uint256)` - Settle short option after expiry. Params: holder, shortTokenId. Returns collateral (returned amount)
+- `trade(uint256 size, bool isBuy, uint256 premiumLimit, address referrer) returns (uint256 totalPremium, (int256 collateral, int256 longs, int256 shorts) delta)` - Buy/sell options from the pool's AMM. `size` is 18-decimal
+- `exercise() returns (uint256 exerciseValue, uint256 exerciseFee)` - Exercise the caller's long position after maturity
+- `settle() returns (uint256 collateral)` - Settle the caller's short position after maturity
 
 ## Notes
 
-- Diamond proxy pattern - single contract for all operations
+- Each pool is a proxy routed through the pool Diamond's facets
 - Supports calls and puts on ETH, BTC, and other assets
-- poolKey (bytes32) encodes the option parameters (strike, expiry, type)
 - Long token = bought option, short token = sold/written option
 - exercise returns the in-the-money value; settle returns remaining collateral to writers

package/sdk/src/skills/reflexer.md

@@ -60,7 +60,7 @@ function main(coinJoinAddress: Address, account: Address, amount: Uint256): Uint
 
 ### ETHJoinABI
 
-- `join(address)` - Join ETH as collateral. Payable (send ETH). Params: account
+- `join(address account, uint256 wad)` - Join WETH as collateral (the `ethJoin` deployment is a CollateralJoin for WETH; approve WETH first)
 - `exit(address,uint256)` - Exit ETH collateral. Params: account, wad (ETH amount)
 
 ## Notes

package/sdk/src/skills/renzo.md

@@ -48,7 +48,7 @@ function main(restakeManagerAddress: Address, collateralToken: Address, amount:
 
 ### RestakeManagerABI
 
-- `deposit(address,uint256)` - Deposit LST collateral for ezETH. Payable. Approve token first
+- `deposit(address,uint256)` - Deposit LST collateral for ezETH (not payable). Approve token first
 - `depositETH()` - Deposit ETH (payable) for ezETH. Send ETH as msg.value
 
 ### EzETHABI

package/sdk/src/skills/safe.md

@@ -4,7 +4,7 @@ The most trusted multi-signature smart contract wallet, securing billions in dig
 
 ## Category
 
-infrastructure | Chains: Ethereum, Arbitrum, Optimism, Base, Polygon
+infrastructure | Chains: Ethereum, Arbitrum, Optimism, Base, Polygon, Arc
 
 ## Key Operations
 

package/sdk/src/skills/seaport.md

@@ -4,7 +4,7 @@ OpenSea's decentralized NFT marketplace protocol supporting flexible order types
 
 ## Category
 
-nft-marketplace | Chains: Ethereum, Arbitrum, Optimism, Polygon, Base
+nft-marketplace | Chains: Ethereum, Arbitrum, Optimism, Polygon, Base, Arc
 
 ## Key Operations
 
@@ -52,8 +52,9 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
   - `zoneHash` (bytes32), `salt` (uint256) - Order uniqueness
   - `offererConduitKey`, `fulfillerConduitKey` (bytes32) - Conduit keys for token transfers
   - `totalOriginalAdditionalRecipients` (uint256) - Creator fees count
+  - `additionalRecipients` (`(uint256 amount, address recipient)[]`) - Extra consideration recipients (fees)
   - `signature` (bytes) - Offerer's EIP-712 signature
-- `cancel(tuple[])` - Cancel orders. Params: orders (array of OrderComponents tuples with offerer, zone, zoneHash, salt, conduitKey, counter). Returns cancelled bool
+- `cancel(tuple[])` - Cancel orders. Params: orders (array of OrderComponents: offerer, zone, offer items, consideration items, orderType, startTime, endTime, zoneHash, salt, conduitKey, counter). Returns cancelled bool
 
 ## Notes
 

package/sdk/src/skills/silo.md

@@ -36,7 +36,8 @@ import { SiloABI as ISilo } from "./abis";
 
 function main(siloAddress: Address, asset: Address, amount: Uint256): Uint256 {
   const silo = ISilo.at(siloAddress);
-  return silo.withdraw(asset, amount, false);
+  const result = silo.withdraw(asset, amount, false);
+  return result.withdrawnAmount;
 }
 ```
 
@@ -80,14 +81,14 @@ function main(siloAddress: Address, asset: Address, amount: Uint256): Uint256 {
 | Chain    | Contract       | Address                                      |
 | -------- | -------------- | -------------------------------------------- |
 | Ethereum | siloRepository | `0xbACBBefda6fD1FbF5a2d6A79916F4B6124eD2D49` |
-| Arbitrum | siloRepository | `0xbACBBefda6fD1FbF5a2d6A79916F4B6124eD2D49` |
+| Arbitrum | siloRepository | `0x8658047e48CC09161f4152c79155Dac1d710Ff0a` |
 
 ## ABI Reference
 
 ### SiloABI
 
 - `deposit(address asset, uint256 amount, bool collateralOnly) returns (uint256 collateralAmount, uint256 collateralShare)` - Deposit asset into Silo
-- `withdraw(address asset, uint256 amount, bool collateralOnly) returns (uint256 withdrawnAmount)` - Withdraw deposited asset
+- `withdraw(address asset, uint256 amount, bool collateralOnly) returns (uint256 withdrawnAmount, uint256 withdrawnShare)` - Withdraw deposited asset
 - `borrow(address asset, uint256 amount) returns (uint256 debtAmount, uint256 debtShare)` - Borrow asset against collateral
 - `repay(address asset, uint256 amount) returns (uint256 repaidAmount, uint256 repaidShare)` - Repay borrowed debt
 

package/sdk/src/skills/socket.md

@@ -17,7 +17,7 @@ import { SocketGatewayABI as ISocketGateway } from "./abis";
 
 function main(gatewayAddress: Address, routeId: Uint256, bridgeData: bytes): Uint256 {
   const gateway = ISocketGateway.at(gatewayAddress);
-  gateway.bridge(routeId, bridgeData);
+  gateway.executeRoute(routeId, bridgeData);
   return 1;
 }
 ```
@@ -43,14 +43,13 @@ function main(gatewayAddress: Address, routeId: Uint256, bridgeData: bytes): Uin
 
 ### SocketGatewayABI
 
-- `bridge(uint32 routeId, bytes bridgeData)` [payable] - Execute a bridge transaction using a pre-computed route
-- `executeRoute(uint32 routeId, bytes data) returns (bytes result)` [payable] - Execute a generic route (bridge, swap, or combined). Returns result data
+- `executeRoute(uint32 routeId, bytes routeData) returns (bytes result)` [payable] - Execute a route (bridge, swap, or combined). Returns result data
 
 ## Notes
 
 - Socket is a bridge **aggregator** -- routes through underlying bridges (Across, Stargate, Hop, cBridge, Connext, etc.)
-- Two-step process: (1) call Socket API to get optimal route + encoded `bridgeData`, (2) execute on-chain via `bridge()` or `executeRoute()`
-- `bridge()` is for pure bridge operations; `executeRoute()` is the general-purpose entry point for bridge, swap, or combined operations
+- Two-step process: (1) call Socket API to get optimal route + encoded `bridgeData`, (2) execute on-chain via `executeRoute()`
+- There is no separate `bridge()` entry point: `executeRoute()` handles bridge, swap, and combined routes
 - Same Gateway address (`0x3a23F9...`) deployed across all supported chains
 - `routeId` identifies the specific bridge integration (each bridge has its own route handler contract)
 - The `bridgeData` is opaque -- generated by the Socket API based on token, amount, source/destination chains

package/sdk/src/skills/spookyswap.md

@@ -37,7 +37,7 @@ function main(
 }
 ```
 
-- `routerAddress`: SpookySwap Router on Fantom (`0xa6AD18C2aC47803E193F75c3677b14BF19B94883`)
+- `routerAddress`: SpookySwap Router on Fantom (`0xF491e7B69E4244ad4002BC14e878a34207E38c29`)
 - `path`: Ordered token address array for the swap route
 - `amountIn`: Exact input amount (in wei)
 - `amountOutMin`: Minimum output for slippage protection
@@ -107,7 +107,7 @@ function main(
 
 | Chain  | Contract  | Address                                      |
 | ------ | --------- | -------------------------------------------- |
-| Fantom | V2 Router | `0xa6AD18C2aC47803E193F75c3677b14BF19B94883` |
+| Fantom | V2 Router | `0xF491e7B69E4244ad4002BC14e878a34207E38c29` |
 
 ## ABI Methods