@eco-incorp/sauce 0.99.0

package/sdk/src/skills/benqi.md

@@ -0,0 +1,98 @@
+# Benqi
+
+Leading lending and borrowing protocol on Avalanche. Compound V2 fork with additional liquid staking (sAVAX) functionality.
+
+## Category
+
+lending | Chains: Avalanche (43114)
+
+## SauceScript Functions
+
+### supply
+
+Supply assets by minting qiTokens. Exchange rate grows as interest accrues.
+
+```typescript
+import { QiTokenABI as IQiToken } from "./abis";
+
+function main(qiTokenAddress: Address, amount: Uint256): Uint256 {
+  const qiToken = IQiToken.at(qiTokenAddress);
+  return qiToken.mint(amount);
+}
+```
+
+- `qiTokenAddress`: The qiToken market contract (each asset has its own qiToken)
+- Returns 0 on success, error code on failure
+- Requires ERC-20 approval of underlying to the qiToken
+
+### withdraw
+
+Withdraw underlying assets by specifying the exact amount.
+
+```typescript
+import { QiTokenABI as IQiToken } from "./abis";
+
+function main(qiTokenAddress: Address, amount: Uint256): Uint256 {
+  const qiToken = IQiToken.at(qiTokenAddress);
+  return qiToken.redeemUnderlying(amount);
+}
+```
+
+### borrow
+
+Borrow assets against qiToken collateral. Must call enterMarkets first.
+
+```typescript
+import { QiTokenABI as IQiToken } from "./abis";
+
+function main(qiTokenAddress: Address, amount: Uint256): Uint256 {
+  const qiToken = IQiToken.at(qiTokenAddress);
+  return qiToken.borrow(amount);
+}
+```
+
+- Must enable collateral via `BenqiComptroller.enterMarkets([qiTokenAddress])` first
+
+### repay
+
+Repay borrowed assets.
+
+```typescript
+import { QiTokenABI as IQiToken } from "./abis";
+
+function main(qiTokenAddress: Address, amount: Uint256): Uint256 {
+  const qiToken = IQiToken.at(qiTokenAddress);
+  return qiToken.repayBorrow(amount);
+}
+```
+
+- Requires ERC-20 approval of underlying to the qiToken
+
+## Deployed Addresses
+
+| Chain     | Contract    | Address                                      |
+| --------- | ----------- | -------------------------------------------- |
+| Avalanche | comptroller | `0x486Af39519B4Dc9a7fCcd318217352830E8AD9b4` |
+
+## ABI Reference
+
+### QiTokenABI
+
+- `mint(uint256 mintAmount) returns (uint256)` - Supply underlying, receive qiTokens
+- `redeem(uint256 redeemTokens) returns (uint256)` - Redeem qiTokens 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
+
+### BenqiComptrollerABI
+
+- `enterMarkets(address[] qiTokens) returns (uint256[])` - Enable qiTokens as collateral
+- `exitMarket(address qiToken) returns (uint256)` - Remove qiToken from collateral
+
+## Notes
+
+- Same interface as Compound V2 (forked codebase)
+- Must call `enterMarkets` on Comptroller before borrowing against any market
+- Also offers sAVAX liquid staking product (separate contract)
+- Return values: 0 = success, non-zero = error code
+- Avalanche-only deployment. TVL: $500M+. Audited

package/sdk/src/skills/camelot.md

