@eco-incorp/sauce 0.99.4 → 0.99.6

package/sdk/src/skills/curve.md

@@ -42,7 +42,8 @@ function main(
 - `j`: Index of the output token within the pool (0-based)
 - `amountIn`: Exact amount of input token (in wei)
 - `minAmountOut`: Minimum output for slippage protection
-- Token indices vary per pool (e.g., 3pool: 0=DAI, 1=USDC, 2=USDT)
+- Token indices vary per pool
+- For StableSwap-NG pools. 3pool's `exchange` returns nothing, so reading back a `uint256` reverts there: use `CurveThreePoolABI` for 3pool
 
 ### addLiquidity
 
@@ -94,17 +95,31 @@ function main(poolAddress: Address, amount: Uint256, minAmounts: Uint256[]): Uin
 
 ### CurveStableSwapABI
 
+The StableSwap-NG pool interface (plain and meta pools). Classic pools such as 3pool have their own shape: see `CurveThreePoolABI` below.
+
 - `exchange(int128 i, int128 j, uint256 dx, uint256 min_dy) -> uint256` - Swap between two tokens in the pool by index
-- `exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) -> uint256` - Swap between underlying tokens (for metapools/lending pools)
+- `exchange_underlying(int128 i, int128 j, uint256 dx, uint256 min_dy) -> uint256` - Swap between underlying tokens (metapools only)
 - `add_liquidity(uint256[] amounts, uint256 min_mint_amount) -> uint256` - Deposit tokens and receive LP tokens (can be imbalanced)
 - `remove_liquidity(uint256 _amount, uint256[] min_amounts) -> uint256[]` - Burn LP tokens and withdraw all tokens proportionally
 - `remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 min_amount) -> uint256` - Burn LP tokens and withdraw as a single token
 - `get_dy(int128 i, int128 j, uint256 dx) -> uint256` - Quote: estimate output for a given input (view)
 - `get_virtual_price() -> uint256` - Get the virtual price of the LP token (view, useful for pricing)
 
+### CurveThreePoolABI
+
+3pool (`threePool` in the addresses), a classic StableSwap pool. Its liquidity arrays are fixed-size, and its state-changing functions return nothing: read amounts as balance changes.
+
+- `exchange(int128 i, int128 j, uint256 dx, uint256 min_dy)` - Swap between two of DAI(0), USDC(1), USDT(2)
+- `add_liquidity(uint256[3] amounts, uint256 min_mint_amount)` - Deposit tokens and receive 3CRV
+- `remove_liquidity(uint256 _amount, uint256[3] min_amounts)` - Burn 3CRV and withdraw all three tokens proportionally
+- `remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 min_amount)` - Burn 3CRV and withdraw one token
+- `get_dy(int128 i, int128 j, uint256 dx) -> uint256` - Quote (view)
+- `get_virtual_price() -> uint256` - Virtual price of 3CRV (view)
+
 ### CurveRouterNGABI
 
 - `exchange(address[11] _route, uint256[5][5] _swap_params, uint256 _amount, uint256 _expected, address[5] _pools) -> uint256` - Multi-pool routed swap for optimal execution
+- `exchange(address[11] _route, uint256[5][5] _swap_params, uint256 _amount, uint256 _min_dy, address[5] _pools, address _receiver) -> uint256` - The same routed swap, paying `_receiver` instead of the caller
 - `get_dy(address[11] _route, uint256[5][5] _swap_params, uint256 _amount, address[5] _pools) -> uint256` - Quote routed swap output (view)
 
 ### CurveAddressProviderABI

package/sdk/src/skills/debridge.md

@@ -4,7 +4,7 @@ Cross-chain trading infrastructure with DLN (DeBridge Liquidity Network). Suppor
 
 ## Category
 
-bridge + cross-chain trading | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), BSC (56), Avalanche (43114)
+bridge + cross-chain trading | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), BSC (56), Avalanche (43114), Arc (5042)
 
 ## SauceScript Functions
 
