@eco-incorp/sauce 0.99.6 → 0.99.7

package/skills/sauce-protocols/references/abracadabra.md

@@ -0,0 +1,72 @@
+# Abracadabra
+
+Lending protocol that lets users borrow MIM stablecoin against yield-bearing collateral via isolated Cauldron markets built on DegenBox.
+
+## Category
+
+cdp | Chains and addresses: [registry/abracadabra.md](registry/abracadabra.md)
+
+## Key Operations
+
+- **borrow**: Borrow MIM from a Cauldron
+- **repay**: Repay MIM debt
+- **addCollateral**: Add collateral to a Cauldron position
+- **removeCollateral**: Remove collateral from a Cauldron position
+
+## Typed templates for the raw compiler (not for `sauce compile`)
+
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
+
+```typescript
+// Borrow MIM from Cauldron
+import { CauldronABI as ICauldron } from "./abis";
+function main(
+  cauldronAddress: Address,
+  to: Address,
+  amount: Uint256,
+): { part: Uint256; share: Uint256 } {
+  const cauldron = ICauldron.at(cauldronAddress);
+  return cauldron.borrow(to, amount);
+}
+
+// Repay MIM debt
+import { CauldronABI as ICauldron } from "./abis";
+function main(cauldronAddress: Address, to: Address, part: Uint256): Uint256 {
+  const cauldron = ICauldron.at(cauldronAddress);
+  return cauldron.repay(to, 0, part);
+}
+
+// Add collateral
+import { CauldronABI as ICauldron } from "./abis";
+function main(cauldronAddress: Address, to: Address, share: Uint256): Uint256 {
+  const cauldron = ICauldron.at(cauldronAddress);
+  cauldron.addCollateral(to, 0, share);
+  return 1;
+}
+
+// Remove collateral
+import { CauldronABI as ICauldron } from "./abis";
+function main(cauldronAddress: Address, to: Address, share: Uint256): Uint256 {
+  const cauldron = ICauldron.at(cauldronAddress);
+  cauldron.removeCollateral(to, share);
+  return 1;
+}
+```
+
+## Deployments and ABI
+
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/abracadabra.md](registry/abracadabra.md).
+
+## Notes
+
+- Isolated Cauldron markets - each has specific collateral type and risk parameters
+- DegenBox is the underlying vault that holds all assets (BentoBox fork)
+- Amounts use "part" (debt accounting) and "share" (DegenBox shares) - not raw token amounts
+- skim=false means transfer tokens from caller; skim=true means use tokens already in DegenBox
+- Deposit collateral to DegenBox first, then addCollateral to a Cauldron
+- Common collateral: sSPELL, yv tokens, LP tokens, yield-bearing assets

package/skills/sauce-protocols/references/across.md

@@ -0,0 +1,73 @@
+# Across
+
+Optimistic cross-chain bridge powered by UMA's optimistic oracle. Uses relayers for fast fills and canonical bridges for settlement.
+
+## Category
+
+bridge | Direction: L2-to-L2, L1-to-L2, L2-to-L1 | Chains and addresses: [registry/across.md](registry/across.md)
+
+## Typed templates for the raw compiler (not for `sauce compile`)
+
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
+
+### bridge
+
+Deposit tokens into the SpokePool for a cross-chain transfer, through `depositV3`.
+
+```typescript
+import { AcrossSpokePoolABI as ISpokePool } from "./abis";
+
+function main(
+  spokePoolAddress: Address,
+  token: Address,
+  outputToken: Address,
+  amount: Uint256,
+  outputAmount: Uint256,
+  destinationChainId: Uint256,
+  recipient: Address,
+  quoteTimestamp: Uint256,
+  fillDeadline: Uint256,
+): Uint256 {
+  const spokePool = ISpokePool.at(spokePoolAddress);
+  spokePool.depositV3(
+    ctx.msgSender(),
+    recipient,
+    token,
+    outputToken,
+    amount,
+    outputAmount,
+    destinationChainId,
+    0x0000000000000000000000000000000000000000,
+    quoteTimestamp,
+    fillDeadline,
+    0,
+    "",
+  );
+  return 1;
+}
+```
+
+- `token` / `outputToken`: ERC-20 to bridge, and the token the recipient receives on the destination
+- `outputAmount`: amount the relayer delivers (input minus the quoted fees)
+- `quoteTimestamp`: the quote's timestamp; the SpokePool rejects one outside its `depositQuoteTimeBuffer`
+- `fillDeadline`: unix time after which the deposit can no longer be filled
+- `recipient`: Address to receive tokens on destination chain
+- Requires ERC-20 approval to the SpokePool
+
+## Deployments and ABI
+
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/across.md](registry/across.md).
+
+## Notes
+
+- Fast fills: relayers fill deposits on destination within minutes, then claim reimbursement via optimistic oracle
+- Finality: deposit confirmation on source chain, fill within 1-10 minutes typically
+- Requires ERC-20 approval to the SpokePool address on source chain
+- HubPool on Ethereum only -- SpokePools on all supported L2s
+- TVL: $500M+. Audited
+- On Arc (5042) the SpokePool's `wrappedNativeToken()` is the zero address, so deposit ERC-20s (USDC is `0x3600000000000000000000000000000000000000`), not native value

