@eco-incorp/sauce 0.99.0

package/sdk/src/skills/dodo.md

@@ -0,0 +1,80 @@
+# DODO
+
+Proactive Market Maker (PMM) DEX with capital-efficient liquidity provision. Unlike constant product AMMs, DODO uses oracle-guided pricing to concentrate liquidity near market price. Features single-token LP, customizable price curves, and smart routing across DODO pools.
+
+## Category
+
+dex | Chains: Ethereum, BSC
+
+## Key Operations
+
+- **swap**: Swap tokens via DODO V2 Proxy with pair-based routing
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/dodo";
+```
+
+## SauceScript Examples
+
+### swap
+
+```typescript
+import { DODOV2ProxyABI as IDODOProxy } from "./abis";
+
+function main(
+  proxyAddress: Address,
+  fromToken: Address,
+  toToken: Address,
+  fromAmount: Uint256,
+  minReturn: Uint256,
+  dodoPairs: Address[],
+  direction: Uint256,
+): Uint256 {
+  const proxy = IDODOProxy.at(proxyAddress);
+  return proxy.dodoSwapV2TokenToToken(
+    fromToken,
+    toToken,
+    fromAmount,
+    minReturn,
+    dodoPairs,
+    direction,
+    false,
+    99999999999,
+  );
+}
+```
+
+- `proxyAddress`: DODO V2 Proxy address for the target chain
+- `fromToken`: Input token address
+- `toToken`: Output token address
+- `fromAmount`: Exact input amount (in wei)
+- `minReturn`: Minimum output for slippage protection
+- `dodoPairs`: Array of DODO pool addresses to route through (ordered for the swap path)
+- `direction`: Bitmask encoding which side of each pool to use. Each bit represents a pool: `0` = sell base token, `1` = sell quote token. For a single pool, use `0` or `1`. For multi-pool, combine bits (e.g., `0b01` = first pool sell quote, second pool sell base)
+- `isIncentive`: Set to `false` (incentive mining flag, usually disabled)
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | V2 Proxy | `0xa356867fDCeA8e71AEaf87805808803806231FDc` |
+| BSC      | V2 Proxy | `0x8F8Dd7DB1bDA5eD3da8C9dAf3bFA471c12d58486` |
+
+## ABI Methods
+
+### DODOV2ProxyABI
+
+- `dodoSwapV2TokenToToken(address fromToken, address toToken, uint256 fromTokenAmount, uint256 minReturnAmount, address[] dodoPairs, uint256 directions, bool isIncentive, uint256 deadLine) -> uint256 returnAmount` - Execute a token-to-token swap through one or more DODO pools
+
+## Notes
+
+- PMM (Proactive Market Maker) provides better capital efficiency than constant product by concentrating liquidity near oracle price
+- `dodoPairs` is an array of DODO pool addresses defining the swap route (each pool has a base token and a quote token)
+- `directions` is a bitmask: for each pool in the path, a bit value of `0` means "sell base token" and `1` means "sell quote token". The least significant bit corresponds to the first pool
+- For a single-pool swap: if you're selling the base token of that pool, `directions = 0`; if selling the quote token, `directions = 1`
+- `isIncentive`: Flag for DODO mining incentives, typically set to `false`
+- Pool discovery requires off-chain lookup via DODO's API or subgraph to find the right pool addresses
+- Input token must be ERC20-approved to the V2 Proxy contract
+- DODO also supports single-token LP (provide only one side of liquidity) which is unique among AMMs

package/sdk/src/skills/eigenlayer.md

@@ -0,0 +1,71 @@
+# EigenLayer
+
+Restaking protocol that enables staked ETH to secure additional protocols (AVS). Deposit LSTs into strategies to earn restaking rewards on top of staking yield.
+
+## Category
+
+restaking | Chains: Ethereum
+
+## Key Operations
+
+- **depositIntoStrategy**: Deposit LSTs (stETH, rETH, cbETH) into a restaking strategy
+- **delegateTo**: Delegate restaked assets to an operator (via DelegationManager)
+- **undelegate**: Undelegate from an operator, initiating withdrawal
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/eigenlayer";
+```
+
+## SauceScript Examples
+
+```typescript
+// Deposit LST into restaking strategy
+import { StrategyManagerABI as IStrategyManager } from "./abis";
+function main(
+  strategyManagerAddress: Address,
+  strategy: Address,
+  token: Address,
+  amount: Uint256,
+): Uint256 {
+  const sm = IStrategyManager.at(strategyManagerAddress);
+  return sm.depositIntoStrategy(strategy, token, amount);
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract          | Address                                      |
+| -------- | ----------------- | -------------------------------------------- |
+| Ethereum | strategyManager   | `0x858646372CC42E1A627fcE94aa7A7033e7CF075A` |
+| Ethereum | delegationManager | `0x39053D51B77DC0d36036Fc1fCc8Cb819df8Ef37A` |
+| Ethereum | stETHStrategy     | `0x93c4b944D05dfe6df7645A86cd2206016c51564D` |
+| Ethereum | rETHStrategy      | `0x1BeE69b7dFFfA4E2d53C2a2Df135C388AD25dCD2` |
+| Ethereum | cbETHStrategy     | `0x54945180dB7943c0ed0FEE7EdaB2Bd24620256bc` |
+
+## ABI Methods
+
+### 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
+
+### DelegationManagerABI
+
+- `delegateTo(address,tuple,bytes32)` - Delegate to operator. Tuple is (signature bytes, expiry uint256). Use empty sig + max expiry
+- `undelegate(address)` - Undelegate staker. Returns withdrawal root bytes32[]
+- `isDelegated(address)` - Check if address is delegated to an operator
+
+### StrategyABI
+
+- `sharesToUnderlyingView(uint256)` - Convert shares to underlying token amount
+- `underlyingToSharesView(uint256)` - Convert underlying amount to shares
+
+## Notes
+
+- TVL: $13B+. Foundation of the restaking ecosystem
+- Approve LST token to StrategyManager before depositing
+- Each LST has its own strategy contract (stETH, rETH, cbETH listed above)
+- Withdrawal has a 7-day delay period after undelegating
+- delegateTo requires approverSignatureAndExpiry tuple - use empty bytes + far-future expiry for typical cases

package/sdk/src/skills/ens.md

@@ -0,0 +1,67 @@
+# ENS
+
+Ethereum Name Service - the decentralized naming system for wallets, websites, and resources. Maps human-readable names to Ethereum addresses.
+
+## Category
+
+infrastructure | Chains: Ethereum
+
+## Key Operations
+
+- **setResolver**: Set the resolver contract for an ENS name
+- **setOwner**: Transfer ownership of an ENS name
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/ens";
+```
+
+## SauceScript Examples
+
+```typescript
+// Set resolver for ENS name
+import { ENSRegistryABI as IENSRegistry } from "./abis";
+function main(registryAddress: Address, node: Uint256, resolver: Address): Uint256 {
+  const registry = IENSRegistry.at(registryAddress);
+  registry.setResolver(node, resolver);
+  return 1;
+}
+
+// Transfer ENS name ownership
+import { ENSRegistryABI as IENSRegistry } from "./abis";
+function main(registryAddress: Address, node: Uint256, owner: Address): Uint256 {
+  const registry = IENSRegistry.at(registryAddress);
+  registry.setOwner(node, owner);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract      | Address                                      |
+| -------- | ------------- | -------------------------------------------- |
+| Ethereum | registry      | `0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e` |
+| Ethereum | baseRegistrar | `0x57f1887a8BF19b14fC0dF6Fd9B2acc9Af147eA85` |
+
+## ABI Methods
+
+### ENSRegistryABI
+
+- `owner(bytes32)` - Query owner of a name node. Params: node (namehash). Returns owner address
+- `resolver(bytes32)` - Query resolver of a name node. Params: node. Returns resolver address
+- `setOwner(bytes32,address)` - Transfer name ownership. Params: node, owner (new owner)
+- `setResolver(bytes32,address)` - Set resolver contract. Params: node, resolver (new resolver)
+
+### BaseRegistrarABI
+
+- `nameExpires(uint256)` - Check when a .eth name expires. Params: id (label hash as uint256). Returns expiry timestamp
+- `reclaim(uint256,address)` - Reclaim ENS registry ownership. Params: id (label hash), owner. Only callable by registrant
+
+## Notes
+
+- node = namehash of the ENS name (e.g. namehash("vitalik.eth") = keccak256 chain)
+- .eth names are ERC-721 NFTs held in the baseRegistrar contract
+- Resolver contract stores the address/content records for a name
+- Only the owner of a node can setResolver or setOwner
+- Registration/renewal happens via the ETHRegistrarController (not in this ABI set)

package/sdk/src/skills/erc20.md

@@ -0,0 +1,101 @@
+# ERC-20
+
+The standard interface for fungible tokens on EVM chains (EIP-20). Defines transfer, approve, transferFrom, balanceOf, allowance, totalSupply, name, symbol, and decimals.
+
+## Category
+
+infrastructure | Chains: (standard interface, any chain)
+
+## Key Operations
+
+- **transfer**: Send tokens to an address
+- **approve**: Authorize a spender to transfer tokens on your behalf
+- **transferFrom**: Transfer tokens from one address to another (requires approval)
+- **balanceOf**: Query token balance of an address
+- **allowance**: Query remaining approved amount for a spender
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/erc20";
+```
+
+## SauceScript Examples
+
+```typescript
+// Transfer tokens
+import { ERC20ABI as IERC20 } from "./abis";
+function main(token: Address, to: Address, amount: Uint256): Uint256 {
+  const t = IERC20.at(token);
+  t.transfer(to, amount);
+  return 1;
+}
+
+// Approve spender
+import { ERC20ABI as IERC20 } from "./abis";
+function main(token: Address, spender: Address, amount: Uint256): Uint256 {
+  const t = IERC20.at(token);
+  t.approve(spender, amount);
+  return 1;
+}
+
+// Transfer from (requires prior approval)
+import { ERC20ABI as IERC20 } from "./abis";
+function main(token: Address, from: Address, to: Address, amount: Uint256): Uint256 {
+  const t = IERC20.at(token);
+  t.transferFrom(from, to, amount);
+  return 1;
+}
+
+// Check balance
+import { ERC20ABI as IERC20 } from "./abis";
+function main(token: Address, account: Address): Uint256 {
+  const t = IERC20.at(token);
+  return t.balanceOf(account);
+}
+
+// Storage-based transfer (demonstrates storage, crypto, abi encode, events)
+function balanceSlot(account: Address): Uint256 {
+  return crypto.keccak256(abi.encode(account, 1));
+}
+function main(to: Address, amount: Uint256): Uint256 {
+  const from = ctx.msgSender();
+  const fromSlot = balanceSlot(from);
+  const fromBalance = evm.sload(fromSlot);
+  if (fromBalance < amount) throw "insufficient balance";
+  evm.sstore(fromSlot, fromBalance - amount);
+  const toSlot = balanceSlot(to);
+  evm.sstore(toSlot, evm.sload(toSlot) + amount);
+  log(abi.encode(from, to, amount), crypto.keccak256("Transfer(address,address,uint256)"));
+  return 1;
+}
+```
+
+## ABI Methods
+
+### ERC20ABI
+
+- `transfer(address,uint256)` - Transfer tokens. Params: to (recipient), amount (token amount). Returns bool success
+- `approve(address,uint256)` - Approve spender. Params: spender (authorized address), amount (max transfer amount). Returns bool success
+- `transferFrom(address,address,uint256)` - Transfer from approved address. Params: from (source), to (destination), amount. Returns bool success
+- `balanceOf(address)` - Query balance. Params: account. Returns uint256 balance
+- `allowance(address,address)` - Query allowance. Params: owner, spender. Returns uint256 remaining allowance
+- `totalSupply()` - Total token supply. Returns uint256
+- `name()` - Token name. Returns string
+- `symbol()` - Token symbol. Returns string
+- `decimals()` - Token decimals. Returns uint8 (typically 18; USDC/USDT use 6)
+
+### Events
+
+- `Transfer(address indexed from, address indexed to, uint256 value)` - Emitted on transfer and transferFrom
+- `Approval(address indexed owner, address indexed spender, uint256 value)` - Emitted on approve
+
+## Notes
+
+- Standard interface (EIP-20) - not a specific deployment, no fixed addresses
+- Every fungible token on every EVM chain implements this interface
+- 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
+- The storageTransfer example demonstrates how to implement ERC-20 logic entirely in SauceScript using storage operations

