@eco-incorp/sauce 0.99.6 → 0.99.7

package/skills/sauce-protocols/references/mantle-meth.md

@@ -0,0 +1,43 @@
+# Mantle mETH
+
+Mantle's liquid staking token for Ethereum. Stake ETH and receive mETH, a non-rebasing token that accrues staking rewards over time.
+
+## Category
+
+liquid-staking | Chains and addresses: [registry/mantle-meth.md](registry/mantle-meth.md)
+
+## Key Operations
+
+- **stake**: Stake ETH for mETH with minimum output check
+
+## 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
+// Stake ETH for mETH
+import { METHStakingABI as IStaking } from "./abis";
+function main(stakingAddress: Address, minMETHAmount: Uint256): Uint256 {
+  const staking = IStaking.at(stakingAddress);
+  staking.stake(minMETHAmount);
+  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/mantle-meth.md](registry/mantle-meth.md).
+
+## Notes
+
+- TVL: $1.5B+. Non-rebasing token backed by Mantle treasury
+- stake() is payable - send ETH as msg.value
+- minMETHAmount param provides slippage protection
+- Use mETHToETH()/ethToMETH() to preview exchange rates
+- The Staking contract (`staking`), not the token.
+- The mETH token (`mETH`).

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

@@ -1,22 +1,23 @@
 # Maverick
 
+> **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.
+
 Dynamic distribution AMM with directional liquidity positioning. Allows LPs to follow price movements automatically with customizable bin strategies. Uses pool addresses directly (no path routing).
 
 ## Category
 
-dex | Chains: Ethereum, Arbitrum, Base
+dex | Chains and addresses: [registry/maverick.md](registry/maverick.md)
 
 ## Key Operations
 
 - **swap**: Exact input single swap via V2 Router, specifying pool address and direction
 
-## SDK Usage
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-```typescript
-import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/maverick";
-```
-
-## 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
 