package/skills/sauce-protocols/references/aerodrome-slipstream.md

@@ -0,0 +1,50 @@
+# Aerodrome Slipstream
+
+> **In a Sauce program**, swap through the Sauce Router wherever it services the pool, with a price limit, a minimum output and the unspent input returned (`sauce-swaps`; several pools under one limit, `sauce-distributed-swap`). The templates below call the protocol's own contracts.
+
+Aerodrome's concentrated-liquidity pools (Uniswap V3-style, keyed by tick spacing rather than fee), on Base and, as Aero Lite, on Arc.
+
+## Category
+
+dex | Chains and addresses: [registry/aerodrome-slipstream.md](registry/aerodrome-slipstream.md)
+
+## Typed templates for the raw compiler (not for `sauce compile`)
+
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
+
+### getPool
+
+```typescript
+import { SlipstreamCLFactoryABI as ICLFactory } from "./abis";
+
+function main(
+  factoryAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
+  tickSpacing: Uint256,
+): Address {
+  const factory = ICLFactory.at(factoryAddress);
+  return factory.getPool(tokenA, tokenB, tickSpacing);
+}
+```
+
+- Pools are keyed by `(tokenA, tokenB, tickSpacing)` within one factory
+- On Base, **ask every CLFactory**: each generation keeps its own pools, so a pair can have a pool at the same tick spacing under more than one. The WETH/USDC tick-spacing-50 pool exists under all three factories, tick spacing 1 under the initial and Gauges V3 ones, and tick spacing 100 under the initial one only
+- **The fee is per pool and changes over time**: read the pool's `fee()` (selector `0xddca3f43`, in millionths) when it matters. The same pair at the same tick spacing can charge different fees under different factories, and `tickSpacingToFee(tickSpacing)` is only the factory's default for a spacing: Base's WETH/USDC pools charge other fees than it
+
+## Deployments and ABI
+
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/aerodrome-slipstream.md](registry/aerodrome-slipstream.md).
+
+## Notes
+
+- Base's addresses are from the aerodrome-finance/slipstream README. Three generations are live there, and new gauges deploy from Gauges V3. Base has no Metarouter
+- The `aerodrome` module carries Aerodrome's basic (stable/volatile) pools on Base; this one carries only Slipstream. Velodrome's Slipstream on Optimism and the Superchain is not in either
+- Aero publishes no address table for Arc. Each address here is Sourcify-verified from the dromos-labs/metadex-public codebase, and the position manager reports `factory() == CLFactory`
+- No voter or gauges are deployed on Arc yet, so pools there earn swap fees only
+- The Base roles are `clFactory`/`nonfungiblePositionManager` (initial), `clFactoryGaugeCaps`/`nonfungiblePositionManagerGaugeCaps` and `clFactoryGaugesV3`/`nonfungiblePositionManagerGaugesV3`.

package/{sdk/src/skills → skills/sauce-protocols/references}/aerodrome.md

@@ -1,10 +1,43 @@
 # Aerodrome
 
+> **In a Sauce program**, swap through the Sauce Router wherever it services the pool, with a price limit, a minimum output and the unspent input returned (`sauce-swaps`; several pools under one limit, `sauce-distributed-swap`). The templates below call the protocol's own contracts.
+
 The central trading and liquidity marketplace on Base. Fork of Velodrome with ve(3,3) tokenomics, the largest DEX on Base by TVL ($1B+). Supports both stable and volatile pool types.
 
