@ostraagent/mcp 0.1.0 → 0.1.1

package/dist/ostra-mcp.js

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 var define_OSTRA_PACKAGED_default;
 var init_define_OSTRA_PACKAGED = __esm({
   "<define:OSTRA_PACKAGED>"() {
-    define_OSTRA_PACKAGED_default = { version: "0.1.0", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xa455cbf5Aa10cE858f3b250dc791FCD900e950BC", vaultBeacon: "0xE9F525B9EaeE48d13AEd28fE146F48f2832a18a0", vaultFactory: "0x043a15c514CFE2c797d33520bFF91a5DCdbf2979", poolImplementation: "0xC04d4a222dC1C966640B977608bE29949b0648ec", poolBeacon: "0x30669Ca534921038a531BBE27116d85bB7406fFF", pool: "0x6ea80F2462e5Fd783B0Ec3B2c7BaC96795980CD6", splitFactory: "0xAAf54A483B2c7c2c5ecFc1eDED5ed1619C1bA882", beaconOwner: "0x55533a51d9bd9b06F2D179d919BB31995EF96E5e", launchpad: { hook: "0x63A784afb8905452aDceC471a45E555F5caE68cC", fees: "0x8e79671DC9729476614C78aFcf2345D4c1963801", launchpad: "0xfC57162C0e3f9773F97fEa8d276e957d7c43A6C5", creatorSplit: "0x987994dE6A1d5303B9e3F50977cB0321BA4D033B", dispatcher: "0x44Bb65164b2855f8E80B142d5Fb9bDb72E869986", locker: "0xb593812363bAd70Ee381c7B54c4FC82b0BA3A4A7", devBuy: "0x0e1Fd799E136dcfEcad5695B07Ac5DAc5B2fF4bc", vesting: "0xadD9C1995910457312c156E7D8120D1b447E179a", airdrop: "0xBC798D956aF4c2B104FFC6106d5322294Bc103bb", owner: "0x6569E27A95a6A3E92A311B4Cc6600fed56aA50A2" } }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz" };
+    define_OSTRA_PACKAGED_default = { version: "0.1.1", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xa455cbf5Aa10cE858f3b250dc791FCD900e950BC", vaultBeacon: "0xE9F525B9EaeE48d13AEd28fE146F48f2832a18a0", vaultFactory: "0x043a15c514CFE2c797d33520bFF91a5DCdbf2979", poolImplementation: "0xC04d4a222dC1C966640B977608bE29949b0648ec", poolBeacon: "0x30669Ca534921038a531BBE27116d85bB7406fFF", pool: "0x6ea80F2462e5Fd783B0Ec3B2c7BaC96795980CD6", splitFactory: "0xAAf54A483B2c7c2c5ecFc1eDED5ed1619C1bA882", beaconOwner: "0x55533a51d9bd9b06F2D179d919BB31995EF96E5e", launchpad: { hook: "0x63A784afb8905452aDceC471a45E555F5caE68cC", fees: "0x8e79671DC9729476614C78aFcf2345D4c1963801", launchpad: "0xfC57162C0e3f9773F97fEa8d276e957d7c43A6C5", creatorSplit: "0x987994dE6A1d5303B9e3F50977cB0321BA4D033B", dispatcher: "0x44Bb65164b2855f8E80B142d5Fb9bDb72E869986", locker: "0xb593812363bAd70Ee381c7B54c4FC82b0BA3A4A7", devBuy: "0x0e1Fd799E136dcfEcad5695B07Ac5DAc5B2fF4bc", vesting: "0xadD9C1995910457312c156E7D8120D1b447E179a", airdrop: "0xBC798D956aF4c2B104FFC6106d5322294Bc103bb", owner: "0x6569E27A95a6A3E92A311B4Cc6600fed56aA50A2" } }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz" };
   }
 });
 
@@ -13598,6 +13598,108 @@ var init_quote = __esm({
   }
 });
 
