@eco-incorp/sauce 0.99.0

package/sdk/src/skills/kyberswap.md

@@ -0,0 +1,100 @@
+# KyberSwap
+
+Multi-chain DEX with concentrated liquidity protocol (KyberSwap Elastic) and a meta-aggregation router that routes across multiple DEXes for best execution. Features dynamic fees and anti-sniping protection.
+
+## Category
+
+dex | Chains: Ethereum, Arbitrum, Optimism, Polygon, BSC, Avalanche, Base
+
+## Key Operations
+
+- **swap**: Exact input single swap via Elastic Router (concentrated liquidity)
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/kyberswap";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { KyberSwapElasticRouterABI as IElasticRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenIn: Address,
+  tokenOut: Address,
+  fee: Uint256,
+  amountIn: Uint256,
+  amountOutMin: Uint256,
+  recipient: Address,
+): Uint256 {
+  const router = IElasticRouter.at(routerAddress);
+  return router.swapExactInputSingle({
+    tokenIn: tokenIn,
+    tokenOut: tokenOut,
+    fee: fee,
+    recipient: recipient,
+    deadline: 99999999999,
+    amountIn: amountIn,
+    minAmountOut: amountOutMin,
+    limitSqrtP: 0,
+  });
+}
+```
+
+- `routerAddress`: KyberSwap Elastic Router address (same on most chains: `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83`)
+- `tokenIn` / `tokenOut`: Input and output token addresses
+- `fee`: Pool fee tier (similar to Uniswap V3 but with KyberSwap's own tiers)
+- `amountIn`: Exact input amount (in wei)
+- `amountOutMin`: Minimum output for slippage protection (named `minAmountOut` not `amountOutMinimum`)
+- `recipient`: Address to receive output tokens
+- `limitSqrtP`: Price limit (set to `0` for no limit; named `limitSqrtP` not `sqrtPriceLimitX96`)
+
+## Key Addresses
+
+| Chain     | Contract           | Address                                      |
+| --------- | ------------------ | -------------------------------------------- |
+| Ethereum  | Elastic Factory    | `0xC7a590291e07B9fe9E64b86c58fD8fC764308C4A` |
+| Ethereum  | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| Ethereum  | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+| Arbitrum  | Elastic Factory    | `0x5F1dddbf348aC2fbe22a163e30F99F9ECE3DD50a` |
+| Arbitrum  | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| Arbitrum  | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+| Optimism  | Elastic Factory    | `0x5F1dddbf348aC2fbe22a163e30F99F9ECE3DD50a` |
+| Optimism  | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| Optimism  | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+| Polygon   | Elastic Factory    | `0x5F1dddbf348aC2fbe22a163e30F99F9ECE3DD50a` |
+| Polygon   | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| Polygon   | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+| BSC       | Elastic Factory    | `0x5F1dddbf348aC2fbe22a163e30F99F9ECE3DD50a` |
+| BSC       | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| BSC       | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+| Avalanche | Elastic Factory    | `0x5F1dddbf348aC2fbe22a163e30F99F9ECE3DD50a` |
+| Avalanche | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| Avalanche | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+| Base      | Elastic Factory    | `0x5F1dddbf348aC2fbe22a163e30F99F9ECE3DD50a` |
+| Base      | Elastic Router     | `0xC1e7dFE73E1598E3910EF4C7845B68A9Ab6F4c83` |
+| Base      | Meta Agg Router V2 | `0x6131B5fae19EA4f9D964eAc0408E4408b66337b5` |
+
+## ABI Methods
+
+### KyberSwapElasticRouterABI
+
+- `swapExactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountIn, uint256 minAmountOut, uint160 limitSqrtP)) -> uint256 amountOut` - Single-hop exact input swap via Elastic pools
+
+### KyberSwapMetaAggregationRouterABI
+
+- `swap(tuple(address callTo, address approveTarget, address tokenIn, address tokenOut, uint256 amountIn, uint256 minAmountOut, address recipient, bytes data)) -> (uint256 returnAmount, uint256 gasUsed)` - Execute a swap via the meta-aggregation router (routes across multiple DEXes for best price)
+
+## Notes
+
+- Elastic Router naming differs from Uniswap V3: `minAmountOut` (not `amountOutMinimum`), `limitSqrtP` (not `sqrtPriceLimitX96`)
+- Elastic Router and Meta Agg Router addresses are consistent across all 7 chains
+- Meta Aggregation Router routes across multiple DEXes (not just KyberSwap pools) for best execution price
+- The `data` field in the Meta Agg Router swap must be pre-encoded from KyberSwap's API
+- Input token must be ERC20-approved to the Elastic Router for direct swaps
+- For Meta Agg swaps, approve to the `approveTarget` address returned by the API

package/sdk/src/skills/layerbank.md

@@ -0,0 +1,97 @@
+# LayerBank
+
+Leading lending protocol on Scroll. Compound V2 fork optimized for L2 rollups with low gas costs.
+
+## Category
+
+lending | Chains: Scroll (534352)
+
+## SauceScript Functions
+
+### supply
+
+Supply assets by minting lTokens. Exchange rate grows as interest accrues.
+
+```typescript
+import { LTokenABI as ILToken } from "./abis";
+
+function main(lTokenAddress: Address, amount: Uint256): Uint256 {
+  const lToken = ILToken.at(lTokenAddress);
+  return lToken.mint(amount);
+}
+```
+
+- `lTokenAddress`: The lToken market contract (each asset has its own lToken)
+- Returns 0 on success, error code on failure
+- Requires ERC-20 approval of underlying to the lToken
+
+### withdraw
+
+Withdraw underlying assets by specifying the exact amount.
+
+```typescript
+import { LTokenABI as ILToken } from "./abis";
+
+function main(lTokenAddress: Address, amount: Uint256): Uint256 {
+  const lToken = ILToken.at(lTokenAddress);
+  return lToken.redeemUnderlying(amount);
+}
+```
+
+### borrow
+
+Borrow assets against lToken collateral. Must call enterMarkets first.
+
+```typescript
+import { LTokenABI as ILToken } from "./abis";
+
+function main(lTokenAddress: Address, amount: Uint256): Uint256 {
+  const lToken = ILToken.at(lTokenAddress);
+  return lToken.borrow(amount);
+}
+```
+
+- Must enable collateral via `LayerBankCore.enterMarkets([lTokenAddress])` first
+
+### repay
+
+Repay borrowed assets.
+
+```typescript
+import { LTokenABI as ILToken } from "./abis";
+
+function main(lTokenAddress: Address, amount: Uint256): Uint256 {
+  const lToken = ILToken.at(lTokenAddress);
+  return lToken.repayBorrow(amount);
+}
+```
+
+- Requires ERC-20 approval of underlying to the lToken
+
+## Deployed Addresses
+
+| Chain  | Contract | Address                                      |
+| ------ | -------- | -------------------------------------------- |
+| Scroll | core     | `0x009a0b7C38B542208936F1179151CD08E2943833` |
+
+## ABI Reference
+
+### LTokenABI
+
+- `mint(uint256 mintAmount) returns (uint256)` - Supply underlying, receive lTokens
+- `redeem(uint256 redeemTokens) returns (uint256)` - Redeem lTokens 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
+
+### LayerBankCoreABI
+
+- `enterMarkets(address[] lTokens) returns (uint256[])` - Enable lTokens as collateral
+- `exitMarket(address lToken) returns (uint256)` - Remove lToken from collateral
+
+## Notes
+
+- Same interface as Compound V2 (forked codebase)
+- Must call `enterMarkets` on Core contract before borrowing against any market
+- Return values: 0 = success, non-zero = error code
+- Scroll-only deployment. TVL: $200M+. Audited

package/sdk/src/skills/layerzero.md

@@ -0,0 +1,72 @@
+# LayerZero
+
+Omnichain interoperability protocol enabling cross-chain messaging. Powers OFT tokens and arbitrary message passing across 50+ chains.
+
+## Category
+
+cross-chain messaging | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137), BSC (56), Avalanche (43114), zkSync (324), Linea (59144), Scroll (534352)
+
+## SauceScript Functions
+
+### sendMessage
+
+Send a cross-chain message via LayerZero Endpoint V2.
+
+```typescript
+import { LayerZeroEndpointV2ABI as IEndpointV2 } from "./abis";
+
+function main(
+  endpointAddress: Address,
+  dstEid: Uint256,
+  receiver: Uint256,
+  message: bytes,
+): { guid: Uint256; nonce: Uint256; fee: { nativeFee: Uint256; lzTokenFee: Uint256 } } {
+  const endpoint = IEndpointV2.at(endpointAddress);
+  return endpoint.send(
+    { dstEid: dstEid, receiver: receiver, message: message, options: 0x00, payInLzToken: false },
+    ctx.msgSender(),
+  );
+}
+```
+
+- `dstEid`: LayerZero endpoint ID for destination chain (NOT the EVM chain ID)
+- `receiver`: Destination contract address as bytes32 (left-padded)
+- `message`: Arbitrary message payload
+- `options`: Execution options (gas limits, etc.). Use `0x00` for defaults
+- `payInLzToken`: false = pay fees in native token, true = pay in ZRO token
+- Requires native token (ETH) for messaging fees (sent as msg.value)
+
+## Deployed Addresses
+
+| Chain     | Contract   | Address                                      |
+| --------- | ---------- | -------------------------------------------- |
+| Ethereum  | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| Arbitrum  | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| Optimism  | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| Base      | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| Polygon   | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| BSC       | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| Avalanche | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| zkSync    | endpointV2 | `0xd07C30aF3Ff30D96BDc9c6044958230Eb5b32e1D` |
+| Linea     | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+| Scroll    | endpointV2 | `0x1a44076050125825900e736c501f859c50fE728c` |
+
+## ABI Reference
+
+### LayerZeroEndpointV2ABI
+
+- `send(MessagingParams _params, address _refundAddress) returns (MessagingReceipt receipt)` [payable] - Send omnichain message. Pay fees as msg.value (native token)
+- `quote(MessagingParams _params, address _sender) returns (MessagingFee fee)` - Quote messaging fee before sending (view)
+
+MessagingParams tuple: `(uint32 dstEid, bytes32 receiver, bytes message, bytes options, bool payInLzToken)`
+MessagingFee tuple: `(uint256 nativeFee, uint256 lzTokenFee)`
+
+## Notes
+
+- This is a messaging protocol, not a direct token bridge. Token bridging is done via OFT (Omnichain Fungible Token) contracts built on top of LayerZero
+- Uses endpoint IDs (dstEid) for chain identification, NOT EVM chain IDs
+- Same endpoint address across most chains (except zkSync)
+- Use `quote` to estimate fees before sending
+- Finality: depends on DVN (Decentralized Verifier Network) configuration, typically 1-5 minutes
+- Powers Stargate V2, OFT tokens, and many cross-chain dApps
+- TVL: $5B+ (across protocols built on LayerZero). Audited

package/sdk/src/skills/level-finance.md

@@ -0,0 +1,76 @@
+# Level Finance
+
+Decentralized perpetual exchange with risk-tranched liquidity pools. Senior (low risk), Mezzanine (medium), and Junior (high risk/reward) tranches.
+
+## Category
+
+perpetuals | Chains: BSC, Arbitrum
+
+## Key Operations
+
+- **addLiquidity**: Add liquidity to a specific risk tranche
+- **removeLiquidity**: Remove liquidity from a tranche
+
+## SDK Usage
+
+```typescript
+import {
+  protocolInfo,
+  deployments,
+  sauceFunctions,
+} from "@eco-incorp/sauce/protocols/level-finance";
+```
+
+## SauceScript Examples
+
+```typescript
+// Add liquidity to tranche
+import { LiquidityPoolABI as ILiquidityPool } from "./abis";
+function main(
+  poolAddress: Address,
+  tranche: Address,
+  token: Address,
+  amountIn: Uint256,
+  minLpAmount: Uint256,
+): Uint256 {
+  const pool = ILiquidityPool.at(poolAddress);
+  pool.addLiquidity(tranche, token, amountIn, minLpAmount);
+  return 1;
+}
+
+// Remove liquidity from tranche
+import { LiquidityPoolABI as ILiquidityPool } from "./abis";
+function main(
+  poolAddress: Address,
+  tranche: Address,
+  tokenOut: Address,
+  lpAmount: Uint256,
+  minOut: Uint256,
+): Uint256 {
+  const pool = ILiquidityPool.at(poolAddress);
+  pool.removeLiquidity(tranche, tokenOut, lpAmount, minOut);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract      | Address                                      |
+| -------- | ------------- | -------------------------------------------- |
+| BSC      | liquidityPool | `0xA5aBFB56a78D2BD4689b25B8A77fd49Bb0675874` |
+| Arbitrum | liquidityPool | `0x32B7bF19cb8b95C27E644183837813d4b595dcc6` |
+
+## ABI Methods
+
+### LiquidityPoolABI
+
+- `addLiquidity(address,address,uint256,uint256)` - Add liquidity. Params: tranche address, token, amountIn, minLpAmount
+- `removeLiquidity(address,address,uint256,uint256)` - Remove liquidity. Params: tranche, tokenOut, lpAmount, minOut
+- `swap(address,address,uint256,address,bytes)` - Swap tokens. Params: tokenIn, tokenOut, minOut, to, extradata
+
+## Notes
+
+- Risk-tranched pools: Senior (low risk, lower yield), Mezzanine (medium), Junior (high risk, higher yield)
+- Each tranche has its own LP token address
+- Approve input token to liquidityPool before adding liquidity
+- minLpAmount/minOut provide slippage protection

package/sdk/src/skills/lido.md

@@ -0,0 +1,75 @@
+# Lido
+
+The largest liquid staking protocol for Ethereum. Stake ETH and receive stETH, a rebasing liquid staking token. wstETH is the non-rebasing wrapped version for DeFi composability.
+
+## Category
+
+liquid-staking | Chains: Ethereum, Arbitrum
+
+## Key Operations
+
+- **submit**: Stake ETH and receive stETH (rebasing)
+- **wrap**: Wrap stETH into wstETH (non-rebasing, DeFi-compatible)
+- **unwrap**: Unwrap wstETH back to stETH
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/lido";
+```
+
+## SauceScript Examples
+
+```typescript
+// Stake ETH for stETH
+import { LidoABI as ILido } from "./abis";
+function main(lidoAddress: Address): Uint256 {
+  const lido = ILido.at(lidoAddress);
+  return lido.submit(0x0000000000000000000000000000000000000000);
+}
+
+// Wrap stETH to wstETH
+import { WstETHABI as IWstETH } from "./abis";
+function main(wstethAddress: Address, amount: Uint256): Uint256 {
+  const wsteth = IWstETH.at(wstethAddress);
+  return wsteth.wrap(amount);
+}
+
+// Unwrap wstETH to stETH
+import { WstETHABI as IWstETH } from "./abis";
+function main(wstethAddress: Address, amount: Uint256): Uint256 {
+  const wsteth = IWstETH.at(wstethAddress);
+  return wsteth.unwrap(amount);
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | stETH    | `0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84` |
+| Ethereum | wstETH   | `0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0` |
+| Arbitrum | wstETH   | `0x5979D7b546E38E414F7E9822514be443A4800529` |
+
+## ABI Methods
+
+### LidoABI (stETH)
+
+- `submit(address)` - Stake ETH (payable), receive stETH. Address param is referral (use zero address). Send ETH as msg.value
+- `balanceOf(address)` - Query stETH balance (rebases daily)
+- `approve(address,uint256)` - Approve stETH spending
+
+### WstETHABI
+
+- `wrap(uint256)` - Wrap stETH amount into wstETH. Requires stETH approval first
+- `unwrap(uint256)` - Unwrap wstETH amount back to stETH
+- `getStETHByWstETH(uint256)` - Preview stETH amount for wstETH input
+- `getWstETHByStETH(uint256)` - Preview wstETH amount for stETH input
+
+## Notes
+
+- TVL: $27.5B+. Largest DeFi protocol by TVL
+- stETH rebases daily (balance increases). wstETH does not rebase (exchange rate increases instead)
+- Always use wstETH for DeFi integrations (Aave, Uniswap, etc.) since rebasing tokens cause issues
+- submit() requires ETH sent as msg.value. The referral parameter can be zero address
+- Approve stETH to wstETH contract before calling wrap()

package/sdk/src/skills/lifi.md

@@ -0,0 +1,88 @@
+# LI.FI
+
+Multi-chain bridge and DEX aggregator via LiFiDiamond proxy. Routes through optimal bridges and DEXes for cross-chain swaps.
+
+## 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)
+
+## SauceScript Functions
+
+### bridge
+
+Bridge tokens cross-chain via LI.FI Diamond.
+
+```typescript
+import { LiFiDiamondABI as ILiFiDiamond } from "./abis";
+
+function main(
+  diamondAddress: Address,
+  transactionId: Uint256,
+  sendingAsset: Address,
+  receiver: Address,
+  amount: Uint256,
+  destinationChainId: 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,
+  });
+  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
+- Requires ERC-20 approval to the LiFi Diamond
+
+## Deployed Addresses
+
+| Chain     | Contract    | Address                                      |
+| --------- | ----------- | -------------------------------------------- |
+| Ethereum  | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Arbitrum  | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Optimism  | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Base      | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Polygon   | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| BSC       | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Avalanche | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Gnosis    | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+| Fantom    | lifiDiamond | `0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE` |
+
+## ABI Reference
+
+### 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)
+
+BridgeData tuple: `(bytes32 transactionId, string bridge, string integrator, address referrer, address sendingAssetId, address receiver, uint256 minAmount, uint256 destinationChainId, bool hasSourceSwaps, bool hasDestinationCall)`
+
+## Notes
+
+- LI.FI is a bridge **aggregator** -- it routes through underlying bridges (Across, Stargate, Hop, cBridge, etc.)
+- Uses a Diamond proxy pattern (EIP-2535) so the contract address is the same across all chains
+- Same Diamond address (`0x1231DEB6...`) deployed on all supported chains
+- Uses standard EVM chain IDs for `destinationChainId`
+- The `bridge` field in BridgeData specifies which underlying bridge to use
+- `hasSourceSwaps` / `hasDestinationCall` enable swap-then-bridge or bridge-then-execute patterns
+- Requires ERC-20 approval to the LiFi Diamond address
+- Finality depends on the underlying bridge selected (varies from 1 minute to 20 minutes)
+- TVL: $300M+. Audited

package/sdk/src/skills/linea-bridge.md

@@ -0,0 +1,54 @@
+# Linea Native Bridge
+
+Official Linea zkEVM bridge via L1MessageService. Deposits ETH from Ethereum to Linea with ZK proof-based finality.
+
+## Category
+
+native L2 bridge | Direction: L1 to L2 (Ethereum to Linea) | Chains: Ethereum (1), Linea (59144)
+
+## SauceScript Functions
+
+### bridgeETH
+
+Bridge ETH from Ethereum L1 to Linea L2 via the message service.
+
+```typescript
+import { LineaL1MessageServiceABI as IL1MessageService } from "./abis";
+
+function main(messageServiceAddress: Address, recipient: Address, fee: Uint256): Uint256 {
+  const service = IL1MessageService.at(messageServiceAddress);
+  service.sendMessage(recipient, fee, 0x00);
+  return 1;
+}
+```
+
+- `recipient`: Address to receive ETH on Linea L2
+- `fee`: Fee for the postman (relayer) to deliver the message on L2. Set to 0 for self-claim
+- `_calldata`: Optional calldata to execute on L2 when message is delivered. `0x00` for simple ETH transfers
+- ETH amount (minus fee) is sent as `msg.value`
+
+## Deployed Addresses
+
+| Chain    | Contract         | Address                                      |
+| -------- | ---------------- | -------------------------------------------- |
+| Ethereum | l1MessageService | `0xd19d4B5d358258f05D7B411E21A1460D11B0876F` |
+| Linea    | l2MessageService | `0x508Ca82Df566dCD1B0DE8296e70a96332cD644ec` |
+
+## ABI Reference
+
+### LineaL1MessageServiceABI
+
+- `sendMessage(address _to, uint256 _fee, bytes _calldata)` [payable] - Send ETH and/or message from L1 to L2. `msg.value` = amount to bridge + fee
+- `claimMessage(address _from, address _to, uint256 _fee, uint256 _value, address _feeRecipient, bytes _calldata, uint256 _nonce)` - Claim a message on the destination side (called by relayers or self-claim)
+
+## Notes
+
+- **L1 to L2** via L1MessageService. L2 to L1 via L2MessageService on Linea
+- `sendMessage` is a general-purpose L1-to-L2 message sender -- ETH transfer is implicit via msg.value
+- The `_fee` parameter incentivizes postmen (relayers) to deliver the message. Set to 0 and self-claim via `claimMessage`
+- `_calldata` enables arbitrary contract execution on L2 when the message is delivered
+- zkEVM architecture -- finality with ZK proofs (typically 8-32 hours for proof generation)
+- L2 to L1 withdrawals also require ZK proof finalization
+- For ERC-20 bridging, use the Linea Token Bridge contracts (separate from the message service)
+- Canonical bridge -- no third-party risk, secured by Linea's ZK proving system (Consensys)
+- Audited

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

@@ -0,0 +1,64 @@
+# Liquity V1
+
+Decentralized borrowing protocol offering interest-free loans against ETH collateral. Issues LUSD stablecoin with minimum 110% collateral ratio.
+
+## Category
+
+cdp | Chains: Ethereum
+
+## Key Operations
+
+- **closeTrove**: Close an existing Trove (repay all debt and withdraw collateral)
+- **repayLUSD**: Repay LUSD debt on an open Trove
+- **openTrove**: Open a new Trove by depositing ETH and borrowing LUSD
+- **adjustTrove**: Adjust Trove collateral and/or debt
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/liquity-v1";
+```
+
+## SauceScript Examples
+
+```typescript
+// Close Trove
+import { BorrowerOperationsABI as IBorrowerOperations } from "./abis";
+function main(borrowerOpsAddress: Address): Uint256 {
+  const borrowerOps = IBorrowerOperations.at(borrowerOpsAddress);
+  borrowerOps.closeTrove();
+  return 1;
+}
+
+// Repay LUSD debt
+import { BorrowerOperationsABI as IBorrowerOperations } from "./abis";
+function main(borrowerOpsAddress: Address, amount: Uint256): Uint256 {
+  const borrowerOps = IBorrowerOperations.at(borrowerOpsAddress);
+  borrowerOps.repayLUSD(amount);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract           | Address                                      |
+| -------- | ------------------ | -------------------------------------------- |
+| Ethereum | lusd               | `0x5f98805A4E8be255a32880FDeC7F6728C6568bA0` |
+| Ethereum | borrowerOperations | `0x24179CD81c9e782A4096035f7eC97fB8B783e007` |
+
+## ABI Methods
+
+### BorrowerOperationsABI
+
+- `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
+
+## Notes
+
+- TVL: $500M+. Interest-free loans with one-time borrowing fee (0.5% - 5%)
+- Minimum collateral ratio: 110%. Below this, Trove can be liquidated
+- Hint addresses (upperHint, lowerHint) optimize sorted trove list insertion - use Liquity frontend SDK to compute
+- Minimum debt: 2000 LUSD (including 200 LUSD gas reserve)
+- closeTrove requires repaying all debt including the 200 LUSD gas reserve

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

@@ -0,0 +1,59 @@
+# Liquity V2
+
+Next generation of Liquity protocol with user-set interest rates, multi-collateral support, and the BOLD stablecoin.
+
+## Category
+
+cdp | Chains: Ethereum
+
+## Key Operations
+
+- **transfer**: Transfer BOLD tokens
+- **approve**: Approve BOLD token spender
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/liquity-v2";
+```
+
+## SauceScript Examples
+
+```typescript
+// Transfer BOLD
+import { BoldTokenABI as IBoldToken } from "./abis";
+function main(boldAddress: Address, to: Address, amount: Uint256): Uint256 {
+  const bold = IBoldToken.at(boldAddress);
+  bold.transfer(to, amount);
+  return 1;
+}
+
+// Approve BOLD spender
+import { BoldTokenABI as IBoldToken } from "./abis";
+function main(boldAddress: Address, spender: Address, amount: Uint256): Uint256 {
+  const bold = IBoldToken.at(boldAddress);
+  bold.approve(spender, amount);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | bold     | `0x6440f144b7e50D6a8439336510312d2F54beB01D` |
+
+## ABI Methods
+
+### BoldTokenABI
+
+- `transfer(address,uint256)` - Transfer BOLD tokens. Params: to, amount. Returns bool
+- `approve(address,uint256)` - Approve spender. Params: spender, amount. Returns bool
+- `balanceOf(address)` - Query balance. Params: account. Returns uint256
+
+## Notes
+
+- User-set interest rates - borrowers choose their own rate (higher rate = lower liquidation risk)
+- Multi-collateral: ETH, wstETH, rETH, and other LSTs
+- BOLD is fully redeemable 1:1 for collateral at any time
+- Successor to Liquity V1 with improved capital efficiency