+## When to use it
+
+- Solidly-style pools on Base, two per pair: **volatile** (constant product) and **stable** (a
+  curve for assets meant to trade near 1:1). Its concentrated-liquidity pools are Aerodrome
+  Slipstream (`aerodrome-slipstream`).
+
+## Pitfalls for a program
+
+- Pick the pool type: `getPool(a, b, stable)` and each route's `stable` flag must agree.
+- Each route names the factory (`Aerodrome.PoolFactory`).
+- `amountOutMin` is the only bound; approve exactly `amountIn` and pass a deadline.
+- Fees are set per pool by the factory, not fixed by the pool type.
+
+## In a Sauce program
+
+Sell the Pot's USDC for WETH on the volatile pool:
+
+```sauce chain=base
+function main(amountIn: Uint256, minOut: Uint256, recipient: Address) {
+  const self = ctx.self();
+  require(Aerodrome.PoolFactory.getPool(USDC, WETH, false) != 0n, "no volatile USDC/WETH pool");
+  const routes = [{ from: USDC, to: WETH, stable: false, factory: Aerodrome.PoolFactory }];
+  const before = WETH.balanceOf(self);
+  USDC.approve(Aerodrome.Router, amountIn);
+  Aerodrome.Router.swapExactTokensForTokens(amountIn, minOut, routes, self, ctx.timestamp());
+  const out = WETH.balanceOf(self) - before;
+  require(out >= minOut, "below minOut");
+  WETH.transfer(recipient, out);
+}
+```
+
 ## Category
 
-dex | Chains: Base
+dex | Chains and addresses: [registry/aerodrome.md](registry/aerodrome.md)
 
 ## Key Operations
 
@@ -12,13 +45,12 @@ dex | Chains: Base
 - **addLiquidity**: Add liquidity to a stable or volatile pool
 - **removeLiquidity**: Remove liquidity from a stable or volatile pool
 
-## SDK Usage
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-```typescript
-import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/aerodrome";
-```
-
-## SauceScript Examples
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
 
 ### swap
 
@@ -121,24 +153,11 @@ function main(
 - `liquidity`: Amount of LP tokens to burn
 - LP token must be approved to the router
 
-## Key Addresses
-
-| Chain | Contract    | Address                                      |
-| ----- | ----------- | -------------------------------------------- |
-| Base  | Router      | `0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43` |
-| Base  | PoolFactory | `0x420DD381b31aEf6683db6B902084cB0FFECe40Da` |
-
-## ABI Methods
-
-### AerodromeRouterABI
-
-- `swapExactTokensForTokens(uint256 amountIn, uint256 amountOutMin, tuple[](address from, address to, bool stable, address factory) routes, address to, uint256 deadline) -> uint256[] amounts` - Swap with route tuples specifying pool type per hop
-- `addLiquidity(address tokenA, address tokenB, bool stable, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB, uint256 liquidity)` - Add liquidity to a stable or volatile pool
-- `removeLiquidity(address tokenA, address tokenB, bool stable, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB)` - Remove liquidity from a pool
-
-### AerodromePoolFactoryABI
+## Deployments and ABI
 
-- `getPool(address tokenA, address tokenB, bool stable) -> address pool` - Look up pool address (view)
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/aerodrome.md](registry/aerodrome.md).
 
 ## Notes
 

package/skills/sauce-protocols/references/aevo.md

@@ -0,0 +1,49 @@
+# Aevo
+
+High-performance options and perpetuals exchange built on a custom OP Stack rollup. Off-chain orderbook with on-chain settlement.
+
+## Category
+
+options | Chains and addresses: [registry/aevo.md](registry/aevo.md)
+
+## Key Operations
+
+- **depositERC20**: Deposit ERC-20 tokens into Aevo L2 for trading
+
+## Typed templates for the raw compiler (not for `sauce compile`)
+
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
+
+```typescript
+// Deposit ERC-20 into Aevo
+import { DepositContractABI as IDeposit } from "./abis";
+function main(
+  depositAddress: Address,
+  token: Address,
+  l2Token: Address,
+  amount: Uint256,
+  minGasLimit: Uint256,
+): Uint256 {
+  const deposit = IDeposit.at(depositAddress);
+  deposit.depositERC20(token, l2Token, amount, minGasLimit, "");
+  return 1;
+}
+```
+
+## Deployments and ABI
+
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/aevo.md](registry/aevo.md).
+
+## Notes
+
+- Custom OP Stack rollup with off-chain orderbook for sub-second matching
+- Supports options and perpetual futures trading
+- Deposits are on Ethereum L1, trading happens on Aevo L2
+- Withdrawals processed by the rollup bridge (takes ~7 days for L2 to L1)
+- Approve ERC-20 tokens to depositContract before calling depositERC20
+- The deposit contract is Aevo's OP Stack `L1StandardBridge`, so these are the standard bridge entry points.