package/sdk/src/skills/erc3156.md

@@ -0,0 +1,54 @@
+# ERC-3156
+
+Standard interface for flash loans (EIP-3156). Provides flashLoan, flashFee, and maxFlashLoan functions for any conforming lender.
+
+## Category
+
+infrastructure | Chains: (standard interface, any chain)
+
+## Key Operations
+
+- **flashFee**: Query the fee for a flash loan of a specific token and amount
+- **maxFlashLoan**: Query the maximum flash loan amount for a token
+- **flashLoan**: Execute a flash loan (borrow and repay in same transaction)
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/erc3156";
+```
+
+## SauceScript Examples
+
+```typescript
+// Query flash loan fee
+import { FlashLenderABI as IFlashLender } from "./abis";
+function main(lenderAddress: Address, token: Address, amount: Uint256): Uint256 {
+  const lender = IFlashLender.at(lenderAddress);
+  return lender.flashFee(token, amount);
+}
+
+// Query max flash loan amount
+import { FlashLenderABI as IFlashLender } from "./abis";
+function main(lenderAddress: Address, token: Address): Uint256 {
+  const lender = IFlashLender.at(lenderAddress);
+  return lender.maxFlashLoan(token);
+}
+```
+
+## ABI Methods
+
+### FlashLenderABI
+
+- `flashLoan(address,address,uint256,bytes)` - Execute flash loan. Params: receiver (contract that receives tokens and implements IERC3156FlashBorrower), token (ERC-20 to borrow), amount (borrow amount), data (arbitrary data passed to receiver callback). Returns bool success
+- `flashFee(address,uint256)` - Query fee for flash loan. Params: token, amount. Returns fee in token units
+- `maxFlashLoan(address)` - Query max borrowable amount. Params: token. Returns max amount (0 if token not supported)
+
+## Notes
+
+- Standard interface (EIP-3156), not a specific deployment - no fixed addresses
+- Aave V3, Maker (sDAI), Uniswap V3, and Balancer all implement ERC-3156
+- Receiver contract must implement `onFlashLoan(address,address,uint256,uint256,bytes)` callback
+- Must approve lender to pull back amount + fee before callback returns
+- Flash loan must be fully repaid within the same transaction (atomic)
+- Fee varies by implementation: Aave charges 0.05-0.09%, Balancer charges 0%, Maker varies

package/sdk/src/skills/erc4626.md

@@ -0,0 +1,93 @@
+# ERC-4626
+
+Standard interface for tokenized vaults (EIP-4626). Provides deposit, withdraw, mint, redeem and preview functions for any conforming vault.
+
+## Category
+
+yield | Chains: (standard interface, any chain)
+
+## Key Operations
+
+- **deposit**: Deposit underlying assets, receive vault shares
+- **withdraw**: Withdraw by specifying asset amount to receive
+- **redeem**: Withdraw by specifying share amount to burn
+- **mint**: Mint exact number of shares by depositing required assets
+- **previewDeposit**: Preview how many shares a deposit would yield
+- **previewWithdraw**: Preview how many shares would be burned for a withdrawal
+- **convertToShares**: Convert asset amount to equivalent shares
+- **convertToAssets**: Convert share amount to equivalent assets
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/erc4626";
+```
+
+## SauceScript Examples
+
+```typescript
+// Deposit assets into vault
+import { VaultABI as IVault } from "./abis";
+function main(vaultAddress: Address, assets: Uint256, receiver: Address): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  return vault.deposit(assets, receiver);
+}
+
+// Withdraw assets from vault
+import { VaultABI as IVault } from "./abis";
+function main(vaultAddress: Address, assets: Uint256, receiver: Address, owner: Address): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  return vault.withdraw(assets, receiver, owner);
+}
+
+// Redeem shares for assets
+import { VaultABI as IVault } from "./abis";
+function main(vaultAddress: Address, shares: Uint256, receiver: Address, owner: Address): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  return vault.redeem(shares, receiver, owner);
+}
+
+// Preview deposit
+import { VaultABI as IVault } from "./abis";
+function main(vaultAddress: Address, assets: Uint256): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  return vault.previewDeposit(assets);
+}
+
+// Convert assets to shares
+import { VaultABI as IVault } from "./abis";
+function main(vaultAddress: Address, assets: Uint256): Uint256 {
+  const vault = IVault.at(vaultAddress);
+  return vault.convertToShares(assets);
+}
+```
+
+## ABI Methods
+
+### VaultABI
+
+- `deposit(uint256,address)` - Deposit assets. Params: assets (underlying token amount), receiver (share recipient). Returns shares minted
+- `mint(uint256,address)` - Mint exact shares. Params: shares (exact shares to mint), receiver. Returns assets required
+- `withdraw(uint256,address,address)` - Withdraw by asset amount. Params: assets (amount to withdraw), receiver, owner (share owner). Returns shares burned
+- `redeem(uint256,address,address)` - Redeem shares. Params: shares (to burn), receiver, owner. Returns assets received
+- `totalAssets()` - Total assets managed by vault. Returns uint256
+- `convertToShares(uint256)` - Convert assets to shares (current rate). Params: assets. Returns shares
+- `convertToAssets(uint256)` - Convert shares to assets (current rate). Params: shares. Returns assets
+- `previewDeposit(uint256)` - Preview deposit (includes fees). Params: assets. Returns shares
+- `previewMint(uint256)` - Preview mint cost. Params: shares. Returns assets needed
+- `previewWithdraw(uint256)` - Preview withdrawal. Params: assets. Returns shares to burn
+- `previewRedeem(uint256)` - Preview redemption. Params: shares. Returns assets received
+- `maxDeposit(address)` - Max deposit allowed. Params: receiver. Returns max assets
+- `maxMint(address)` - Max mint allowed. Params: receiver. Returns max shares
+- `maxWithdraw(address)` - Max withdrawal allowed. Params: owner. Returns max assets
+- `maxRedeem(address)` - Max redemption allowed. Params: owner. Returns max shares
+- `asset()` - Underlying asset address. Returns address
+
+## Notes
+
+- Standard interface (EIP-4626) - protocols that implement it: sDAI, sfrxETH, pufETH, Yearn V3, sUSDe, Beefy vaults
+- deposit/withdraw operate in asset terms; mint/redeem operate in share terms
+- preview* functions account for fees; convert* are pure exchange rate calculations
+- Approve the underlying asset to the vault before calling deposit
+- owner parameter in withdraw/redeem allows withdrawal on behalf of another address (requires approval)
+- Share price typically increases over time as yield accrues