@@ -82,7 +82,7 @@ function main(
 
 ### DlnSourceABI
 
-- `createOrder(OrderCreation _orderCreation, bytes _affiliateFee, uint32 _referralCode, bytes _permitEnvelope) returns (uint256 orderId)` [payable] - Create a cross-chain limit order. Market makers compete to fill on destination
+- `createOrder(OrderCreation _orderCreation, bytes _affiliateFee, uint32 _referralCode, bytes _permitEnvelope) returns (bytes32 orderId)` [payable] - Create a cross-chain limit order. Market makers compete to fill on destination
 
 OrderCreation tuple: `(address giveTokenAddress, uint256 giveAmount, bytes takeTokenAddress, uint256 takeAmount, uint256 takeChainId, bytes receiverDst, address givePatchAuthoritySrc, bytes orderAuthorityAddressDst, bytes allowedTakerDst, bytes externalCall, bytes allowedCancelBeneficiarySrc)`
 
@@ -103,3 +103,4 @@ Order tuple: `(uint64 makerOrderNonce, bytes makerSrc, uint256 giveChainId, byte
 - Finality: typically 1-5 minutes (market maker fills immediately, then settles asynchronously)
 - Requires ERC-20 approval to DlnSource for the give token
 - TVL: $200M+. Audited
+- On Arc (5042) the DLN `globalFixedNativeFee()` is `1000000000000000000` wei, which is 1 USDC: Arc's native coin is USDC at 18 decimals, paid from the same balance as the USDC ERC-20 `0x3600…0000` (read 2026-09-28)

package/sdk/src/skills/eigenlayer.md

@@ -49,7 +49,7 @@ function main(
 ### StrategyManagerABI
 
 - `depositIntoStrategy(address,address,uint256)` - Deposit token into strategy. Params: strategy address, token address, amount. Returns shares
-- `stakerStrategyShares(address,address)` - Query staker's shares in a strategy
+- `stakerDepositShares(address staker, address strategy)` - Query staker's deposit shares in a strategy (renamed from `stakerStrategyShares`)
 
 ### DelegationManagerABI
 

package/sdk/src/skills/erc20.md

@@ -24,26 +24,23 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
 
 ```typescript
 // Transfer tokens
-import { ERC20ABI as IERC20 } from "./abis";
+import { transfer } from "@sauce/token";
 function main(token: Address, to: Address, amount: Uint256): Uint256 {
-  const t = IERC20.at(token);
-  t.transfer(to, amount);
+  transfer(token, to, amount);
   return 1;
 }
 
 // Approve spender
-import { ERC20ABI as IERC20 } from "./abis";
+import { approve } from "@sauce/token";
 function main(token: Address, spender: Address, amount: Uint256): Uint256 {
-  const t = IERC20.at(token);
-  t.approve(spender, amount);
+  approve(token, spender, amount);
   return 1;
 }
 
 // Transfer from (requires prior approval)
-import { ERC20ABI as IERC20 } from "./abis";
+import { transferFrom } from "@sauce/token";
 function main(token: Address, from: Address, to: Address, amount: Uint256): Uint256 {
-  const t = IERC20.at(token);
-  t.transferFrom(from, to, amount);
+  transferFrom(token, from, to, amount);
   return 1;
 }
 
@@ -97,5 +94,6 @@ function main(to: Address, amount: Uint256): Uint256 {
 - approve before transferFrom: spender must be approved by the owner first
 - Common pattern: approve max (type(uint256).max) for DeFi interactions, or use exact amounts for security
 - decimals varies: most tokens use 18, USDC/USDT use 6, WBTC uses 8
-- Some tokens (USDT) do not return bool from transfer/approve -- use SafeERC20 wrapper for compatibility
+- Some tokens (USDT) do not return bool from transfer/approve. The writes above are `@sauce/token`'s, which follow OpenZeppelin SafeERC20: empty returndata is accepted from a contract, a `false` return reverts, and `approve` resets a non-zero allowance to zero first. They return nothing, since a refused write reverts the program
+- `ERC20ABI.at(token).transfer(...)` is the raw ABI call and is NOT SafeERC20: it reverts on a token that returns nothing and accepts one that returns `false`. Use it only when that is what you mean
 - The storageTransfer example demonstrates how to implement ERC-20 logic entirely in SauceScript using storage operations

package/sdk/src/skills/etherfi.md

@@ -62,7 +62,7 @@ function main(weethAddress: Address, amount: Uint256): Uint256 {
 - `wrap(uint256)` - Wrap eETH amount into weETH. Requires eETH approval
 - `unwrap(uint256)` - Unwrap weETH back to eETH
 - `getEETHByWeETH(uint256)` - Preview eETH for weETH amount
-- `getWeETHByEETH(uint256)` - Preview weETH for eETH amount
+- `getWeETHByeETH(uint256)` - Preview weETH for eETH amount (note the lower-case `e`)
 - `balanceOf(address)` - Query weETH balance
 
 ### EETHABI

package/sdk/src/skills/fluid.md

@@ -8,76 +8,79 @@ lending | Chains: Ethereum (1), Arbitrum (42161)
 
 ## SauceScript Functions
 
+The Liquidity layer (`liquidity` below) has no user-level deposit or borrow function: its only entry point, `operate`, is restricted to Fluid's own protocols. Users lend through **fTokens** (ERC-4626 vaults such as fUSDC) and borrow through **Vaults**.
+
 ### deposit
 
-Deposit tokens into the Fluid liquidity layer.
+Deposit the fToken's underlying asset and receive fToken shares.
 
 ```typescript
-import { FluidLendingABI as IFluidLending } from "./abis";
+import { FluidLendingABI as IFToken } from "./abis";
 
-function main(liquidityAddress: Address, token: Address, amount: Uint256, to: Address): Uint256 {
-  const lending = IFluidLending.at(liquidityAddress);
-  return lending.deposit(token, amount, to);
+function main(fTokenAddress: Address, amount: Uint256, to: Address): Uint256 {
+  const fToken = IFToken.at(fTokenAddress);
+  return fToken.deposit(amount, to);
 }
 ```
 
-- `token`: ERC-20 token address to deposit
-- `to`: Address that receives the deposit position
-- Returns shares representing the deposit
-- Requires ERC-20 approval to the liquidity address
+- `fTokenAddress`: the fToken for the asset (e.g. fUSDC `0x9Fb7b4477576Fe5B32be4C1843aFB1e55F251B33` on Ethereum)
+- `to`: Address that receives the shares
+- Returns the shares minted
+- Requires ERC-20 approval of the underlying to the fToken
 
 ### withdraw
 
-Withdraw tokens from the liquidity layer.
+Withdraw an amount of the underlying asset, burning the owner's shares.
 
 ```typescript
-import { FluidLendingABI as IFluidLending } from "./abis";
+import { FluidLendingABI as IFToken } from "./abis";
 
-function main(liquidityAddress: Address, token: Address, amount: Uint256, to: Address): Uint256 {
-  const lending = IFluidLending.at(liquidityAddress);
-  return lending.withdraw(token, amount, to);
+function main(fTokenAddress: Address, amount: Uint256, to: Address, owner: Address): Uint256 {
+  const fToken = IFToken.at(fTokenAddress);
+  return fToken.withdraw(amount, to, owner);
 }
 ```
 
-- Returns actual amount withdrawn
+- Returns the shares burned
 
 ### borrow
 
-Borrow tokens against deposited assets.
+Borrow from a Vault position: `operate` with a positive debt delta.
 
 ```typescript
-import { FluidLendingABI as IFluidLending } from "./abis";
+import { FluidVaultABI as IFluidVault } from "./abis";
 
-function main(liquidityAddress: Address, token: Address, amount: Uint256, to: Address): Uint256 {
-  const lending = IFluidLending.at(liquidityAddress);
-  return lending.borrow(token, amount, to);
+function main(vaultAddress: Address, nftId: Uint256, amount: Uint256, to: Address): Uint256 {
+  const vault = IFluidVault.at(vaultAddress);
+  vault.operate(nftId, 0, amount, to);
+  return 1;
 }
 ```
 
-- Must have sufficient collateral deposited first
-- Returns actual amount borrowed
+- `nftId`: the position NFT (0 opens a new position)
+- The position must hold enough collateral (a positive `newCol` delta deposits it)
 
 ### repay
 
-Repay borrowed tokens.
+Repay a Vault position's debt: `operate` with a negative debt delta.
 
 ```typescript
-import { FluidLendingABI as IFluidLending } from "./abis";
+import { FluidVaultABI as IFluidVault } from "./abis";
 
 function main(
-  liquidityAddress: Address,
-  token: Address,
-  amount: Uint256,
-  onBehalfOf: Address,
+  vaultAddress: Address,
+  nftId: Uint256,
+  negativeDebtDelta: Uint256,
+  to: Address,
 ): Uint256 {
-  const lending = IFluidLending.at(liquidityAddress);
-  return lending.repay(token, amount, onBehalfOf);
+  const vault = IFluidVault.at(vaultAddress);
+  vault.operate(nftId, 0, negativeDebtDelta, to);
+  return 1;
 }
 ```
 
-- `onBehalfOf`: Address whose debt is being repaid
-- Requires ERC-20 approval to the liquidity address
-- Returns actual amount repaid
+- `negativeDebtDelta`: the repayment as a negative `int256`, passed in two's complement (`2**256 - amount`)
+- Requires ERC-20 approval of the debt token to the Vault
 
 ## Deployed Addresses
 
@@ -88,12 +91,16 @@ function main(
 
 ## ABI Reference
 
-### FluidLendingABI
+### FluidLendingABI (an fToken)
+
+- `deposit(uint256 assets, address receiver) returns (uint256 shares)` - ERC-4626 deposit
+- `withdraw(uint256 assets, address receiver, address owner) returns (uint256 shares)` - ERC-4626 withdraw
+- `redeem(uint256 shares, address receiver, address owner) returns (uint256 assets)` - ERC-4626 redeem
+- `asset() returns (address)` - The underlying token
+
+### FluidVaultABI (a Vault)
 
-- `deposit(address token, uint256 amount, address to) returns (uint256 shares)` - Deposit token into liquidity layer
-- `withdraw(address token, uint256 amount, address to) returns (uint256 actualAmount)` - Withdraw token
-- `borrow(address token, uint256 amount, address to) returns (uint256 actualAmount)` - Borrow token against deposits
-- `repay(address token, uint256 amount, address onBehalfOf) returns (uint256 actualAmount)` - Repay borrowed debt
+- `operate(uint256 nftId, int256 newCol, int256 newDebt, address to) returns (uint256, int256, int256)` [payable] - Change a position's collateral and debt in one call; positive deltas deposit/borrow, negative ones withdraw/repay
 
 ## Notes
 
@@ -101,5 +108,5 @@ function main(
 - No interest rate mode selection -- all rates are algorithmically determined
 - Same contract address on Ethereum and Arbitrum
 - Built by the Instadapp team
-- All deposit/repay operations require ERC-20 approval
+- All deposit/repay operations require ERC-20 approval (to the fToken or Vault)
 - TVL: $1B+. Audited

package/sdk/src/skills/frax.md

@@ -21,17 +21,17 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
 
 ```typescript
 // Transfer FRAX
-import { FraxERC20ABI as IFRAX } from "./abis";
+import { transfer } from "@sauce/token";
 function main(fraxAddress: Address, to: Address, amount: Uint256): Uint256 {
-  const frax = IFRAX.at(fraxAddress);
-  return frax.transfer(to, amount);
+  transfer(fraxAddress, to, amount);
+  return 1;
 }
 
 // Approve FRAX spender
-import { FraxERC20ABI as IFRAX } from "./abis";
+import { approve } from "@sauce/token";
 function main(fraxAddress: Address, spender: Address, amount: Uint256): Uint256 {
-  const frax = IFRAX.at(fraxAddress);
-  return frax.approve(spender, amount);
+  approve(fraxAddress, spender, amount);
+  return 1;
 }
 ```
 

package/sdk/src/skills/gains-network.md

@@ -27,35 +27,25 @@ import {
 ```typescript
 // Close trade at market price
 import { DiamondABI as IDiamond } from "./abis";
-function main(diamondAddress: Address, pairIndex: Uint256, index: Uint256): Uint256 {
+function main(diamondAddress: Address, index: Uint256, expectedPrice: Uint256): Uint256 {
   const diamond = IDiamond.at(diamondAddress);
-  diamond.closeTradeMarket(pairIndex, index);
+  diamond.closeTradeMarket(index, expectedPrice);
   return 1;
 }
 
 // Update stop loss
 import { DiamondABI as IDiamond } from "./abis";
-function main(
-  diamondAddress: Address,
-  pairIndex: Uint256,
-  index: Uint256,
-  newSl: Uint256,
-): Uint256 {
+function main(diamondAddress: Address, index: Uint256, newSl: Uint256): Uint256 {
   const diamond = IDiamond.at(diamondAddress);
-  diamond.updateSl(pairIndex, index, newSl);
+  diamond.updateSl(index, newSl);
   return 1;
 }
 
 // Update take profit
 import { DiamondABI as IDiamond } from "./abis";
-function main(
-  diamondAddress: Address,
-  pairIndex: Uint256,
-  index: Uint256,
-  newTp: Uint256,
-): Uint256 {
+function main(diamondAddress: Address, index: Uint256, newTp: Uint256): Uint256 {
   const diamond = IDiamond.at(diamondAddress);
-  diamond.updateTp(pairIndex, index, newTp);
+  diamond.updateTp(index, newTp);
   return 1;
 }
 ```
@@ -72,15 +62,17 @@ function main(
 
 ### DiamondABI
 
-- `openTrade(tuple,uint8,uint256)` - Open trade. Tuple: { trader, pairIndex, index, initialPosToken, positionSizeDai, openPrice, buy, leverage, tp, sl }. orderType: 0=market, 1=limit. slippageP: max slippage %
-- `closeTradeMarket(uint256,uint256)` - Close at market. Params: pairIndex, index
-- `updateSl(uint256,uint256,uint256)` - Update stop loss. Params: pairIndex, index, newSl
-- `updateTp(uint256,uint256,uint256)` - Update take profit. Params: pairIndex, index, newTp
+These are the multi-collateral Diamond's (v8+) signatures. A trade is addressed by the trader's own `index` (their Nth trade), not by `(pairIndex, index)`.
+
+- `openTrade(Trade trade, uint16 maxSlippageP, address referrer)` - Open a trade. Trade: `(address user, uint32 index, uint16 pairIndex, uint24 leverage, bool long, bool isOpen, uint8 collateralIndex, uint8 tradeType, uint120 collateralAmount, uint64 openPrice, uint64 tp, uint64 sl, bool isCounterTrade, uint160 positionSizeToken, uint24 __placeholder)`
+- `closeTradeMarket(uint32 index, uint64 expectedPrice)` - Close at market
+- `updateSl(uint32 index, uint64 newSl)` - Update stop loss
+- `updateTp(uint32 index, uint64 newTp)` - Update take profit
 
 ## Notes
 
 - TVL: $50M+. Up to 1000x leverage on forex, 250x on crypto
 - Diamond proxy pattern - single contract for all operations
 - pairIndex identifies the trading pair (0=BTC/USD, 1=ETH/USD, etc.)
-- index identifies which trade for a given pair (user can have multiple)
+- index identifies one of the trader's trades (a trader can have several)
 - openTrade uses complex tuple param for trade parameters

package/sdk/src/skills/gamma.md

@@ -4,7 +4,7 @@ Active concentrated liquidity management protocol. Manages Uniswap V3, Algebra,
 
 ## Category
 
-yield | Chains: Ethereum, Polygon, Arbitrum
+yield | Chains: Ethereum, Polygon
 
 ## Key Operations
 
@@ -44,11 +44,10 @@ function main(hypervisorAddress: Address, shares: Uint256, to: Address, from: Ad
 
 ## Key Addresses
 
-| Chain    | Contract | Address                                      |
-| -------- | -------- | -------------------------------------------- |
-| Ethereum | uniProxy | `0xf5bfa20f4a77933fee0c7bb7f39e7642a070d599` |
-| Polygon  | uniProxy | `0xA42d55074869491D60Ac05490376B74cF19B00e6` |
-| Arbitrum | uniProxy | `0xf5bfa20f4a77933fee0c7bb7f39e7642a070d599` |
+| Chain    | Contract | Address                                                                                    |
+| -------- | -------- | ------------------------------------------------------------------------------------------ |
+| Ethereum | uniProxy | `0xf5bfa20f4a77933fee0c7bb7f39e7642a070d599` (an earlier release: use `UniProxyLegacyABI`) |
+| Polygon  | uniProxy | `0xA42d55074869491D60Ac05490376B74cF19B00e6`                                               |
 
 ## ABI Methods
 
@@ -57,6 +56,13 @@ function main(hypervisorAddress: Address, shares: Uint256, to: Address, from: Ad
 - `deposit(uint256,uint256,address,address,uint256[4])` - Deposit tokens. Params: deposit0, deposit1, to (receiver), pos (hypervisor address), minIn[4] (slippage, use [0,0,0,0])
 - `getDepositAmount(address,address,uint256)` - Preview required token1 amount for given token0 deposit. Params: pos, token, deposit amount. Returns (amountStart, amountEnd)
 
+### UniProxyLegacyABI
+
+The Ethereum UniProxy is an earlier release; its `deposit` has no `minIn` (the `depositLegacy` template calls it).
+
+- `deposit(uint256,uint256,address,address)` - Deposit tokens. Params: deposit0, deposit1, to (receiver), pos (hypervisor address). Returns shares
+- `getDepositAmount(address,address,uint256)` - As on the current UniProxy
+
 ### HypervisorABI
 
 - `withdraw(uint256,address,address,uint256[4])` - Withdraw by burning shares. Params: shares, to, from, minAmounts[4]. Returns (amount0, amount1)

package/sdk/src/skills/gho.md

@@ -21,18 +21,16 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
 
 ```typescript
 // Transfer GHO
-import { GhoTokenABI as IGhoToken } from "./abis";
+import { transfer } from "@sauce/token";
 function main(ghoAddress: Address, to: Address, amount: Uint256): Uint256 {
-  const gho = IGhoToken.at(ghoAddress);
-  gho.transfer(to, amount);
+  transfer(ghoAddress, to, amount);
   return 1;
 }
 
 // Approve GHO spender
-import { GhoTokenABI as IGhoToken } from "./abis";
+import { approve } from "@sauce/token";
 function main(ghoAddress: Address, spender: Address, amount: Uint256): Uint256 {
-  const gho = IGhoToken.at(ghoAddress);
-  gho.approve(spender, amount);
+  approve(ghoAddress, spender, amount);
   return 1;
 }
 ```

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

@@ -42,6 +42,7 @@ function main(
     0,
     200000000000000,
     0x0000000000000000000000000000000000000000000000000000000000000000,
+    0x0000000000000000000000000000000000000000,
   );
   return 1;
 }
@@ -69,6 +70,7 @@ function main(
     0,
     200000000000000,
     false,
+    0x0000000000000000000000000000000000000000,
   );
   return 1;
 }
@@ -103,8 +105,8 @@ function main(
 
 ### PositionRouterABI
 
-- `createIncreasePosition(address[],address,uint256,uint256,uint256,bool,uint256,uint256,bytes32)` - Open/increase. Params: path, indexToken, amountIn, minOut, sizeDelta, isLong, acceptablePrice, executionFee, referralCode
-- `createDecreasePosition(address[],address,uint256,uint256,bool,address,uint256,uint256,uint256,bool)` - Close/decrease. Params: path, indexToken, collateralDelta, sizeDelta, isLong, receiver, acceptablePrice, minOut, executionFee, withdrawETH
+- `createIncreasePosition(address[],address,uint256,uint256,uint256,bool,uint256,uint256,bytes32,address) returns (bytes32)` - Open/increase. Params: path, indexToken, amountIn, minOut, sizeDelta, isLong, acceptablePrice, executionFee, referralCode, callbackTarget (zero for none). Returns the request key
+- `createDecreasePosition(address[],address,uint256,uint256,bool,address,uint256,uint256,uint256,bool,address) returns (bytes32)` - Close/decrease. Params: path, indexToken, collateralDelta, sizeDelta, isLong, receiver, acceptablePrice, minOut, executionFee, withdrawETH, callbackTarget (zero for none). Returns the request key
 
 ### RouterABI
 

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

@@ -57,6 +57,7 @@ function main(
       executionFee: executionFee,
       callbackGasLimit: 0,
       minOutputAmount: minOutputAmount,
+      validFromTime: 0,
     },
     orderType: orderType,
     decreasePositionSwapType: 0,
@@ -64,6 +65,7 @@ function main(
     shouldUnwrapNativeToken: false,
     autoCancel: false,
     referralCode: 0x0000000000000000000000000000000000000000000000000000000000000000,
+    dataList: [],
   });
   return result;
 }
@@ -94,7 +96,7 @@ function main(exchangeRouterAddress: Address, orderKey: Uint256): Uint256 {
 
 | Chain    | Contract       | Address                                      |
 | -------- | -------------- | -------------------------------------------- |
-| Arbitrum | exchangeRouter | `0x7C68C7866A64FA2160F78EEaE12217FFbf871fa8` |
+| Arbitrum | exchangeRouter | `0x7dE39FF2e232A2203196788d37e234cF8F1b83f1` |
 | Arbitrum | dataStore      | `0xFD70de6b91282D8017aA4E741e9Ae325CAb992d8` |
 
 ## ABI Methods
@@ -108,7 +110,8 @@ function main(exchangeRouterAddress: Address, orderKey: Uint256): Uint256 {
 ### CreateOrderParams Struct
 
 - **addresses**: { receiver, cancellationReceiver, callbackContract, uiFeeReceiver, market, initialCollateralToken, swapPath[] }
-- **numbers**: { sizeDeltaUsd, initialCollateralDeltaAmount, triggerPrice, acceptablePrice, executionFee, callbackGasLimit, minOutputAmount }
+- **numbers**: { sizeDeltaUsd, initialCollateralDeltaAmount, triggerPrice, acceptablePrice, executionFee, callbackGasLimit, minOutputAmount, validFromTime }
+- **flags and extras**: orderType, decreasePositionSwapType, isLong, shouldUnwrapNativeToken, autoCancel, referralCode (bytes32), dataList (bytes32[])
 - **orderType**: 0=MarketSwap, 1=LimitSwap, 2=MarketIncrease, 3=LimitIncrease, 4=MarketDecrease, 5=LimitDecrease, 6=StopLossDecrease
 - **isLong**: true for long, false for short
 
@@ -116,6 +119,7 @@ function main(exchangeRouterAddress: Address, orderKey: Uint256): Uint256 {
 
 - TVL: $800M+. Isolated markets with separate GM tokens per trading pair
 - Order flow: 1) sendTokens to market vault, 2) createOrder with execution fee
+- GMX redeploys the ExchangeRouter on upgrades and revokes the old one; the listed router is the one RoleStore currently grants CONTROLLER
 - executionFee is paid in ETH (msg.value) to cover keeper gas costs
 - sizeDeltaUsd is in USD with 30 decimals (1 USD = 1e30)
 - Each market has its own address - query dataStore for market info

package/sdk/src/skills/harvest.md

@@ -40,8 +40,8 @@ function main(vaultAddress: Address, amount: Uint256): Uint256 {
 
 ## ABI Methods
 
-- `deposit(uint256)` - Deposit tokens
-- `withdraw(uint256)` - Withdraw shares
+- `deposit(uint256) returns (uint256)` - Deposit tokens
+- `withdraw(uint256) returns (uint256)` - Withdraw shares
 - `getPricePerFullShare()` - Get share price
 
 ## Notes

package/sdk/src/skills/hegic.md

@@ -19,26 +19,27 @@ import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/pro
 ## SauceScript Examples
 
 ```typescript
-// Exercise option
+// Exercise option: the OperationalTreasury pays off the position to `account`
 import { HegicABI as IHegic } from "./abis";
-function main(hegicAddress: Address, optionId: Uint256): Uint256 {
-  const hegic = IHegic.at(hegicAddress);
-  hegic.exercise(optionId);
+function main(treasuryAddress: Address, optionId: Uint256, account: Address): Uint256 {
+  const treasury = IHegic.at(treasuryAddress);
+  treasury.payOff(optionId, account);
   return 1;
 }
 ```
 
 ## Key Addresses
 
-| Chain    | Contract | Address                                      |
-| -------- | -------- | -------------------------------------------- |
-| Arbitrum | hegic    | `0x431402e8b9dE9aa016C743880e04E517074D8cEC` |
+| Chain    | Contract            | Address                                                    |
+| -------- | ------------------- | ---------------------------------------------------------- |
+| Arbitrum | hegic               | `0x431402e8b9dE9aa016C743880e04E517074D8cEC` (HEGIC token) |
+| Arbitrum | operationalTreasury | `0xec096ea6eB9aa5ea689b0CF00882366E92377371`               |
 
 ## ABI Methods
 
 ### HegicABI
 
-- `exercise(uint256)` - Exercise option by ID. Params: optionId (NFT token ID of the option)
+- `payOff(uint256 positionID, address account)` - Exercise an option by ID on the OperationalTreasury; the payout goes to `account`
 
 ## Notes
 

package/sdk/src/skills/hop.md

@@ -45,14 +45,14 @@ function main(
 
 ## Deployed Addresses
 
-| Chain    | Contract     | Address                                      |
-| -------- | ------------ | -------------------------------------------- |
-| Ethereum | l1EthBridge  | `0xb8901acb165ed027e32754e0ffe830802919727f` |
-| Ethereum | l1UsdcBridge | `0x3666f603Cc164936C1b87e207F36BEBa4AC5f18a` |
-| Arbitrum | l2AmmWrapper | `0x33ceb27b39d2Bb7D2e36F8Cda811Da1d199967c8` |
-| Optimism | l2AmmWrapper | `0x86cA30bEF97fB651b8d866D45503684b90cb3312` |
-| Polygon  | l2AmmWrapper | `0x76b22b8C1079A44F1211D867D68b1eda76a635A7` |
-| Base     | l2AmmWrapper | `0x46ae9BaB8CEA96610807a275EBD36f8e916b5571` |
+| Chain    | Contract              | Address                                      |
+| -------- | --------------------- | -------------------------------------------- |
+| Ethereum | l1EthBridge           | `0xb8901acb165ed027e32754e0ffe830802919727f` |
+| Ethereum | l1UsdcBridge          | `0x3666f603Cc164936C1b87e207F36BEBa4AC5f18a` |
+| Arbitrum | l2AmmWrapper (WETH)   | `0x33ceb27b39d2Bb7D2e61F7564d3Df29344020417` |
+| Optimism | l2AmmWrapper (WETH)   | `0x86cA30bEF97fB651b8d866D45503684b90cb3312` |
+| Polygon  | l2AmmWrapper (USDC.e) | `0x76b22b8C1079A44F1211D867D68b1eda76a635A7` |
+| Base     | l2AmmWrapper (WETH)   | `0x10541b07d8Ad2647Dc6cD67abd4c03575dade261` |
 
 ## ABI Reference
 

package/sdk/src/skills/hyperlane.md

@@ -4,7 +4,7 @@ Permissionless interchain messaging protocol. Supports modular security with ISM
 
 ## Category
 
-cross-chain messaging | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), Avalanche (43114), BSC (56)
+cross-chain messaging | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), Avalanche (43114), BSC (56), Arc (5042)
 
 ## SauceScript Functions
 
@@ -48,9 +48,9 @@ function main(
 
 ### HyperlaneMailboxABI
 
-- `dispatch(uint32 _destinationDomain, bytes32 _recipientAddress, bytes _messageBody) returns (uint256)` [payable] - Send interchain message. Returns message ID
+- `dispatch(uint32 _destinationDomain, bytes32 _recipientAddress, bytes _messageBody) returns (bytes32)` [payable] - Send interchain message. Returns message ID
 - `quoteDispatch(uint32 _destinationDomain, bytes32 _recipientAddress, bytes _messageBody) returns (uint256)` - Quote fee for dispatching a message (view)
-- `process(bytes _metadata, bytes _message)` - Process an inbound message on the destination chain (called by relayers)
+- `process(bytes _metadata, bytes _message)` [payable] - Process an inbound message on the destination chain (called by relayers)
 - `delivered(bytes32 _id) returns (bool)` - Check if a message has been delivered (view)
 
 ## Notes
@@ -63,3 +63,4 @@ function main(
 - `delivered()` to check if a message has already been processed on the destination
 - Finality: depends on ISM configuration, typically 1-5 minutes
 - TVL: $200M+. Audited
+- On Arc (5042) interchain gas is paid in native USDC at 18 decimals, from the same balance as the USDC ERC-20 `0x3600…0000`. A transfer of the whole USDC balance cannot also pay its gas. Hyperlane's CCTP-backed USDC warp route on Arc is `0x16BF93e259ee7f7074453a2948379C35C6851b71` (its `quoteGasPayment(8453)` was about 0.054 USDC on 2026-09-28)