package/{sdk/src/skills → skills/sauce-protocols/references}/alchemix.md

@@ -4,7 +4,7 @@ Self-repaying loan protocol. Deposit yield-bearing collateral to borrow syntheti
 
 ## Category
 
-cdp | Chains: Ethereum
+cdp | Chains and addresses: [registry/alchemix.md](registry/alchemix.md)
 
 ## Key Operations
 
@@ -13,13 +13,12 @@ cdp | Chains: Ethereum
 - **mint**: Borrow synthetic asset (alUSD or alETH) against collateral
 - **burn**: Repay synthetic asset debt
 
-## SDK Usage
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-```typescript
-import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/alchemix";
-```
-
-## SauceScript Examples
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
 
 ```typescript
 // Deposit yield-bearing collateral
@@ -62,25 +61,11 @@ function main(alchemistAddress: Address, amount: Uint256, recipient: Address): U
 }
 ```
 
-## Key Addresses
-
-| Chain    | Contract       | Address                                      |
-| -------- | -------------- | -------------------------------------------- |
-| Ethereum | alchemistAlUSD | `0x5C6374a2ac4EBC38DeA0Fc1F8716e5Ea1ADD94dd` |
-| Ethereum | alchemistAlETH | `0x062Bf725dC4cDF947aa79Ca2aaCCD4F385b13b5c` |
-| Ethereum | alUSD          | `0xBC6DA0FE9aD5f3b0d58160288917AA56653660E9` |
-| Ethereum | alETH          | `0x0100546F2cD4C9D97f798fFC9755E47865FF7Ee6` |
-
-## ABI Methods
-
-### AlchemistABI
+## Deployments and ABI
 
-- `deposit(address,uint256,address)` - Deposit yield-bearing collateral. Params: yieldToken (e.g. yvDAI, yvUSDC), amount, recipient. Returns shares
-- `withdraw(address,uint256,address)` - Withdraw collateral. Params: yieldToken, shares (deposit shares to burn), recipient. Returns amountWithdrawn
-- `mint(uint256,address)` - Borrow synthetic asset. Params: amount (alUSD/alETH to mint), recipient. Max borrow = 50% of collateral value
-- `burn(uint256,address)` - Repay debt by burning synthetic. Params: amount (alUSD/alETH to burn), recipient (whose debt to repay). Returns uint256
-- `liquidate(address,uint256,uint256)` - Liquidate undercollateralized position. Params: yieldToken, shares, minimumAmountOut. Returns uint256
-- `accounts(address)` - Query account info. Params: owner. Returns (debt as int256, depositedTokens as address[])
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/alchemix.md](registry/alchemix.md).
 
 ## Notes
 

package/{sdk/src/skills → skills/sauce-protocols/references}/ambient.md

@@ -1,22 +1,23 @@
 # Ambient
 
+> **In a Sauce program**, swap through the Sauce Router wherever it services the pool, with a price limit, a minimum output and the unspent input returned (`sauce-swaps`; several pools under one limit, `sauce-distributed-swap`). The templates below call the protocol's own contracts.
+
 Single-contract DEX (formerly CrocSwap) with ambient (full-range) and concentrated liquidity in one unified pool. Extremely gas-efficient architecture where all liquidity lives in one contract.
 
 ## Category
 
-dex | Chains: Ethereum, Scroll
+dex | Chains and addresses: [registry/ambient.md](registry/ambient.md)
 
 ## Key Operations
 
 - **swap**: Swap tokens via the CrocSwapDex contract with base/quote pair addressing
 
-## SDK Usage
-
-```typescript
-import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/ambient";
-```
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-## SauceScript Examples
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
 
 ### swap
 