+// ../sdk/src/pairs.ts
+import { getAddress as getAddress9, parseAbi as parseAbi2, zeroAddress as zeroAddress6 } from "viem";
+function findLaunchPair(symbolOrAddress) {
+  const s = symbolOrAddress.trim();
+  if (/^0x[0-9a-fA-F]{40}$/.test(s)) {
+    const a = getAddress9(s);
+    return LAUNCH_PAIRS.find((q) => q.address === a) ?? null;
+  }
+  const u = s.toUpperCase();
+  return LAUNCH_PAIRS.find((q) => q.symbol === u) ?? null;
+}
+function launchPair(symbolOrAddress) {
+  const q = findLaunchPair(symbolOrAddress);
+  if (q === null) throw new RangeError(`${symbolOrAddress} is not a pair Ostra offers; the pairs are ${LAUNCH_PAIRS.map((x) => x.symbol).join(", ")}`);
+  return q;
+}
+async function readPairUsdPrice(client, quote) {
+  const block = await client.getBlock();
+  const now3 = Number(block.timestamp);
+  if (quote.feed === null) return { quote, priceE8: 100000000n, updatedAt: now3 };
+  const [decimals, round] = await Promise.all([
+    client.readContract({ address: quote.feed, abi: chainlinkAggregatorAbi, functionName: "decimals" }),
+    client.readContract({ address: quote.feed, abi: chainlinkAggregatorAbi, functionName: "latestRoundData" })
+  ]);
+  if (Number(decimals) !== 8) throw new Error(`the ${quote.symbol}/USD feed ${quote.feed} has ${decimals} decimals, not 8`);
+  const answer = round[1];
+  const updatedAt = Number(round[3]);
+  if (answer <= 0n) throw new Error(`the ${quote.symbol}/USD feed ${quote.feed} answers ${answer}`);
+  const maxAge = quote.kind === "stock" ? STOCK_PRICE_MAX_AGE : ETH_PRICE_MAX_AGE;
+  if (now3 - updatedAt > maxAge) {
+    throw new Error(`the ${quote.symbol}/USD price was last updated ${Math.round((now3 - updatedAt) / 3600)} hours ago, older than ${Math.round(maxAge / 3600)} hours; try again once the feed updates`);
+  }
+  let priceE8 = answer;
+  if (quote.kind === "stock") {
+    const multiplier = await client.readContract({ address: quote.address, abi: stockTokenAbi, functionName: "uiMultiplier" });
+    if (multiplier <= 0n) throw new Error(`${quote.symbol} reports a uiMultiplier of ${multiplier}`);
+    priceE8 = answer * multiplier / 10n ** 18n;
+  }
+  return { quote, priceE8, updatedAt };
+}
+function usdToQuoteUnits(usdE6, priceE8, decimals) {
+  if (usdE6 <= 0n) throw new RangeError("the amount in USD must be positive");
+  if (priceE8 <= 0n) throw new RangeError("the price must be positive");
+  return usdE6 * 10n ** BigInt(decimals) * 100n / priceE8;
+}
+var STOCK_PRICE_MAX_AGE, ETH_PRICE_MAX_AGE, stock, LAUNCH_PAIRS, stockTokenAbi;
+var init_pairs = __esm({
+  "../sdk/src/pairs.ts"() {
+    "use strict";
+    init_define_OSTRA_PACKAGED();
+    init_constants();
+    init_external_abi();
+    STOCK_PRICE_MAX_AGE = 4 * 86400;
+    ETH_PRICE_MAX_AGE = 86400 + 3600;
+    stock = (symbol, name, address4, feed) => ({
+      symbol,
+      name,
+      kind: "stock",
+      address: getAddress9(address4),
+      decimals: 18,
+      feed: getAddress9(feed)
+    });
+    LAUNCH_PAIRS = [
+      { symbol: "USDG", name: "Global Dollar", kind: "usdg", address: USDG, decimals: 6, feed: null },
+      { symbol: "ETH", name: "Ether", kind: "eth", address: zeroAddress6, decimals: 18, feed: CHAINLINK_ETH_USD },
+      stock("AAPL", "Apple", "0xaF3D76f1834A1d425780943C99Ea8A608f8a93f9", "0x6B22A786bAa607d76728168703a39Ea9C99f2cD0"),
+      stock("AMZN", "Amazon", "0x12f190a9F9d7D37a250758b26824B97CE941bF54", "0xD5a1508ceD74c084eBf3cBe853e2C968fB2a651C"),
+      stock("ASML", "ASML Holding", "0x47F93d52cBeC7C6D2CfC080e154002370a60dAEA", "0xB4106147E8cce40b7d46124090d373A71b70f87D"),
+      stock("BABA", "Alibaba Group", "0xad25Ac6C84D497db898fa1E8387bf6Af3532a1c4", "0x62Cc8F9b5f56a33c9C8A60c8B92779f523c4E984"),
+      stock("CLSK", "CleanSpark", "0xcBB95BBF36099d34dA091dc6Fa6F49EfA257Cee3", "0x810c12D3a554Bc47fd39597Fe3b3AAC4941F50eF"),
+      stock("COIN", "Coinbase", "0x6330D8C3178a418788dF01a47479c0ce7CCF450b", "0xA3a468A452940B7D6b69991207B508c609a98Ef2"),
+      stock("CRCL", "Circle Internet Group", "0xdF0992E440dD0be65BD8439b609d6D4366bf1CB5", "0x6652eDf64bA3731C4F2D3ce821A0Fb1f1f6b482a"),
+      stock("DELL", "Dell Technologies", "0x941AE714EC6D8130c7B75d67160Ca08f1e7d11Dd", "0x1C6c8cADBe02E19129c39dDB92281cE4c0bf206b"),
+      stock("EWY", "iShares MSCI South Korea ETF", "0x7f0aBeF0C07280F82c6a08ead09dEd6BAE2C13Fc", "0xEFdf54610B62A7753Ec30bDc380847c12D32e1D1"),
+      stock("GOOGL", "Alphabet", "0x2e0847E8910a9732eB3fb1bb4b70a580ADAD4FE3", "0xF6f373a037c30F0e5010d854385cA89185AE638b"),
+      stock("INTC", "Intel", "0xc72b96e0E48ecd4DC75E1e45396e26300BC39681", "0x3f390C5C24628Ac7C489515402235FeAD71D1913"),
+      stock("IONQ", "IonQ", "0x558378E000D634A36593E338eBacdd6207640EfE", "0x22EfeC4919baf55F360E0EDee4AbEB26DE4971eb"),
+      stock("META", "Meta", "0xc0D6457C16Cc70d6790Dd43521C899C87ce02f35", "0x7C38C00C30BEe9378381E7B6135d7283356D71b1"),
+      stock("MSFT", "Microsoft", "0xe93237C50D904957Cf27E7B1133b510C669c2e74", "0x45C3C877C15E6BA2EBB19eA114Ea508d14C1Af2E"),
+      stock("MSTR", "MicroStrategy", "0xec262a75e413fAfD0dF80480274532C79D42da09", "0x396118bdFB181e6240E74D243F266B061c0edc3D"),
+      stock("MU", "Micron Technology", "0xfF080c8ce2E5feadaCa0Da81314Ae59D232d4afD", "0x425EEFdCf05ed6526C3cE61Af99429A228a6d596"),
+      stock("NBIS", "Nebius Group", "0x9D9c6684F596F66a64C030B93A886D51Fd4D7931", "0xE1D87B116Ba0fe898998f1D140339D1fA1E09705"),
+      stock("NVDA", "Nvidia", "0xd0601CE157Db5bdC3162BbaC2a2C8aF5320D9EEC", "0x379EC4f7C378F34a1B47E4F3cbeBCbAC3E8E9F15"),
+      stock("ORCL", "Oracle", "0xb0992820E760d836549ba69BC7598b4af75dEE03", "0x0e6a64a2B58A6693a531E6c555f3A5d042eEA844"),
+      stock("PLTR", "Palantir Technologies", "0x894E1EC2D74FFE5AEF8Dc8A9e84686acCB964F2A", "0x820ABedFF239034956B7A9d2F0a331f9F075eB4c"),
+      stock("QQQ", "Invesco QQQ ETF", "0xD5f3879160bc7c32ebb4dC785F8a4F505888de68", "0x80901d846d5D7B030F26B480776EE3b29374C2ae"),
+      stock("RGTI", "Rigetti Computing", "0x284358abc07F9359f19f4b5b4aC91901Be2597Ba", "0x2A045cF1C49c61c166C036d2f06FA2D2d984f765"),
+      stock("RKLB", "Rocket Lab", "0x3b14C39E89D60D627b42a1A4CA45b5bb45Fc12e2", "0x045477BF65Aef6f4F2386ad0164579e48381CC74"),
+      stock("SGOV", "iShares 0-3 Month Treasury Bond ETF", "0x92FD66527192E3e61d4DDd13322Aa222DE86F9B5", "0xa0DF4ee0fFf975306345875E3548Fcc519577A11"),
+      stock("SLV", "iShares Silver Trust ETF", "0x411eFb0E7f985935DAec3D4C3ebaEa0d0AD7D89f", "0x209b73908e92Ae021826eD79609845451Ecba2ce"),
+      stock("SNDK", "SanDisk", "0xB90A19fF0Af67f7779afF50A882A9CfF42446400", "0xfb133Fa4B7b385802B693a293606682Df47109A3"),
+      stock("SPCX", "Space Exploration Technologies", "0x4a0E65A3EcceC6dBe60AE065F2e7bb85Fae35eEa", "0xB265810950ba6c5C0Ff821c9963014a56fD8Bffb"),
+      stock("SPY", "SPDR S&P 500 ETF", "0x117cc2133c37B721F49dE2A7a74833232B3B4C0C", "0x319724394D3A0e3669269846abE664Cd621f9f6A"),
+      stock("TSLA", "Tesla", "0x322F0929c4625eD5bAd873c95208D54E1c003b2d", "0x4A1166a659A55625345e9515b32adECea5547C38"),
+      stock("TSM", "Taiwan Semiconductor", "0x58FfE4a942d3885bAa22D7520691F611EF09e7AA", "0x874cF94aa8eC88Fd9560094dD065f2fB3E41Fc2F"),
+      stock("USAR", "USA Rare Earth", "0xd917B029C761D264c6A312BBbcDA868658eF86a6", "0xA994d3684e8400A6c8078226925779FdeE682DD9"),
+      stock("USO", "United States Oil Fund ETF", "0xa30FA36Db767ad9eD3f7a60fC79526fB4d56D344", "0x75a9c76Ef439e2C7c2E5a34Ab105EcFe3766431c")
+    ];
+    stockTokenAbi = parseAbi2(["function uiMultiplier() view returns (uint256)"]);
+  }
+});
+
 // ../sdk/src/browser.ts
 var init_browser = __esm({
   "../sdk/src/browser.ts"() {
@@ -13617,6 +13719,7 @@ var init_browser = __esm({
     init_lthash();
     init_messages();
     init_quote();
+    init_pairs();
     init_reads();
     init_relayer();
     init_wots();
@@ -13624,7 +13727,7 @@ var init_browser = __esm({
 });
 
 // ../sdk/src/deploy.ts
-import { concat as concat3, encodeDeployData, encodeFunctionData as encodeFunctionData5, getAddress as getAddress9, getContractAddress as getContractAddress2, keccak256 as keccak2569, numberToHex as numberToHex2 } from "viem";
+import { concat as concat3, encodeDeployData, encodeFunctionData as encodeFunctionData5, getAddress as getAddress10, getContractAddress as getContractAddress2, keccak256 as keccak2569, numberToHex as numberToHex2 } from "viem";
 var init_deploy = __esm({
   "../sdk/src/deploy.ts"() {
     "use strict";
@@ -13859,13 +13962,13 @@ var init_config = __esm({
 });
 
 // ../core/src/relay.ts
-import { decodeFunctionData as decodeFunctionData3, getAddress as getAddress10, isAddress as isAddress5 } from "viem";
+import { decodeFunctionData as decodeFunctionData3, getAddress as getAddress11, isAddress as isAddress5 } from "viem";
 import { x402Client, x402HTTPClient } from "@x402/core/client";
 import { toClientEvmSigner } from "@x402/evm";
 import { BatchSettlementEvmScheme } from "@x402/evm/batch-settlement/client";
 function address(value, what) {
   if (typeof value !== "string" || !isAddress5(value, { strict: false })) throw new Error(`${what} is not an address`);
-  return getAddress10(value);
+  return getAddress11(value);
 }
 function checkSplits(raw, what) {
   if (!Array.isArray(raw)) throw new Error(`${what} are not a list`);
@@ -13886,7 +13989,7 @@ function checkRelayerFacts(raw, want) {
   const f = raw;
   if (f === null || typeof f !== "object") throw new Error("the relayer's terms are not an object");
   if (f.chainId !== want.chainId) throw new Error(`the relayer serves chain ${String(f.chainId)}, not ${want.chainId}`);
-  if (address(f.token, "the relayer's token") !== getAddress10(want.token)) throw new Error(`the relayer serves token ${String(f.token)}, not ${want.token}`);
+  if (address(f.token, "the relayer's token") !== getAddress11(want.token)) throw new Error(`the relayer serves token ${String(f.token)}, not ${want.token}`);
   if (f.decimals !== TOKEN_DECIMALS) throw new Error(`the relayer's token has ${String(f.decimals)} decimals, not ${TOKEN_DECIMALS}`);
   if (address(f.priceFeed, "the relayer's price feed") !== CHAINLINK_ETH_USD) throw new Error(`the relayer prices from ${String(f.priceFeed)}, not the Chainlink ETH/USD feed ${CHAINLINK_ETH_USD}`);
   if (f.maxCalls !== MAX_RELAY_CALLS) throw new Error(`the relayer takes ${String(f.maxCalls)} calls per request, not ${MAX_RELAY_CALLS}`);
@@ -13914,10 +14017,10 @@ function relayerChannelDeposit(needed, vaultBalance, keep = 0n) {
 function relayerOfferProblem(r, want) {
   if (r.scheme !== "batch-settlement") return `the offer is ${r.scheme}, not batch-settlement`;
   if (r.network !== want.network) return `the offer is on ${r.network}, not ${want.network}`;
-  if (!isAddress5(r.asset, { strict: false }) || getAddress10(r.asset) !== getAddress10(want.config.token)) return `the offer is in ${r.asset}, not ${want.config.token}`;
-  if (!isAddress5(r.payTo, { strict: false }) || getAddress10(r.payTo) !== getAddress10(want.config.receiver)) return `the offer pays ${r.payTo}, not the relayer's split ${want.config.receiver}`;
+  if (!isAddress5(r.asset, { strict: false }) || getAddress11(r.asset) !== getAddress11(want.config.token)) return `the offer is in ${r.asset}, not ${want.config.token}`;
+  if (!isAddress5(r.payTo, { strict: false }) || getAddress11(r.payTo) !== getAddress11(want.config.receiver)) return `the offer pays ${r.payTo}, not the relayer's split ${want.config.receiver}`;
   const extra = r.extra ?? {};
-  if (typeof extra.receiverAuthorizer !== "string" || !isAddress5(extra.receiverAuthorizer, { strict: false }) || getAddress10(extra.receiverAuthorizer) !== getAddress10(want.config.receiverAuthorizer)) {
+  if (typeof extra.receiverAuthorizer !== "string" || !isAddress5(extra.receiverAuthorizer, { strict: false }) || getAddress11(extra.receiverAuthorizer) !== getAddress11(want.config.receiverAuthorizer)) {
     return `the offer's receiverAuthorizer is ${String(extra.receiverAuthorizer)}, not the relayer's vault ${want.config.receiverAuthorizer}`;
   }
   if (extra.withdrawDelay !== want.config.withdrawDelay) return `the offer's withdrawDelay is ${String(extra.withdrawDelay)}, not the relayer's ${want.config.withdrawDelay} s`;
@@ -13930,7 +14033,7 @@ function relayerOfferProblem(r, want) {
 }
 function openChannelCall(calls, vault, token) {
   for (const c of calls) {
-    if (getAddress10(c.to) !== getAddress10(vault)) continue;
+    if (getAddress11(c.to) !== getAddress11(vault)) continue;
     let decoded;
     try {
       decoded = decodeFunctionData3({ abi: ostraVaultAbi, data: c.data });
@@ -13945,7 +14048,7 @@ function openChannelCall(calls, vault, token) {
   }
   return null;
 }
-var RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS, MAX_STEPS, MAX_RESENDS, LANDED_TIMEOUT_MS, BPS_DENOMINATOR, now, LocalSender, RelayerUnavailableError, PendingSpendUnpaidError, RelayerError, RelayerStore, RelayerClient;
+var RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS, MAX_STEPS, MAX_RESENDS, LANDED_TIMEOUT_MS, OPEN_READ_TRIES, OPEN_READ_INTERVAL_MS, BPS_DENOMINATOR, now, LocalSender, RelayerUnavailableError, PendingSpendUnpaidError, RelayerError, RelayerStore, RelayerClient;
 var init_relay = __esm({
   "../core/src/relay.ts"() {
     "use strict";
@@ -13960,6 +14063,8 @@ var init_relay = __esm({
     MAX_STEPS = 8;
     MAX_RESENDS = 3;
     LANDED_TIMEOUT_MS = 6e4;
+    OPEN_READ_TRIES = 20;
+    OPEN_READ_INTERVAL_MS = 500;
     BPS_DENOMINATOR = 1e4;
     now = () => Math.floor(Date.now() / 1e3);
     LocalSender = class {
@@ -14014,7 +14119,7 @@ var init_relay = __esm({
       #name;
       constructor(agentFolder, chainId, token, relayerVault) {
         this.#folder = agentFolder.folder(RELAYER_DIR);
-        this.#name = `${chainId}-${getAddress10(token)}-${getAddress10(relayerVault)}.json`;
+        this.#name = `${chainId}-${getAddress11(token)}-${getAddress11(relayerVault)}.json`;
       }
       async load() {
         const text2 = await this.#folder.read(this.#name);
@@ -14099,7 +14204,7 @@ var init_relay = __esm({
           functionName: "splitAddress",
           args: [d.token, facts.vault, facts.splits.map((s) => s.recipient), facts.splits.map((s) => s.bps)]
         });
-        if (getAddress10(split) !== facts.split) throw new Error(`the relayer's split ${facts.split} is not the OstraSplit of its vault and splits (${split})`);
+        if (getAddress11(split) !== facts.split) throw new Error(`the relayer's split ${facts.split} is not the OstraSplit of its vault and splits (${split})`);
         this.#facts = facts;
         this.#store = new RelayerStore(this.#keys.folder, this.#config.chainId, d.token, facts.vault);
         return facts;
@@ -14121,7 +14226,7 @@ var init_relay = __esm({
             channel: String(open3.channel).toLowerCase(),
             amount: BigInt(String(open3.amount)),
             txHash: String(open3.txHash),
-            calls: Array.isArray(open3.calls) ? open3.calls.map((c) => ({ to: getAddress10(c.to), data: c.data })) : []
+            calls: Array.isArray(open3.calls) ? open3.calls.map((c) => ({ to: getAddress11(c.to), data: c.data })) : []
           }
         };
       }
@@ -14175,7 +14280,7 @@ var init_relay = __esm({
             continue;
           }
           const ch = await readChannel(this.#client, this.#config.deployment.batchSettlement, c.channel);
-          const usable = payer !== null && getAddress10(c.config.payer) === payer && getAddress10(c.config.receiverAuthorizer) === facts.vault && getAddress10(c.config.receiver) === facts.split && ch.pendingWithdrawal === null && ch.balance - BigInt(c.cumulative) >= amount;
+          const usable = payer !== null && getAddress11(c.config.payer) === payer && getAddress11(c.config.receiverAuthorizer) === facts.vault && getAddress11(c.config.receiver) === facts.split && ch.pendingWithdrawal === null && ch.balance - BigInt(c.cumulative) >= amount;
           if (!usable) {
             c.retired = true;
             await this.#save();
@@ -14243,7 +14348,7 @@ var init_relay = __esm({
         else this.#reserved.delete(reservation.channel);
       }
       async #post(calls, extra, headers = {}) {
-        const body = { calls: calls.map((c) => ({ to: getAddress10(c.to), data: c.data })) };
+        const body = { calls: calls.map((c) => ({ to: getAddress11(c.to), data: c.data })) };
         if (extra.prepay === true) body.prepay = true;
         if (extra.payer !== null) body.payer = extra.payer;
         if (extra.allowFailedSwaps === true) body.allowFailedSwaps = true;
@@ -14252,10 +14357,10 @@ var init_relay = __esm({
       /** The x402 HTTP client of relayer channel `c`: the stock batch-settlement client, the vault as payer, the channel's voucher key signing, never depositing. */
       #x402(c) {
         const voucherKey = this.#keys.channelVoucherSigner(this.#config.chainId, this.#config.deployment.token, c.config.salt);
-        if (voucherKey.address !== getAddress10(c.config.payerAuthorizer)) throw new Error(`the voucher key of relayer channel ${c.channel} is not derived from this machine's master seed`);
+        if (voucherKey.address !== getAddress11(c.config.payerAuthorizer)) throw new Error(`the voucher key of relayer channel ${c.channel} is not derived from this machine's master seed`);
         const client = this.#client;
         const payer = {
-          address: getAddress10(c.config.payer),
+          address: getAddress11(c.config.payer),
           signTypedData: () => Promise.reject(new Error("a vault never signs typed data")),
           readContract: (args) => client.readContract(args)
         };
@@ -14338,7 +14443,7 @@ var init_relay = __esm({
        * records it, and pays the open and the vault's debt with its first
        * voucher (the same request sent again).
        */
-      async #payOpen(calls, channel, paymentDue, debt) {
+      async #payOpen(calls, channel, openTx, paymentDue, debt) {
         const facts = await this.facts();
         const d = this.#config.deployment;
         const vault = await this.#buyerVault().vaultAddress();
@@ -14347,12 +14452,12 @@ var init_relay = __esm({
         const config = found.config;
         const id = channelId(config, this.#config.chainId, d.batchSettlement).toLowerCase();
         if (id !== channel.toLowerCase()) throw new Error(`the relayer reports channel ${channel}, but the open in the request is channel ${id}`);
-        if (getAddress10(config.receiver) !== facts.split || getAddress10(config.receiverAuthorizer) !== facts.vault || config.withdrawDelay !== facts.gracePeriodSeconds) {
+        if (getAddress11(config.receiver) !== facts.split || getAddress11(config.receiverAuthorizer) !== facts.vault || config.withdrawDelay !== facts.gracePeriodSeconds) {
           throw new Error(`channel ${channel} is not on the relayer's terms`);
         }
         const voucherKey = this.#keys.channelVoucherSigner(this.#config.chainId, d.token, config.salt);
-        if (voucherKey.address !== getAddress10(config.payerAuthorizer)) throw new Error(`the voucher key of relayer channel ${channel} is not derived from this machine's master seed`);
-        const ch = await readChannel(this.#client, d.batchSettlement, id);
+        if (voucherKey.address !== getAddress11(config.payerAuthorizer)) throw new Error(`the voucher key of relayer channel ${channel} is not derived from this machine's master seed`);
+        const ch = await this.#openedChannel(id, openTx);
         if (ch.balance !== found.amount || ch.pendingWithdrawal !== null) throw new Error(`relayer channel ${channel} does not hold its deposit of ${found.amount}`);
         const most = debt + await this.#spendBound();
         if (paymentDue > most) throw new Error(`the relayer asks ${formatTokenAmount(paymentDue)} for the open of channel ${channel}, more than an open's price and the vault's debt (${formatTokenAmount(most)})`);
@@ -14379,7 +14484,22 @@ var init_relay = __esm({
       /** Pays an open the relayer sent before payment that this machine did not pay (it stopped, or was restored from the seed). */
       async #payUnpaidOpen(unpaid, debt) {
         if (unpaid.calls.length === 0) throw new Error(`the relayer holds an unpaid open of channel ${unpaid.channel} without its calls; it cannot be paid from here`);
-        await this.#landed(await this.#payOpen(unpaid.calls, unpaid.channel, unpaid.amount, debt));
+        await this.#landed(await this.#payOpen(unpaid.calls, unpaid.channel, unpaid.txHash, unpaid.amount, debt));
+      }
+      /**
+       * Channel `id` as its open `openTx` left it: the open's receipt on this RPC
+       * first (it must have landed and succeeded), then reads until the channel
+       * shows on the node that answers, for at most OPEN_READ_TRIES reads.
+       */
+      async #openedChannel(id, openTx) {
+        await this.#landed(openTx);
+        const settlement = this.#config.deployment.batchSettlement;
+        let ch = await readChannel(this.#client, settlement, id);
+        for (let i = 1; i < OPEN_READ_TRIES && ch.balance === 0n && ch.pendingWithdrawal === null; i++) {
+          await new Promise((resolve) => setTimeout(resolve, OPEN_READ_INTERVAL_MS));
+          ch = await readChannel(this.#client, settlement, id);
+        }
+        return ch;
       }
       /** Waits until `hash` has a successful receipt on this RPC. */
       async #landed(hash) {
@@ -14431,7 +14551,7 @@ var init_relay = __esm({
             const b = answer.body;
             const error = typeof b?.error === "string" ? b.error : "";
             if (answer.status === 200 && typeof b?.txHash === "string") {
-              const hash = typeof b.paymentDue === "string" && typeof b.channel === "string" ? await this.#payOpen(calls, b.channel, BigInt(b.paymentDue), (await this.vaultState(await this.#buyerVault().vaultAddress())).debt) : b.txHash;
+              const hash = typeof b.paymentDue === "string" && typeof b.channel === "string" ? await this.#payOpen(calls, b.channel, b.txHash, BigInt(b.paymentDue), (await this.vaultState(await this.#buyerVault().vaultAddress())).debt) : b.txHash;
               await this.#landed(hash);
               return hash;
             }
@@ -14491,7 +14611,7 @@ var init_relay = __esm({
 });
 
 // ../core/src/channels.ts
-import { bytesToHex as bytesToHex7, decodeFunctionData as decodeFunctionData4, encodeFunctionData as encodeFunctionData6, getAddress as getAddress11, isAddress as isAddress6, parseAbiItem } from "viem";
+import { bytesToHex as bytesToHex7, decodeFunctionData as decodeFunctionData4, encodeFunctionData as encodeFunctionData6, getAddress as getAddress12, isAddress as isAddress6, parseAbiItem } from "viem";
 async function channelOpenedLogs(client, vault, channel, fromBlock, toBlock) {
   const out = [];
   for (let from = fromBlock; from <= toBlock; from += LOG_WINDOW_BLOCKS) {
@@ -14507,7 +14627,7 @@ function parseRecipients(input) {
   const out = [];
   for (const r of input) {
     if (!isAddress6(r.recipient, { strict: false })) throw new RangeError(`${r.recipient} is not an address`);
-    const recipient = getAddress11(r.recipient);
+    const recipient = getAddress12(r.recipient);
     if (BigInt(recipient) === 0n) throw new RangeError("a recipient must not be the zero address");
     if (!Number.isInteger(r.bps) || r.bps < 1 || r.bps > BPS_DENOMINATOR2) throw new RangeError(`the bps of ${recipient} must be an integer from 1 to ${BPS_DENOMINATOR2}`);
     if (seen.has(recipient)) throw new RangeError(`${recipient} is listed twice`);
@@ -14526,7 +14646,7 @@ function parseGracePeriod(seconds) {
 }
 async function splitAddress(client, config, vault, recipients) {
   const d = config.deployment;
-  return getAddress11(
+  return getAddress12(
     await client.readContract({
       address: d.splitFactory,
       abi: ostraSplitFactoryAbi,
@@ -14560,12 +14680,12 @@ async function recoverChannelConfig(client, config, vault, channel) {
     if (log2.transactionHash === null) continue;
     const tx = await client.getTransaction({ hash: log2.transactionHash });
     const calls = [];
-    if (tx.to !== null && tx.to !== void 0 && getAddress11(tx.to) === getAddress11(vault)) calls.push({ to: vault, data: tx.input });
-    if (tx.to !== null && tx.to !== void 0 && getAddress11(tx.to) === MULTICALL3) {
+    if (tx.to !== null && tx.to !== void 0 && getAddress12(tx.to) === getAddress12(vault)) calls.push({ to: vault, data: tx.input });
+    if (tx.to !== null && tx.to !== void 0 && getAddress12(tx.to) === MULTICALL3) {
       try {
         const decoded = decodeFunctionData4({ abi: multicall3Abi, data: tx.input });
         const inner = decoded.args[0];
-        for (const c of inner) if (getAddress11(c.target) === getAddress11(vault)) calls.push({ to: vault, data: c.callData });
+        for (const c of inner) if (getAddress12(c.target) === getAddress12(vault)) calls.push({ to: vault, data: c.callData });
       } catch {
       }
     }
@@ -14645,7 +14765,7 @@ var init_channels = __esm({
           const text2 = await this.#folder.read(name);
           if (text2 === void 0) continue;
           const record = this.#check(JSON.parse(text2), name);
-          if (record.chainId === chainId && getAddress11(record.token) === getAddress11(token)) out.push(record);
+          if (record.chainId === chainId && getAddress12(record.token) === getAddress12(token)) out.push(record);
         }
         return out.sort((x, y) => x.createdAt - y.createdAt);
       }
@@ -14693,8 +14813,8 @@ var init_channels = __esm({
           vault,
           channel: opening.channel,
           config: opening.config,
-          payee: getAddress11(o.receiverAuthorizer),
-          voucherKey: getAddress11(o.payerAuthorizer),
+          payee: getAddress12(o.receiverAuthorizer),
+          voucherKey: getAddress12(o.payerAuthorizer),
           deposit: o.amount.toString(),
           gracePeriod: o.withdrawDelay,
           recipients,
@@ -14730,7 +14850,7 @@ var init_channels = __esm({
       open(input) {
         return this.#serial(async () => {
           if (!isAddress6(input.payee, { strict: false })) throw new RangeError(`${input.payee} is not an address`);
-          const payee = getAddress11(input.payee);
+          const payee = getAddress12(input.payee);
           const deposit = parseTokenAmount(input.deposit);
           if (deposit === 0n) throw new RangeError("deposit must be greater than zero");
           const gracePeriod = parseGracePeriod(input.gracePeriod);
@@ -14739,8 +14859,8 @@ var init_channels = __esm({
           if (payeeVault === null) throw new Error(`${payee} is not an Ostra vault; open_channel pays Ostra vaults only (pay other sellers with pay)`);
           if (payeeVault.token !== this.#token()) throw new Error(`the payee vault holds ${payeeVault.token}, not ${this.#token()}`);
           if (input.receiver !== void 0 && recipients.length !== 0) throw new RangeError("a channel names its receiver or the recipients its split is derived from, not both");
-          const receiver = input.receiver !== void 0 ? getAddress11(input.receiver) : await splitAddress(this.#client, this.#config, payee, recipients);
-          if (receiver === getAddress11("0x0000000000000000000000000000000000000000")) throw new RangeError("the receiver must not be the zero address");
+          const receiver = input.receiver !== void 0 ? getAddress12(input.receiver) : await splitAddress(this.#client, this.#config, payee, recipients);
+          if (receiver === getAddress12("0x0000000000000000000000000000000000000000")) throw new RangeError("the receiver must not be the zero address");
           const salt = randomSalt();
           const voucher = this.#keys.channelVoucherSigner(this.#config.chainId, this.#token(), salt);
           const open3 = { payerAuthorizer: voucher.address, receiver, receiverAuthorizer: payee, withdrawDelay: gracePeriod, salt, amount: deposit };
@@ -14784,7 +14904,7 @@ var init_channels = __esm({
             const view2 = {
               channel: record.channel,
               payee: record.payee,
-              receiver: getAddress11(record.config.receiver),
+              receiver: getAddress12(record.config.receiver),
               gracePeriod: record.gracePeriod,
               voucherKey: record.voucherKey,
               closeRequested: record.closeRequested,
@@ -14821,11 +14941,11 @@ var init_channels = __esm({
             const cfg = config ?? await recoverChannelConfig(this.#client, this.#config, vault, channel);
             if (cfg === null) throw new Error(`channel ${channel} was not opened by this agent's vault`);
             const d = this.#config.deployment;
-            if (channelId(cfg, this.#config.chainId, d.batchSettlement).toLowerCase() !== channel || getAddress11(cfg.payer) !== vault || getAddress11(cfg.token) !== d.token) {
+            if (channelId(cfg, this.#config.chainId, d.batchSettlement).toLowerCase() !== channel || getAddress12(cfg.payer) !== vault || getAddress12(cfg.token) !== d.token) {
               throw new Error(`channel ${channel} was not opened by this agent's vault`);
             }
             const voucher = this.#keys.channelVoucherSigner(this.#config.chainId, d.token, cfg.salt);
-            if (voucher.address !== getAddress11(cfg.payerAuthorizer)) throw new Error(`channel ${channel} uses a voucher key this machine cannot derive`);
+            if (voucher.address !== getAddress12(cfg.payerAuthorizer)) throw new Error(`channel ${channel} uses a voucher key this machine cannot derive`);
             const ch = await this.#read(channel);
             const open3 = {
               payerAuthorizer: cfg.payerAuthorizer,
@@ -14903,7 +15023,7 @@ var init_channels = __esm({
           sent,
           ...extra
         });
-        if (getAddress11(record.config.payer) !== getAddress11(record.vault)) throw new Error(`channel ${channel} does not belong to this vault's record`);
+        if (getAddress12(record.config.payer) !== getAddress12(record.vault)) throw new Error(`channel ${channel} does not belong to this vault's record`);
         for (let i = 0; i < MAX_STEPS_PER_CALL; i++) {
           const ch = await this.#read(channel);
           const status = channelStatus(ch);
@@ -14918,7 +15038,7 @@ var init_channels = __esm({
           try {
             if (status === "open") {
               const voucher = this.voucherSigner(record);
-              if (voucher.address !== getAddress11(record.config.payerAuthorizer)) throw new Error(`the voucher key of channel ${channel} could not be derived`);
+              if (voucher.address !== getAddress12(record.config.payerAuthorizer)) throw new Error(`the voucher key of channel ${channel} could not be derived`);
               const amount = ch.balance - ch.totalClaimed;
               const closeNonce = await this.#client.readContract({ address: record.vault, abi: ostraVaultAbi, functionName: "closeNonce", args: [channel] });
               const deadline = await chainTime(this.#client) + CLOSE_REQUEST_TTL_SECONDS;
@@ -15108,14 +15228,14 @@ var init_passkey = __esm({
 });
 
 // ../core/src/keys.ts
-import { bytesToHex as bytesToHex9, getAddress as getAddress12, hexToBytes as hexToBytes7 } from "viem";
+import { bytesToHex as bytesToHex9, getAddress as getAddress13, hexToBytes as hexToBytes7 } from "viem";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 function chainBytes(chainId) {
   if (!Number.isSafeInteger(chainId) || chainId <= 0) throw new RangeError("chainId must be a positive integer");
   return hexToBytes7(`0x${BigInt(chainId).toString(16).padStart(64, "0")}`);
 }
 function tokenBytes(token) {
-  return hexToBytes7(getAddress12(token));
+  return hexToBytes7(getAddress13(token));
 }
 function u64Be(value) {
   if (value < 0n || value > U64_MAX5) throw new RangeError("index out of range");
@@ -15207,7 +15327,7 @@ var init_keys = __esm({
        * payer and the WOTS store stay the agent's.
        */
       async forPrivateVault(chainId, token, index) {
-        const folder = this.#root.folder(PRIVATE_DIR).folder(`${chainId}-${getAddress12(token)}-${index}`);
+        const folder = this.#root.folder(PRIVATE_DIR).folder(`${chainId}-${getAddress13(token)}-${index}`);
         await folder.ensure();
         return new _Keys({ master: this.#master, feePayer: this.feePayer, store: this.store, folder, root: this.#root, backupExported: this.#backupExported, escrow: this.escrow });
       }
@@ -15218,7 +15338,7 @@ var init_keys = __esm({
        * agent's folder (ShieldService takes the agent's keys).
        */
       async forCreatorVault(chainId, token) {
-        const folder = this.#root.folder(CREATOR_DIR).folder(`${chainId}-${getAddress12(token)}`);
+        const folder = this.#root.folder(CREATOR_DIR).folder(`${chainId}-${getAddress13(token)}`);
         await folder.ensure();
         return new _Keys({ master: this.#master, feePayer: this.feePayer, store: this.store, folder, root: this.#root, backupExported: this.#backupExported, escrow: this.escrow });
       }
@@ -15299,13 +15419,13 @@ var init_keys = __esm({
 });
 
 // ../core/src/pools.ts
-import { getAddress as getAddress13, isAddress as isAddress7, zeroAddress as zeroAddress6 } from "viem";
+import { getAddress as getAddress14, isAddress as isAddress7, zeroAddress as zeroAddress7 } from "viem";
 function iso(seconds) {
   return new Date(Number(seconds) * 1e3).toISOString();
 }
 function launchedTokenAddress(text2, what = "token") {
   if (!isAddress7(text2, { strict: false })) throw new RangeError(`${what} ${text2} is not an address`);
-  return getAddress13(text2);
+  return getAddress14(text2);
 }
 async function readLaunchedPool(client, lp, tokenText) {
   const token = launchedTokenAddress(tokenText);
@@ -15318,13 +15438,13 @@ async function readLaunchedPool(client, lp, tokenText) {
   return { token, id, key, config };
 }
 function quoteOfPool(pool) {
-  return getAddress13(pool.config.tokenIs0 ? pool.key.currency1 : pool.key.currency0);
+  return getAddress14(pool.config.tokenIs0 ? pool.key.currency1 : pool.key.currency0);
 }
 async function readPoolView(client, lp, tokenText) {
   const pool = await readLaunchedPool(client, lp, tokenText);
   const c = pool.config;
   const quote = quoteOfPool(pool);
-  const quoteDecimals = quote === zeroAddress6 ? 18 : await tokenDecimals(client, quote);
+  const quoteDecimals = quote === zeroAddress7 ? 18 : await tokenDecimals(client, quote);
   const read = (address4, abi, functionName, args = []) => client.readContract({ address: address4, abi, functionName, args });
   const [state, rates, tick, name, symbol, round, available, nextAmount, shares, maxWallet, limitsReleased] = await Promise.all([
     read(lp.hook, ostraHookAbi, "poolState", [pool.id]),
@@ -15352,7 +15472,7 @@ async function readPoolView(client, lp, tokenText) {
     name,
     symbol,
     quote,
-    creatorVault: getAddress13(c.creatorVault),
+    creatorVault: getAddress14(c.creatorVault),
     graduated: state.graduated,
     tokensSold: formatUnitsAmount(state.tokensSold < 0n ? 0n : state.tokensSold, 18),
     quoteRaised: fmtQuote(state.quoteRaised),
@@ -15364,7 +15484,7 @@ async function readPoolView(client, lp, tokenText) {
     sellTaxBps: Number(rates[1]),
     antiSnipeBps: Number(rates[2]),
     maxBuy: c.maxBuy === 0n ? null : formatUnitsAmount(c.maxBuy, 18),
-    dividendToken: getAddress13(c.dividendToken) === zeroAddress6 ? null : getAddress13(c.dividendToken),
+    dividendToken: getAddress14(c.dividendToken) === zeroAddress7 ? null : getAddress14(c.dividendToken),
     launchedAt: iso(BigInt(c.launchedAt)),
     airdrop: {
       round: round.number,
@@ -15375,7 +15495,7 @@ async function readPoolView(client, lp, tokenText) {
       available: formatUnitsAmount(available, 18),
       nextRoundAmount: formatUnitsAmount(nextAmount, 18)
     },
-    creatorShares: shares[0].map((recipient, i) => ({ recipient: getAddress13(recipient), bps: Number(shares[1][i]) })),
+    creatorShares: shares[0].map((recipient, i) => ({ recipient: getAddress14(recipient), bps: Number(shares[1][i]) })),
     rules: {
       quoteDecimals,
       supply: formatUnitsAmount(state.supply, 18),
@@ -15516,7 +15636,7 @@ var init_publish = __esm({
 });
 
 // ../core/src/pending.ts
-import { zeroAddress as zeroAddress7 } from "viem";
+import { zeroAddress as zeroAddress8 } from "viem";
 function decodeVaultSpendHeader(message) {
   const s = decodeVaultSpendMessage(message);
   return { chainId: s.chainId, vault: s.vault, nonce: s.nonce, nextKeyRoot: s.nextKeyRoot, action: s.action };
@@ -15537,7 +15657,7 @@ function decodeVaultOpenChannelMessage(message) {
 function decodeVaultSetCrankKeyMessage(message) {
   const { header, params } = decodeAs(message, VAULT_ACTION.SET_CRANK_KEY);
   const crank = decodeSetCrankParams(params);
-  return { ...header, crank: crank === zeroAddress7 ? null : crank };
+  return { ...header, crank: crank === zeroAddress8 ? null : crank };
 }
 var init_pending = __esm({
   "../core/src/pending.ts"() {
@@ -15548,7 +15668,7 @@ var init_pending = __esm({
 });
 
 // ../core/src/vault.ts
-import { bytesToHex as bytesToHex10, encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData7, getAddress as getAddress14, isAddress as isAddress8, keccak256 as keccak25610, zeroAddress as zeroAddress8 } from "viem";
+import { bytesToHex as bytesToHex10, encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData7, getAddress as getAddress15, isAddress as isAddress8, keccak256 as keccak25610, zeroAddress as zeroAddress9 } from "viem";
 function spendGas(calls) {
   return calls.reduce((gas, c) => gas + reservedSwapGas(c), VAULT_SPEND_GAS);
 }
@@ -15591,10 +15711,11 @@ var init_vault = __esm({
       #onChannelOpening = null;
       constructor(client, transport, config, keys, sender, kind = "buyer", privateIndex = null, vaultToken = null) {
         if (kind === "private" !== (privateIndex !== null)) throw new Error("a private vault, and only a private vault, has an index");
-        if (kind === "token" !== (vaultToken !== null)) throw new Error("a token vault, and only a token vault, names its token");
-        if (vaultToken !== null && getAddress14(vaultToken) === config.deployment.token) throw new Error(`the vault in ${vaultToken} is the buyer vault, not a token vault`);
+        if (kind === "token" && vaultToken === null) throw new Error("a token vault names its token");
+        if (vaultToken !== null && kind !== "token" && kind !== "creator") throw new Error("only a token vault or a creator vault names its token");
+        if (vaultToken !== null && getAddress15(vaultToken) === config.deployment.token) throw new Error(`the vault in ${vaultToken} is the ${kind === "creator" ? "USDG creator vault, named without a token" : "buyer vault, not a token vault"}`);
         this.kind = kind;
-        this.token = vaultToken === null ? config.deployment.token : getAddress14(vaultToken);
+        this.token = vaultToken === null ? config.deployment.token : getAddress15(vaultToken);
         this.privateIndex = privateIndex;
         this.#client = client;
         this.#transport = transport;
@@ -15603,17 +15724,21 @@ var init_vault = __esm({
         this.#sender = sender;
         const token = this.token;
         this.#keychain = kind === "buyer" || kind === "token" ? keys.vaultKeychain(config.chainId, token) : kind === "seller" ? keys.sellerKeychain(config.chainId, token) : kind === "creator" ? keys.creatorKeychain(config.chainId, token) : keys.privateVaultKeychain(config.chainId, token, privateIndex);
-        this.#initCrank = kind === "seller" ? null : zeroAddress8;
+        this.#initCrank = kind === "seller" ? null : zeroAddress9;
       }
       /** Seller vault: the crank it is (or will be) created with, which is part of its address. */
       setInitCrank(crank) {
         if (this.kind !== "seller") throw new Error(`the ${this.kind} vault is created without a crank`);
         if (!isAddress8(crank, { strict: false })) throw new RangeError("a crank is an address");
-        this.#initCrank = getAddress14(crank);
+        this.#initCrank = getAddress15(crank);
+      }
+      /** A vault in the deployment's token (USDG); else a token vault or a pair's creator vault, paid for by the buyer vault. */
+      #inUsdg() {
+        return this.token === this.#config.deployment.token;
       }
       #missing() {
         if (this.kind === "private") return `private vault ${this.privateIndex} does not exist yet; unshield creates it`;
-        if (this.kind === "creator") return "this agent has no creator vault yet; open it before a launch names it";
+        if (this.kind === "creator") return `this agent has no creator vault${this.#inUsdg() ? "" : ` in ${this.token}`} yet; open it before a launch names it`;
         if (this.kind === "token") return `this agent has no vault in ${this.token} yet; buying the token creates it`;
         return this.kind === "buyer" ? "this agent has no vault yet; call open_vault first" : "this agent has no seller vault yet; call accept_payments first";
       }
@@ -15645,10 +15770,10 @@ var init_vault = __esm({
           return null;
         }
         const r = JSON.parse(text2);
-        if (r.chainId !== this.#config.chainId || typeof r.token !== "string" || getAddress14(r.token) !== this.token || typeof r.vault !== "string" || !isAddress8(r.vault, { strict: false })) {
+        if (r.chainId !== this.#config.chainId || typeof r.token !== "string" || getAddress15(r.token) !== this.token || typeof r.vault !== "string" || !isAddress8(r.vault, { strict: false })) {
           throw new Error(`${this.#adoptedName()} is not a recovered vault of chain ${this.#config.chainId} in ${this.token}`);
         }
-        this.#adopted = getAddress14(r.vault);
+        this.#adopted = getAddress15(r.vault);
         return this.#adopted;
       }
       async vaultAddress() {
@@ -15679,6 +15804,7 @@ var init_vault = __esm({
       }
       async #checkToken() {
         if (this.kind === "token") throw new Error(`the vault in ${this.token} spends only through its token operations (sell, transfer, claim dividends)`);
+        if (!this.#inUsdg()) throw new Error(`the creator vault in ${this.token} spends only through the launchpad (launch, pool settings, creator_withdraw)`);
         const decimals = await tokenDecimals(this.#client, this.#config.deployment.token);
         if (decimals !== TOKEN_DECIMALS) throw new Error(`token ${this.#config.deployment.token} has ${decimals} decimals; this package supports ${TOKEN_DECIMALS}`);
       }
@@ -15720,7 +15846,7 @@ var init_vault = __esm({
       }
       /** The vaults that open relayer channels and pay their own requests: the buyer, a private and the creator vault (not the seller vault nor a token vault). */
       #paysRelayer() {
-        return this.kind !== "seller" && this.kind !== "token";
+        return this.kind !== "seller" && this.kind !== "token" && this.#inUsdg();
       }
       #options(extra = {}) {
         const openChannel = this.#opener();
@@ -15739,7 +15865,7 @@ var init_vault = __esm({
       open() {
         return this.#serial(async () => {
           if (this.kind === "private") throw new Error("a private vault is created by unshield, together with the leaf spent into it");
-          if (this.kind !== "token") await this.#checkToken();
+          if (this.kind !== "token" && this.#inUsdg()) await this.#checkToken();
           const vault = await this.vaultAddress();
           const token = this.token;
           const softLimit = formatTokenAmount(VAULT_SOFT_LIMIT);
@@ -15750,9 +15876,9 @@ var init_vault = __esm({
             return found;
           }
           await this.requireEth(CREATE_VAULT_GAS, "open the vault");
-          const txHash = await this.#sender.send([await this.createCall()], this.#options({ prepay: this.kind === "seller" || this.kind === "token" }));
+          const txHash = await this.#sender.send([await this.createCall()], this.#options({ prepay: this.kind === "seller" || !this.#paysRelayer() }));
           const result = { vault, token, nonce: "0", created: true, txHash, softLimit };
-          if (this.#sender.relayed && (this.kind === "buyer" || this.kind === "creator")) {
+          if (this.#sender.relayed && (this.kind === "buyer" || this.kind === "creator") && this.#paysRelayer()) {
             result.note = "the Ostra relayer paid the vault's creation; the vault owes that price, paid with the first voucher of its channel to the relayer, which this server opens from the vault once it holds tokens (nothing else is relayed for the vault until then)";
           }
           if (!await this.#keys.backupExported()) result.backupReminder = BACKUP_REMINDER;
@@ -15803,6 +15929,7 @@ var init_vault = __esm({
       status() {
         return this.#serial(async () => {
           if (this.kind === "token") throw new Error(`the vault in ${this.token} is read with its token's tools (token_vault)`);
+          if (!this.#inUsdg()) throw new Error(`the creator vault in ${this.token} is read with the launchpad's pair tools`);
           const vault = await this.vaultAddress();
           const token = this.#config.deployment.token;
           const v = await this.#read(vault);
@@ -15872,7 +15999,7 @@ var init_vault = __esm({
           throw new Error("the stored signature does not belong to this vault and nonce");
         }
         const token = this.#config.deployment.token;
-        if (header.action === VAULT_ACTION.TRANSFER && this.kind !== "token") {
+        if (header.action === VAULT_ACTION.TRANSFER && this.#inUsdg()) {
           const t = decodeVaultTransferMessage(message);
           await this.#notFrozen(t.to, "the destination of a withdrawal signed earlier,");
           const params = transferParams({ to: t.to, amount: t.amount });
@@ -15890,7 +16017,7 @@ var init_vault = __esm({
         }
         if (header.action === VAULT_ACTION.SET_CRANK_KEY) {
           const { crank, nextKeyRoot } = decodeVaultSetCrankKeyMessage(message);
-          const params = setCrankParams(crank ?? zeroAddress8);
+          const params = setCrankParams(crank ?? zeroAddress9);
           const txHash2 = await sender.send([spendCall(vault, { action: VAULT_ACTION.SET_CRANK_KEY, nextKeyRoot, params, signature })], { reservation });
           return { operation: "set_crank", txHash: txHash2, crank };
         }
@@ -15898,7 +16025,7 @@ var init_vault = __esm({
           const s2 = decodeVaultSpendMessage(message);
           const { devBuy, launchHash: hash } = decodeDevBuyParams(s2.params);
           const lp = this.#config.deployment.launchpad;
-          if (lp === void 0 || getAddress14(devBuy) !== lp.devBuy) throw new Error(`the vault signed a DevBuy for ${devBuy}, not this deployment's OstraDevBuy`);
+          if (lp === void 0 || getAddress15(devBuy) !== lp.devBuy) throw new Error(`the vault signed a DevBuy for ${devBuy}, not this deployment's OstraDevBuy`);
           const l = await this.#signedLaunch(vault, v.nonce, hash);
           const call = { to: lp.devBuy, data: launchFromVaultData(l.launch, l.dev, { nextKeyRoot: s2.nextKeyRoot, signature }) };
           const txHash2 = await sender.send([call], { reservation, value: LAUNCHPAD.FEE_WEI });
@@ -16001,8 +16128,8 @@ the signed ${op.what} is kept; the next call on this vault sends it again before
           const amount = parseTokenAmount(amountText);
           if (amount === 0n) throw new RangeError("amount must be greater than zero");
           if (!isAddress8(destinationText, { strict: false })) throw new RangeError(`${destinationText} is not an address`);
-          const destination = getAddress14(destinationText);
-          if (destination === zeroAddress8) throw new RangeError("the destination must not be the zero address");
+          const destination = getAddress15(destinationText);
+          if (destination === zeroAddress9) throw new RangeError("the destination must not be the zero address");
           await this.#checkToken();
           const vault = await this.vaultAddress();
           if (await this.#read(vault) === null) throw new Error(this.#missing());
@@ -16052,7 +16179,7 @@ the signed withdrawal is kept; the next withdraw or open_channel call sends it a
           if (this.kind === "seller") throw new Error("channels are not opened from the seller vault");
           await this.#checkToken();
           const vault = await this.vaultAddress();
-          if (getAddress14(open3.receiverAuthorizer) === vault || getAddress14(open3.receiver) === vault) throw new Error("the channel would pay this agent's own vault");
+          if (getAddress15(open3.receiverAuthorizer) === vault || getAddress15(open3.receiver) === vault) throw new Error("the channel would pay this agent's own vault");
           if (await this.#read(vault) === null) throw new Error(this.#missing());
           await this.requireEth(VAULT_SPEND_GAS, "send the vault operation");
           return this.#paidSpend(this.#sender, async (sender, reservation) => {
@@ -16126,8 +16253,8 @@ the signed channel open is kept; the next open_channel or withdraw call sends it
       setCrankKey(crankText, via) {
         return this.#serial(async () => {
           if (!isAddress8(crankText, { strict: false })) throw new RangeError("a crank is an address");
-          const crank = getAddress14(crankText);
-          const target = crank === zeroAddress8 ? null : crank;
+          const crank = getAddress15(crankText);
+          const target = crank === zeroAddress9 ? null : crank;
           const vault = await this.vaultAddress();
           if (await this.#read(vault) === null) throw new Error(this.#missing());
           const chosen = via ?? this.#sender;
@@ -16214,8 +16341,8 @@ the signed operation is kept; the next call on this vault sends it again before
       /** Adds (enabled) or removes a guardian of this vault: another Ostra vault keeps the recovery post-quantum. */
       async setGuardian(guardianText, enabled, via) {
         if (!isAddress8(guardianText, { strict: false })) throw new RangeError(`${guardianText} is not an address`);
-        const guardian = getAddress14(guardianText);
-        if (guardian === zeroAddress8) throw new RangeError("a guardian is not the zero address");
+        const guardian = getAddress15(guardianText);
+        if (guardian === zeroAddress9) throw new RangeError("a guardian is not the zero address");
         return this.#recoverySpend(
           (v) => signVaultSetGuardian(this.#keychain, v, { chainId: this.#config.chainId, guardian, enabled }),
           async (_v, vault) => {
@@ -16260,7 +16387,7 @@ the signed operation is kept; the next call on this vault sends it again before
       /** As a guardian (this vault), supports moving `vaultText` to `newKeyRootText` (the key root its owner's new device gave). */
       async supportRecovery(vaultText, newKeyRootText, via) {
         if (!isAddress8(vaultText, { strict: false })) throw new RangeError(`${vaultText} is not an address`);
-        const target = getAddress14(vaultText);
+        const target = getAddress15(vaultText);
         if (!/^0x[0-9a-fA-F]{64}$/.test(newKeyRootText) || /^0x0{64}$/.test(newKeyRootText)) throw new RangeError("the new key root is 32 bytes of 0x hex, not zero");
         const newKeyRoot = newKeyRootText.toLowerCase();
         return this.#recoverySpend(
@@ -16289,7 +16416,7 @@ the signed operation is kept; the next call on this vault sends it again before
         return this.#serial(async () => {
           if (this.kind === "private") throw new Error("a private vault is recovered with the seed that unshielded it");
           if (!isAddress8(vaultText, { strict: false })) throw new RangeError(`${vaultText} is not an address`);
-          const vault = getAddress14(vaultText);
+          const vault = getAddress15(vaultText);
           const v = await readVault(this.#client, this.#config.deployment, vault);
           if (v === null || v.token !== this.token) throw new Error(`${vault} is not an Ostra vault in ${this.token}`);
           const adopted = await this.#adoptedVault();
@@ -16347,7 +16474,7 @@ the signed operation is kept; the next call on this vault sends it again before
 });
 
 // ../core/src/launchpad.ts
-import { bytesToHex as bytesToHex11, decodeEventLog as decodeEventLog3, encodeFunctionData as encodeFunctionData8, getAddress as getAddress15, isAddress as isAddress9, parseAbiItem as parseAbiItem2, zeroAddress as zeroAddress9 } from "viem";
+import { bytesToHex as bytesToHex11, decodeEventLog as decodeEventLog3, encodeFunctionData as encodeFunctionData8, getAddress as getAddress16, isAddress as isAddress9, parseAbiItem as parseAbiItem2, zeroAddress as zeroAddress10 } from "viem";
 async function readIpfsJson(uri2) {
   if (uri2 === null || !uri2.startsWith("ipfs://")) return null;
   const path = uri2.slice("ipfs://".length).replace(/^ipfs\//, "");
@@ -16384,7 +16511,7 @@ function nowIso(seconds) {
 }
 function address2(text2, what) {
   if (!isAddress9(text2, { strict: false })) throw new RangeError(`${what} ${text2} is not an address`);
-  return getAddress15(text2);
+  return getAddress16(text2);
 }
 function slippage(bps) {
   const s = bps ?? QUOTE_DEFAULT_SLIPPAGE_BPS;
@@ -16398,7 +16525,7 @@ function simulatedGas(gasUsed) {
   const g = gasUsed * 5n / 4n + SPEND_GAS_HEADROOM;
   return g > VAULT_SPEND_GAS ? g : VAULT_SPEND_GAS;
 }
-var LAUNCHPAD_DIR, CREATE_VAULT_GAS2, LAUNCH_GAS_HEADROOM, SPEND_GAS_HEADROOM, DAY, TOKEN_LIST_MAX, IPFS_GATEWAY, METADATA_MAX_BYTES, METADATA_TIMEOUT_MS, launchedEvent, POOL_SETTING_NAMES, LaunchpadService;
+var LAUNCHPAD_DIR, CREATE_VAULT_GAS2, LAUNCH_GAS_HEADROOM, PAIRS_READ_CONCURRENCY, SPEND_GAS_HEADROOM, DAY, TOKEN_LIST_MAX, IPFS_GATEWAY, METADATA_MAX_BYTES, METADATA_TIMEOUT_MS, launchedEvent, POOL_SETTING_NAMES, LaunchpadService;
 var init_launchpad = __esm({
   "../core/src/launchpad.ts"() {
     "use strict";
@@ -16415,6 +16542,7 @@ var init_launchpad = __esm({
     LAUNCHPAD_DIR = "launchpad";
     CREATE_VAULT_GAS2 = 300000n;
     LAUNCH_GAS_HEADROOM = 300000n;
+    PAIRS_READ_CONCURRENCY = 6;
     SPEND_GAS_HEADROOM = 100000n;
     DAY = 86400;
     TOKEN_LIST_MAX = 50;
@@ -16445,6 +16573,8 @@ var init_launchpad = __esm({
       #creatorSender;
       #folder;
       #tokenVaults = /* @__PURE__ */ new Map();
+      /** A pair's creator vault (not USDG's), one per token: created once, so its operations share one queue. */
+      #pairCreators = /* @__PURE__ */ new Map();
       constructor(p) {
         if (p.creator.kind !== "creator" || p.buyer.kind !== "buyer") throw new Error("the launchpad takes the agent's buyer and creator vaults");
         this.#client = p.client;
@@ -16476,6 +16606,87 @@ var init_launchpad = __esm({
         }
         return v;
       }
+      /**
+       * Refuses to pay `paid` to an Ostra vault (of this deployment) in another
+       * token: a vault only ever moves its own token, so what it is paid in
+       * another stays there for good. A vault not created yet cannot be told
+       * from any other address.
+       */
+      async #notStranded(to, paid, what) {
+        const v = await readVault(this.#client, this.#config.deployment, to);
+        if (v !== null && v.token !== getAddress16(paid)) {
+          throw new Error(`${to} is an Ostra vault in ${v.token}: a vault only moves its own token, so ${what} in ${getAddress16(paid)} would be stuck there for good; nothing was signed`);
+        }
+      }
+      /** The token a pair's vaults hold: the pair's own; WETH for ETH. */
+      #pairToken(pair3) {
+        return pair3.kind === "eth" ? WETH : pair3.address;
+      }
+      /**
+       * The agent's creator vault for `pairText` and the sender of its operations:
+       * for USDG the USDG creator vault and its own relayer client; for a stock
+       * token or ETH, the creator vault in that token (WETH for ETH), paid for by
+       * the buyer vault.
+       */
+      async pairCreator(pairText) {
+        const pair3 = launchPair(pairText);
+        if (pair3.kind === "usdg") return { pair: pair3, vault: this.#creator, sender: this.#creatorSender };
+        const token = this.#pairToken(pair3);
+        let made = this.#pairCreators.get(token);
+        if (made === void 0) {
+          made = this.#keys.forCreatorVault(this.#config.chainId, token).then((keys) => new VaultService(this.#client, this.#transport, this.#config, keys, this.#buyerSender, "creator", null, token));
+          this.#pairCreators.set(token, made);
+          made.catch(() => {
+            if (this.#pairCreators.get(token) === made) this.#pairCreators.delete(token);
+          });
+        }
+        return { pair: pair3, vault: await made, sender: this.#buyerSender };
+      }
+      /**
+       * The pairs a launch can take, with this agent's vaults for each: its
+       * creator vault (what a launch's dev buy is paid from) and its vault of the
+       * pair's token (what it buys that pair's pools with); with `prices`, each
+       * pair's USD price now.
+       */
+      async pairs(a = {}) {
+        const out = new Array(LAUNCH_PAIRS.length);
+        let next = 0;
+        const worker = async () => {
+          while (next < LAUNCH_PAIRS.length) {
+            const i = next++;
+            out[i] = await this.#pairRow(LAUNCH_PAIRS[i], a.prices === true);
+          }
+        };
+        await Promise.all(Array.from({ length: PAIRS_READ_CONCURRENCY }, worker));
+        return out;
+      }
+      /** One row of pairs(). */
+      async #pairRow(pair3, prices) {
+        const { vault } = await this.pairCreator(pair3.symbol);
+        const s = await vault.state();
+        const token = this.#pairToken(pair3);
+        const row = {
+          symbol: pair3.symbol,
+          name: pair3.name,
+          kind: pair3.kind,
+          token: pair3.address,
+          decimals: pair3.decimals,
+          creatorVault: s.vault,
+          creatorBalance: formatUnitsAmount(s.balance, pair3.decimals),
+          tradingVault: pair3.kind === "eth" ? null : await this.tokenVault(token).vaultAddress()
+        };
+        if (prices) {
+          try {
+            const price = await readPairUsdPrice(this.#client, pair3);
+            row.priceUsd = formatUnitsAmount(price.priceE8, 8);
+            row.priceAt = new Date(price.updatedAt * 1e3).toISOString();
+          } catch {
+            row.priceUsd = null;
+            row.priceAt = null;
+          }
+        }
+        return row;
+      }
       // ---------------------------------------------------------------------------
       // Reads
       // ---------------------------------------------------------------------------
@@ -16496,9 +16707,9 @@ var init_launchpad = __esm({
         const pool = await this.#pool(tokenText);
         const s = await this.tokenVault(pool.token).state();
         let dividends = null;
-        if (getAddress15(pool.config.dividendToken) !== zeroAddress9) {
+        if (getAddress16(pool.config.dividendToken) !== zeroAddress10) {
           const owed = await this.#client.readContract({ address: pool.token, abi: ostraTokenAbi, functionName: "dividendOf", args: [s.vault] });
-          const decimals = getAddress15(pool.config.dividendToken) === this.#usdg() ? TOKEN_DECIMALS : await tokenDecimals(this.#client, getAddress15(pool.config.dividendToken));
+          const decimals = getAddress16(pool.config.dividendToken) === this.#usdg() ? TOKEN_DECIMALS : await tokenDecimals(this.#client, getAddress16(pool.config.dividendToken));
           dividends = formatUnitsAmount(owed, decimals);
         }
         return { token: pool.token, vault: s.vault, exists: s.exists, balance: formatUnitsAmount(s.balance, 18), dividends, pendingOperation: s.pendingAction };
@@ -16520,38 +16731,44 @@ var init_launchpad = __esm({
       async #swapQuote(a, create) {
         const pool = await this.#pool(a.token);
         const quote = this.#quoteOf(pool);
-        if (quote !== this.#usdg()) throw new Error(`the pool of ${pool.token} trades against ${quote === zeroAddress9 ? "ETH" : quote}; this agent trades USDG pools`);
+        if (quote === zeroAddress10) {
+          throw new Error(`the pool of ${pool.token} trades against ETH: an Ostra vault holds one ERC-20 and cannot pay or take native ETH, so this pool is traded from a wallet; nothing was signed`);
+        }
+        const pair3 = findLaunchPair(quote);
+        if (pair3 === null) throw new Error(`the pool of ${pool.token} trades against ${quote}, not a pair Ostra offers (USDG, ETH or a listed stock token); nothing was signed`);
         const referrer = a.referrer === void 0 ? void 0 : address2(a.referrer, "referrer");
-        const usdgIs0 = getAddress15(pool.key.currency0) === this.#usdg();
+        const quoteIs0 = getAddress16(pool.key.currency0) === quote;
         const buying = a.side === "buy";
-        const from = buying ? this.#buyer : this.tokenVault(pool.token);
+        const quoteVault = this.tokenVault(quote);
+        const from = buying ? quoteVault : this.tokenVault(pool.token);
         const fromVault = await from.vaultAddress();
-        const to = buying ? await this.tokenVault(pool.token).vaultAddress() : await this.#buyer.vaultAddress();
-        const amountIn = buying ? parseTokenAmount(a.amount) : parseUnitsAmount(a.amount, 18);
+        const to = buying ? await this.tokenVault(pool.token).vaultAddress() : await quoteVault.vaultAddress();
+        const amountIn = buying ? parseUnitsAmount(a.amount, pair3.decimals) : parseUnitsAmount(a.amount, 18);
         if (amountIn === 0n) throw new RangeError("amount must be greater than zero");
         const state = await from.state();
-        if (!state.exists && buying) throw new Error("this agent has no vault yet; call open_vault first");
+        if (!state.exists && from === this.#buyer) throw new Error("this agent has no vault yet; call open_vault first");
         if (state.balance < amountIn) {
-          throw new Error(`the ${buying ? "vault" : `vault in ${pool.token}`} holds ${buying ? formatTokenAmount(state.balance) : formatUnitsAmount(state.balance, 18)}, less than ${a.amount}`);
+          const what = from === this.#buyer ? "vault" : `vault in ${buying ? pair3.symbol : pool.token}`;
+          throw new Error(`the ${what} holds ${formatUnitsAmount(state.balance, buying ? pair3.decimals : 18)}, less than ${a.amount}`);
         }
         const sender = this.#buyerSender;
         if (!state.exists) {
-          if (!create) throw new Error(`the vault in ${pool.token} holds tokens but is not created yet; sell creates it, then quotes`);
+          if (!create) throw new Error(`the vault in ${buying ? pair3.symbol : pool.token} holds tokens but is not created yet; ${a.side} creates it, then quotes`);
           await from.open();
         }
         const q = await quoteVaultSwap(this.#client, this.#config.deployment, {
           vault: fromVault,
           relayer: await sender.payer(),
-          swap: { key: pool.key, zeroForOne: buying ? usdgIs0 : !usdgIs0, amountIn, recipient: to, ...referrer === void 0 ? {} : { referrer } },
+          swap: { key: pool.key, zeroForOne: buying ? quoteIs0 : !quoteIs0, amountIn, recipient: to, ...referrer === void 0 ? {} : { referrer } },
           slippageBps: slippage(a.slippageBps)
         });
-        return { q, pool, from, fromVault, to, inDecimals: buying ? TOKEN_DECIMALS : 18, outDecimals: buying ? 18 : TOKEN_DECIMALS, sender };
+        return { q, pool, from, fromVault, to, inDecimals: buying ? pair3.decimals : 18, outDecimals: buying ? 18 : pair3.decimals, sender };
       }
       /** What the vault's Swap in `txHash` did: Swapped (in, out) or SwapFailed. */
       async #swapOutcome(txHash, vault) {
         const receipt = await this.#client.getTransactionReceipt({ hash: txHash });
         for (const log2 of receipt.logs) {
-          if (getAddress15(log2.address) !== vault) continue;
+          if (getAddress16(log2.address) !== vault) continue;
           try {
             const e = decodeEventLog3({ abi: ostraVaultAbi, topics: log2.topics, data: log2.data });
             if (e.eventName === "Swapped") {
@@ -16564,11 +16781,11 @@ var init_launchpad = __esm({
         }
         throw new Error(`transaction ${txHash} has no Swap of ${vault}`);
       }
-      /** Buys `token` with `amount` USDG of the buyer vault, into the agent's token vault. */
+      /** Buys `token` with `amount` of its pool's pair (USDG from the buyer vault, a stock token from its token vault), into the agent's token vault. */
       buy(a) {
         return this.#swap({ ...a, side: "buy" });
       }
-      /** Sells `amount` of `token` from the agent's token vault for USDG into the buyer vault. */
+      /** Sells `amount` of `token` from the agent's token vault for its pool's pair, into the agent's vault of the pair (the buyer vault for USDG). */
       sell(a) {
         return this.#swap({ ...a, side: "sell" });
       }
@@ -16577,7 +16794,7 @@ var init_launchpad = __esm({
         const buying = a.side === "buy";
         const tokenVault = this.tokenVault(pool.token);
         const createTokenVault = buying && !(await tokenVault.state()).exists;
-        const inToken = buying ? this.#usdg() : pool.token;
+        const inToken = buying ? this.#quoteOf(pool) : pool.token;
         const result = await from.operate({
           gas: swapSpendGas(q.swap.swapGas) + (createTokenVault ? CREATE_VAULT_GAS2 : 0n),
           moves: q.amountIn,
@@ -16623,7 +16840,7 @@ var init_launchpad = __esm({
       async transferToken(a) {
         const token = address2(a.token, "token");
         const destination = address2(a.destination, "destination");
-        if (destination === zeroAddress9) throw new RangeError("the destination must not be the zero address");
+        if (destination === zeroAddress10) throw new RangeError("the destination must not be the zero address");
         const v = this.tokenVault(token);
         if (v === this.#buyer) throw new Error("USDG is withdrawn with withdraw");
         const decimals = await tokenDecimals(this.#client, token);
@@ -16633,6 +16850,7 @@ var init_launchpad = __esm({
         if (!s.exists) throw new Error(`this agent has no vault in ${token}`);
         if (s.balance < amount) throw new Error(`the vault in ${token} holds ${formatUnitsAmount(s.balance, decimals)}, less than ${a.amount}`);
         if (destination === s.vault) throw new Error("the destination is the vault itself");
+        await this.#notStranded(destination, token, "the transfer");
         return this.#simulatedSpend(v, this.#buyerSender, VAULT_ACTION.TRANSFER, transferParams({ to: destination, amount }), "token transfer");
       }
       /** The agent's vault that receives `dividendToken`: the buyer vault for USDG, else the token vault of that token. */
@@ -16642,8 +16860,8 @@ var init_launchpad = __esm({
       /** Claims the dividends the agent's token vault for `token` earned, into the agent's vault of the dividend token. */
       async claimDividends(tokenText) {
         const pool = await this.#pool(tokenText);
-        const dividendToken = getAddress15(pool.config.dividendToken);
-        if (dividendToken === zeroAddress9) throw new Error(`the pool of ${pool.token} pays no dividends`);
+        const dividendToken = getAddress16(pool.config.dividendToken);
+        if (dividendToken === zeroAddress10) throw new Error(`the pool of ${pool.token} pays no dividends`);
         const v = this.tokenVault(pool.token);
         const s = await v.state();
         if (!s.exists) throw new Error(`this agent has no vault in ${pool.token}`);
@@ -16670,11 +16888,51 @@ var init_launchpad = __esm({
         }
         return out.sort((x, y) => x.at - y.at);
       }
-      /** Moves `amount` USDG from the buyer vault into the creator vault (what a launch's dev buy and the creator's relayer requests are paid from). */
-      async fundCreatorVault(amount) {
-        const creator = await this.#creator.vaultAddress();
-        if ((await this.#creator.state()).exists === false) await this.#creator.open();
-        return this.#buyer.withdraw(creator, amount);
+      /**
+       * Moves `amount` into the creator vault of `pairText` (default USDG): USDG
+       * from the buyer vault (a launch's dev buy and the USDG creator vault's
+       * relayer requests are paid from it); a stock token or WETH from the
+       * agent's token vault of it (what a dev buy in that pair is paid from). The
+       * creator vault is created first when it does not exist yet.
+       */
+      async fundCreatorVault(amount, pairText = "USDG") {
+        const { pair: pair3, vault: creator } = await this.pairCreator(pairText);
+        const to = await creator.vaultAddress();
+        if (pair3.kind === "usdg") {
+          if ((await creator.state()).exists === false) await creator.open();
+          return this.#buyer.withdraw(to, amount);
+        }
+        const units2 = parseUnitsAmount(amount, pair3.decimals);
+        if (units2 === 0n) throw new RangeError("amount must be greater than zero");
+        const token = this.#pairToken(pair3);
+        const from = this.tokenVault(token);
+        const s = await from.state();
+        const tokenName = pair3.kind === "eth" ? "WETH" : pair3.symbol;
+        if (s.balance < units2) {
+          throw new Error(
+            `this agent's vault in ${tokenName} (${s.vault}) holds ${formatUnitsAmount(s.balance, pair3.decimals)}, less than ${amount}; send ${tokenName} to it, or straight to the ${pair3.symbol} creator vault ${to}; nothing was signed`
+          );
+        }
+        if (!s.exists) await from.open();
+        if ((await creator.state()).exists === false) await creator.open();
+        return this.#simulatedSpend(from, this.#buyerSender, VAULT_ACTION.TRANSFER, transferParams({ to, amount: units2 }), `${tokenName} transfer to the ${pair3.symbol} creator vault`);
+      }
+      /** Sends `amount` from the creator vault of `pair` (default USDG) to `destination` (default: the agent's vault of that token; for ETH, required). */
+      async creatorWithdraw(a) {
+        const { pair: pair3, vault: creator, sender } = await this.pairCreator(a.pair ?? "USDG");
+        const token = this.#pairToken(pair3);
+        if (pair3.kind !== "usdg" && pair3.kind !== "stock" && a.destination === void 0) throw new RangeError(`a ${pair3.symbol} creator vault holds WETH: name the destination`);
+        const destination = a.destination === void 0 ? await this.tokenVault(token).vaultAddress() : address2(a.destination, "destination");
+        await this.#notStranded(destination, token, `the ${pair3.symbol} creator vault's transfer`);
+        if (pair3.kind === "usdg") return creator.withdraw(destination, a.amount);
+        if (destination === zeroAddress10) throw new RangeError("the destination must not be the zero address");
+        const units2 = parseUnitsAmount(a.amount, pair3.decimals);
+        if (units2 === 0n) throw new RangeError("amount must be greater than zero");
+        const s = await creator.state();
+        if (!s.exists) throw new Error(`this agent has no ${pair3.symbol} creator vault yet`);
+        if (destination === s.vault) throw new Error("the destination is the vault itself");
+        if (s.balance < units2) throw new Error(`the ${pair3.symbol} creator vault holds ${formatUnitsAmount(s.balance, pair3.decimals)}, less than ${a.amount}`);
+        return this.#simulatedSpend(creator, sender, VAULT_ACTION.TRANSFER, transferParams({ to: destination, amount: units2 }), `${pair3.symbol} creator vault transfer`);
       }
       /**
        * Launches a token from the creator vault (OstraDevBuy.launchFromVault),
@@ -16685,13 +16943,20 @@ var init_launchpad = __esm({
         const lp = this.#lp();
         if (typeof input.name !== "string" || input.name.length === 0 || input.name.length > 64) throw new RangeError("a name is 1..64 characters");
         if (typeof input.symbol !== "string" || !/^[A-Za-z0-9]{1,11}$/.test(input.symbol)) throw new RangeError("a symbol is 1..11 letters and digits");
-        if (input.marketCap === void 0 === (input.startTick === void 0)) throw new RangeError("give the starting marketCap (USDG) or the startTick, one of them");
-        const startTick = input.startTick ?? startTickForMarketCap(parseTokenAmount(input.marketCap));
+        if (input.marketCap === void 0 === (input.startTick === void 0)) throw new RangeError("give the starting marketCap (US dollars) or the startTick, one of them");
+        const { pair: pair3, vault: creator, sender } = await this.pairCreator(input.pair ?? "USDG");
+        const marketCapUsd = input.marketCap === void 0 ? null : parseTokenAmount(input.marketCap);
+        const price = marketCapUsd === null ? null : await readPairUsdPrice(this.#client, pair3);
+        const marketCapUnits = marketCapUsd === null || price === null ? null : usdToQuoteUnits(marketCapUsd, price.priceE8, pair3.decimals);
+        if (marketCapUnits === 0n) throw new RangeError(`a market cap of ${input.marketCap} USD is less than one base unit of ${pair3.symbol}`);
+        const startTick = input.startTick ?? startTickForMarketCap(marketCapUnits);
         if (!Number.isInteger(startTick) || startTick % LAUNCHPAD.TICK_SPACING !== 0) throw new RangeError(`the start tick must be a multiple of ${LAUNCHPAD.TICK_SPACING}`);
-        let creatorState = await this.#creator.state();
+        const vaultToken = this.#pairToken(pair3);
+        const pairUnits = (x) => formatUnitsAmount(x, pair3.decimals);
+        let creatorState = await creator.state();
         if (!creatorState.exists) {
-          await this.#creator.open();
-          creatorState = await this.#creator.state();
+          await creator.open();
+          creatorState = await creator.state();
         }
         const creatorVault = creatorState.vault;
         const p = launchParams({
@@ -16699,46 +16964,46 @@ var init_launchpad = __esm({
           name: input.name,
           symbol: input.symbol,
           salt: bytesToHex11(randomBytes3(32)),
-          quote: this.#usdg(),
+          quote: pair3.address,
           creatorVault,
           startTick
         });
-        const token = getAddress15(await this.#client.readContract({ address: lp.devBuy, abi: ostraDevBuyAbi, functionName: "tokenAddressFromVault", args: [p] }));
+        const token = getAddress16(await this.#client.readContract({ address: lp.devBuy, abi: ostraDevBuyAbi, functionName: "tokenAddressFromVault", args: [p] }));
         const tokenVault = await this.tokenVault(token).vaultAddress();
         let dev = NO_DEV_BUY;
         if (input.devBuy !== void 0) {
-          const quoteIn = parseTokenAmount(input.devBuy.amount);
+          const quoteIn = parseUnitsAmount(input.devBuy.amount, pair3.decimals);
           if (quoteIn === 0n) throw new RangeError("the dev buy amount must be greater than zero (leave devBuy out for none)");
           const cliff = Math.round((input.devBuy.cliffDays ?? DEV_BUY.MIN_CLIFF / DAY) * DAY);
           const duration = Math.round((input.devBuy.vestingDays ?? 0) * DAY);
-          const dividendToken = getAddress15(p.dividendToken);
+          const dividendToken = getAddress16(p.dividendToken);
           dev = {
             quoteIn,
             beneficiary: tokenVault,
             // The dividend token is the launched token itself, USDG or another token: the agent's vault of it.
             // (OstraLaunchpad takes "dividends in the token" as its own address: the token does not exist yet.)
-            dividendRecipient: dividendToken === zeroAddress9 ? zeroAddress9 : dividendToken === lp.launchpad || dividendToken === token ? tokenVault : await this.#vaultFor(dividendToken),
+            dividendRecipient: dividendToken === zeroAddress10 ? zeroAddress10 : dividendToken === lp.launchpad || dividendToken === token ? tokenVault : await this.#vaultFor(dividendToken),
             cliff,
             duration
           };
           if (creatorState.balance < quoteIn) {
             throw new Error(
-              `the creator vault ${creatorVault} holds ${formatTokenAmount(creatorState.balance)}, less than the dev buy of ${input.devBuy.amount}; fund it first with fund_creator_vault (the dev buy plus about 1 USDG for its relayer channel)`
+              `the ${pair3.symbol} creator vault ${creatorVault} holds ${pairUnits(creatorState.balance)}, less than the dev buy of ${input.devBuy.amount}; ` + (pair3.kind === "usdg" ? "fund it first with fund_creator_vault (the dev buy plus about 1 USDG for its relayer channel)" : `fund it first with fund_creator_vault (pair ${pair3.symbol}), or send ${pair3.kind === "eth" ? "WETH" : pair3.symbol} straight to it`)
             );
           }
         }
-        const q = await quoteVaultLaunch(this.#client, this.#config.deployment, { relayer: await this.#creatorSender.payer(), launch: p, dev });
-        const result = await this.#creator.operate({
+        const q = await quoteVaultLaunch(this.#client, this.#config.deployment, { relayer: await sender.payer(), launch: p, dev });
+        const result = await creator.operate({
           gas: q.gasUsed * 5n / 4n + LAUNCH_GAS_HEADROOM,
           value: LAUNCHPAD.FEE_WEI,
           moves: dev.quoteIn,
           what: "launch",
           build: async ({ v, keychain, chainId }) => {
             if (dev.quoteIn !== 0n) {
-              const balance = await tokenBalance(this.#client, this.#usdg(), creatorVault);
-              if (balance < dev.quoteIn) throw new Error(`the creator vault holds ${formatTokenAmount(balance)} now, less than the dev buy; nothing was signed`);
+              const balance = await tokenBalance(this.#client, vaultToken, creatorVault);
+              if (balance < dev.quoteIn) throw new Error(`the creator vault holds ${pairUnits(balance)} now, less than the dev buy; nothing was signed`);
             }
-            await this.#creator.keepLaunch(v.nonce, p, dev);
+            await creator.keepLaunch(v.nonce, p, dev);
             const signed = await signVaultDevBuy(keychain, v, { chainId, devBuy: lp.devBuy, launch: p, dev });
             return [{ to: lp.devBuy, data: launchFromVaultData(p, dev, signed) }];
           }
@@ -16749,14 +17014,14 @@ var init_launchpad = __esm({
         let bought = null;
         for (const log2 of receipt.logs) {
           try {
-            if (getAddress15(log2.address) === lp.launchpad) {
+            if (getAddress16(log2.address) === lp.launchpad) {
               const e = decodeEventLog3({ abi: ostraLaunchpadAbi, topics: log2.topics, data: log2.data });
               if (e.eventName === "Launched") poolId2 = e.args.poolId;
-            } else if (getAddress15(log2.address) === lp.devBuy) {
+            } else if (getAddress16(log2.address) === lp.devBuy) {
               const e = decodeEventLog3({ abi: ostraDevBuyAbi, topics: log2.topics, data: log2.data });
               if (e.eventName === "DevBought") {
                 const g = e.args;
-                bought = { ...g, vesting: getAddress15(g.vesting) };
+                bought = { ...g, vesting: getAddress16(g.vesting) };
               }
             }
           } catch {
@@ -16764,7 +17029,7 @@ var init_launchpad = __esm({
         }
         if (poolId2 === null) throw new Error(`transaction ${result.txHash} landed without the launch`);
         await this.#folder.ensure();
-        await this.#folder.write(this.#launchName(token), `${JSON.stringify({ version: 1, token, poolId: poolId2, txHash: result.txHash, vesting: bought?.vesting ?? null, at: Math.floor(Date.now() / 1e3) })}
+        await this.#folder.write(this.#launchName(token), `${JSON.stringify({ version: 1, token, poolId: poolId2, txHash: result.txHash, vesting: bought?.vesting ?? null, pair: pair3.symbol, creatorVault, at: Math.floor(Date.now() / 1e3) })}
 `);
         return {
           status: "launched",
@@ -16773,16 +17038,28 @@ var init_launchpad = __esm({
           poolId: poolId2,
           creatorVault,
           tokenVault,
-          devBuy: bought === null ? null : { paid: formatTokenAmount(bought.quotePaid), tokens: formatUnitsAmount(bought.tokens, 18), vesting: bought.vesting, cliffEnd: nowIso(bought.cliffEnd), vestingEnd: nowIso(bought.vestingEnd) },
-          note: bought === null ? "the token is live; the creator vault owns the pool (settings, creator shares, airdrops) and receives the creator payouts" : "the token is live; the dev buy's tokens vest to this agent's token vault (vesting_release after the cliff); the creator vault owns the pool and receives the creator payouts"
+          pair: pair3.symbol,
+          marketCapUsd: marketCapUsd === null ? null : formatTokenAmount(marketCapUsd),
+          marketCapInPair: marketCapUnits === null ? "" : pairUnits(marketCapUnits),
+          pairPriceUsd: price === null ? null : formatUnitsAmount(price.priceE8, 8),
+          pairPriceAt: price === null ? null : new Date(price.updatedAt * 1e3).toISOString(),
+          devBuy: bought === null ? null : { paid: pairUnits(bought.quotePaid), tokens: formatUnitsAmount(bought.tokens, 18), vesting: bought.vesting, cliffEnd: nowIso(bought.cliffEnd), vestingEnd: nowIso(bought.vestingEnd) },
+          note: (bought === null ? `the token is live; the ${pair3.symbol} creator vault owns the pool (settings, creator shares, airdrops) and receives the creator payouts` : `the token is live; the dev buy's tokens vest to this agent's token vault (vesting_release after the cliff); the ${pair3.symbol} creator vault owns the pool and receives the creator payouts`) + (pair3.kind === "usdg" ? "" : `, in ${pair3.kind === "eth" ? "WETH" : pair3.symbol}; publish_profile again shows this agent's profile on the pool`)
         };
       }
-      /** The pool's creator vault must be this agent's. */
+      /** The pool's pair (null: a quote Ostra does not offer). */
+      #pairOf(pool) {
+        return findLaunchPair(this.#quoteOf(pool));
+      }
+      /** The pool's creator vault must be this agent's creator vault of the pool's pair: the pool, that vault and its sender. */
       async #ownPool(tokenText) {
         const pool = await this.#pool(tokenText);
-        const creatorVault = await this.#creator.vaultAddress();
-        if (getAddress15(pool.config.creatorVault) !== creatorVault) throw new Error(`the pool of ${pool.token} belongs to the creator vault ${pool.config.creatorVault}, not this agent's ${creatorVault}`);
-        return pool;
+        const pair3 = this.#pairOf(pool);
+        if (pair3 === null) throw new Error(`the pool of ${pool.token} trades against ${this.#quoteOf(pool)}, not a pair Ostra offers; no creator vault of this agent owns it`);
+        const { vault: creator, sender } = await this.pairCreator(pair3.symbol);
+        const creatorVault = await creator.vaultAddress();
+        if (getAddress16(pool.config.creatorVault) !== creatorVault) throw new Error(`the pool of ${pool.token} belongs to the creator vault ${pool.config.creatorVault}, not this agent's ${pair3.symbol} creator vault ${creatorVault}`);
+        return { pool, pair: pair3, creator, sender };
       }
       /**
        * Changes one of the pool's rules (POOL_SETTING_NAMES), only in the
@@ -16794,27 +17071,28 @@ var init_launchpad = __esm({
         const field = POOL_SETTING_NAMES[a.setting];
         if (field === void 0) throw new RangeError(`unknown setting ${a.setting}; one of ${Object.keys(POOL_SETTING_NAMES).join(", ")}`);
         if (!/^(0|[1-9][0-9]*)$/.test(a.value)) throw new RangeError("the value is a whole number (bps, unix seconds, ticks, or token base units for max_buy)");
-        const pool = await this.#ownPool(a.token);
+        const { pool, creator, sender } = await this.#ownPool(a.token);
         const params = configurePoolParams({ hook: this.#lp().hook, poolId: pool.id, field, value: BigInt(a.value) });
-        return this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.CONFIGURE_POOL, params, "pool setting");
+        return this.#simulatedSpend(creator, sender, VAULT_ACTION.CONFIGURE_POOL, params, "pool setting");
       }
       /** Sets `recipient`'s share (bps; 0 removes it) of the pool's creator payouts; the creator vault keeps the rest. */
       async setCreatorShare(a) {
         if (!Number.isInteger(a.bps) || a.bps < 0 || a.bps > CREATOR_SPLIT.BPS) throw new RangeError(`bps must be 0..${CREATOR_SPLIT.BPS}`);
-        const pool = await this.#ownPool(a.token);
+        const { pool, creator, sender } = await this.#ownPool(a.token);
         const params = creatorShareParams({ split: this.#lp().creatorSplit, poolId: pool.id, recipient: address2(a.recipient, "recipient"), bps: a.bps });
-        return this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.CONFIGURE_POOL, params, "creator share");
+        return this.#simulatedSpend(creator, sender, VAULT_ACTION.CONFIGURE_POOL, params, "creator share");
       }
-      /** Pays out what the creator split owes `account` (default: this agent's creator vault) for the pool. */
+      /** Pays out what the creator split owes `account` (default: this agent's creator vault of the pool's pair) for the pool. */
       async releaseCreatorPayout(a) {
         const lp = this.#lp();
         const pool = await this.#pool(a.token);
-        const account = a.account === void 0 ? await this.#creator.vaultAddress() : address2(a.account, "account");
+        const pair3 = this.#pairOf(pool);
+        const own = pair3 === null ? this.#creator : (await this.pairCreator(pair3.symbol)).vault;
+        const account = a.account === void 0 ? await own.vaultAddress() : address2(a.account, "account");
         const owed = await this.#client.readContract({ address: lp.creatorSplit, abi: ostraCreatorSplitAbi, functionName: "owedOf", args: [pool.id, account] });
         if (owed === 0n) throw new Error(`the creator split owes ${account} nothing for this pool now`);
         const txHash = await this.#public({ to: lp.creatorSplit, data: encodeFunctionData8({ abi: ostraCreatorSplitAbi, functionName: "release", args: [pool.id, account] }) }, "release the creator payout");
-        const quote = this.#quoteOf(pool);
-        return { txHash, account, amount: formatUnitsAmount(owed, quote === this.#usdg() ? TOKEN_DECIMALS : 18) };
+        return { txHash, account, amount: formatUnitsAmount(owed, pair3 === null ? await tokenDecimals(this.#client, this.#quoteOf(pool)) : pair3.decimals) };
       }
       /** A call anyone may make, sent for the buyer vault (its relayer channel pays). */
       async #public(call, purpose) {
@@ -16824,27 +17102,27 @@ var init_launchpad = __esm({
       // ---------------------------------------------------------------------------
       // Airdrops
       // ---------------------------------------------------------------------------
-      /** Buys `amount` USDG of the token from the creator vault into OstraAirdrop, for the pool's next round. */
+      /** Buys `amount` of the pool's pair worth of the token from its creator vault into OstraAirdrop, for the pool's next round (USDG and stock pools). */
       async airdropFund(a) {
         const lp = this.#lp();
-        const pool = await this.#ownPool(a.token);
-        if (this.#quoteOf(pool) !== this.#usdg()) throw new Error("this agent funds airdrops of USDG pools");
-        const amountIn = parseTokenAmount(a.amount);
+        const { pool, pair: pair3, creator, sender } = await this.#ownPool(a.token);
+        if (pair3.kind === "eth") throw new Error("an ETH pool's airdrop is bought from a wallet: a vault cannot pay native ETH; nothing was signed");
+        const amountIn = parseUnitsAmount(a.amount, pair3.decimals);
         if (amountIn === 0n) throw new RangeError("amount must be greater than zero");
-        const s = await this.#creator.state();
-        if (s.balance < amountIn) throw new Error(`the creator vault holds ${formatTokenAmount(s.balance)}, less than ${a.amount}; fund it with fund_creator_vault`);
-        const usdgIs0 = getAddress15(pool.key.currency0) === this.#usdg();
+        const s = await creator.state();
+        if (s.balance < amountIn) throw new Error(`the ${pair3.symbol} creator vault holds ${formatUnitsAmount(s.balance, pair3.decimals)}, less than ${a.amount}; fund it with fund_creator_vault`);
+        const quoteIs0 = getAddress16(pool.key.currency0) === pair3.address;
         const q = await quoteVaultSwap(this.#client, this.#config.deployment, {
           vault: s.vault,
-          relayer: await this.#creatorSender.payer(),
-          swap: { key: pool.key, zeroForOne: usdgIs0, amountIn, recipient: lp.airdrop },
+          relayer: await sender.payer(),
+          swap: { key: pool.key, zeroForOne: quoteIs0, amountIn, recipient: lp.airdrop },
           slippageBps: slippage(a.slippageBps)
         });
-        const result = await this.#creator.operate({
+        const result = await creator.operate({
           gas: swapSpendGas(q.swap.swapGas),
           moves: amountIn,
           what: "airdrop purchase",
-          build: async ({ v, vault, keychain, chainId }) => [spendCall(vault, await signVaultSwap(keychain, v, { chainId, token: this.#usdg(), swap: q.swap }))]
+          build: async ({ v, vault, keychain, chainId }) => [spendCall(vault, await signVaultSwap(keychain, v, { chainId, token: pair3.address, swap: q.swap }))]
         });
         if (result.status !== "sent") return result;
         const outcome = await this.#swapOutcome(result.txHash, s.vault);
@@ -16852,7 +17130,7 @@ var init_launchpad = __esm({
           status: "sent",
           txHash: result.txHash,
           swapped: outcome.swapped,
-          amountIn: formatTokenAmount(outcome.amountIn),
+          amountIn: formatUnitsAmount(outcome.amountIn, pair3.decimals),
           amountOut: formatUnitsAmount(outcome.amountOut, 18),
           minOut: formatUnitsAmount(q.swap.minOut, 18),
           from: s.vault,
@@ -16871,7 +17149,7 @@ var init_launchpad = __esm({
        */
       async airdropStart(a) {
         const lp = this.#lp();
-        const pool = await this.#ownPool(a.token);
+        const { pool, creator, sender } = await this.#ownPool(a.token);
         const entries = a.entries.map((e) => ({ account: address2(e.account, "account"), amount: parseUnitsAmount(e.amount, 18) }));
         const read = (functionName, args) => this.#client.readContract({ address: lp.airdrop, abi: ostraAirdropAbi, functionName, args });
         const current = await read("round", [pool.id]);
@@ -16895,7 +17173,7 @@ var init_launchpad = __esm({
 `);
         const sent = [];
         const step2 = async (params, what) => {
-          const r = await this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.CONFIGURE_POOL, params, what);
+          const r = await this.#simulatedSpend(creator, sender, VAULT_ACTION.CONFIGURE_POOL, params, what);
           if (r.status !== "sent") throw new Error(`${r.note}; airdrop_start was not finished, call it again with the same entries`);
           sent.push(r.txHash);
         };
@@ -16919,7 +17197,7 @@ var init_launchpad = __esm({
         } else {
           const text2 = await this.#folder.read(this.#airdropName(pool.id, r.number));
           if (text2 === void 0) throw new Error(`no tree of round ${r.number} is kept here; give the amount and proof`);
-          const claim = JSON.parse(text2).claims.find((c) => getAddress15(c.account) === account);
+          const claim = JSON.parse(text2).claims.find((c) => getAddress16(c.account) === account);
           if (claim === void 0) throw new Error(`${account} is not in round ${r.number}`);
           amount = BigInt(claim.amount);
           proof = claim.proof;
@@ -16954,7 +17232,7 @@ var init_launchpad = __esm({
           const text2 = await this.#folder.read(this.#launchName(token));
           const v = text2 === void 0 ? null : JSON.parse(text2).vesting ?? null;
           if (v === null) throw new Error(`this agent's records hold no dev buy vesting of ${token}; give its address`);
-          vesting = getAddress15(v);
+          vesting = getAddress16(v);
         }
         const id = await this.#client.readContract({ address: lp.devBuy, abi: ostraDevBuyAbi, functionName: "vestingPool", args: [vesting] });
         if (BigInt(id) === 0n) throw new Error(`${vesting} is not an Ostra dev buy's vesting`);
@@ -16965,8 +17243,8 @@ var init_launchpad = __esm({
         const vesting = await this.#vesting(a.token, a.vesting);
         const read = (functionName) => this.#client.readContract({ address: vesting, abi: ostraVestingAbi, functionName });
         const [terms, schedule, releasable] = await Promise.all([read("terms"), read("schedule"), read("releasable")]);
-        const held = await tokenBalance(this.#client, getAddress15(terms.token), vesting);
-        return { vesting, beneficiary: getAddress15(terms.beneficiary), cliffEnd: nowIso(schedule[0]), end: nowIso(schedule[1]), held: formatUnitsAmount(held, 18), releasable: formatUnitsAmount(releasable, 18) };
+        const held = await tokenBalance(this.#client, getAddress16(terms.token), vesting);
+        return { vesting, beneficiary: getAddress16(terms.beneficiary), cliffEnd: nowIso(schedule[0]), end: nowIso(schedule[1]), held: formatUnitsAmount(held, 18), releasable: formatUnitsAmount(releasable, 18) };
       }
       /** Releases what the vesting has vested to its beneficiary (this agent's token vault). */
       async vestingRelease(a) {
@@ -16982,14 +17260,17 @@ var init_launchpad = __esm({
         const txHash = await this.#public({ to: vesting, data: encodeFunctionData8({ abi: ostraVestingAbi, functionName: "claimDividends" }) }, "claim the vesting's dividends");
         return { txHash };
       }
-      /** Claims what swaps that named `referrer` (default: this agent's buyer vault) earned it, in USDG. */
+      /** Claims what swaps that named `referrer` earned it in the pair `pair` (default USDG; referrer default: this agent's vault of that token), paid in that token (WETH for ETH). */
       async claimReferral(a = {}) {
         const lp = this.#lp();
-        const referrer = a.referrer === void 0 ? await this.#buyer.vaultAddress() : address2(a.referrer, "referrer");
-        const owed = await this.#client.readContract({ address: lp.hook, abi: ostraHookAbi, functionName: "referralOwed", args: [referrer, this.#usdg()] });
-        if (owed === 0n) throw new Error(`${referrer} has no referral earnings in USDG to claim`);
-        const txHash = await this.#public({ to: lp.dispatcher, data: encodeFunctionData8({ abi: ostraDispatcherAbi, functionName: "claimReferral", args: [referrer, this.#usdg()] }) }, "claim the referral earnings");
-        return { txHash, referrer, amount: formatTokenAmount(owed) };
+        const pair3 = launchPair(a.pair ?? "USDG");
+        if (pair3.kind === "eth" && a.referrer === void 0) throw new RangeError("ETH referral earnings are paid in WETH: name the referrer they are owed to");
+        const referrer = a.referrer === void 0 ? await this.tokenVault(pair3.address).vaultAddress() : address2(a.referrer, "referrer");
+        await this.#notStranded(referrer, this.#pairToken(pair3), "the referral earnings");
+        const owed = await this.#client.readContract({ address: lp.hook, abi: ostraHookAbi, functionName: "referralOwed", args: [referrer, pair3.address] });
+        if (owed === 0n) throw new Error(`${referrer} has no referral earnings in ${pair3.symbol} to claim`);
+        const txHash = await this.#public({ to: lp.dispatcher, data: encodeFunctionData8({ abi: ostraDispatcherAbi, functionName: "claimReferral", args: [referrer, pair3.address] }) }, "claim the referral earnings");
+        return { txHash, referrer, amount: formatUnitsAmount(owed, pair3.decimals), pair: pair3.symbol };
       }
       // ---------------------------------------------------------------------------
       // The token list (every Ostra launch, for any buyer)
@@ -17000,7 +17281,7 @@ var init_launchpad = __esm({
         await this.#folder.ensure();
         const text2 = await this.#folder.read("token-index.json");
         let index = text2 === void 0 ? { version: 1, launchpad: lp.launchpad, scannedTo: (BigInt(this.#config.deployment.fromBlock) - 1n).toString(), launches: [] } : JSON.parse(text2);
-        if (getAddress15(index.launchpad) !== getAddress15(lp.launchpad)) index = { version: 1, launchpad: lp.launchpad, scannedTo: (BigInt(this.#config.deployment.fromBlock) - 1n).toString(), launches: [] };
+        if (getAddress16(index.launchpad) !== getAddress16(lp.launchpad)) index = { version: 1, launchpad: lp.launchpad, scannedTo: (BigInt(this.#config.deployment.fromBlock) - 1n).toString(), launches: [] };
         const latest = await this.#client.getBlockNumber();
         let from = BigInt(index.scannedTo) + 1n;
         if (from > latest) return index;
@@ -17009,7 +17290,7 @@ var init_launchpad = __esm({
           const logs = await this.#client.getLogs({ address: lp.launchpad, event: launchedEvent, fromBlock: from, toBlock: to });
           for (const l of logs) {
             if (l.args.token === void 0 || l.args.poolId === void 0 || l.args.creatorVault === void 0 || l.args.quote === void 0 || l.transactionHash === null || l.blockNumber === null) continue;
-            index.launches.push({ token: getAddress15(l.args.token), poolId: l.args.poolId, creatorVault: getAddress15(l.args.creatorVault), quote: getAddress15(l.args.quote), block: l.blockNumber.toString(), txHash: l.transactionHash });
+            index.launches.push({ token: getAddress16(l.args.token), poolId: l.args.poolId, creatorVault: getAddress16(l.args.creatorVault), quote: getAddress16(l.args.quote), block: l.blockNumber.toString(), txHash: l.transactionHash });
           }
           index.scannedTo = to.toString();
         }
@@ -17060,11 +17341,15 @@ var init_launchpad = __esm({
       // ---------------------------------------------------------------------------
       // The agent's identity: profile, ERC-8004 registration, token metadata (vault version 2)
       // ---------------------------------------------------------------------------
-      /** The creator vault, once it exists and runs vault version 2 with OstraRegistry in the deployment record; else throws before anything is signed. */
-      async #identityVault() {
+      /** Throws before anything is signed when the deployment record has no OstraRegistry (vault version 2 not executed yet). */
+      #requireRegistry() {
         if (this.#config.deployment.registry === void 0) {
           throw new Error(`this deployment record has no OstraRegistry: profiles, token metadata and agent identity open once the vaults run version ${VAULT_VERSION} (the upgrade waits its public delay in OstraUpgradeOwner); nothing was signed`);
         }
+      }
+      /** The creator vault, once it exists and runs vault version 2 with OstraRegistry in the deployment record; else throws before anything is signed. */
+      async #identityVault() {
+        this.#requireRegistry();
         const s = await this.#creator.state();
         if (!s.exists) throw new Error("the creator vault, the agent's identity, does not exist yet: fund it first (fund_creator_vault); nothing was signed");
         let version = 1;
@@ -17105,7 +17390,7 @@ var init_launchpad = __esm({
         const receipt = await this.#client.getTransactionReceipt({ hash: r.txHash });
         let agentId;
         for (const log2 of receipt.logs) {
-          if (getAddress15(log2.address) !== vault) continue;
+          if (getAddress16(log2.address) !== vault) continue;
           try {
             const e = decodeEventLog3({ abi: ostraVaultAbi, data: log2.data, topics: log2.topics });
             if (e.eventName === "AgentRegistered") agentId = e.args.agentId.toString();
@@ -17127,13 +17412,25 @@ var init_launchpad = __esm({
         if (r.status === "sent") await this.#folder.write("agent.json", JSON.stringify({ ...record, uri: uri2, at: Math.floor(Date.now() / 1e3) }, null, 2));
         return r;
       }
-      /** Sets the metadata (a URI to its JSON: image, description, links) of a token this agent's creator vault launched. */
+      /** Sets the metadata (a URI to its JSON: image, description, links) of a token this agent launched, from the creator vault of its pair. */
       async setTokenMetadata(a) {
         checkUri(a.uri);
-        const vault = await this.#identityVault();
-        const pool = await this.#pool(a.token);
-        if (getAddress15(pool.config.creatorVault) !== vault) throw new Error(`${pool.token} was launched by the creator vault ${getAddress15(pool.config.creatorVault)}, not by this agent's ${vault}; nothing was signed`);
-        return this.#simulatedSpend(this.#creator, this.#creatorSender, VAULT_ACTION.SET_TOKEN_METADATA, setTokenMetadataParams({ token: pool.token, poolId: pool.id, uri: a.uri }), "token metadata");
+        this.#requireRegistry();
+        const { pool, creator, sender } = await this.#ownPool(a.token);
+        await this.#registryVersion(creator);
+        return this.#simulatedSpend(creator, sender, VAULT_ACTION.SET_TOKEN_METADATA, setTokenMetadataParams({ token: pool.token, poolId: pool.id, uri: a.uri }), "token metadata");
+      }
+      /** `vault` runs vault version VAULT_VERSION (OstraRegistry's writers); else throws before anything is signed. */
+      async #registryVersion(vault) {
+        const s = await vault.state();
+        if (!s.exists) throw new Error(`the creator vault ${s.vault} does not exist yet; nothing was signed`);
+        let version = 1;
+        try {
+          version = Number(await this.#client.readContract({ address: s.vault, abi: ostraVaultAbi, functionName: "VERSION" }));
+        } catch {
+          version = 1;
+        }
+        if (version < VAULT_VERSION) throw new Error(`the creator vault ${s.vault} runs version ${version}, not ${VAULT_VERSION}; nothing was signed`);
       }
       /**
        * Publishes the agent's profile: builds its ERC-8004 registration file (name, description, image, links, the
@@ -17146,14 +17443,29 @@ var init_launchpad = __esm({
         const file = profileFile({ ...p, vault, agentId: record?.agentId ?? null });
         const uri2 = await uploadJson(this.#config.relayerUrl, file);
         const profile = await this.setProfile(uri2);
-        if (profile.status !== "sent" || record === null) return { uri: uri2, profile, agentUri: null };
-        return { uri: uri2, profile, agentUri: await this.setAgentUri(uri2) };
+        const pairCreators = [];
+        if (profile.status === "sent") {
+          const pairs = new Set((await this.launches()).map((l) => l.pair ?? "USDG").filter((x) => x !== "USDG"));
+          for (const symbol of pairs) {
+            const { vault: creator, sender } = await this.pairCreator(symbol);
+            const at = await creator.vaultAddress();
+            try {
+              await this.#registryVersion(creator);
+              pairCreators.push({ pair: symbol, vault: at, result: await this.#simulatedSpend(creator, sender, VAULT_ACTION.SET_PROFILE, setProfileParams(uri2), `${symbol} creator vault profile`) });
+            } catch (err) {
+              pairCreators.push({ pair: symbol, vault: at, error: err.message });
+            }
+          }
+        }
+        if (profile.status !== "sent" || record === null) return { uri: uri2, profile, agentUri: null, pairCreators };
+        return { uri: uri2, profile, agentUri: await this.setAgentUri(uri2), pairCreators };
       }
       /** Publishes the metadata of a token this agent launched (description, image, links), pins it and sets it in OstraRegistry. */
       async publishTokenMetadata(a) {
-        const vault = await this.#identityVault();
-        const pool = await this.#pool(a.token);
-        if (getAddress15(pool.config.creatorVault) !== vault) throw new Error(`${pool.token} was launched by the creator vault ${getAddress15(pool.config.creatorVault)}, not by this agent's ${vault}; nothing was signed`);
+        this.#requireRegistry();
+        const { pool, creator } = await this.#ownPool(a.token);
+        await this.#registryVersion(creator);
+        const vault = await creator.vaultAddress();
         const [name, symbol] = await Promise.all([
           this.#client.readContract({ address: pool.token, abi: ostraTokenAbi, functionName: "name" }),
           this.#client.readContract({ address: pool.token, abi: ostraTokenAbi, functionName: "symbol" })
@@ -17167,14 +17479,14 @@ var init_launchpad = __esm({
 });
 
 // ../core/src/pay.ts
-import { getAddress as getAddress16, isAddress as isAddress10 } from "viem";
+import { getAddress as getAddress17, isAddress as isAddress10 } from "viem";
 import { x402Client as x402Client2, x402HTTPClient as x402HTTPClient2 } from "@x402/core/client";
 import { toClientEvmSigner as toClientEvmSigner2 } from "@x402/evm";
 import { BatchSettlementEvmScheme as BatchSettlementEvmScheme2 } from "@x402/evm/batch-settlement/client";
 function offerProblem(r, network, token) {
   if (r.scheme !== "batch-settlement") return `${r.scheme} (this agent pays batch-settlement)`;
   if (r.network !== network) return `on ${r.network} (this agent pays on ${network})`;
-  if (!isAddress10(r.asset, { strict: false }) || getAddress16(r.asset) !== token) return `in ${r.asset} (this agent pays in ${token})`;
+  if (!isAddress10(r.asset, { strict: false }) || getAddress17(r.asset) !== token) return `in ${r.asset} (this agent pays in ${token})`;
   return null;
 }
 var PAY_CHANNEL_DEPOSIT, PAY_MAX_BODY_CHARS, REQUEST_TIMEOUT_MS2, MIN_LIFE_LEFT_SECONDS, now2, PayService;
@@ -17239,7 +17551,7 @@ var init_pay = __esm({
       async #channelFor(payee, receiver, withdrawDelay, price) {
         for (const r of await this.#channels.payRecords()) {
           if (r.pay === void 0 || r.closeRequested) continue;
-          if (getAddress16(r.payee) !== payee || getAddress16(r.config.receiver) !== receiver || r.gracePeriod !== withdrawDelay) continue;
+          if (getAddress17(r.payee) !== payee || getAddress17(r.config.receiver) !== receiver || r.gracePeriod !== withdrawDelay) continue;
           if (r.pay.expiresAt < now2() + MIN_LIFE_LEFT_SECONDS || payCapacity(r) < price) continue;
           const ch = await readChannel(this.#client, this.#config.deployment.batchSettlement, r.channel);
           if (ch.pendingWithdrawal !== null || ch.balance < BigInt(r.pay.cumulative) + price) continue;
@@ -17250,10 +17562,10 @@ var init_pay = __esm({
       /** The stock x402 client paying from channel record `r` (the vault as payer, the channel's voucher key signing, never depositing). */
       #x402(r) {
         const voucherKey = this.#channels.voucherSigner(r);
-        if (voucherKey.address !== getAddress16(r.config.payerAuthorizer)) throw new Error(`the voucher key of channel ${r.channel} is not derived from this machine's master seed`);
+        if (voucherKey.address !== getAddress17(r.config.payerAuthorizer)) throw new Error(`the voucher key of channel ${r.channel} is not derived from this machine's master seed`);
         const client = this.#client;
         const payer = {
-          address: getAddress16(r.config.payer),
+          address: getAddress17(r.config.payer),
           signTypedData: () => Promise.reject(new Error("a vault never signs typed data")),
           readContract: (args) => client.readContract(args)
         };
@@ -17322,13 +17634,13 @@ var init_pay = __esm({
           if (price > maxPrice) throw new Error(`${input.url} asks ${formatTokenAmount(price)}, more than maxPrice ${input.maxPrice}; nothing was paid`);
           const extra = offer.extra ?? {};
           if (typeof extra.receiverAuthorizer !== "string" || !isAddress10(extra.receiverAuthorizer, { strict: false })) throw new Error("the offer names no receiverAuthorizer; nothing was paid");
-          const payee = getAddress16(extra.receiverAuthorizer);
+          const payee = getAddress17(extra.receiverAuthorizer);
           const withdrawDelay = extra.withdrawDelay;
           if (typeof withdrawDelay !== "number" || !Number.isInteger(withdrawDelay) || withdrawDelay < 900 || withdrawDelay > BATCH_MAX_WITHDRAW_DELAY_SECONDS) {
             throw new Error(`the offer's withdrawDelay ${String(withdrawDelay)} is not 900..${BATCH_MAX_WITHDRAW_DELAY_SECONDS} s; nothing was paid`);
           }
           if (!isAddress10(offer.payTo, { strict: false })) throw new Error("the offer's payTo is not an address; nothing was paid");
-          const receiver = getAddress16(offer.payTo);
+          const receiver = getAddress17(offer.payTo);
           const payeeVault = await readVault(this.#client, this.#config.deployment, payee);
           if (payeeVault === null || payeeVault.token !== token) throw new Error(`the seller's receiverAuthorizer ${payee} is not an Ostra vault in ${token}: this agent pays Ostra sellers from its vault; nothing was paid`);
           if (payee === await this.#vault.vaultAddress()) throw new Error("the seller is this agent's own vault");
@@ -17396,8 +17708,21 @@ var init_pay = __esm({
   }
 });
 
+// ../core/src/seed-backup.ts
+import { scryptAsync } from "@noble/hashes/scrypt.js";
+var SCRYPT, AAD, SCRYPT_MAXMEM;
+var init_seed_backup = __esm({
+  "../core/src/seed-backup.ts"() {
+    "use strict";
+    init_define_OSTRA_PACKAGED();
+    SCRYPT = { N: 1 << 17, r: 8, p: 1 };
+    AAD = new TextEncoder().encode("OSTRA/SEED-BACKUP/v1");
+    SCRYPT_MAXMEM = 256 * 1024 * 1024;
+  }
+});
+
 // ../core/src/sessions.ts
-import { bytesToHex as bytesToHex12, getAddress as getAddress17, isAddress as isAddress11 } from "viem";
+import { bytesToHex as bytesToHex12, getAddress as getAddress18, isAddress as isAddress11 } from "viem";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 var init_sessions = __esm({
   "../core/src/sessions.ts"() {
@@ -17409,19 +17734,19 @@ var init_sessions = __esm({
 });
 
 // ../core/src/shield.ts
-import { bytesToHex as bytesToHex13, encodeFunctionData as encodeFunctionData9, getAddress as getAddress18, hexToBytes as hexToBytes8, parseSignature } from "viem";
+import { bytesToHex as bytesToHex13, encodeFunctionData as encodeFunctionData9, getAddress as getAddress19, hexToBytes as hexToBytes8, parseSignature } from "viem";
 function leafKeyIndex(attempt, j) {
   if (!Number.isInteger(attempt) || attempt < 0 || attempt >= MAX_LEAF_ATTEMPTS) throw new RangeError(`leaf set ${String(attempt)} is out of range`);
   if (!Number.isInteger(j) || j < 0 || j >= LEAF_KEYS_PER_ATTEMPT) throw new RangeError(`leaf ${String(j)} is out of range`);
   return attempt * LEAF_KEYS_PER_ATTEMPT + j;
 }
 function recordName(chainId, token, index) {
-  return `${chainId}-${getAddress18(token)}-${index}.json`;
+  return `${chainId}-${getAddress19(token)}-${index}.json`;
 }
 function decodeApproveMessage(message) {
   if (message.length !== APPROVE_MESSAGE_LEN) throw new Error("not an approval message");
   const chainId = Number(BigInt(bytesToHex13(message.subarray(20, 52))));
-  const pool = getAddress18(bytesToHex13(message.subarray(52, 72)));
+  const pool = getAddress19(bytesToHex13(message.subarray(52, 72)));
   const key = bytesToHex13(message.subarray(72, 104));
   const batchId = BigInt(bytesToHex13(message.subarray(104, 112)));
   const state = bytesToHex13(message.subarray(112, 144));
@@ -17496,7 +17821,7 @@ var init_shield = __esm({
       /** True when `record` belongs to this service's vault. */
       async #mine(record) {
         if (record.vault === void 0) return this.#vault.kind === "buyer";
-        return getAddress18(record.vault) === await this.#vault.vaultAddress();
+        return getAddress19(record.vault) === await this.#vault.vaultAddress();
       }
       /** A new record under the first free deposit number (created exclusively: another vault's service may be creating one too). */
       async #createRecord(make) {
@@ -17657,8 +17982,8 @@ var init_shield = __esm({
         const { batchCount } = await readPool(this.#client, this.#pool());
         const health = await this.#aggregator("GET", "/v1/health");
         if (typeof health.aggregator !== "string") throw new Error("the aggregator's health names no aggregator account");
-        const aggregator = getAddress18(health.aggregator);
-        const accounts = /* @__PURE__ */ new Set([...(record.aggregators ?? []).map((a) => getAddress18(a)), aggregator]);
+        const aggregator = getAddress19(health.aggregator);
+        const accounts = /* @__PURE__ */ new Set([...(record.aggregators ?? []).map((a) => getAddress19(a)), aggregator]);
         if (accounts.size !== (record.aggregators ?? []).length) {
           record.aggregators = [...accounts];
           await this.#save(record);
@@ -17713,11 +18038,11 @@ var init_shield = __esm({
         const room = await this.#room(p.maxTotal);
         if (amount > room) throw new RangeError(`the pool has room for ${formatTokenAmount(room)} more, and a deposit of ${leaves} leaves is ${formatTokenAmount(amount)}; nothing was signed`);
         const terms = await this.#aggregator("GET", "/v1/terms");
-        if (terms.chainId !== this.#config.chainId || typeof terms.pool !== "string" || getAddress18(terms.pool) !== pool || typeof terms.token !== "string" || getAddress18(terms.token) !== this.#token()) {
+        if (terms.chainId !== this.#config.chainId || typeof terms.pool !== "string" || getAddress19(terms.pool) !== pool || typeof terms.token !== "string" || getAddress19(terms.token) !== this.#token()) {
           throw new Error(`the aggregator serves pool ${String(terms.pool)} on chain ${String(terms.chainId)}, not ${pool} on ${this.#config.chainId}`);
         }
         if (typeof terms.aggregator !== "string") throw new Error("the aggregator's terms name no aggregator account");
-        const aggregatorAccount = getAddress18(terms.aggregator);
+        const aggregatorAccount = getAddress19(terms.aggregator);
         const status = await this.#vault.status();
         if (!status.vaultExists) throw new Error("open the vault and fund it first (open_vault)");
         const vault = await this.#vault.vaultAddress();
@@ -17974,7 +18299,7 @@ var init_shield = __esm({
                 leavesInPool.push({ batch: r.batch, leafIndex: i, key: leafKeyIndex(r.attempt ?? 0, j), amount: formatTokenAmount(LEAF_DENOMINATION), spent: b.status === "none" || leaf === void 0 || leaf.spent });
               });
             }
-            out.push({ index: r.index, vault: r.vault === void 0 ? null : getAddress18(r.vault), deposit: r.deposit, leaves: r.leaves, amount: formatTokenAmount(BigInt(r.amount)), status: r.status, batch: r.batch, leavesInPool });
+            out.push({ index: r.index, vault: r.vault === void 0 ? null : getAddress19(r.vault), deposit: r.deposit, leaves: r.leaves, amount: formatTokenAmount(BigInt(r.amount)), status: r.status, batch: r.batch, leavesInPool });
           }
           return out;
         });
@@ -17992,9 +18317,9 @@ var init_storage = __esm({
 });
 
 // ../core/src/unshield.ts
-import { encodeFunctionData as encodeFunctionData10, getAddress as getAddress19 } from "viem";
+import { encodeFunctionData as encodeFunctionData10, getAddress as getAddress20 } from "viem";
 function recordName2(chainId, token, index) {
-  return `${chainId}-${getAddress19(token)}-${index}.json`;
+  return `${chainId}-${getAddress20(token)}-${index}.json`;
 }
 function unshieldDelaySeconds(windowHours) {
   if (!Number.isFinite(windowHours) || windowHours < 0 || windowHours > UNSHIELD_MAX_WINDOW_HOURS) {
@@ -18067,7 +18392,7 @@ var init_unshield = __esm({
       }
       /** The private vaults created so far (their leaf spent), by index. */
       vaults() {
-        return this.#serial(async () => (await this.#records()).filter((r) => r.status === "spent").map((r) => ({ index: BigInt(r.index), vault: getAddress19(r.vault) })));
+        return this.#serial(async () => (await this.#records()).filter((r) => r.status === "spent").map((r) => ({ index: BigInt(r.index), vault: getAddress20(r.vault) })));
       }
       /** The number of the private vault at `vault`, or throws when it is none of this agent's. */
       async indexOf(vault) {
@@ -18166,7 +18491,7 @@ var init_unshield = __esm({
       async #spend(r) {
         const ctx = await this.#context(BigInt(r.index));
         const vault = await ctx.vault.vaultAddress();
-        if (vault !== getAddress19(r.vault)) throw new Error(`private vault ${r.index} is ${vault}, not the recorded ${r.vault}`);
+        if (vault !== getAddress20(r.vault)) throw new Error(`private vault ${r.index} is ${vault}, not the recorded ${r.vault}`);
         const pool = this.#config.deployment.pool;
         const batch = await readBatch(this.#client, pool, BigInt(r.batch));
         const leaf = batch.leaves[r.leafIndex];
@@ -18205,10 +18530,10 @@ import {
   decodeErrorResult as decodeErrorResult2,
   encodeAbiParameters as encodeAbiParameters6,
   encodeFunctionData as encodeFunctionData11,
-  getAddress as getAddress20,
+  getAddress as getAddress21,
   maxUint256,
-  parseAbi as parseAbi2,
-  zeroAddress as zeroAddress10
+  parseAbi as parseAbi3,
+  zeroAddress as zeroAddress11
 } from "viem";
 var MAX_UINT160, MAX_UINT128, universalRouterAbi, permit2Abi, wrappedErrorAbi;
 var init_wallet_swap = __esm({
@@ -18219,21 +18544,21 @@ var init_wallet_swap = __esm({
     init_pools();
     MAX_UINT160 = (1n << 160n) - 1n;
     MAX_UINT128 = (1n << 128n) - 1n;
-    universalRouterAbi = parseAbi2([
+    universalRouterAbi = parseAbi3([
       "function execute(bytes commands, bytes[] inputs, uint256 deadline) payable",
       "error TransactionDeadlinePassed()",
       "error ExecutionFailed(uint256 commandIndex, bytes message)",
       "error V4TooLittleReceived(uint256 minAmountOutReceived, uint256 amountReceived)",
       "error V4TooMuchRequested(uint256 maxAmountInRequested, uint256 amountRequested)"
     ]);
-    permit2Abi = parseAbi2([
+    permit2Abi = parseAbi3([
       "function allowance(address owner, address token, address spender) view returns (uint160 amount, uint48 expiration, uint48 nonce)",
       "error AllowanceExpired(uint256 deadline)",
       "error InsufficientAllowance(uint256 amount)",
       "error InvalidNonce()",
       "error SignatureExpired(uint256 signatureDeadline)"
     ]);
-    wrappedErrorAbi = parseAbi2(["error WrappedError(address target, bytes4 selector, bytes reason, bytes details)"]);
+    wrappedErrorAbi = parseAbi3(["error WrappedError(address target, bytes4 selector, bytes reason, bytes details)"]);
   }
 });
 
@@ -18257,6 +18582,7 @@ var init_src2 = __esm({
     init_pools();
     init_random();
     init_relay();
+    init_seed_backup();
     init_sessions();
     init_shield();
     init_storage();
@@ -18355,7 +18681,7 @@ import { join as join4 } from "node:path";
 import { createInterface } from "node:readline";
 import { Writable } from "node:stream";
 function scrypt(passphrase, salt) {
-  return new Promise((resolve, reject) => scryptCb(passphrase, salt, 32, SCRYPT, (err, key) => err === null ? resolve(key) : reject(err)));
+  return new Promise((resolve, reject) => scryptCb(passphrase, salt, 32, SCRYPT2, (err, key) => err === null ? resolve(key) : reject(err)));
 }
 async function sealSeedWithPassphrase(seed, passphrase) {
   if (seed.length !== 32) throw new RangeError("the seed is 32 bytes");
@@ -18363,18 +18689,18 @@ async function sealSeedWithPassphrase(seed, passphrase) {
   const iv = randomBytes5(12);
   const key = await scrypt(passphrase, salt);
   const cipher = createCipheriv("aes-256-gcm", key, iv);
-  cipher.setAAD(AAD);
+  cipher.setAAD(AAD2);
   const ciphertext = Buffer.concat([cipher.update(seed), cipher.final()]);
-  return `${JSON.stringify({ version: 1, kdf: { name: "scrypt", N: SCRYPT.N, r: SCRYPT.r, p: SCRYPT.p }, salt: salt.toString("hex"), iv: iv.toString("hex"), ciphertext: ciphertext.toString("hex"), tag: cipher.getAuthTag().toString("hex") })}
+  return `${JSON.stringify({ version: 1, kdf: { name: "scrypt", N: SCRYPT2.N, r: SCRYPT2.r, p: SCRYPT2.p }, salt: salt.toString("hex"), iv: iv.toString("hex"), ciphertext: ciphertext.toString("hex"), tag: cipher.getAuthTag().toString("hex") })}
 `;
 }
 async function openSeedWithPassphrase(text2, passphrase) {
   const b = JSON.parse(text2);
-  if (b.version !== 1 || b.kdf?.name !== "scrypt" || b.kdf.N !== SCRYPT.N || b.kdf.r !== SCRYPT.r || b.kdf.p !== SCRYPT.p) throw new Error("not an Ostra seed backup (version 1)");
+  if (b.version !== 1 || b.kdf?.name !== "scrypt" || b.kdf.N !== SCRYPT2.N || b.kdf.r !== SCRYPT2.r || b.kdf.p !== SCRYPT2.p) throw new Error("not an Ostra seed backup (version 1)");
   for (const f of [b.salt, b.iv, b.ciphertext, b.tag]) if (typeof f !== "string" || !/^[0-9a-f]+$/.test(f)) throw new Error("not an Ostra seed backup");
   const key = await scrypt(passphrase, Buffer.from(b.salt, "hex"));
   const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(b.iv, "hex"));
-  decipher.setAAD(AAD);
+  decipher.setAAD(AAD2);
   decipher.setAuthTag(Buffer.from(b.tag, "hex"));
   let seed;
   try {
@@ -18437,7 +18763,7 @@ async function runBackup(args) {
   process.stderr.write(`the seed is in ${join4(home, MASTER_FILE)}; the MCP server recovers the vaults from it (the relayer's signature escrow sends any signature still in flight)
 `);
 }
-var AAD, SCRYPT, MIN_PASSPHRASE;
+var AAD2, SCRYPT2, MIN_PASSPHRASE;
 var init_backup_cli = __esm({
   "src/backup-cli.ts"() {
     "use strict";
@@ -18445,8 +18771,8 @@ var init_backup_cli = __esm({
     init_disk();
     init_keys2();
     init_packaged();
-    AAD = Buffer.from("OSTRA/SEED-BACKUP/v1", "utf8");
-    SCRYPT = { N: 1 << 17, r: 8, p: 1, maxmem: 256 * 1024 * 1024 };
+    AAD2 = Buffer.from("OSTRA/SEED-BACKUP/v1", "utf8");
+    SCRYPT2 = { N: 1 << 17, r: 8, p: 1, maxmem: 256 * 1024 * 1024 };
     MIN_PASSPHRASE = 12;
     if (packaged === null && import.meta.url === `file://${process.argv[1]}`) {
       runBackup(process.argv.slice(2)).catch((err) => {
@@ -18461,7 +18787,7 @@ var init_backup_cli = __esm({
 // src/agent.ts
 import { readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join5 } from "node:path";
-import { createPublicClient as createPublicClient2, getAddress as getAddress21, isAddress as isAddress12 } from "viem";
+import { createPublicClient as createPublicClient2, getAddress as getAddress22, isAddress as isAddress12 } from "viem";
 import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
 var SWEEP_SECONDS, SELLER_RECORD, MERCHANT_DIR, Agent;
 var init_agent = __esm({
@@ -18554,7 +18880,7 @@ var init_agent = __esm({
         if (text2 === void 0) return;
         const r = JSON.parse(text2);
         if (r.chainId !== this.config.chainId || typeof r.crank !== "string" || !isAddress12(r.crank, { strict: false })) throw new Error(`${SELLER_RECORD} is not a seller record of chain ${this.config.chainId}`);
-        this.seller.setInitCrank(getAddress21(r.crank));
+        this.seller.setInitCrank(getAddress22(r.crank));
       }
       /** True once accept_payments set the seller vault up. */
       async sellerReady() {
@@ -18574,7 +18900,7 @@ var init_agent = __esm({
         let crank;
         const known = await this.keys.folder.read(SELLER_RECORD);
         if (known !== void 0) {
-          crank = getAddress21(JSON.parse(known).crank);
+          crank = getAddress22(JSON.parse(known).crank);
         } else {
           let res;
           try {
@@ -18584,7 +18910,7 @@ var init_agent = __esm({
           }
           const body = await res.json().catch(() => null);
           if (res.status !== 200 || typeof body?.crank !== "string" || !isAddress12(body.crank, { strict: false })) throw new Error(`the keeper answered ${res.status} without a crank`);
-          crank = getAddress21(body.crank);
+          crank = getAddress22(body.crank);
           this.seller.setInitCrank(crank);
           await this.keys.folder.write(SELLER_RECORD, `${JSON.stringify({ chainId: this.config.chainId, token, crank, merchant })}
 `);
@@ -18786,42 +19112,65 @@ function registerTools(server, agent) {
   tool("pool_info", "A token the Ostra launchpad launched: price, market cap, taxes, circuit breaker band, airdrop round, creator shares.", { token: address3 }, (a) => lp().poolInfo(a.token));
   tool(
     "quote_swap",
-    "Quotes a buy (USDG in) or sell (token in) as it would be signed now: expected and minimum output, the gas the swap reserves, the share of the circuit breaker's room used. Nothing is signed.",
+    "Quotes a buy (the pool's pair in: USDG or a stock token) or sell (token in) as it would be signed now: expected and minimum output, the gas the swap reserves, the share of the circuit breaker's room used. Nothing is signed.",
     { side: z.enum(["buy", "sell"]), token: address3, amount: units, slippageBps: slippage2, referrer: address3.optional() },
     (a) => lp().quote({ side: a.side, token: a.token, amount: a.amount, ...a.slippageBps === void 0 ? {} : { slippageBps: a.slippageBps }, ...a.referrer === void 0 ? {} : { referrer: a.referrer } })
   );
   tool(
     "buy",
-    "Buys a launched token with USDG from the vault; the tokens go to the agent's vault for that token (created in the same transaction).",
-    { token: address3, amount: usdg, slippageBps: slippage2, referrer: address3.optional() },
+    "Buys a launched token with its pool's pair: USDG from the vault, or a stock token from the agent's vault of that stock token (pairs: tradingVault). The tokens go to the agent's vault for that token (created in the same transaction). An ETH pool is traded from a wallet, not a vault.",
+    { token: address3, amount: units.describe("in the pool's pair: USDG (6 decimals) or the stock token (18)"), slippageBps: slippage2, referrer: address3.optional() },
     (a) => lp().buy({ token: a.token, amount: a.amount, ...a.slippageBps === void 0 ? {} : { slippageBps: a.slippageBps }, ...a.referrer === void 0 ? {} : { referrer: a.referrer } })
   );
   tool(
     "sell",
-    "Sells a launched token from the agent's token vault for USDG into the vault.",
+    "Sells a launched token from the agent's token vault for its pool's pair, into the agent's vault of that pair (USDG: the vault).",
     { token: address3, amount: units, slippageBps: slippage2, referrer: address3.optional() },
     (a) => lp().sell({ token: a.token, amount: a.amount, ...a.slippageBps === void 0 ? {} : { slippageBps: a.slippageBps }, ...a.referrer === void 0 ? {} : { referrer: a.referrer } })
   );
   tool("token_vault", "The agent's vault for a launched token: address, balance, dividends to claim.", { token: address3 }, (a) => lp().tokenVaultInfo(a.token));
   tool("transfer_token", "Sends a launched token from the agent's token vault to an address.", { token: address3, destination: address3, amount: units }, (a) => lp().transferToken(a));
   tool("claim_dividends", "Claims the dividends the agent's token vault earned, into the agent's vault of the dividend token.", { token: address3 }, (a) => lp().claimDividends(a.token));
-  tool("claim_referral", "Claims the USDG that swaps naming `referrer` (default: the agent's vault) earned it.", { referrer: address3.optional() }, (a) => lp().claimReferral(a.referrer === void 0 ? {} : { referrer: a.referrer }));
-  tool("fund_creator_vault", "Moves USDG from the vault into the creator vault, which pays launches, dev buys and airdrops (and its own relayer requests).", { amount: usdg }, (a) => lp().fundCreatorVault(a.amount));
-  tool("creator_withdraw", "Sends USDG from the creator vault (default: to the agent's vault): creator payouts it received, for example.", { amount: usdg, destination: address3.optional() }, async (a) => agent.creator.withdraw(a.destination ?? await agent.buyer.vaultAddress(), a.amount));
+  tool(
+    "claim_referral",
+    "Claims what swaps naming `referrer` earned it in a pair (default USDG; referrer default: the agent's vault of that pair's token; ETH earnings are paid in WETH to the referrer named).",
+    { referrer: address3.optional(), pair: pair2.optional() },
+    (a) => lp().claimReferral({ ...a.referrer === void 0 ? {} : { referrer: a.referrer }, ...a.pair === void 0 ? {} : { pair: a.pair } })
+  );
+  tool(
+    "pairs",
+    "The pairs a launch can take (USDG, ETH and the listed stock tokens), each with its USD price now, this agent's creator vault for it (what that pair's dev buys are paid from, and what owns its pools and receives their creator payouts) and the agent's vault of its token (what its pools are bought with).",
+    {},
+    () => lp().pairs({ prices: true })
+  );
+  tool(
+    "fund_creator_vault",
+    "Moves funds into the creator vault of a pair (default USDG): USDG from the vault (USDG launches, dev buys, airdrops and the USDG creator vault's relayer requests); a stock token or WETH from the agent's vault of it. Funds can also be sent straight to a pair's creator vault (pairs).",
+    { amount: units.describe("in the pair's token: USDG (6 decimals), WETH or the stock token (18)"), pair: pair2.optional() },
+    (a) => lp().fundCreatorVault(a.amount, a.pair ?? "USDG")
+  );
+  tool(
+    "creator_withdraw",
+    "Sends funds from the creator vault of a pair (default USDG; default destination: the agent's vault of that token; a WETH creator vault names it): creator payouts it received, for example.",
+    { amount: units.describe("in the pair's token"), destination: address3.optional(), pair: pair2.optional() },
+    (a) => lp().creatorWithdraw({ amount: a.amount, ...a.destination === void 0 ? {} : { destination: a.destination }, ...a.pair === void 0 ? {} : { pair: a.pair } })
+  );
   tool(
     "launch",
-    "Launches a token on the Ostra launchpad from the creator vault (USDG pool, 1 billion supply), optionally with a dev buy paid by the creator vault in the same transaction and vesting to the agent's token vault. The relayer fronts the 0.0002 ETH launch fee and charges it in USDG. The launch is simulated first; nothing is signed if it would fail. `options` sets LaunchParams fields (taxes, buckets, anti-snipe, limits, graduation, circuit breaker) beyond Ostra's defaults.",
+    "Launches a token on the Ostra launchpad (1 billion supply) paired with USDG (default), ETH or a listed stock token (pairs), from the agent's creator vault of that pair, optionally with a dev buy in the pair's token paid by that creator vault in the same transaction and vesting to the agent's token vault. The market cap is in US dollars, set in the pair's token at its price now (Chainlink for ETH and stocks). The relayer fronts the 0.0002 ETH launch fee and charges it in USDG. The launch is simulated first; nothing is signed if it would fail. `options` sets LaunchParams fields (taxes, buckets, anti-snipe, limits, graduation, circuit breaker) beyond Ostra's defaults.",
     {
       name: z.string().min(1).max(64),
       symbol: z.string().regex(/^[A-Za-z0-9]{1,11}$/),
-      marketCap: usdg.optional().describe("the starting market cap in USDG (or startTick)"),
+      pair: pair2.optional().describe("the pool's pair: USDG (default), ETH or a listed stock token's ticker"),
+      marketCap: usdg.optional().describe("the starting market cap in US dollars (or startTick)"),
       startTick: z.number().int().optional(),
-      devBuy: z.object({ amount: usdg, cliffDays: z.number().min(7).max(365).optional(), vestingDays: z.number().min(0).max(365).optional() }).optional(),
+      devBuy: z.object({ amount: units.describe("in the pair's token"), cliffDays: z.number().min(7).max(365).optional(), vestingDays: z.number().min(0).max(365).optional() }).optional(),
       options: z.record(z.string(), z.unknown()).optional()
     },
     (a) => lp().launch({
       name: a.name,
       symbol: a.symbol,
+      ...a.pair === void 0 ? {} : { pair: a.pair },
       ...a.marketCap === void 0 ? {} : { marketCap: a.marketCap },
       ...a.startTick === void 0 ? {} : { startTick: a.startTick },
       ...a.devBuy === void 0 ? {} : { devBuy: { amount: a.devBuy.amount, ...a.devBuy.cliffDays === void 0 ? {} : { cliffDays: a.devBuy.cliffDays }, ...a.devBuy.vestingDays === void 0 ? {} : { vestingDays: a.devBuy.vestingDays } } },
@@ -18920,7 +19269,7 @@ function launchOptions(raw) {
   }
   return out;
 }
-var toJson, address3, usdg, units, slippage2, bytes323, uri, publicFields, BIGINT_FIELDS, ALLOWED_OPTIONS;
+var toJson, address3, usdg, units, pair2, slippage2, bytes323, uri, publicFields, BIGINT_FIELDS, ALLOWED_OPTIONS;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
@@ -18931,6 +19280,7 @@ var init_tools = __esm({
     address3 = z.string().regex(/^0x[0-9a-fA-F]{40}$/, "an address: 0x and 40 hex characters");
     usdg = z.string().regex(/^(0|[1-9][0-9]*)(\.[0-9]{1,6})?$/, "a USDG amount: a plain decimal with at most 6 decimals");
     units = z.string().regex(/^(0|[1-9][0-9]*)(\.[0-9]{1,18})?$/, "an amount: a plain decimal with at most 18 decimals");
+    pair2 = z.enum(LAUNCH_PAIRS.map((p) => p.symbol));
     slippage2 = z.number().int().min(0).max(1e3).optional().describe("slippage in bps (default 100 = 1%, at most 1000)");
     bytes323 = z.string().regex(/^0x[0-9a-fA-F]{64}$/, "32 bytes of 0x hex");
     uri = z.string().max(256).regex(/^(ipfs|https):\/\/[^\s]+$/, "an ipfs:// or https:// URI of at most 256 bytes");