@@ -0,0 +1,175 @@
+# Camelot
+
+Native Arbitrum DEX with dual AMM: V2 constant product pools (with native fee-on-transfer token support) and V3 concentrated liquidity pools (Algebra-based with dynamic fees, no fixed fee tiers).
+
+## Category
+
+dex | Chains: Arbitrum
+
+## Key Operations
+
+- **swapV2**: Swap via V2 router with fee-on-transfer token support and referral tracking
+- **swapV3**: Swap via V3 concentrated liquidity router (Algebra-based, dynamic fees)
+- **addLiquidity**: Add liquidity to V2 pools
+- **removeLiquidity**: Remove liquidity from V2 pools
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/camelot";
+```
+
+## SauceScript Examples
+
+### swapV2
+
+```typescript
+import { CamelotV2RouterABI as ICamelotRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  path: Address[],
+  amountIn: Uint256,
+  amountOutMin: Uint256,
+  recipient: Address,
+  referrer: Address,
+): Uint256 {
+  const router = ICamelotRouter.at(routerAddress);
+  router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
+    amountIn,
+    amountOutMin,
+    path,
+    recipient,
+    referrer,
+    99999999999,
+  );
+  return 1;
+}
+```
+
+- `routerAddress`: Camelot V2 Router on Arbitrum
+- `path`: Ordered token address array for the swap route
+- `amountIn`: Exact input amount (in wei)
+- `amountOutMin`: Minimum output for slippage protection
+- `recipient`: Address to receive output tokens
+- `referrer`: Address of the referrer for fee sharing (use zero address if none)
+- This method supports fee-on-transfer (rebasing) tokens natively
+
+### swapV3
+
+```typescript
+import { CamelotV3SwapRouterABI as ICamelotV3Router } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenIn: Address,
+  tokenOut: Address,
+  amountIn: Uint256,
+  amountOutMin: Uint256,
+  recipient: Address,
+): Uint256 {
+  const router = ICamelotV3Router.at(routerAddress);
+  return router.exactInputSingle({
+    tokenIn: tokenIn,
+    tokenOut: tokenOut,
+    recipient: recipient,
+    deadline: 99999999999,
+    amountIn: amountIn,
+    amountOutMinimum: amountOutMin,
+    limitSqrtPrice: 0,
+  });
+}
+```
+
+- `routerAddress`: Camelot V3 SwapRouter on Arbitrum
+- No `fee` parameter needed: Camelot V3 uses dynamic fees (Algebra-based), not fixed fee tiers
+- `limitSqrtPrice`: Set to `0` for no price limit
+
+### addLiquidity
+
+```typescript
+import { CamelotV2RouterABI as ICamelotRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
+  amountADesired: Uint256,
+  amountBDesired: Uint256,
+  amountAMin: Uint256,
+  amountBMin: Uint256,
+  recipient: Address,
+): { amountA: Uint256; amountB: Uint256; liquidity: Uint256 } {
+  const router = ICamelotRouter.at(routerAddress);
+  return router.addLiquidity(
+    tokenA,
+    tokenB,
+    amountADesired,
+    amountBDesired,
+    amountAMin,
+    amountBMin,
+    recipient,
+    99999999999,
+  );
+}
+```
+
+- Both tokens must be approved to the V2 router
+
+### removeLiquidity
+
+```typescript
+import { CamelotV2RouterABI as ICamelotRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  tokenA: Address,
+  tokenB: Address,
+  liquidity: Uint256,
+  amountAMin: Uint256,
+  amountBMin: Uint256,
+  recipient: Address,
+): { amountA: Uint256; amountB: Uint256 } {
+  const router = ICamelotRouter.at(routerAddress);
+  return router.removeLiquidity(
+    tokenA,
+    tokenB,
+    liquidity,
+    amountAMin,
+    amountBMin,
+    recipient,
+    99999999999,
+  );
+}
+```
+
+- LP token must be approved to the V2 router
+
+## Key Addresses
+
+| Chain    | Contract      | Address                                      |
+| -------- | ------------- | -------------------------------------------- |
+| Arbitrum | V2 Factory    | `0x6EcCab422D763aC031210895C81787E87B43A652` |
+| Arbitrum | V2 Router     | `0xc873fEcbd354f5A56E00E710B90EF4201db2448d` |
+| Arbitrum | V3 Factory    | `0x1a3c9B1d2F0529D97f2afC5136Cc23e58f1FD35B` |
+| Arbitrum | V3 SwapRouter | `0x1F721E2E82F6676FCE4eA07A5958cF098D339e18` |
+
+## ABI Methods
+
+### CamelotV2RouterABI
+
+- `swapExactTokensForTokensSupportingFeeOnTransferTokens(uint256 amountIn, uint256 amountOutMin, address[] path, address to, address referrer, uint256 deadline)` - V2 swap with fee-on-transfer token support and referral. Note: no return value
+- `addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB, uint256 liquidity)` - Add V2 LP
+- `removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) -> (uint256 amountA, uint256 amountB)` - Remove V2 LP
+
+### CamelotV3SwapRouterABI
+
+- `exactInputSingle(tuple(address tokenIn, address tokenOut, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum, uint160 limitSqrtPrice)) -> uint256 amountOut` - V3 concentrated liquidity swap with dynamic fees
+
+## Notes
+
+- V2 router uses `swapExactTokensForTokensSupportingFeeOnTransferTokens` (not standard `swapExactTokensForTokens`) which natively handles rebasing/tax tokens
+- V2 router includes a `referrer` parameter for referral fee sharing (unique to Camelot)
+- V3 uses Algebra protocol (dynamic fees that adjust based on volatility, NOT fixed fee tiers like Uniswap V3)
+- V3 uses `limitSqrtPrice` instead of `sqrtPriceLimitX96`
+- Arbitrum-only deployment; the native DEX for Arbitrum ecosystem projects

package/sdk/src/skills/cbeth.md

@@ -0,0 +1,62 @@
+# Coinbase Wrapped Staked ETH
+
+Coinbase's liquid staking token for Ethereum. cbETH represents staked ETH plus accrued staking rewards. Non-rebasing.
+
+## Category
+
+liquid-staking | Chains: Ethereum, Base
+
+## Key Operations
+
+- **transfer**: Transfer cbETH tokens
+- **approve**: Approve spender for cbETH
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/cbeth";
+```
+
+## SauceScript Examples
+
+```typescript
+// Transfer cbETH
+import { CbETHABI as ICbETH } from "./abis";
+function main(cbethAddress: Address, to: Address, amount: Uint256): Uint256 {
+  const cbeth = ICbETH.at(cbethAddress);
+  cbeth.transfer(to, amount);
+  return 1;
+}
+
+// Approve cbETH
+import { CbETHABI as ICbETH } from "./abis";
+function main(cbethAddress: Address, spender: Address, amount: Uint256): Uint256 {
+  const cbeth = ICbETH.at(cbethAddress);
+  cbeth.approve(spender, amount);
+  return 1;
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | cbETH    | `0xBe9895146f7AF43049ca1c1AE358B0541Ea49704` |
+| Base     | cbETH    | `0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22` |
+
+## ABI Methods
+
+### CbETHABI
+
+- `mint(uint256)` - Mint cbETH (restricted to Coinbase)
+- `exchangeRate()` - Current cbETH/ETH exchange rate
+- `balanceOf(address)` - Query cbETH balance
+- `approve(address,uint256)` - Approve spender
+- `transfer(address,uint256)` - Transfer cbETH
+
+## Notes
+
+- TVL: $2.5B+. Non-rebasing - exchange rate increases over time
+- Minted by Coinbase (mint is permissioned). On-chain operations are transfer/approve
+- Compatible with EigenLayer restaking (cbETH strategy available)
+- Available natively on Base L2

package/sdk/src/skills/celer.md

@@ -0,0 +1,65 @@
+# Celer Network
+
+Multi-chain bridging protocol using SGN (State Guardian Network) for cross-chain message validation and token transfers.
+
+## Category
+
+bridge | Direction: any-to-any (L1-to-L2, L2-to-L2, L2-to-L1) | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Polygon (137), BSC (56), Avalanche (43114)
+
+## SauceScript Functions
+
+### bridge
+
+Send ERC-20 tokens cross-chain via cBridge.
+
+```typescript
+import { CelerBridgeABI as IBridge } from "./abis";
+
+function main(
+  bridgeAddress: Address,
+  receiver: Address,
+  token: Address,
+  amount: Uint256,
+  dstChainId: Uint256,
+  maxSlippage: Uint256,
+): Uint256 {
+  const bridge = IBridge.at(bridgeAddress);
+  bridge.send(receiver, token, amount, dstChainId, 0, maxSlippage);
+  return 1;
+}
+```
+
+- `receiver`: Address to receive tokens on destination chain
+- `token`: ERC-20 token to bridge
+- `dstChainId`: Destination EVM chain ID (as uint64)
+- `nonce`: Set to 0 (auto-generated)
+- `maxSlippage`: Maximum slippage in basis points (e.g. 500 = 5%). Applied during pool-based bridging
+- Requires ERC-20 approval to the Bridge
+
+## Deployed Addresses
+
+| Chain     | Contract | Address                                      |
+| --------- | -------- | -------------------------------------------- |
+| Ethereum  | bridge   | `0x5427FEFA711Eff984124bFBB1AB6fbf5E3DA1820` |
+| Arbitrum  | bridge   | `0x1619DE6B6B20eD217a58d00f37B9d47C7663feca` |
+| Optimism  | bridge   | `0x9D39Fc627A6d9d9F8C831c16995b209548cc3401` |
+| Polygon   | bridge   | `0x88DCDC47D2f83a99CF0000FDF667A468bB958a78` |
+| BSC       | bridge   | `0xdd90E5E87A2081Dcf0391920868eBc2FFB81a1aF` |
+| Avalanche | bridge   | `0xef3c714c9425a8F3697A9C969Dc1af30ba82e5d4` |
+
+## ABI Reference
+
+### CelerBridgeABI
+
+- `send(address _receiver, address _token, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage)` - Send ERC-20 tokens cross-chain via liquidity pool
+- `sendNative(address _receiver, uint256 _amount, uint64 _dstChainId, uint64 _nonce, uint32 _maxSlippage)` [payable] - Send native token (ETH/BNB/etc.) cross-chain
+
+## Notes
+
+- `send` for ERC-20 tokens, `sendNative` for native tokens (ETH, BNB, AVAX, etc.)
+- `nonce` is used for unique transfer identification -- can set to 0 or use block.timestamp
+- `maxSlippage` is in basis points (1 = 0.01%, 100 = 1%, 5000 = 50%)
+- Uses SGN validators to verify cross-chain messages
+- Finality: typically 5-20 minutes depending on chain confirmation requirements
+- Requires ERC-20 approval to the Bridge address
+- TVL: $150M+. Audited

package/sdk/src/skills/chainlink-ccip.md

@@ -0,0 +1,74 @@
+# Chainlink CCIP
+
+Cross-Chain Interoperability Protocol by Chainlink. Enterprise-grade cross-chain messaging with DON (Decentralized Oracle Network) security and token transfers.
+
+## Category
+
+cross-chain messaging + token transfer | Direction: any-to-any | Chains: Ethereum (1), Arbitrum (42161), Optimism (10), Base (8453), Polygon (137)
+
+## SauceScript Functions
+
+### sendMessage
+
+Send a cross-chain message via CCIP Router.
+
+```typescript
+import { CCIPRouterABI as ICCIPRouter } from "./abis";
+
+function main(
+  routerAddress: Address,
+  destinationChainSelector: Uint256,
+  receiver: bytes,
+  data: bytes,
+): Uint256 {
+  const router = ICCIPRouter.at(routerAddress);
+  return router.ccipSend(destinationChainSelector, {
+    receiver: receiver,
+    data: data,
+    tokenAmounts: [],
+    feeToken: 0x0000000000000000000000000000000000000000,
+    extraArgs: 0x00,
+  });
+}
+```
+
+- `destinationChainSelector`: CCIP chain selector (NOT EVM chain ID). These are unique uint64 identifiers per chain
+- `receiver`: ABI-encoded destination address (bytes, not raw address)
+- `data`: Arbitrary message payload (bytes)
+- `tokenAmounts`: Array of `{token, amount}` tuples for cross-chain token transfers. Empty array `[]` for message-only
+- `feeToken`: Address of token to pay fees in. `address(0)` = pay in native token (ETH). Can also use LINK token address
+- `extraArgs`: Optional encoded extra arguments (gas limits, etc.). `0x00` for defaults
+- Requires native token (ETH) as msg.value when `feeToken` is `address(0)`
+- Requires ERC-20 approval to the Router for any tokens in `tokenAmounts`
+
+## Deployed Addresses
+
+| Chain    | Contract | Address                                      |
+| -------- | -------- | -------------------------------------------- |
+| Ethereum | router   | `0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D` |
+| Arbitrum | router   | `0x141fa059441E0ca23ce184B6A78bafD2A517DdE8` |
+| Optimism | router   | `0x3206695CaE29952f4b0c22a169725a865bc8Ce0f` |
+| Base     | router   | `0x881e3A65B4d4a04dD529061dd0071cf975F58bCD` |
+| Polygon  | router   | `0x849c5ED5a80F5B408Dd4969b78c2C8fdf0565Bfe` |
+
+## ABI Reference
+
+### CCIPRouterABI
+
+- `ccipSend(uint64 destinationChainSelector, EVM2AnyMessage message) returns (uint256 messageId)` [payable] - Send cross-chain message and/or tokens. Returns message ID for tracking
+- `getFee(uint64 destinationChainSelector, EVM2AnyMessage message) returns (uint256 fee)` - Estimate fee for a CCIP message before sending (view)
+- `isChainSupported(uint64 chainSelector) returns (bool)` - Check if a destination chain selector is supported (view)
+
+EVM2AnyMessage tuple: `(bytes receiver, bytes data, EVMTokenAmount[] tokenAmounts, address feeToken, bytes extraArgs)`
+EVMTokenAmount tuple: `(address token, uint256 amount)`
+
+## Notes
+
+- Uses CCIP chain selectors (uint64), NOT EVM chain IDs. Each supported chain has a unique selector
+- Fees can be paid in native token (ETH) or LINK token
+- Use `getFee()` to estimate costs before sending
+- Supports both message-only and message+token transfers in a single call
+- DON-based security with Chainlink oracle network -- no external validators needed
+- Finality: typically 5-20 minutes depending on source chain finality
+- Rate limits apply per lane (source-destination pair)
+- TVL: $1B+. Audited

package/sdk/src/skills/chainlink.md

@@ -0,0 +1,62 @@
+# Chainlink
+
+Industry-standard decentralized oracle network providing price feeds, VRF randomness, automation, and cross-chain interoperability (CCIP).
+
+## Category
+
+oracle | Chains: Ethereum
+
+## Key Operations
+
+- **getLatestPrice**: Read latest price from a Chainlink price feed aggregator
+
+## SDK Usage
+
+```typescript
+import { protocolInfo, deployments, sauceFunctions } from "@eco-incorp/sauce/protocols/chainlink";
+```
+
+## SauceScript Examples
+
+```typescript
+// Get latest price from feed
+import { AggregatorV3ABI as IAggregatorV3 } from "./abis";
+function main(feedAddress: Address): {
+  roundId: Uint256;
+  answer: Uint256;
+  startedAt: Uint256;
+  updatedAt: Uint256;
+  answeredInRound: Uint256;
+} {
+  const feed = IAggregatorV3.at(feedAddress);
+  return feed.latestRoundData();
+}
+```
+
+## Key Addresses
+
+| Chain    | Contract         | Address                                      |
+| -------- | ---------------- | -------------------------------------------- |
+| Ethereum | ethUsdFeed       | `0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419` |
+| Ethereum | feedRegistry     | `0x47Fb2585D2C56Fe188D0E6ec628a38b74fCeeeDf` |
+| Ethereum | vrfV2Coordinator | `0x271682DEB8C4E0901D1a1550aD2e64D568E69909` |
+
+## ABI Methods
+
+### AggregatorV3ABI
+
+- `latestRoundData()` - Get latest price data. Returns tuple: (roundId uint80, answer int256, startedAt uint256, updatedAt uint256, answeredInRound uint80). answer is the price with feed-specific decimals
+- `decimals()` - Get price feed decimal precision. Returns uint8 (usually 8 for USD feeds, 18 for ETH feeds)
+
+### FeedRegistryABI
+
+- `latestRoundData(address,address)` - Get latest price for a base/quote pair. Params: base (token address), quote (denomination address, use 0x348... for USD). Returns same tuple as AggregatorV3
+- `getFeed(address,address)` - Look up aggregator address for a pair. Params: base, quote. Returns aggregator address
+
+## Notes
+
+- Price feeds return answer in int256 with feed-specific decimals (usually 8 for USD pairs)
+- Always check updatedAt timestamp for staleness - stale prices can cause issues
+- Feed Registry is Ethereum-only; on L2s, use individual feed addresses directly
+- VRF provides verifiable randomness for on-chain applications
+- Common feed addresses vary by chain - check Chainlink docs for specific chain deployments

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

@@ -0,0 +1,109 @@
+# Compound V2
+
+Legacy algorithmic money market protocol on Ethereum. Pioneered cToken model where deposits mint interest-bearing tokens.
+
+## Category
+
+lending | Chains: Ethereum (1)
+
+## SauceScript Functions
+
+### supply
+
+Supply assets by minting cTokens. The cToken exchange rate increases over time as interest accrues.
+
+```typescript
+import { CErc20ABI as ICErc20 } from "./abis";
+
+function main(cTokenAddress: Address, amount: Uint256): Uint256 {
+  const cToken = ICErc20.at(cTokenAddress);
+  return cToken.mint(amount);
+}
+```
+
+- `cTokenAddress`: The cToken market contract (e.g. cUSDC, cETH)
+- `amount`: Amount of underlying token to supply
+- Returns 0 on success, error code on failure
+- Requires ERC-20 approval of the underlying token to the cToken address
+
+### withdraw
+
+Withdraw by specifying the amount of underlying tokens to receive.
+
+```typescript
+import { CErc20ABI as ICErc20 } from "./abis";
+
+function main(cTokenAddress: Address, amount: Uint256): Uint256 {
+  const cToken = ICErc20.at(cTokenAddress);
+  return cToken.redeemUnderlying(amount);
+}
+```
+
+- `amount`: Amount of underlying tokens to withdraw
+- Returns 0 on success, error code on failure
+
+### borrow
+
+Borrow assets against supplied collateral. Must call `enterMarkets` on Comptroller first.
+
+```typescript
+import { CErc20ABI as ICErc20 } from "./abis";
+
+function main(cTokenAddress: Address, amount: Uint256): Uint256 {
+  const cToken = ICErc20.at(cTokenAddress);
+  return cToken.borrow(amount);
+}
+```
+
+- `amount`: Amount of underlying to borrow
+- Must have collateral enabled via Comptroller.enterMarkets first
+
+### repay
+
+Repay borrowed assets.
+
+```typescript
+import { CErc20ABI as ICErc20 } from "./abis";
+
+function main(cTokenAddress: Address, amount: Uint256): Uint256 {
+  const cToken = ICErc20.at(cTokenAddress);
+  return cToken.repayBorrow(amount);
+}
+```
+
+- `amount`: Amount to repay. Use `type(uint256).max` to repay full debt
+- Requires ERC-20 approval of the underlying token to the cToken
+
+## Deployed Addresses
+
+| Chain    | Contract    | Address                                      |
+| -------- | ----------- | -------------------------------------------- |
+| Ethereum | comptroller | `0x3d9819210A31b4961b30EF54bE2aeD79B9c9Cd3B` |
+| Ethereum | cETH        | `0x4Ddc2D193948926D02f9B1fE9e1daa0718270ED5` |
+| Ethereum | cUSDC       | `0x39AA39c021dfbaE8faC545936693aC917d5E7563` |
+
+## ABI Reference
+
+### CErc20ABI
+
+- `mint(uint256 mintAmount) returns (uint256)` - Supply underlying, receive cTokens. Returns 0 on success
+- `redeem(uint256 redeemTokens) returns (uint256)` - Redeem cTokens for underlying (specify cToken amount)
+- `redeemUnderlying(uint256 redeemAmount) returns (uint256)` - Redeem for exact underlying amount
+- `borrow(uint256 borrowAmount) returns (uint256)` - Borrow underlying tokens
+- `repayBorrow(uint256 repayAmount) returns (uint256)` - Repay borrow debt
+- `balanceOfUnderlying(address owner) returns (uint256)` - Get underlying balance including accrued interest (view)
+- `borrowBalanceCurrent(address account) returns (uint256)` - Get current borrow balance with interest (view)
+
+### ComptrollerABI
+
+- `enterMarkets(address[] cTokens) returns (uint256[])` - Enable cTokens as collateral. Must call before borrowing
+- `exitMarket(address cToken) returns (uint256)` - Remove cToken from collateral (fails if would cause shortfall)
+
+## Notes
+
+- Must call `Comptroller.enterMarkets([cTokenAddress])` before borrowing against a market
+- Return values: 0 = success, non-zero = error code (e.g. 3 = COMPTROLLER_REJECTION)
+- cToken exchange rate grows over time -- holding cTokens earns interest automatically
+- Each asset has its own cToken contract (not a shared pool like Aave)
+- Legacy protocol -- consider Compound V3 (Comet) for new deployments
+- TVL: $1B+. Audited