@@ -46,21 +47,13 @@ function main(
 - `inBaseQty`: `true` = qty is denominated in base token; `false` = qty is in quote token
 - `qty`: Amount to swap (in wei)
 - `minOut`: Minimum output for slippage protection
-- Additional params set to `0`: `tip` (optional tip), `limitPrice` (no price limit), `reserveFlags` (no reserve usage)
-
-## Key Addresses
-
-| Chain    | Contract    | Address                                      |
-| -------- | ----------- | -------------------------------------------- |
-| Ethereum | CrocSwapDex | `0xAaAaAAAaA24eEeb8d57D431224f73832bC34f688` |
-| Scroll   | CrocSwapDex | `0xaaaaAAAACB71BF2C8CaE522EA5fa455571A74106` |
-
-## ABI Methods
+- Additional params set to `0`: `tip` (optional tip), `limitPrice` (no price limit, so `minOut` is the only bound), `reserveFlags` (no reserve usage)
 
-### CrocSwapDexABI
+## Deployments and ABI
 
-- `swap(address base, address quote, uint256 poolIdx, bool isBuy, bool inBaseQty, uint128 qty, uint16 tip, uint128 limitPrice, uint128 minOut, uint8 reserveFlags) -> (int128 baseFlow, int128 quoteFlow)` - Execute a swap with full parameter control. Returns signed token flows (negative = tokens out from user)
-- `userCmd(uint16 callpath, bytes cmd) -> bytes result` - Execute arbitrary protocol commands (advanced: liquidity operations, governance, etc.)
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/ambient.md](registry/ambient.md).
 
 ## Notes
 
@@ -70,7 +63,7 @@ function main(
 - Common pool indices: `420` (standard on Ethereum), `36000` (stable pairs on Scroll)
 - `isBuy` + `inBaseQty` together determine the exact swap semantics
 - `tip`: Optional tip in basis points for priority execution (usually `0`)
-- `limitPrice`: Price limit as sqrt price Q64.64 fixed-point (set to `0` for no limit)
+- `limitPrice`: Price limit as sqrt price Q64.64 fixed-point (`0` is no limit, which leaves `minOut` as the only bound)
 - `reserveFlags`: Bitmask for using surplus collateral (set to `0` for standard swaps)
 - `userCmd` is the universal command interface for all non-swap operations (adding/removing liquidity, etc.)
 - callpath `1` = liquidity operations, `3` = warm path operations

package/{sdk/src/skills → skills/sauce-protocols/references}/arbitrum-bridge.md

@@ -4,9 +4,14 @@ Official Arbitrum L1-L2 gateway bridge. Routes tokens through the canonical Arbi
 
 ## Category
 
-native L2 bridge | Direction: L1 to L2 (Ethereum to Arbitrum) | Chains: Ethereum (1), Arbitrum (42161)
+native L2 bridge | Direction: L1 to L2 (Ethereum to Arbitrum) | Chains and addresses: [registry/arbitrum-bridge.md](registry/arbitrum-bridge.md)
 
-## SauceScript Functions
+## Typed templates for the raw compiler (not for `sauce compile`)
+
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
 
 ### depositToL2
 
@@ -37,19 +42,11 @@ function main(
 - Requires ERC-20 approval to the appropriate gateway (use `getGateway(token)` to find it)
 - Requires ETH as msg.value to cover L2 execution costs (`maxGas * gasPriceBid + maxSubmissionCost`)
 
-## Deployed Addresses
-
-| Chain    | Contract        | Address                                      |
-| -------- | --------------- | -------------------------------------------- |
-| Ethereum | l1GatewayRouter | `0x72Ce9c846789fdB6fC1f34aC4AD25Dd9ef7031ef` |
-| Arbitrum | l2GatewayRouter | `0x5288c571Fd7aD117beA99bF60FE0846C4E84F933` |
-
-## ABI Reference
-
-### ArbitrumL1GatewayRouterABI
+## Deployments and ABI
 
-- `outboundTransfer(address _token, address _to, uint256 _amount, uint256 _maxGas, uint256 _gasPriceBid, bytes _data) returns (bytes)` [payable] - Deposit tokens from L1 to L2. Routes to the correct gateway automatically based on the token
-- `getGateway(address _token) returns (address)` - Look up the gateway contract for a specific token (view). Approve tokens to this address, not the router
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/arbitrum-bridge.md](registry/arbitrum-bridge.md).
 
 ## Notes
 

package/{sdk/src/skills → skills/sauce-protocols/references}/arrakis.md

@@ -4,20 +4,19 @@ Automated liquidity management protocol for Uniswap V3. Provides vaults that act
 
 ## Category
 
-yield | Chains: Ethereum
+yield | Chains and addresses: [registry/arrakis.md](registry/arrakis.md)
 
 ## Key Operations
 
 - **addLiquidity**: Add liquidity to an Arrakis vault via router (tuple params)
 - **removeLiquidity**: Remove liquidity from vault via router (tuple params)
 
-## SDK Usage
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-```typescript
-import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/arrakis";
-```
-
-## SauceScript Examples
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
 
 ```typescript
 // Add liquidity - NOTE: uses tuple params via router
@@ -34,26 +33,11 @@ function main(
 }
 ```
 
-## Key Addresses
-
-| Chain    | Contract | Address                                      |
-| -------- | -------- | -------------------------------------------- |
-| Ethereum | factory  | `0xEA1aFf9dbFfD1580F6b81A3ad3589E66652dB7D9` |
-| Ethereum | router   | `0x6aC8Bab8B775a03b8B72B2940251432442f61B94` |
-
-## ABI Methods
-
-### ArrakisRouterABI
-
-- `addLiquidity(tuple)` [payable] - Add liquidity. Tuple: (amount0Max, amount1Max, amount0Min, amount1Min, amountSharesMin, vault, receiver, gauge). Returns (amount0, amount1, sharesReceived)
-- `removeLiquidity(tuple)` - Remove liquidity. Tuple: (burnAmount, amount0Min, amount1Min, vault, receiver, gauge, receiveETH). Returns (amount0, amount1)
-
-### ArrakisVaultABI
+## Deployments and ABI
 
-- `totalSupply()` - Total vault shares outstanding
-- `balanceOf(address)` - Query vault share balance
-- `token0()` - First token address
-- `token1()` - Second token address
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/arrakis.md](registry/arrakis.md).
 
 ## Notes
 