@@ -44,25 +45,11 @@ function main(
 - `recipient`: Address to receive output tokens
 - Note: parameter order is `(recipient, pool, tokenAIn, amountIn, amountOutMin)` - recipient comes FIRST
 
-## Key Addresses
-
-| Chain    | Contract   | Address                                      |
-| -------- | ---------- | -------------------------------------------- |
-| Ethereum | V2 Router  | `0x62e31802c6145A2D5E842EeD8efe01fC224422fA` |
-| Ethereum | V2 Factory | `0x0A7e848Aca42d879EF06507Fca0E7b33A0a63c1e` |
-| Arbitrum | V2 Router  | `0x5c3b380e5Aeec389d1014Da3Eb372FA2C9e0fc76` |
-| Base     | V2 Router  | `0x5eDEd0d7E76C563FF081Ca01D9d12D6B404Df527` |
-
-## ABI Methods
-
-### 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, uint256 amountOut)` - Swap to get exact output from a specific pool
-
-### MaverickV2FactoryABI
+## Deployments and ABI
 
-- `lookup(address tokenA, address tokenB, uint256 startIndex, uint256 endIndex) -> address[] pools` - Look up a page of the pools for a token pair (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/maverick.md](registry/maverick.md).
 
 ## Notes
 
@@ -73,3 +60,4 @@ function main(
 - 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)
 - Input token must be ERC20-approved to the V2 Router
+- From a Pot program, `@sauce/router`'s `maverickV2(pool, tokenIn, tokenOut, amountIn, minOut, recipient)` swaps a Maverick V2 pool through the Pot's Sauce Router, which pays in the pool's callback exactly what the pool asks for, so a partial fill strands nothing: what the pool did not take stays in the Pot. It does not use the pool's pre-pay mode, where the unfilled part of a pushed input would stay in the pool. The `maverickV2Swap` action is the same call

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

@@ -4,9 +4,14 @@ Leading lending protocol on Base. Compound V2 fork with governance and safety mo
 
 ## Category
 
-lending | Chains: Base (8453)
+lending | Chains and addresses: [registry/moonwell.md](registry/moonwell.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`).
 
 ### supply
 
@@ -68,26 +73,11 @@ function main(mTokenAddress: Address, amount: Uint256): Uint256 {
 
 - Requires ERC-20 approval of underlying to the mToken
 
-## Deployed Addresses
-
-| Chain | Contract    | Address                                      |
-| ----- | ----------- | -------------------------------------------- |
-| Base  | comptroller | `0xfBb21d0380beE3312B33c4353c8936a0F13EF26C` |
-
-## ABI Reference
-
-### MTokenABI
-
-- `mint(uint256 mintAmount) returns (uint256)` - Supply underlying, receive mTokens
-- `redeem(uint256 redeemTokens) returns (uint256)` - Redeem mTokens for underlying
-- `redeemUnderlying(uint256 redeemAmount) returns (uint256)` - Redeem exact underlying amount
-- `borrow(uint256 borrowAmount) returns (uint256)` - Borrow underlying
-- `repayBorrow(uint256 repayAmount) returns (uint256)` - Repay borrow debt
-
-### MoonwellComptrollerABI
+## Deployments and ABI
 
-- `enterMarkets(address[] mTokens) returns (uint256[])` - Enable mTokens as collateral
-- `exitMarket(address mToken) returns (uint256)` - Remove mToken from collateral
+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/moonwell.md](registry/moonwell.md).
 
 ## Notes
 

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

@@ -2,11 +2,49 @@
 
 Minimal and gas-efficient lending primitive with permissionless market creation. Markets are defined by a unique (loanToken, collateralToken, oracle, IRM, LLTV) tuple.
 
+## When to use it
+
+- Isolated markets: each pairs one loan asset with one collateral, its own oracle, interest
+  rate model and liquidation LTV (`lltv`), named by those five `MarketParams`. One market's bad
+  debt does not reach another.
+- Choose it to lend or borrow in a specific pair with a specific oracle, or to build on a market
+  someone created; for shared liquidity across many assets, Aave V3.
+
+## Pitfalls for a program
+
+- A market exists only for exactly the `MarketParams` it was created with: pass all five.
+- Give exactly one of `assets` and `shares`, the other `0n`.
+- Vet the market's oracle: it alone decides liquidations there.
+- `supplyCollateral` earns nothing; only `supply` of the loan asset earns interest.
+- Approve Morpho for the amount; `data` is empty bytes unless you want its callback, which a
+  Sauce program cannot receive.
+
+## In a Sauce program
+
+Supply the loan asset to a market given as `main`'s input:
+
+```sauce chain=base,ethereum
+function main(
+  market: { loanToken: Address, collateralToken: Address, oracle: Address, irm: Address, lltv: Uint256 },
+  assets: Uint256
+) {
+  const self = ctx.self();
+  Token(market.loanToken).approve(MorphoBlue.Morpho, assets);
+  const empty = hex``;
+  MorphoBlue.Morpho.supply(market, assets, 0n, self, empty);
+}
+```
+
 ## Category
 
-lending | Chains: Ethereum (1), Base (8453), Arc (5042)
+lending | Chains and addresses: [registry/morpho-blue.md](registry/morpho-blue.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`).
 
 ### supply
 
@@ -162,26 +200,11 @@ function main(
 
 - Requires ERC-20 approval of loanToken to the Morpho address
 
-## Deployed Addresses
-
-| Chain    | Contract | Address                                      |
-| -------- | -------- | -------------------------------------------- |
-| Ethereum | morpho   | `0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb` |
-| Ethereum | bundler3 | `0x6566194141eefa99Af43Bb5Aa71460Ca2Dc90245` |
-| Base     | morpho   | `0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb` |
-
-## ABI Reference
-
-### MorphoABI
-
-- `supply(MarketParams marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) returns (uint256 assetsSupplied, uint256 sharesSupplied)` - Supply loan tokens (specify assets OR shares, set other to 0)
-- `withdraw(MarketParams marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) returns (uint256 assetsWithdrawn, uint256 sharesWithdrawn)` - Withdraw loan tokens
-- `borrow(MarketParams marketParams, uint256 assets, uint256 shares, address onBehalf, address receiver) returns (uint256 assetsBorrowed, uint256 sharesBorrowed)` - Borrow loan tokens
-- `repay(MarketParams marketParams, uint256 assets, uint256 shares, address onBehalf, bytes data) returns (uint256 assetsRepaid, uint256 sharesRepaid)` - Repay borrowed debt
-- `supplyCollateral(MarketParams marketParams, uint256 assets, address onBehalf, bytes data)` - Supply collateral tokens (required before borrowing)
-- `withdrawCollateral(MarketParams marketParams, uint256 assets, address onBehalf, address receiver)` - Withdraw collateral tokens
+## Deployments and ABI
 
-MarketParams tuple: `(address loanToken, address collateralToken, address oracle, address irm, uint256 lltv)`
+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/morpho-blue.md](registry/morpho-blue.md).
 
 ## Notes
 

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

@@ -4,7 +4,7 @@ Leveraged trading aggregator on Arbitrum. Routes trades across multiple perpetua
 
 ## Category
 
-perpetuals | Chains: Arbitrum
+perpetuals | Chains and addresses: [registry/mux-protocol.md](registry/mux-protocol.md)
 
 ## Key Operations
 
@@ -13,17 +13,12 @@ perpetuals | Chains: Arbitrum
 - **placePositionOrder3**: Place a leveraged position order
 - **cancelOrder**: Cancel a pending order
 
-## SDK Usage
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-```typescript
-import {
-  protocolInfo,
-  deployments,
-  sauceFunctions,
-} from "@eco-incorp/sauce/protocols/mux-protocol";
-```
-
-## 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`).
 
 Liquidity moves through OrderBook orders that MUX brokers fill; the LiquidityPool's own add/remove functions are callable only by the OrderBook.
 
@@ -45,26 +40,11 @@ function main(orderBookAddress: Address, assetId: Uint256, mlpAmount: Uint256):
 }
 ```
 
-## Key Addresses
-
-| Chain    | Contract      | Address                                      |
-| -------- | ------------- | -------------------------------------------- |
-| Arbitrum | orderBook     | `0xa19fD5aB6C8DCffa2A295F78a5Bb4aC543AAF5e3` |
-| Arbitrum | liquidityPool | `0x3e0199792Ce69DC29A0a36146bFa68bd7C8D6633` |
-
-## ABI Methods
-
-### OrderBookABI
-
-- `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
+## Deployments and ABI
 
