@continuumdao/ctm-mpc-defi 0.2.29 → 0.2.31

package/dist/agent/skills/aerodrome/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: aerodrome
+description: Aerodrome AMM on Base — Sugar discovery, swaps, basic LP, Slipstream CL, gauges, and MPC multisign.
+---
+
+# Aerodrome (MCP)
+
+Aerodrome is **Base-only (`chainId` 8453)**. Reads use the on-chain **LpSugar** aggregator. Writes build unsigned EVM batches (optional ERC-20 approve + Router / NFPM / gauge) for Continuum MPC.
+
+Native ETH in the app and MCP is **`0x0000000000000000000000000000000000000000`**. Map to WETH (`0x4200000000000000000000000000000000000006`) at the Sugar/router boundary. Do not pass Curve’s `0xeeee…` placeholder.
+
+## Quote first (Coinbase B20 / AAPLc)
+
+**Do not** dump listed tokens or `ctm_aerodrome_fetch_pools`. There is no Sugar token directory on MCP. Tickers resolve inside quote / discover.
+
+For a price, **call `ctm_aerodrome_quote` immediately**:
+
+```
+ctm_aerodrome_quote({ chainId: 8453, tokenIn: "USDC", tokenOut: "AAPLc", amountHuman: "1000" })
+```
+
+- `tokenIn` / `tokenOut` accept **tickers** (`AAPLc`, `USDC`, `ETH`, `WETH`, `AERO`) or 0x addresses. Do **not** ask the user for a B20 contract address.
+- B20 stocks are **8 decimals**. Omit `tokenInDecimals`.
+- Quote output includes `amountOutHuman` and `priceImpactPercent` (0–100, vs a tiny same-route probe; `null` if the probe failed). State both before building a swap.
+- To see **which pools exist** for a token (not a price): `ctm_aerodrome_discover_pools({ token: "AAPLc" })` — factory `getPool` vs USDC/WETH/AERO (optional `tokenOut`). Then quote.
+
+Use `get_defi_protocol_supported_tokens` only as a slim ticker list (ETH, USDC, AERO, B20). `issued` for a stock is `totalSupply > 0` on quote/discover (unissued throws).
+
+## Before writes
+
+1. `load_defi_protocol({ protocolId: "aerodrome" })` — activates **market-data** (includes quote)
+2. `get_defi_protocol_supported_chains` — must include 8453 with a node `rpcGateway`
+3. Writes: `activate_tool_group` with `aerodrome:swap`, `aerodrome:lp`, or `aerodrome:rewards`
+
+`aerodrome:trading` expands to swaps + lp + rewards (not market-data).
+
+## Confirm before creating a sign request
+
+After the quote (include `amountOutHuman` and `priceImpactPercent`), **stop and ask** before any `ctm_aerodrome_build_*_multisign`:
+
+1. `get_multi_sign_gas_options({ chainId: 8453 })` — confirm `useCustomGas` **false** (live RPC, default) vs **true** (Custom Gas Config from the chain registry).
+2. Confirm the **30-minute** multiSignRequest deadline (members must agree, Get Sig, and broadcast before it expires). The on-chain router/NFPM deadline uses the same window. Omit `expiryDate` for 30 minutes; pass `expiryDate` as unix seconds only if they choose a different window.
+
+Do not create the request until they confirm both.
+
+## Tool packs
+
+| Pack | Tools | Sign request? |
+|------|-------|----------------|
+| market-data | `ctm_aerodrome_discover_pools`, `ctm_aerodrome_quote`, `ctm_aerodrome_fetch_positions`, `ctm_aerodrome_fetch_pools` (Sugar dump — avoid) | No |
+| swaps | `ctm_aerodrome_build_swap_multisign` | Yes |
+| lp | `quote_add_liquidity`, `quote_cl_deposit`, add/remove liquidity, CL mint/increase/decrease/burn, gauge stake/unstake | Quotes no; builds yes |
+| rewards | claim fees, CL collect, claim emissions | Yes |
+
+## Liquidity (dialog parity)
+
+Same as the Multi-Sign Liquidity tab:
+
+```
+ctm_aerodrome_quote_add_liquidity({ chainId: 8453, tokenA: "ETH", tokenB: "USDC", amountAHuman: "0.01" })
+```
+
+- One-sided: pass **either** `amountAHuman` or `amountBHuman`. The other side is filled from the current vAMM/sAMM reserves, or from Slipstream `slot0` when there is no v2 pool.
+- Tickers work (`AAPLc`, `USDC`, `ETH`). B20 stocks are 8 decimals. Unissued stocks (`totalSupply == 0`) error the same as the dialog.
+- **ETH / Coinbase stock has no pool.** `seedable` is `false` and `hint` tells you to pair the stock vs **USDC**. Do not first-deposit an empty vAMM.
+- `kind: "cl"` means the ratio came from Slipstream. `ctm_aerodrome_build_add_liquidity_multisign` is **v2 only** — use `ctm_aerodrome_quote_cl_deposit` + `ctm_aerodrome_build_cl_mint_multisign` for that pool. AAPLc/USDC also has a small vAMM if you want basic LP.
+
+## Rewards (dialog parity)
+
+Same as the Multi-Sign Rewards tab. **Start with** `ctm_aerodrome_fetch_positions` (account / keyGen). Rows are labeled (`vAMM-USDC/AERO`, `CL #id`) and dust-filtered.
+
+| Dialog radio | Tool | Argument |
+|--------------|------|----------|
+| Fees from the pool | `ctm_aerodrome_build_claim_fees_multisign` | `pool` = `claimFees.pool` (`lp`) |
+| Emissions from the gauge in AERO | `ctm_aerodrome_build_claim_emissions_multisign` | `gauge` = `claimEmissions.gauge`; Slipstream staked also needs `tokenId` + `cl: true` |
+
+Skip emissions when `claimEmissions` is `null` (no gauge). Slipstream unstaked fees use `ctm_aerodrome_build_cl_collect_fees_multisign` with the NFT `id`.
+
+## Native ETH
+
+| Phase | tokenIn / tokenA |
+|-------|------------------|
+| Quote / build | `0x0` or `eth` for native; ticker or ERC-20 otherwise |
+
+## Addresses
+
+Loaded from official GitHub (`velodrome-finance/sugar` `deployments/base.env` and `aerodrome-finance/docs` security.mdx) with baked fallbacks. Do not invent addresses.
+
+Coinbase B20 stocks (AAPLc, NVDAc, METAc, GOOGLc, SPCXc, …) trade on **Slipstream 3** (`clFactory3`) vs USDC. New official names are picked up from the [Base tokenized-stocks docs](https://docs.base.org/base-chain/asset-issuance/tokenized-stocks-on-base) and from Sugar tokens whose address uses the B20 ASSET prefix `0xb200…`. The docs fetch is optional: if that page is gone or unusable, discovery continues from the seed list + Sugar. `issued` is live `totalSupply() > 0` — do not hard-code unissued tickers. Quotes use factory `getPool` discovery + MixedRouteQuoterV3 (path bitmasks). Sugar `forSwaps` alone misses these pools. Native ETH → stock is typically WETH → USDC → stock.
+
+## Out of scope
+
+veNFT lock/vote/rebases, Velodrome Superchain, Pool Launcher, incentives.

package/dist/agent/skills/compound-v3/SKILL.md

@@ -0,0 +1,132 @@
+---
+name: compound-v3
+description: Compound III (Comet) lending — supply, withdraw/borrow, repay, claim rewards, optional Bulker.
+---
+
+# Compound III (MCP)
+
+Each Compound III market is an isolated **Comet**. You always call the **Comet proxy** with the **CometInterface ABI**. Never the implementation or `CometExt` address.
+
+| Concept | What it is | Agent needs to know |
+|---------|------------|---------------------|
+| **Comet proxy** | The only market address you call | From `ctm_compound_v3_fetch_markets` → `comet` |
+| **Base asset** | The one asset you earn or borrow | `baseToken` on the market |
+| **Collateral** | Other assets that back a borrow | `assets` where `role = collateral` |
+| **Supply base** | Earn interest | Also **repays** if the account is borrowed |
+| **Withdraw base** | Withdraw supplied base, or **borrow** if undercollateralized | Same `withdraw` tool |
+| **Bulker** | Optional combined `invoke` | Not required for ETH wrap |
+
+## Before any action
+
+1. `load_defi_protocol({ protocolId: "compound-v3" })`
+2. `get_defi_protocol_skill({ protocolId: "compound-v3" })`
+3. `get_defi_protocol_supported_chains` — intersect with `get_chain_registry` (`rpcGateway` required)
+4. `get_defi_protocol_supported_tokens({ protocolId: "compound-v3", chainId })`
+5. `ctm_compound_v3_fetch_markets` → copy `comet`
+6. `ctm_compound_v3_fetch_account` before withdraw / repay / claim
+
+## Tool selection
+
+Do **not** web-search Compound III markets, collaterals, or APRs. Load the protocol and use the fetch tools below.
+
+| User intent | MCP tool |
+|-------------|----------|
+| List markets / what can I borrow against X | `ctm_compound_v3_fetch_markets` |
+| Market detail (CFs, prices, APR) | `ctm_compound_v3_fetch_market` |
+| Position + liquidation risk + claimable | `ctm_compound_v3_fetch_account` |
+| Supply collateral or base (earn / repay) | `ctm_compound_v3_build_supply_multisign` |
+| Withdraw or borrow base | `ctm_compound_v3_build_withdraw_multisign` |
+| Repay debt | `ctm_compound_v3_build_repay_multisign` |
+| Claim COMP / rewards | `ctm_compound_v3_build_claim_rewards_multisign` |
+| Combined actions | `ctm_compound_v3_build_bulker_multisign` |
+
+## Common write inputs
+
+| Field | Required | Notes |
+|-------|----------|-------|
+| `keyGenId` | yes | Preferred KeyGen |
+| `chainId` | yes | EVM chain id |
+| `purposeText` | yes | Human-readable reason |
+| `comet` | yes | **Proxy** from fetch_markets |
+| `asset` | yes (except claim) | Token; native ETH = `0x000…000` |
+| `amountHuman` | yes (except claim) | Human amount |
+| `isNative` | no | Wrap/unwrap ETH automatically |
+| `useCustomGas` | no | Chain registry gas |
+
+## ETH wrap / unwrap (automatic)
+
+If the user supplies or withdraws **native ETH** (`asset` is the zero address, or `isNative: true`):
+
+- **Without Bulker:** `WETH.deposit` → approve → `Comet.supply` on the way in; `Comet.withdraw` → `WETH.withdraw` on the way out.
+- **With Bulker:** native legs use `ACTION_SUPPLY_NATIVE_TOKEN` / `ACTION_WITHDRAW_NATIVE_TOKEN`.
+
+Do **not** ask the user to wrap first. Do **not** require `useBulker` for ETH.
+
+## Workflows
+
+### What can I borrow against an asset (read-only)
+
+Example: “What assets can I borrow against USDC on Ethereum using Compound III?”
+
+1. `load_defi_protocol({ protocolId: "compound-v3" })` then `get_defi_protocol_skill`.
+2. `ctm_compound_v3_fetch_markets` with `chainId` 1 (Ethereum). Do not guess collaterals from the web.
+3. Each Comet has **one borrowable base** and a list of **collateral** assets (`role`).
+   - “Borrow **against** USDC” → markets where USDC is `role = collateral`. The **base** of those markets is what you can borrow (e.g. cWETHv3 → WETH).
+   - “Borrow USDC” / “collateral to borrow USDC” → the market whose base is USDC (`cUSDCv3`). Assets with `role = collateral` are accepted collateral.
+4. `ctm_compound_v3_fetch_market` on the chosen `comet` for collateral factors and APRs.
+
+### Earn (supply base)
+
+1. `ctm_compound_v3_fetch_markets` — pick the Comet whose `baseToken` matches the token.
+2. `ctm_compound_v3_build_supply_multisign` with that `comet`, `asset`, `amountHuman`.
+
+### Borrow
+
+1. Supply collateral first (`build_supply_multisign` with a collateral `asset`).
+2. `ctm_compound_v3_fetch_account` — confirm `isBorrowCollateralized` and not `isLiquidatable`.
+3. `ctm_compound_v3_build_withdraw_multisign` with `asset` = **base token**. That withdraw **is** the borrow.
+
+### Repay then withdraw collateral
+
+1. `ctm_compound_v3_build_repay_multisign` (`asset` = base).
+2. `ctm_compound_v3_build_withdraw_multisign` (`asset` = collateral).
+
+### Combined (optional Bulker)
+
+```json
+{
+  "keyGenId": "<keygen-id>",
+  "chainId": 1,
+  "purposeText": "Supply WETH collateral and borrow USDC on Compound III",
+  "comet": "0xc3d688B66703497DAA19211EEdff47f25384cdc3",
+  "steps": [
+    { "action": "supply", "asset": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", "amountHuman": "0.1" },
+    { "action": "withdraw", "asset": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "amountHuman": "100" }
+  ]
+}
+```
+
+## Example: supply 0.001 ETH on Ethereum cWETHv3
+
+```json
+{
+  "keyGenId": "<keygen-id>",
+  "chainId": 1,
+  "purposeText": "Supply 0.001 ETH to Compound III cWETHv3",
+  "useCustomGas": true,
+  "comet": "0xA17581A9E3356d9A858b789D68B4d866e593aE94",
+  "asset": "0x0000000000000000000000000000000000000000",
+  "amountHuman": "0.001"
+}
+```
+
+## Troubleshooting
+
+| Symptom | Cause | Fix |
+|---------|--------|-----|
+| Unknown Comet | Guessed implementation address | Use `comet` from fetch_markets |
+| Not collateralized | Withdraw/borrow exceeds CF | Supply more collateral or repay |
+| Native max unwrap | `amountHuman: "max"` + ETH out | Pass an explicit amount |
+| No RPC | Chain not in node registry | Add the chain with `rpcGateway` |
+
+Supported live chains: Ethereum, Base, Arbitrum, Optimism, Polygon, Mantle, Unichain, Linea.

package/dist/agent/skills/continuum-dao/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: continuum-dao
+description: ContinuumDAO CTM lock, veCTM escrow, node attach, and Linea governance (Bravo/Delta propose, vote, execute, cancel).
+---
+
+# ContinuumDAO (MCP)
+
+## Chains
+
+- **Linea (59144) / Linea Sepolia (59141)** — create lock, escrow actions, attach veCTM, request detach, and governance.
+- **Ethereum mainnet (`chainId: 1`)** — CTM hold/transfer only. Governance is Linea-only.
+
+Addresses are placeholders until CTM / VotingEscrow / NodeProperties / Rewards / Governor are redeployed. Prefer live `GET https://app-api.continuumdao.org/protocol/dao|ve|networks` and pass `governor` when the constant is still zero. Do not submit write tools until the target address is non-zero.
+
+## Billing
+
+These tools build protocol batches only. Do **not** prepend MPA billing legs (`register`, `deposit`, `syncBilling`). Fee payment stays on Compose / credit modals.
+
+## Governance encoding
+
+One contract: `ContinuumDAO.propose`. Bravo vs Delta is encoding, not a separate function. Five UI types (Admin / Constitution / Decision / Election / Treasury) are backend tags; their **meaning** is the Constitution section **ContinuumDAO Proposals and Voting** (`get_continuum_doc` path `ContinuumDAO/Governance/Constitution`, `sectionId` `continuumdao-proposals-and-voting`). Load **`continuum-dao-proposal-standards`** and apply that fetch before choosing a type or appraising a proposal.
+
+- **Bravo:** `targets[] / values[] / calldatas[]` are the actions; on-chain `description` is the title. Empty user actions insert one succeeding no-op (`target = KeyGen ETH`, `value = 0`, `calldata = 0x`) so `targets.length >= 1` and `targets[0] != address(0)`.
+- **Delta:** slot 0 is metadata (`targets[0]=0`, `values[0]=0`, `calldatas[0]` = nOptions, nWinners, 1-indexed option starts). Remaining slots are flattened option actions. Empty options get the same no-op so start indices increment. Option **label** is required. Backend payload stores `actions: []` for empty options (user actions only).
+- **Delta vote:** `weights` must be **nOptions + 1**. The last slot is baked-in NOTA. Do not ship nOptions-only params.
+- **Queue is not implemented.** `queue()` reverts. Execute from `Succeeded`.
+
+After a propose multi-sign request is **mined**, call `ctm_continuum_dao_register_proposal` (`POST /proposals/create`) so [app.continuumdao.org/governance](https://app.continuumdao.org/governance) stays in sync. If the POST fails, retry — do not revert the chain tx. `onchainId` comes from `hashProposal` or `ProposalCreated`.
+
+`load_defi_protocol({ protocolId: "continuum-dao" })` loads escrow, attach, and governance together.
+
+## Chat: “What proposals are live now?”
+
+Do **not** answer from `ctm_continuum_dao_fetch_proposals` or backend `status` alone.
+
+1. `load_defi_protocol({ protocolId: "continuum-dao" })` if not already loaded.
+2. `ctm_continuum_dao_fetch_live_proposals({ chainId: 59144, rpcUrl })` (Linea Sepolia: `59141`). Get `rpcUrl` from the chain registry. Pass `governor` when the constant is still zero (from `GET https://app-api.continuumdao.org/protocol/dao`).
+3. Read the returned `note`, then the buckets:
+   - **`live`** — `state === Active` (voting now). This is the answer to “live now.”
+   - **`pending`** — proposed, voting has not started.
+   - **`readyToExecute`** — `Succeeded`. No queue. Offer `ctm_continuum_dao_build_execute_multisign`.
+   - **`recentlyCompleted`** — Canceled / Defeated / Expired / Executed in this scan.
+   - **`unknown`** — no on-chain overlay (missing governor/RPC, or a failed `state` read). Do not call these live.
+4. If `overlay` is `backend-only`, say you could not confirm live Governor state.
+
+For one proposal, call `ctm_continuum_dao_explain_proposal` and read `briefing` aloud (every action / Delta option, no-ops labeled signaling, C3 called out). Do not vote from this protocol skill.
+
+Operator presentation and vote policy live in the node catalogue (mpc-config): load skills **`continuum-dao-proposals`** and **`continuum-dao-vote-policy`** via `agent_load_skill`. To **create** a proposal in chat, load **`continuum-dao-compose-proposal`** (interactive only). Cron must never propose or load that skill — vote and governor Join only.
+
+When a proposal has a `forumKey`, fetch that thread (`ctm_continuum_dao_forum_resolve` then `forum_fetch_thread` / `forum_fetch_post`) before voting. Check `section` on the thread against the proposal type. List recent posts with `forum_recent` (`hours` or `since`; privilege-filtered, whole forum; id, title, username, createdAt), or find matching posts with `forum_search` (title of a new thread or body text, case-insensitive; optional `hours` / `since`), then `forum_fetch_post` on a returned `id`. Walk a user's posts with `forum_user_post_ids` then `forum_fetch_post`. Writes need a `ticket` from forum EIP-712 login. `forum_unread` / `forum_mark_read` / `forum_mark_unread` are **interactive inbox** tools (NodeBB Unread is per topic). Confirm before `forum_mark_read` with `all: true`. `forum_delete` is **admin/moderator only** (not the post owner): exactly one of `pid`, `tid`/`url`, or `username`; optional `hours` / `since` (default all). Confirm with the operator before deleting. Never from cron.
+
+**Classify first: Idea vs formal proposal.** An Idea/Suggestion is early discussion or feedback — not a Temperature Check. Post it with `forum_create_idea`. Do **not** use that URL as `forumKey`. A formal proposal belongs in a **Governance** section and must go on-chain.
+
+| Type | Forum `section` | Typical vote |
+|------|-----------------|--------------|
+| Decision | `decision` | Bravo |
+| Election | `election` | Delta |
+| Treasury | `treasury` | Bravo |
+| Constitution | `constitution` | Bravo (include the new Constitution text) |
+| Admin | `admin` | Bravo |
+
+**A proposal MUST have a Governance forum thread.** Never call `build_propose_*` or `register_proposal` with the homepage, an empty `forumKey`, or an Ideas thread. Required agent order:
+
+1. `forum_sign_in_eligible` then `build_forum_sign_in_multisign` (if no ticket).
+2. If it is only an idea: `forum_create_idea`. Stop (no propose).
+3. If it is a proposal: `forum_create_topic` with the matching Governance `section` (proposal-threshold veCTM). Keep the returned `url`.
+4. `build_propose_bravo_multisign` or `build_propose_delta_multisign` with that `url` as `forumKey`.
+5. After the propose tx is mined, `register_proposal` with the same `forumKey`.
+
+`forumKey` must match `/topic/:tid` or `/t/:tid` on forum.continuumdao.org. Builders and `register_proposal` throw otherwise.
+
+Forum KeyGen sign-in is EIP-712 multi-sign (no EVM tx). Always check eligibility first:
+
+1. `ctm_continuum_dao_forum_sign_in_eligible({ address })` — holder or attach-key veCTM vs `veCtmThresholdPower`. If `eligible` is false, stop. Do **not** compose a multi-sign request.
+2. `ctm_continuum_dao_build_forum_sign_in_multisign` also refuses ineligible addresses (same gate) so other nodes never enter the sign loop. Pass `nodeKey` (username = first 16 chars) or a `username` on first login.
+3. After the multi-sign request is signed, exchange the signature for a ticket (`/api/continuum/eip712/ticket`). Then `forum_reply` / `forum_react` / `forum_create_topic` / `forum_create_idea`.
+4. `ctm_continuum_dao_forum_sign_out({ ticket })` revokes the ticket and forum sessions. No multi-sign.
+
+Forum sign-in and sign-out are **agent/MCP only**. There is no Sign in / Sign out control in the node-app Compose header.
+
+Propose builders read live `proposalThreshold()` and refuse if `getVotes(KeyGen) < threshold`. On-chain rule (vectm `ContinuumDAO`): `max(1000 ether, 1% of past total voting power)`. Do not hardcode `1000`.
+
+## Tools
+
+| Intent | Tool |
+|--------|------|
+| Create lock | `ctm_continuum_dao_build_create_lock_multisign` |
+| Increase amount | `ctm_continuum_dao_build_increase_amount_multisign` |
+| Increase unlock time | `ctm_continuum_dao_build_increase_unlock_time_multisign` |
+| Split | `ctm_continuum_dao_build_split_multisign` |
+| Merge | `ctm_continuum_dao_build_merge_multisign` |
+| Withdraw | `ctm_continuum_dao_build_withdraw_multisign` |
+| Liquidate | `ctm_continuum_dao_build_liquidate_multisign` |
+| Delegate | `ctm_continuum_dao_build_delegate_multisign` |
+| Undelegate (delegate to self) | `ctm_continuum_dao_build_undelegate_multisign` |
+| Fetch current delegatee | `ctm_continuum_dao_fetch_delegates` |
+| Transfer NFT | `ctm_continuum_dao_build_transfer_multisign` |
+| Attach veCTM | `ctm_continuum_dao_build_attach_multisign` |
+| Request detach | `ctm_continuum_dao_build_request_detach_multisign` |
+| Propose Bravo | `ctm_continuum_dao_build_propose_bravo_multisign` |
+| Propose Delta | `ctm_continuum_dao_build_propose_delta_multisign` |
+| Vote Bravo | `ctm_continuum_dao_build_cast_vote_bravo_multisign` |
+| Vote Delta (+ NOTA) | `ctm_continuum_dao_build_cast_vote_delta_multisign` |
+| Execute | `ctm_continuum_dao_build_execute_multisign` |
+| Cancel | `ctm_continuum_dao_build_cancel_multisign` |
+| Register proposal (backend) | `ctm_continuum_dao_register_proposal` |
+| Fetch live / pending / executable | `ctm_continuum_dao_fetch_live_proposals` |
+| Explain / deconstruct one proposal | `ctm_continuum_dao_explain_proposal` |
+| Fetch raw backend list | `ctm_continuum_dao_fetch_proposals` |
+| Fetch one proposal | `ctm_continuum_dao_fetch_proposal` |
+| Fetch on-chain state | `ctm_continuum_dao_fetch_proposal_state` |
+| Fetch voting power | `ctm_continuum_dao_fetch_voting_power` |
+| Forum sign-in eligible? | `ctm_continuum_dao_forum_sign_in_eligible` |
+| Forum KeyGen sign-in | `ctm_continuum_dao_build_forum_sign_in_multisign` |
+| Forum sign-out | `ctm_continuum_dao_forum_sign_out` |
+| Resolve forum URL | `ctm_continuum_dao_forum_resolve` |
+| Fetch forum thread | `ctm_continuum_dao_forum_fetch_thread` |
+| Fetch one forum post | `ctm_continuum_dao_forum_fetch_post` |
+| Search forum (title/body, optional recency) | `ctm_continuum_dao_forum_search` |
+| Recent forum posts (id, title, username, createdAt; hours / since) | `ctm_continuum_dao_forum_recent` |
+| Admin/mod delete post, thread, or user posts | `ctm_continuum_dao_forum_delete` |
+| User post ids | `ctm_continuum_dao_forum_user_post_ids` |
+| Forum reply count | `ctm_continuum_dao_forum_reply_count` |
+| Forum reply | `ctm_continuum_dao_forum_reply` |
+| Forum react | `ctm_continuum_dao_forum_react` |
+| Create Governance proposal thread | `ctm_continuum_dao_forum_create_topic` |
+| Post Idea / Suggestion | `ctm_continuum_dao_forum_create_idea` |
+| Forum unread topics | `ctm_continuum_dao_forum_unread` |
+| Forum mark topic read | `ctm_continuum_dao_forum_mark_read` |
+| Forum mark topic unread | `ctm_continuum_dao_forum_mark_unread` |
+| Forum me / sections | `ctm_continuum_dao_forum_me` / `ctm_continuum_dao_forum_sections` |
+
+Attach requires the claimed `nodeWithdrawAuthority` KeyGen that owns the NFT. `groupId` is implicit from that KeyGen. You cannot replace an attached NFT — only governance detaches after `request detach`.
+
+Attached locks block transfer / merge / split / withdraw on-chain (`checkNotAttached`).
+
+Propose and vote use `getVotes` at the **KeyGen** address. If the KeyGen has delegated away (`fetch_delegates` → `self: false`), that power sits with the delegatee until `build_undelegate_multisign` (on-chain this is `delegate(self)`; there is no `undelegate()`). Attach-to-node is unrelated. Propose requires `getVotes(keyAddress) >= proposalThreshold()`. The live threshold is `max(1000e18 ve power, 1% of total voting power)`, not a flat 1000. `ctm_continuum_dao_build_propose_*` throws if the KeyGen is below the live bar.
+
+All `ctm_continuum_dao_build_*_multisign` tools return `{ requestId }` on success (shared gas/submit section appended by the server).

package/dist/agent/skills/morpho/SKILL.md

@@ -66,14 +66,17 @@ Do **not** use `ctm_arcus_build_deposit_multisign` for yield — that funds perp
 
 ## Morpho Midnight (fixed rate / fixed term)
 
-Midnight is a separate order-book primitive (not Blue). Users **take** existing offers via MidnightBundles. Launch liquidity is strongest on **Base (8453)** (e.g. cbBTC/USDC maturities).
+Midnight is a separate order-book primitive (not Blue). Users can **take** existing offers via MidnightBundles, or **post a lend offer** that parks the loan token in Morpho Blue (variable yield) until a borrower fills it. Launch liquidity is strongest on **Base (8453)** (e.g. cbBTC/USDC maturities).
 
 | Goal | Tool |
 |------|------|
 | List books | `ctm_morpho_fetch_midnight_books({ chainId: 8453, loan?, collateral?, side? })` |
 | Preview fill | `ctm_morpho_fetch_midnight_quote({ marketId, side: "asks"\|"bids", assets })` |
 | User positions | `ctm_morpho_fetch_midnight_positions({ user })` |
-| Lend (take asks) | `ctm_morpho_build_midnight_lend_multisign` |
+| Open lend offers | `ctm_morpho_fetch_midnight_offers({ user, chainId? })` |
+| Lend now (take asks) | `ctm_morpho_build_midnight_lend_multisign` |
+| Lend offer (earn until filled) | `ctm_morpho_build_midnight_lend_offer_multisign` |
+| Cancel lend offer + withdraw unused | `ctm_morpho_build_midnight_cancel_lend_offer_multisign` |
 | Borrow (collateral + take bids) | `ctm_morpho_build_midnight_borrow_multisign` |
 | Repay + withdraw collateral | `ctm_morpho_build_midnight_repay_multisign` |
 
@@ -81,11 +84,13 @@ Workflow:
 
 1. `ctm_morpho_fetch_midnight_books` — pick `marketId`, note `loanTokenAddress` / `primaryCollateralTokenAddress`, `lendApr` / `borrowApr`, maturity.
 2. Optional: `ctm_morpho_fetch_midnight_quote` with raw `assets` (loan token base units).
-3. Lend: `ctm_morpho_build_midnight_lend_multisign({ marketId, amountHuman, … })`.
-4. Borrow: `ctm_morpho_build_midnight_borrow_multisign({ marketId, borrowAmountHuman, collateralAmountHuman, collateralToken, … })`.
-5. Exit: `ctm_morpho_fetch_midnight_positions` → `ctm_morpho_build_midnight_repay_multisign({ marketId })`.
+3. Immediate lend: `ctm_morpho_build_midnight_lend_multisign({ marketId, amountHuman, … })`.
+4. Limit lend that earns while waiting: `ctm_morpho_build_midnight_lend_offer_multisign({ marketId, amountHuman, lendAprPct? })`. Funds are supplied to the deepest Blue market for that loan token via BlueBuyCallback.
+5. Borrow: `ctm_morpho_build_midnight_borrow_multisign({ marketId, borrowAmountHuman, collateralAmountHuman, collateralToken, … })`.
+6. Exit a matched borrow: `ctm_morpho_fetch_midnight_positions` → `ctm_morpho_build_midnight_repay_multisign({ marketId })`.
+7. Cancel an unfilled offer: `ctm_morpho_fetch_midnight_offers` → `ctm_morpho_build_midnight_cancel_lend_offer_multisign({ group, callback, callbackData })`.
 
-Server re-quotes at build time and fills `taker` / `onBehalf` from the executor. Maker offer posting is not supported.
+Server re-quotes at build time and fills `taker` / `maker` / `onBehalf` from the executor.
 
 ## MCP multisign tools
 
@@ -96,13 +101,16 @@ Server re-quotes at build time and fills `taker` / `onBehalf` from the executor.
 | `ctm_morpho_fetch_midnight_books` | List Midnight books |
 | `ctm_morpho_fetch_midnight_quote` | Quote Midnight fill |
 | `ctm_morpho_fetch_midnight_positions` | Midnight positions |
+| `ctm_morpho_fetch_midnight_offers` | Open Midnight lend offers |
 | `ctm_morpho_build_vault_deposit_multisign` | Vault deposit (listed V1 or V2) |
 | `ctm_morpho_build_vault_withdraw_multisign` | Vault withdraw |
 | `ctm_morpho_build_blue_collateral_deposit_multisign` | Blue supplyCollateral |
 | `ctm_morpho_build_blue_borrow_multisign` | Blue borrow |
 | `ctm_morpho_build_blue_repay_multisign` | Blue repay |
 | `ctm_morpho_build_blue_collateral_withdraw_multisign` | Blue withdrawCollateral |
-| `ctm_morpho_build_midnight_lend_multisign` | Midnight lend |
+| `ctm_morpho_build_midnight_lend_multisign` | Midnight lend now (take asks) |
+| `ctm_morpho_build_midnight_lend_offer_multisign` | Midnight lend offer (Blue yield until filled) |
+| `ctm_morpho_build_midnight_cancel_lend_offer_multisign` | Cancel Midnight lend offer |
 | `ctm_morpho_build_midnight_borrow_multisign` | Midnight borrow |
 | `ctm_morpho_build_midnight_repay_multisign` | Midnight repay + withdraw |
 | `ctm_morpho_build_merkl_claim_multisign` | Merkl claim |
@@ -116,7 +124,7 @@ Pass `marketId` from Morpho API for Blue/Midnight tools (not recomputed on-chain
 2. `ctm_morpho_fetch_earn_vaults` — pick `vaultAddress` and `underlyingAddress` by asset and/or name.
 3. `ctm_morpho_build_vault_deposit_multisign` — use each tool’s **input schema** (`keyGenId`, fetch output addresses, `amountHuman`, etc.). Server resolves `keyGen`, `executorAddress`, `rpcUrl`, `chainDetail`; agents must not pass those.
 4. Blue borrow/collateral: `marketId` from Morpho API; server resolves `marketParams`.
-5. Midnight: books → quote → lend/borrow/repay builders as above.
+5. Midnight: books → quote → lend now, lend offer (earn until filled), borrow, or cancel/repay as above.
 
 ## Troubleshooting
 

package/dist/buildBatch-CngvebiD.d.ts

@@ -0,0 +1,45 @@
+import { Address, PublicClient } from 'viem';
+import { M as MultisignBuildResult } from './types-PZrvtjv8.js';
+import { f as finalizeMultisign } from './envelope-C_bfuKab.js';
+import { b as EvmTxStep, a as EvmProtocolContext } from './types-RZWOTm8c.js';
+
+type EvmBatchMetaBuilder = (args: {
+    step: EvmTxStep;
+    index: number;
+    gasLimit: bigint;
+}) => Record<string, unknown>;
+type EvmBuildBatchArgs = {
+    context: EvmProtocolContext;
+    steps: EvmTxStep[];
+    purposeSuffix?: string;
+    buildBatchMeta: EvmBatchMetaBuilder;
+    /** First leg msgRaw without 0x prefix; defaults to first step calldata */
+    firstMsgRawNo0x?: string;
+    destinationAddress?: Address;
+    /** Top-level `value` on bodyForSign when the payable amount is not on the first leg */
+    payableValueWei?: bigint;
+    resolveGasLimit?: (args: {
+        step: EvmTxStep;
+        index: number;
+        estimatedGas: bigint;
+        publicClient: PublicClient;
+    }) => Promise<bigint> | bigint;
+    /** Override default `estimateGas` (e.g. trade-API gas, skip post-approve deposit estimate). */
+    estimateGasForStep?: (args: {
+        step: EvmTxStep;
+        index: number;
+        publicClient: PublicClient;
+        executor: Address;
+    }) => Promise<bigint> | bigint;
+};
+/**
+ * Build unsigned EVM txs, estimate gas, serialize, hash — then assemble mpc-auth body via core envelope.
+ */
+declare function buildEvmMultisignBatch(args: EvmBuildBatchArgs): Promise<MultisignBuildResult>;
+declare const evmChainCategoryModule: {
+    category: "evm";
+    finalizeMultisign: typeof finalizeMultisign;
+    buildEvmMultisignBatch: typeof buildEvmMultisignBatch;
+};
+
+export { type EvmBatchMetaBuilder as E, type EvmBuildBatchArgs as a, buildEvmMultisignBatch as b, evmChainCategoryModule as e };

package/dist/chains/evm/index.d.ts

@@ -1,47 +1,9 @@
-import { b as EvmTxStep, a as EvmProtocolContext } from '../../types-RZWOTm8c.js';
-export { E as EvmChainDetail, i as isEvmNativeToken, m as matchEvmTokenKind } from '../../types-RZWOTm8c.js';
+import { b as EvmTxStep } from '../../types-RZWOTm8c.js';
+export { E as EvmChainDetail, a as EvmProtocolContext, i as isEvmNativeToken, m as matchEvmTokenKind } from '../../types-RZWOTm8c.js';
+export { E as EvmBatchMetaBuilder, a as EvmBuildBatchArgs, b as buildEvmMultisignBatch, e as evmChainCategoryModule } from '../../buildBatch-CngvebiD.js';
 import { Address, PublicClient } from 'viem';
-import { M as MultisignBuildResult } from '../../types-PZrvtjv8.js';
-import { f as finalizeMultisign } from '../../envelope-C_bfuKab.js';
-
-type EvmBatchMetaBuilder = (args: {
-    step: EvmTxStep;
-    index: number;
-    gasLimit: bigint;
-}) => Record<string, unknown>;
-type EvmBuildBatchArgs = {
-    context: EvmProtocolContext;
-    steps: EvmTxStep[];
-    purposeSuffix?: string;
-    buildBatchMeta: EvmBatchMetaBuilder;
-    /** First leg msgRaw without 0x prefix; defaults to first step calldata */
-    firstMsgRawNo0x?: string;
-    destinationAddress?: Address;
-    /** Top-level `value` on bodyForSign when the payable amount is not on the first leg */
-    payableValueWei?: bigint;
-    resolveGasLimit?: (args: {
-        step: EvmTxStep;
-        index: number;
-        estimatedGas: bigint;
-        publicClient: PublicClient;
-    }) => Promise<bigint> | bigint;
-    /** Override default `estimateGas` (e.g. trade-API gas, skip post-approve deposit estimate). */
-    estimateGasForStep?: (args: {
-        step: EvmTxStep;
-        index: number;
-        publicClient: PublicClient;
-        executor: Address;
-    }) => Promise<bigint> | bigint;
-};
-/**
- * Build unsigned EVM txs, estimate gas, serialize, hash — then assemble mpc-auth body via core envelope.
- */
-declare function buildEvmMultisignBatch(args: EvmBuildBatchArgs): Promise<MultisignBuildResult>;
-declare const evmChainCategoryModule: {
-    category: "evm";
-    finalizeMultisign: typeof finalizeMultisign;
-    buildEvmMultisignBatch: typeof buildEvmMultisignBatch;
-};
+import '../../types-PZrvtjv8.js';
+import '../../envelope-C_bfuKab.js';
 
 /** Parse chain id for comparisons (decimal, 0x hex, CAIP-2 eip155:N, bigint). */
 declare function parseEvmChainIdToNumber(chainId: string | number | bigint | null | undefined): number;
@@ -91,4 +53,4 @@ declare function coingeckoPlatformForChainId(chainId: string | number): string |
 /** Curve router swap gas: chain cap when set, else 12/10 estimate bump. */
 declare function routerSwapGasLimitFromEstimate(estimatedGas: bigint, chainGasLimit?: number | null): bigint;
 
-export { COINGECKO_PLATFORM_BY_CHAIN_ID, type ConditionalApproveStep, type EvmBatchMetaBuilder, type EvmBuildBatchArgs, EvmProtocolContext, EvmTxStep, approveStepsToEvmTxSteps, buildConditionalErc20ApproveSteps, buildEvmMultisignBatch, coingeckoPlatformForChainId, evmChainCategoryModule, normalizeCurveRouterAmountString, normalizeHumanDecimalAmount, parseEvmChainIdToNumber, publicClientForRpc, resolveErc20Decimals, routerSwapGasLimitFromEstimate };
+export { COINGECKO_PLATFORM_BY_CHAIN_ID, type ConditionalApproveStep, EvmTxStep, approveStepsToEvmTxSteps, buildConditionalErc20ApproveSteps, coingeckoPlatformForChainId, normalizeCurveRouterAmountString, normalizeHumanDecimalAmount, parseEvmChainIdToNumber, publicClientForRpc, resolveErc20Decimals, routerSwapGasLimitFromEstimate };

package/dist/core/index.cjs

@@ -182,57 +182,60 @@ function eip712SignatureText(domain, primaryType) {
 function jsonStringifyForAudit(value) {
   return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
 }
-function eip712MsgRawHex(typedData, delivery) {
-  const envelope = {
+function eip712LegEnvelope(typedData, delivery, digest) {
+  return {
     version: 1,
-    ...typedData,
-    delivery
-  };
-  return viem.stringToHex(jsonStringifyForAudit(envelope));
-}
-function buildEip712MultisignBody(args) {
-  const { typedData, delivery } = args;
-  const digest = viem.hashTypedData({
+    digest,
     domain: typedData.domain,
     types: typedData.types,
     primaryType: typedData.primaryType,
-    message: typedData.message
-  });
-  const extraJSON = {
-    signRequestKind: EIP712_SIGN_REQUEST_KIND,
-    eip712: {
-      version: 1,
-      digest,
-      domain: typedData.domain,
-      types: typedData.types,
-      primaryType: typedData.primaryType,
-      message: typedData.message
-    },
+    message: typedData.message,
     delivery
   };
+}
+function eip712MsgRawHex(envelope) {
+  return viem.stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712Multisign(args) {
+  if (args.legs.length < 1) {
+    throw new Error("buildEip712Multisign requires at least one leg");
+  }
+  const eip712 = [];
+  const legs = args.legs.map((leg) => {
+    const digest = viem.hashTypedData({
+      domain: leg.typedData.domain,
+      types: leg.typedData.types,
+      primaryType: leg.typedData.primaryType,
+      message: leg.typedData.message
+    });
+    const envelope = eip712LegEnvelope(leg.typedData, leg.delivery, digest);
+    eip712.push(envelope);
+    return {
+      msgHash: msgHashNo0x(digest),
+      msgRaw: eip712MsgRawHex(envelope),
+      destinationAddress: args.destinationAddress,
+      signatureText: eip712SignatureText(leg.typedData.domain, leg.typedData.primaryType),
+      audit: {
+        kind: "EIP712",
+        primaryType: leg.typedData.primaryType,
+        deliveryKind: leg.delivery.kind,
+        ...leg.audit ?? {}
+      },
+      feeSnapshot: {}
+    };
+  });
   return finalizeMultisign({
     keyGen: args.keyGen,
     purposeText: args.purposeText,
     purposeSuffix: args.purposeSuffix,
     destinationChainID: args.destinationChainID,
     destinationAddress: args.destinationAddress,
-    extraJSON,
+    extraJSON: {
+      signRequestKind: EIP712_SIGN_REQUEST_KIND,
+      eip712
+    },
     expiryDate: args.expiryDate,
-    legs: [
-      {
-        msgHash: msgHashNo0x(digest),
-        msgRaw: eip712MsgRawHex(typedData, delivery),
-        destinationAddress: args.destinationAddress,
-        signatureText: eip712SignatureText(typedData.domain, typedData.primaryType),
-        audit: {
-          kind: "EIP712",
-          primaryType: typedData.primaryType,
-          deliveryKind: delivery.kind,
-          ...args.audit ?? {}
-        },
-        feeSnapshot: {}
-      }
-    ]
+    legs
   });
 }
 var PAYLOAD_SIGN_ED25519_REQUEST_KIND = "payload_sign_ed25519";
@@ -295,7 +298,8 @@ var DEFI_PROTOCOLS_WITH_30MIN_EXPIRY = /* @__PURE__ */ new Set([
   "gmx",
   "hyperliquid",
   "arcus",
-  "curve-dao"
+  "curve-dao",
+  "aerodrome"
 ]);
 function defiMultisignExpiryUnixSeconds(protocolId, explicitExpiryDate) {
   if (typeof explicitExpiryDate === "number" && Number.isFinite(explicitExpiryDate) && explicitExpiryDate > 0) {
@@ -315,7 +319,7 @@ exports.DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS = DEFAULT_DEFI_MULTISIGN_EXPIRY_SE
 exports.DEFI_PROTOCOLS_WITH_30MIN_EXPIRY = DEFI_PROTOCOLS_WITH_30MIN_EXPIRY;
 exports.EIP712_SIGN_REQUEST_KIND = EIP712_SIGN_REQUEST_KIND;
 exports.PAYLOAD_SIGN_ED25519_REQUEST_KIND = PAYLOAD_SIGN_ED25519_REQUEST_KIND;
-exports.buildEip712MultisignBody = buildEip712MultisignBody;
+exports.buildEip712Multisign = buildEip712Multisign;
 exports.buildPayloadSignEd25519MultisignBody = buildPayloadSignEd25519MultisignBody;
 exports.coreChainCategoryModule = coreChainCategoryModule;
 exports.defiMultisignExpiryUnixSeconds = defiMultisignExpiryUnixSeconds;