package/skills/sauce-protocols/references/axelar.md

@@ -0,0 +1,56 @@
+# Axelar
+
+Universal cross-chain communication protocol with decentralized validator set. Supports GMP (General Message Passing) and ITS (Interchain Token Service).
+
+## Category
+
+cross-chain messaging + bridge | Direction: any-to-any | Chains and addresses: [registry/axelar.md](registry/axelar.md)
+
+## Typed templates for the raw compiler (not for `sauce compile`)
+
+These import the protocol's ABI from `./abis`, the way the registry compiles them with the raw
+compiler; `sauce compile` has no such module. In a program for a chain, name the contract by its
+namespace, or import its ABI from `./protocols/<slug>/<Export>.json` as the registry file at the
+top of this document shows, and write SauceScript's values (`~0n`, not `type(uint256).max`).
+
+### sendToken
+
+Send tokens cross-chain via the Axelar Gateway.
+
+```typescript
+import { AxelarGatewayABI as IGateway } from "./abis";
+
+function main(
+  gatewayAddress: Address,
+  destinationChain: string,
+  destinationAddress: string,
+  symbol: string,
+  amount: Uint256,
+): Uint256 {
+  const gateway = IGateway.at(gatewayAddress);
+  gateway.sendToken(destinationChain, destinationAddress, symbol, amount);
+  return 1;
+}
+```
+
+- `destinationChain`: Chain name as string (e.g. "ethereum", "arbitrum", "base")
+- `destinationAddress`: Recipient address as string
+- `symbol`: Token symbol as string (e.g. "axlUSDC", "WETH")
+- Requires ERC-20 approval to the Gateway
+
+## Deployments and ABI
+
+The registry's addresses per chain, how a program names each contract there (a namespace, or
+an ABI import bound to the address), and the ABI functions are generated in
+[registry/axelar.md](registry/axelar.md).
+
+## Notes
+
+- Uses chain name strings for destination (e.g. "ethereum", "arbitrum", "Polygon") -- NOT chain IDs
+- `sendToken`: Simple token transfer. `callContract`: GMP message. `callContractWithToken`: Both
+- GMP calls require pre-paying gas via GasService or including gasValue in ITS calls
+- ITS (Interchain Token Service) enables native cross-chain tokens without wrapping
+- Same ITS address (`0xB5FB...`) across all chains
+- `tokenAddresses(symbol)` to look up the local address of an Axelar-supported token
+- Finality: typically 2-5 minutes depending on source chain
+- TVL: $800M+. Audited