-- `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
+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/mux-protocol.md](registry/mux-protocol.md).
 
 ## Notes
 

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

@@ -0,0 +1,39 @@
+# Olympus DAO
+
+Decentralized reserve currency protocol. OHM staking and bonding mechanism with protocol-owned liquidity and treasury management.
+
+## Category
+
+staking | Chains and addresses: [registry/olympus.md](registry/olympus.md)
+
+## Key Operations
+
+- **stake**: Stake OHM tokens
+- **unstake**: Unstake OHM tokens
+
+## 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
+// Stake OHM
+import { StakingABI as IStaking } from "./abis";
+
+function main(stakingAddress: Address, to: Address, amount: Uint256): Uint256 {
+  const staking = IStaking.at(stakingAddress);
+  return staking.stake(to, amount, 1, 1);
+}
+```
+
+## 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/olympus.md](registry/olympus.md).
+
+## Notes
+
+- Protocol-owned liquidity model. Rebase mechanism for staking rewards.

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

@@ -0,0 +1,81 @@
+# 1inch
+
+> **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.
+
+Leading DEX aggregator that finds optimal swap routes across multiple liquidity sources. Supports limit orders and Fusion mode for gasless swaps.
+
+## When to use it
+
+- An aggregator: its router fills a swap across many venues along a route its off-chain API
+  quotes. Use it for a route the program does not want to choose itself.
+
+## Pitfalls for a program
+
+- The calldata is quoted for one sender, amount and moment: quote it for the Pot (the swap's
+  sender) and send it soon.
+- Approve the router for exactly `amountIn`, and clear the allowance after.
+- The calldata's own minimum is not yours: check the output as a balance delta against your
+  `minOut`.
+
+## In a Sauce program
+
+Forward a 1inch quote for the Pot, checked by the WETH received:
+
+```sauce chain=base,arbitrum
+function main(amountIn: Uint256, minOut: Uint256, call: bytes, recipient: Address) {
+  const self = ctx.self();
+  const before = WETH.balanceOf(self);
+  USDC.approve(Oneinch.AggregationRouterV6, amountIn);
+  evm.call(Oneinch.AggregationRouterV6, 0n, call);
+  const out = WETH.balanceOf(self) - before;
+  require(out >= minOut, "below minOut");
+  USDC.approve(Oneinch.AggregationRouterV6, 0n);
+  WETH.transfer(recipient, out);
+}
+```
+
+## Category
+
+aggregator | Chains and addresses: [registry/oneinch.md](registry/oneinch.md)
+
+## Key Operations
+
+- **unoswap**: Single-source optimized swap via AggregationRouter
+- **swap**: Multi-source aggregated swap with custom routing
+
+## 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
+// Unoswap (single-source swap)
+import { AggregationRouterV6ABI as IAggregationRouterV6 } from "./abis";
+function main(
+  routerAddress: Address,
+  srcToken: Address,
+  amount: Uint256,
+  minReturn: Uint256,
+  dex: Uint256,
+): Uint256 {
+  const router = IAggregationRouterV6.at(routerAddress);
+  return router.unoswap(srcToken, amount, minReturn, dex);
+}
+```
+
+## 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/oneinch.md](registry/oneinch.md).
+
+## 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
+- `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/skills/sauce-protocols/references/openocean.md