package/sdk/src/skills/ethena.md

@@ -0,0 +1,76 @@
+# Ethena
+
+Synthetic dollar protocol providing USDe, a crypto-native dollar backed by delta-neutral positions. sUSDe offers yield from staking and funding rates.
+
+## Category
+
+cdp | Chains: Ethereum
+
+## Key Operations
+
+- **stakeUSDe**: Stake USDe to receive sUSDe (yield-bearing)
+- **cooldownAssets**: Start cooldown period to unstake (by asset amount)
+- **cooldownShares**: Start cooldown period to unstake (by share amount)
+- **unstake**: Complete unstake after cooldown period
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/ethena";
+```
+
+## SauceScript Examples
+
+```typescript
+// Stake USDe for sUSDe
+import { StakedUSDeABI as IStakedUSDe } from "./abis";
+function main(susdeAddress: Address, amount: Uint256, receiver: Address): Uint256 {
+  const susde = IStakedUSDe.at(susdeAddress);
+  return susde.deposit(amount, receiver);
+}
+
+// Start cooldown to unstake
+import { StakedUSDeABI as IStakedUSDe } from "./abis";
+function main(susdeAddress: Address, assets: Uint256): Uint256 {
+  const susde = IStakedUSDe.at(susdeAddress);
+  return susde.cooldownAssets(assets);
+}
+
+// Complete unstake after cooldown
+import { StakedUSDeABI as IStakedUSDe } from "./abis";
+function main(susdeAddress: Address, receiver: Address): Uint256 {
+  const susde = IStakedUSDe.at(susdeAddress);
+  susde.unstake(receiver);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | usde     | `0x4c9EDD5852cd905f086C759E8383e09bff1e68b3` |
+| Ethereum | susde    | `0x9D39A5DE30e57443BfF2A8307A4256c8797A3497` |
+
+## ABI Methods
+
+### StakedUSDeABI (ERC-4626 + cooldown)
+
+- `deposit(uint256,address)` - Stake USDe, receive sUSDe. Params: assets (USDe amount), receiver. Returns shares (sUSDe minted)
+- `withdraw(uint256,address,address)` - Withdraw by asset amount (after cooldown). Params: assets, receiver, owner. Returns shares burned
+- `redeem(uint256,address,address)` - Redeem by share amount (after cooldown). Params: shares, receiver, owner. Returns assets
+- `cooldownAssets(uint256)` - Start cooldown by specifying USDe amount. Params: assets. Returns shares that will be burned
+- `cooldownShares(uint256)` - Start cooldown by specifying sUSDe amount. Params: shares. Returns assets that will be received
+- `unstake(address)` - Complete unstake after cooldown. Params: receiver (address to receive USDe)
+
+### USDeABI
+
+- `approve(address,uint256)` - Approve USDe spender. Params: spender, amount. Returns bool
+
+## Notes
+
+- TVL: $3B+. Yield comes from ETH staking rewards + perpetual funding rates
+- 7-day cooldown period required before unstaking
+- Flow: deposit (stake) -> cooldownAssets/cooldownShares (start cooldown) -> unstake (after 7 days)
+- Approve USDe to sUSDe contract before depositing
+- sUSDe appreciates against USDe as yield accrues

package/sdk/src/skills/etherfi.md

@@ -0,0 +1,79 @@
+# ether.fi
+
+Decentralized, non-custodial liquid restaking protocol. Stake ETH to receive eETH (rebasing), or wrap it as weETH (non-rebasing) for DeFi composability. Natively restaked via EigenLayer.
+
+## Category
+
+restaking | Chains: Ethereum
+
+## Key Operations
+
+- **deposit**: Stake ETH and receive eETH
+- **wrap**: Wrap eETH into weETH (non-rebasing)
+- **unwrap**: Unwrap weETH back to eETH
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/etherfi";
+```
+
+## SauceScript Examples
+
+```typescript
+// Deposit ETH for eETH
+import { LiquidityPoolABI as ILiquidityPool } from "./abis";
+function main(liquidityPoolAddress: Address): Uint256 {
+  const pool = ILiquidityPool.at(liquidityPoolAddress);
+  return pool.deposit();
+}
+
+// Wrap eETH to weETH
+import { WeETHABI as IWeETH } from "./abis";
+function main(weethAddress: Address, amount: Uint256): Uint256 {
+  const weeth = IWeETH.at(weethAddress);
+  return weeth.wrap(amount);
+}
+
+// Unwrap weETH to eETH
+import { WeETHABI as IWeETH } from "./abis";
+function main(weethAddress: Address, amount: Uint256): Uint256 {
+  const weeth = IWeETH.at(weethAddress);
+  return weeth.unwrap(amount);
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract      | Address                                      |
+| -------- | ------------- | -------------------------------------------- |
+| Ethereum | eETH          | `0x35fA164735182de50811E8e2E824cFb9B6118ac2` |
+| Ethereum | weETH         | `0xCd5fE23C85820F7B72D0926FC9b05b43E359b7ee` |
+| Ethereum | liquidityPool | `0x308861A430be4cce5502d0A12724771Fc6DaF216` |
+
+## ABI Methods
+
+### LiquidityPoolABI
+
+- `deposit()` - Stake ETH (payable), receive eETH. Returns shares minted
+
+### WeETHABI
+
+- `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
+- `balanceOf(address)` - Query weETH balance
+
+### EETHABI
+
+- `balanceOf(address)` - Query eETH balance
+- `approve(address,uint256)` - Approve eETH spending
+
+## Notes
+
+- TVL: $5.8B+. Largest liquid restaking protocol
+- eETH rebases like stETH. Use weETH for DeFi (Aave, Pendle, etc.)
+- deposit() is payable - send ETH as msg.value
+- Approve eETH to weETH contract before wrapping
+- Natively restaked on EigenLayer for additional AVS yield