@@ -0,0 +1,69 @@
+# OpenOcean
+
+> **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.
+
+Cross-chain DEX aggregator providing optimal swap routing across multiple DEXes and chains.
+
+## Category
+
+aggregator | Chains and addresses: [registry/openocean.md](registry/openocean.md)
+
+## Key Operations
+
+- **swap**: Execute aggregated swap via OpenOcean Exchange
+
+## 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
+// Swap via OpenOcean
+import { OpenOceanExchangeV2ABI as IOpenOceanExchange } from "./abis";
+function main(
+  exchangeAddress: Address,
+  caller: Address,
+  srcToken: Address,
+  dstToken: Address,
+  srcReceiver: Address,
+  dstReceiver: Address,
+  amount: Uint256,
+  minReturnAmount: Uint256,
+  guaranteedAmount: Uint256,
+  referrer: Address,
+  calls: { target: Uint256; gasLimit: Uint256; value: Uint256; data: bytes }[],
+): Uint256 {
+  const exchange = IOpenOceanExchange.at(exchangeAddress);
+  return exchange.swap(
+    caller,
+    {
+      srcToken: srcToken,
+      dstToken: dstToken,
+      srcReceiver: srcReceiver,
+      dstReceiver: dstReceiver,
+      amount: amount,
+      minReturnAmount: minReturnAmount,
+      guaranteedAmount: guaranteedAmount,
+      flags: 0,
+      referrer: referrer,
+      permit: 0x00,
+    },
+    calls,
+  );
+}
+```
+
+## 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/openocean.md](registry/openocean.md).
+
+## Notes
+
+- TVL: $200M+. Same contract address across all 7 supported chains
+- Route computation via OpenOcean API - calls parameter comes from API response
+- Approve srcToken to exchangeV2 before swapping
+- caller is typically msg.sender; srcReceiver receives tokens from the caller

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

@@ -4,9 +4,14 @@ Official Optimism L1StandardBridge for depositing ETH and ERC-20 tokens from Eth
 
 ## Category
 
-native L2 bridge | Direction: L1 to L2 (Ethereum to Optimism) | Chains: Ethereum (1), Optimism (10)
+native L2 bridge | Direction: L1 to L2 (Ethereum to Optimism) | Chains and addresses: [registry/optimism-bridge.md](registry/optimism-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`).
 
 ### depositETH
 
@@ -52,21 +57,11 @@ function main(
 - `_extraData`: Optional extra data (typically `0x00`)
 - Requires ERC-20 approval to the L1StandardBridge
 
-## Deployed Addresses
-
-| Chain    | Contract         | Address                                      |
-| -------- | ---------------- | -------------------------------------------- |
-| Ethereum | l1StandardBridge | `0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1` |
-| Optimism | l2StandardBridge | `0x4200000000000000000000000000000000000010` |
-
-## ABI Reference
-
-### OptimismL1StandardBridgeABI
+## Deployments and ABI
 
-- `depositETH(uint32 _minGasLimit, bytes _extraData)` [payable] - Deposit ETH to your own address on L2. Amount = msg.value
-- `depositERC20(address _l1Token, address _l2Token, uint256 _amount, uint32 _minGasLimit, bytes _extraData)` - Deposit ERC-20 tokens to your own address on L2
-- `depositETHTo(address _to, uint32 _minGasLimit, bytes _extraData)` [payable] - Deposit ETH to a specific recipient on L2
-- `depositERC20To(address _l1Token, address _l2Token, address _to, uint256 _amount, uint32 _minGasLimit, bytes _extraData)` - Deposit ERC-20 tokens to a specific recipient on L2
+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/optimism-bridge.md](registry/optimism-bridge.md).
 
 ## Notes
 

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

@@ -4,7 +4,7 @@ DeFi options protocol known for Squeeth (squared ETH), a power perpetual that pr
 
 ## Category
 
-options | Chains: Ethereum
+options | Chains and addresses: [registry/opyn.md](registry/opyn.md)
 
 ## Key Operations
 
@@ -13,13 +13,12 @@ options | Chains: Ethereum
 - **mintSqueeth**: Mint oSQTH (open squeeth position) by depositing ETH collateral
 - **deposit**: Deposit additional ETH collateral to an existing vault
 
-## SDK Usage
+## Typed templates for the raw compiler (not for `sauce compile`)
 
-```typescript
-import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/opyn";
-```
-
-## 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
 // Burn Squeeth to reduce position
@@ -44,21 +43,11 @@ function main(controllerAddress: Address, vaultId: Uint256, amount: Uint256): Ui
 }
 ```
 
-## Key Addresses
-
-| Chain    | Contract   | Address                                      |
-| -------- | ---------- | -------------------------------------------- |
-| Ethereum | controller | `0x64187ae08781B09368e6253F9E94951243A493D5` |
-| Ethereum | oSQTH      | `0xf1B99e3E573A1a9C5E6B2Ce818b617F0E664E86B` |
-
-## ABI Methods
-
-### ControllerABI
+## Deployments and ABI
 
-- `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) 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)
+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/opyn.md](registry/opyn.md).
 
 ## Notes