@ostraagent/mcp 0.1.3 → 0.1.5

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.3", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xD20c6744Cfa46d9ec564b119cC923bAb2f9f9331", 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" }, registry: "0xcE6Cc1f93744f4090DA1444Bb8590d9206157506" }, swapDeployment: { chainId: 4663, fromBlock: "94940585", router: "0x5b9686f384A5Fb768B2360cF0B893F0d1E960B01", stake: "0xaDA4FaB9c8aB9165bf4d6cD9d4Da6d6b32Bb4BC6", buyback: "0xd86083031b7Af66ecD5C9c5e90D4C6d8E661F3f5", spendVerifier: "0x0a0E28a81DE6289e5044950163FfE95b37180e3B", privatePool: "0xe4250895Da2499602Cee4e178Fb46A0cF39F5b76" }, prover: { wasm: "0xd5f3069334ab49a2f955e4b4be9493b80c3f7b2a85f4ff2073a327ef5fbc2747", glue: "0x4bc8bef7c755c83daaf833623f85473a20a7c40b390d8d639d9e4353618a0537" }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz" };
+    define_OSTRA_PACKAGED_default = { version: "0.1.5", deployment: { version: 1, chainId: 4663, fromBlock: "91991509", token: "0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168", batchSettlement: "0x4020074e9dF2ce1deE5A9C1b5c3f541D02a10003", vaultImplementation: "0xD20c6744Cfa46d9ec564b119cC923bAb2f9f9331", 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" }, registry: "0xcE6Cc1f93744f4090DA1444Bb8590d9206157506" }, swapDeployment: { chainId: 4663, fromBlock: "94940585", router: "0x5b9686f384A5Fb768B2360cF0B893F0d1E960B01", stake: "0xaDA4FaB9c8aB9165bf4d6cD9d4Da6d6b32Bb4BC6", buyback: "0xd86083031b7Af66ecD5C9c5e90D4C6d8E661F3f5", spendVerifier: "0x0a0E28a81DE6289e5044950163FfE95b37180e3B", privatePool: "0xe4250895Da2499602Cee4e178Fb46A0cF39F5b76" }, prover: { wasm: "0xd5f3069334ab49a2f955e4b4be9493b80c3f7b2a85f4ff2073a327ef5fbc2747", glue: "0x4bc8bef7c755c83daaf833623f85473a20a7c40b390d8d639d9e4353618a0537" }, relayerUrl: "https://relayer.ostraagent.xyz", keeperUrl: "https://keeper.ostraagent.xyz", aggregatorUrl: "https://aggregator.ostraagent.xyz", aiUrl: "https://ai.ostraagent.xyz" };
   }
 });
 
@@ -11721,7 +11721,7 @@ var init_hash = __esm({
 });
 
 // ../sdk/src/constants.ts
-var ROBINHOOD_CHAIN_ID, ROBINHOOD_PUBLIC_RPC, USDG, USDG_EIP712_DOMAIN, X402_BATCH_SETTLEMENT, X402_BATCH_SETTLEMENT_DOMAIN, X402_MIN_WITHDRAW_DELAY, X402_MAX_WITHDRAW_DELAY, UNISWAP_V4_POOL_MANAGER, CHAINLINK_ETH_USD, CHAINLINK_ETH_USD_DECIMALS, ERC8004_IDENTITY_REGISTRY, WETH, OSTRA, OSTRA_DECIMALS, OSTRA_PONS_CURVE, MULTICALL3, ARBITRUM_NODE_INTERFACE, MAX_FEE_BPS, DEPOSIT_TIMEOUT_SECONDS, VAULT_SWAP_GAS_RESERVE, VAULT_VERSION, VAULT_MAX_URI_LENGTH, VAULT_ACTION, MIN_RECOVERY_DELAY, MAX_RECOVERY_DELAY, POOL_SETTING, CIRCUIT_BREAKER, VAULT_SWAP_GAS, LAUNCHPAD, DEV_BUY, AIRDROP, CREATOR_SPLIT, DEPOSIT_STATUS, BATCH_STATUS;
+var ROBINHOOD_CHAIN_ID, ROBINHOOD_PUBLIC_RPC, USDG, USDG_EIP712_DOMAIN, X402_BATCH_SETTLEMENT, X402_BATCH_SETTLEMENT_DOMAIN, X402_MIN_WITHDRAW_DELAY, X402_MAX_WITHDRAW_DELAY, UNISWAP_V4_POOL_MANAGER, CHAINLINK_ETH_USD, CHAINLINK_ETH_USD_DECIMALS, ERC8004_IDENTITY_REGISTRY, WETH, OSTRA, OSTRA_DECIMALS, OSTRA_PONS_CURVE, PONS_HOOK, OSTRA_POOL_FEE, OSTRA_POOL_TICK_SPACING, MULTICALL3, ARBITRUM_NODE_INTERFACE, MAX_FEE_BPS, DEPOSIT_TIMEOUT_SECONDS, VAULT_SWAP_GAS_RESERVE, VAULT_VERSION, VAULT_MAX_URI_LENGTH, VAULT_ACTION, MIN_RECOVERY_DELAY, MAX_RECOVERY_DELAY, POOL_SETTING, CIRCUIT_BREAKER, VAULT_SWAP_GAS, LAUNCHPAD, DEV_BUY, AIRDROP, CREATOR_SPLIT, DEPOSIT_STATUS, BATCH_STATUS;
 var init_constants = __esm({
   "../sdk/src/constants.ts"() {
     "use strict";
@@ -11747,6 +11747,9 @@ var init_constants = __esm({
     OSTRA = "0x68Ff81dFFF6eccefb74706fE1e0a86320CB2Eb96";
     OSTRA_DECIMALS = 18;
     OSTRA_PONS_CURVE = "0xef89C3a9832Ae6f8Dc5F785484b1B5cb1120F372";
+    PONS_HOOK = "0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044";
+    OSTRA_POOL_FEE = 0;
+    OSTRA_POOL_TICK_SPACING = 200;
     MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
     ARBITRUM_NODE_INTERFACE = "0x00000000000000000000000000000000000000C8";
     MAX_FEE_BPS = 500;
@@ -12123,7 +12126,7 @@ var init_deployment = __esm({
 
 // ../sdk/src/external-abi.ts
 import { parseAbi } from "viem";
-var usdgAbi, chainlinkAggregatorAbi, ponsCurveAbi, multicall3Abi, nodeInterfaceAbi;
+var usdgAbi, chainlinkAggregatorAbi, ponsCurveAbi, poolManagerExtsloadAbi, multicall3Abi, nodeInterfaceAbi;
 var init_external_abi = __esm({
   "../sdk/src/external-abi.ts"() {
     "use strict";
@@ -12157,6 +12160,7 @@ var init_external_abi = __esm({
       "function getReserves() view returns (uint256 ethReserve, uint256 tokenReserve)",
       "function buy(uint256 ethIn, uint256 minTokensOut, address recipient) payable returns (uint256 tokensOut)"
     ]);
+    poolManagerExtsloadAbi = parseAbi(["function extsload(bytes32 slot) view returns (bytes32)"]);
     multicall3Abi = parseAbi([
       "struct Call3 { address target; bool allowFailure; bytes callData; }",
       "struct Result { bool success; bytes returnData; }",
@@ -13673,7 +13677,7 @@ var init_quote = __esm({
 });
 
 // ../sdk/src/pairs.ts
-import { getAddress as getAddress9, parseAbi as parseAbi2, zeroAddress as zeroAddress6 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters5, getAddress as getAddress9, hexToBigInt, keccak256 as keccak2569, parseAbi as parseAbi2, toHex as toHex2, zeroAddress as zeroAddress6 } from "viem";
 function findLaunchPair(symbolOrAddress) {
   const s = symbolOrAddress.trim();
   if (/^0x[0-9a-fA-F]{40}$/.test(s)) {
@@ -13688,6 +13692,14 @@ function launchPair(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 readOstraPool(client) {
+  const slot0 = keccak2569(encodeAbiParameters5([{ type: "bytes32" }, { type: "uint256" }], [OSTRA_POOL_ID, POOLS_SLOT2]));
+  const [word, liq] = await Promise.all([
+    client.readContract({ address: UNISWAP_V4_POOL_MANAGER, abi: poolManagerExtsloadAbi, functionName: "extsload", args: [slot0] }),
+    client.readContract({ address: UNISWAP_V4_POOL_MANAGER, abi: poolManagerExtsloadAbi, functionName: "extsload", args: [toHex2(hexToBigInt(slot0) + LIQUIDITY_OFFSET, { size: 32 })] })
+  ]);
+  return { sqrtPriceX96: hexToBigInt(word) & (1n << 160n) - 1n, liquidity: hexToBigInt(liq) & (1n << 128n) - 1n };
+}
 async function readPairUsdPrice(client, quote) {
   const block = await client.getBlock();
   const now3 = Number(block.timestamp);
@@ -13710,10 +13722,15 @@ async function readPairUsdPrice(client, quote) {
       client.readContract({ address: OSTRA_PONS_CURVE, abi: ponsCurveAbi, functionName: "graduated" }),
       client.readContract({ address: OSTRA_PONS_CURVE, abi: ponsCurveAbi, functionName: "getReserves" })
     ]);
-    if (graduated) throw new Error("OSTRA has graduated from its Pons curve and migrated; its price is not read from its new pool yet");
-    const [ethReserve, tokenReserve] = reserves;
-    if (ethReserve <= 0n || tokenReserve <= 0n) throw new Error(`the OSTRA Pons curve reports reserves of ${ethReserve} wei and ${tokenReserve} tokens`);
-    priceE8 = answer * ethReserve / tokenReserve;
+    if (graduated) {
+      const { sqrtPriceX96, liquidity } = await readOstraPool(client);
+      if (sqrtPriceX96 === 0n || liquidity === 0n) throw new Error(`OSTRA's pool ${OSTRA_POOL_ID} has no price or no liquidity in range`);
+      priceE8 = (answer << 192n) / (sqrtPriceX96 * sqrtPriceX96);
+    } else {
+      const [ethReserve, tokenReserve] = reserves;
+      if (ethReserve <= 0n || tokenReserve <= 0n) throw new Error(`the OSTRA Pons curve reports reserves of ${ethReserve} wei and ${tokenReserve} tokens`);
+      priceE8 = answer * ethReserve / tokenReserve;
+    }
     if (priceE8 < 100n) throw new Error(`OSTRA's price (${priceE8} x 0.00000001 USD) is too small to set a market cap in within 1%`);
   }
   if (quote.kind === "stock") {
@@ -13728,7 +13745,7 @@ function usdToQuoteUnits(usdE6, priceE8, decimals) {
   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 STOCK_PRICE_MAX_AGE, ETH_PRICE_MAX_AGE, stock, LAUNCH_PAIRS, stockTokenAbi, OSTRA_POOL_ID, POOLS_SLOT2, LIQUIDITY_OFFSET;
 var init_pairs = __esm({
   "../sdk/src/pairs.ts"() {
     "use strict";
@@ -13783,6 +13800,14 @@ var init_pairs = __esm({
       stock("USO", "United States Oil Fund ETF", "0xa30FA36Db767ad9eD3f7a60fC79526fB4d56D344", "0x75a9c76Ef439e2C7c2E5a34Ab105EcFe3766431c")
     ];
     stockTokenAbi = parseAbi2(["function uiMultiplier() view returns (uint256)"]);
+    OSTRA_POOL_ID = keccak2569(
+      encodeAbiParameters5(
+        [{ type: "address" }, { type: "address" }, { type: "uint24" }, { type: "int24" }, { type: "address" }],
+        [zeroAddress6, OSTRA, OSTRA_POOL_FEE, OSTRA_POOL_TICK_SPACING, PONS_HOOK]
+      )
+    );
+    POOLS_SLOT2 = 6n;
+    LIQUIDITY_OFFSET = 3n;
   }
 });
 
@@ -13813,7 +13838,7 @@ var init_browser = __esm({
 });
 
 // ../sdk/src/deploy.ts
-import { concat as concat3, encodeDeployData, encodeFunctionData as encodeFunctionData5, getAddress as getAddress10, 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 keccak25610, numberToHex as numberToHex2 } from "viem";
 var init_deploy = __esm({
   "../sdk/src/deploy.ts"() {
     "use strict";
@@ -13959,6 +13984,132 @@ var init_amount = __esm({
   }
 });
 
+// ../core/src/ai.ts
+import { getAddress as getAddress11 } from "viem";
+function textStreamAnswer(sse) {
+  let content = "";
+  let reasoning = "";
+  const calls = [];
+  let closing = null;
+  let finish = null;
+  for (const event of sse.split(/\r?\n\r?\n/)) {
+    const lines = event.split(/\r?\n/).filter((l) => l !== "" && !l.startsWith(":"));
+    if (lines.length === 0) continue;
+    const named = lines[0]?.startsWith("event: ") ? lines[0].slice("event: ".length) : null;
+    const data = lines.filter((l) => l.startsWith("data: ")).map((l) => l.slice("data: ".length)).join("\n");
+    if (data === "" || data === "[DONE]") continue;
+    let json;
+    try {
+      json = JSON.parse(data);
+    } catch {
+      continue;
+    }
+    if (named === "ostra" || json.object === "ostra.task") {
+      closing = json;
+      continue;
+    }
+    const choice = json.choices?.[0];
+    if (choice === void 0) continue;
+    if (choice.finish_reason !== null && choice.finish_reason !== void 0) finish = choice.finish_reason;
+    const d = choice.delta ?? {};
+    if (typeof d.content === "string") content += d.content;
+    if (typeof d.reasoning === "string") reasoning += d.reasoning;
+    for (const tc of d.tool_calls ?? []) {
+      const i = typeof tc.index === "number" ? tc.index : 0;
+      const cur = calls[i] ?? (calls[i] = { type: "function", function: { name: "", arguments: "" } });
+      if (typeof tc.id === "string") cur.id = tc.id;
+      if (typeof tc.type === "string") cur.type = tc.type;
+      if (typeof tc.function?.name === "string") cur.function.name += tc.function.name;
+      if (typeof tc.function?.arguments === "string") cur.function.arguments += tc.function.arguments;
+    }
+  }
+  const message = { role: "assistant", content, reasoning: reasoning === "" ? null : reasoning, ...calls.length === 0 ? {} : { tool_calls: calls.filter((c) => c !== void 0) } };
+  if (closing === null) return { error: "stream_incomplete", message: "the answer's stream ended before what it was charged was told", partial: message };
+  const { object: _object, ...rest } = closing;
+  if (typeof rest.error === "string") return { ...rest, partial: message };
+  return { ...rest, message, finish_reason: rest.finish_reason ?? finish };
+}
+var AI_TASK_KINDS, AI_MAX_BODY_CHARS, SET_HERE, REQUEST_TIMEOUT_MS, TASK_TIMEOUT_MS, RAW_ANSWER_CHARS, AiService;
+var init_ai = __esm({
+  "../core/src/ai.ts"() {
+    "use strict";
+    init_define_OSTRA_PACKAGED();
+    init_amount();
+    AI_TASK_KINDS = ["text", "image", "video"];
+    AI_MAX_BODY_CHARS = 48 * 1024 * 1024;
+    SET_HERE = ["task", "max_price", "payer", "stream"];
+    REQUEST_TIMEOUT_MS = 6e4;
+    TASK_TIMEOUT_MS = 66e4;
+    RAW_ANSWER_CHARS = 4e3;
+    AiService = class {
+      #url;
+      #payments;
+      #vault;
+      constructor(config, payments, vault) {
+        if (config.aiUrl === null) throw new Error("Ostra AI is not configured here (OSTRA_AI_URL)");
+        this.#url = config.aiUrl.replace(/\/+$/, "");
+        this.#payments = payments;
+        this.#vault = vault;
+      }
+      /** Runs a `kind` task with `request`'s parameters, paying at most `maxPrice` USDG from a channel of the vault. */
+      async task(kind, request, maxPrice, deposit) {
+        if (!AI_TASK_KINDS.includes(kind)) throw new RangeError(`the task is one of ${AI_TASK_KINDS.join(", ")}`);
+        for (const key of SET_HERE) if (key in request) throw new RangeError(`${key} is set by ostra_ai: leave it out of request`);
+        const units2 = parseTokenAmount(maxPrice);
+        if (units2 <= 0n) throw new RangeError("maxPrice must be positive");
+        const payer = getAddress11(await this.#vault.vaultAddress());
+        const body = JSON.stringify({ ...request, task: kind, max_price: units2.toString(), payer, ...kind === "text" ? { stream: true } : {} });
+        const r = await this.#payments.pay({
+          url: `${this.#url}/v1/ai/${kind}`,
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body,
+          maxPrice,
+          maxBodyChars: AI_MAX_BODY_CHARS,
+          timeoutMs: TASK_TIMEOUT_MS,
+          ...deposit === void 0 ? {} : { deposit }
+        });
+        let answer;
+        const head = r.body.trimStart();
+        if (r.status === 200 && kind === "text" && (head.startsWith("data:") || head.startsWith(":") || head.startsWith("event:"))) answer = textStreamAnswer(r.body);
+        else {
+          try {
+            answer = JSON.parse(r.body);
+          } catch {
+            answer = r.body.slice(0, RAW_ANSWER_CHARS);
+          }
+        }
+        const failed = answer !== null && typeof answer === "object" && typeof answer.error === "string";
+        const notes = [r.note, r.truncated ? "the answer was longer than ostra_ai reads and was cut" : void 0, r.status === 200 && failed ? "the task failed after it began (answer.error): what it was charged is the vault's credit with Ostra AI" : void 0].filter((x) => x !== void 0);
+        return { status: r.status, paid: r.paid, channel: r.channel, channelLeft: r.channelLeft, answer, ...notes.length === 0 ? {} : { note: notes.join("; ") } };
+      }
+      /** A video job's status; the first final one settles its cost and credits the rest. */
+      async job(id) {
+        if (!/^[0-9a-f]{32}$/.test(id)) throw new RangeError("job is the 32 hex characters ostra_ai gave");
+        const res = await fetch(`${this.#url}/v1/ai/video/${id}`, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+        const text2 = await res.text();
+        try {
+          return { status: res.status, answer: JSON.parse(text2) };
+        } catch {
+          return { status: res.status, answer: text2.slice(0, 2e3) };
+        }
+      }
+      /** Where a finished video job's content is read (no payment). */
+      contentUrl(id) {
+        if (!/^[0-9a-f]{32}$/.test(id)) throw new RangeError("job is the 32 hex characters ostra_ai gave");
+        return `${this.#url}/v1/ai/video/${id}/content`;
+      }
+      /** The vault's credit with Ostra AI (USDG base units). */
+      async credit() {
+        const payer = getAddress11(await this.#vault.vaultAddress());
+        const res = await fetch(`${this.#url}/v1/ai/credits/${payer}`, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+        if (!res.ok) throw new Error(`Ostra AI answered ${res.status} for the vault's credit`);
+        return res.json();
+      }
+    };
+  }
+});
+
 // ../core/src/chain.ts
 import { createWalletClient } from "viem";
 function tokenBalance(client, token, owner) {
@@ -14053,13 +14204,13 @@ var init_config = __esm({
 });
 
 // ../core/src/relay.ts
-import { decodeFunctionData as decodeFunctionData3, getAddress as getAddress11, isAddress as isAddress5 } from "viem";
+import { decodeFunctionData as decodeFunctionData3, getAddress as getAddress12, 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 getAddress11(value);
+  return getAddress12(value);
 }
 function checkSplits(raw, what) {
   if (!Array.isArray(raw)) throw new Error(`${what} are not a list`);
@@ -14080,7 +14231,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") !== getAddress11(want.token)) throw new Error(`the relayer serves token ${String(f.token)}, not ${want.token}`);
+  if (address(f.token, "the relayer's token") !== getAddress12(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}`);
@@ -14108,10 +14259,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 }) || 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}`;
+  if (!isAddress5(r.asset, { strict: false }) || getAddress12(r.asset) !== getAddress12(want.config.token)) return `the offer is in ${r.asset}, not ${want.config.token}`;
+  if (!isAddress5(r.payTo, { strict: false }) || getAddress12(r.payTo) !== getAddress12(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 }) || getAddress11(extra.receiverAuthorizer) !== getAddress11(want.config.receiverAuthorizer)) {
+  if (typeof extra.receiverAuthorizer !== "string" || !isAddress5(extra.receiverAuthorizer, { strict: false }) || getAddress12(extra.receiverAuthorizer) !== getAddress12(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`;
@@ -14124,7 +14275,7 @@ function relayerOfferProblem(r, want) {
 }
 function openChannelCall(calls, vault, token) {
   for (const c of calls) {
-    if (getAddress11(c.to) !== getAddress11(vault)) continue;
+    if (getAddress12(c.to) !== getAddress12(vault)) continue;
     let decoded;
     try {
       decoded = decodeFunctionData3({ abi: ostraVaultAbi, data: c.data });
@@ -14139,7 +14290,7 @@ function openChannelCall(calls, vault, token) {
   }
   return null;
 }
-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 RELAYER_DIR, VAULT_SPEND_GAS, REQUEST_TIMEOUT_MS2, 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";
@@ -14150,7 +14301,7 @@ var init_relay = __esm({
     init_config();
     RELAYER_DIR = "relayer";
     VAULT_SPEND_GAS = 400000n;
-    REQUEST_TIMEOUT_MS = 24e4;
+    REQUEST_TIMEOUT_MS2 = 24e4;
     MAX_STEPS = 8;
     MAX_RESENDS = 3;
     LANDED_TIMEOUT_MS = 6e4;
@@ -14210,7 +14361,7 @@ var init_relay = __esm({
       #name;
       constructor(agentFolder, chainId, token, relayerVault) {
         this.#folder = agentFolder.folder(RELAYER_DIR);
-        this.#name = `${chainId}-${getAddress11(token)}-${getAddress11(relayerVault)}.json`;
+        this.#name = `${chainId}-${getAddress12(token)}-${getAddress12(relayerVault)}.json`;
       }
       async load() {
         const text2 = await this.#folder.read(this.#name);
@@ -14264,7 +14415,7 @@ var init_relay = __esm({
             method,
             headers: body === void 0 ? headers : { "content-type": "application/json", ...headers },
             ...body === void 0 ? {} : { body },
-            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
           });
         } catch (err) {
           throw new RelayerUnavailableError(`the relayer at ${this.url} cannot be reached: ${err.message}`);
@@ -14295,7 +14446,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 (getAddress11(split) !== facts.split) throw new Error(`the relayer's split ${facts.split} is not the OstraSplit of its vault and splits (${split})`);
+        if (getAddress12(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;
@@ -14317,7 +14468,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: getAddress11(c.to), data: c.data })) : []
+            calls: Array.isArray(open3.calls) ? open3.calls.map((c) => ({ to: getAddress12(c.to), data: c.data })) : []
           }
         };
       }
@@ -14371,7 +14522,7 @@ var init_relay = __esm({
             continue;
           }
           const ch = await readChannel(this.#client, this.#config.deployment.batchSettlement, c.channel);
-          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;
+          const usable = payer !== null && getAddress12(c.config.payer) === payer && getAddress12(c.config.receiverAuthorizer) === facts.vault && getAddress12(c.config.receiver) === facts.split && ch.pendingWithdrawal === null && ch.balance - BigInt(c.cumulative) >= amount;
           if (!usable) {
             c.retired = true;
             await this.#save();
@@ -14439,7 +14590,7 @@ var init_relay = __esm({
         else this.#reserved.delete(reservation.channel);
       }
       async #post(calls, extra, headers = {}) {
-        const body = { calls: calls.map((c) => ({ to: getAddress11(c.to), data: c.data })) };
+        const body = { calls: calls.map((c) => ({ to: getAddress12(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;
@@ -14448,10 +14599,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 !== getAddress11(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 !== getAddress12(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: getAddress11(c.config.payer),
+          address: getAddress12(c.config.payer),
           signTypedData: () => Promise.reject(new Error("a vault never signs typed data")),
           readContract: (args) => client.readContract(args)
         };
@@ -14543,11 +14694,11 @@ 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 (getAddress11(config.receiver) !== facts.split || getAddress11(config.receiverAuthorizer) !== facts.vault || config.withdrawDelay !== facts.gracePeriodSeconds) {
+        if (getAddress12(config.receiver) !== facts.split || getAddress12(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 !== getAddress11(config.payerAuthorizer)) throw new Error(`the voucher key of relayer channel ${channel} is not derived from this machine's master seed`);
+        if (voucherKey.address !== getAddress12(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();
@@ -14702,7 +14853,7 @@ var init_relay = __esm({
 });
 
 // ../core/src/channels.ts
-import { bytesToHex as bytesToHex7, decodeFunctionData as decodeFunctionData4, encodeFunctionData as encodeFunctionData6, getAddress as getAddress12, isAddress as isAddress6, parseAbiItem } from "viem";
+import { bytesToHex as bytesToHex7, decodeFunctionData as decodeFunctionData4, encodeFunctionData as encodeFunctionData6, getAddress as getAddress13, 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) {
@@ -14718,7 +14869,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 = getAddress12(r.recipient);
+    const recipient = getAddress13(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`);
@@ -14737,7 +14888,7 @@ function parseGracePeriod(seconds) {
 }
 async function splitAddress(client, config, vault, recipients) {
   const d = config.deployment;
-  return getAddress12(
+  return getAddress13(
     await client.readContract({
       address: d.splitFactory,
       abi: ostraSplitFactoryAbi,
@@ -14771,12 +14922,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 && getAddress12(tx.to) === getAddress12(vault)) calls.push({ to: vault, data: tx.input });
-    if (tx.to !== null && tx.to !== void 0 && getAddress12(tx.to) === MULTICALL3) {
+    if (tx.to !== null && tx.to !== void 0 && getAddress13(tx.to) === getAddress13(vault)) calls.push({ to: vault, data: tx.input });
+    if (tx.to !== null && tx.to !== void 0 && getAddress13(tx.to) === MULTICALL3) {
       try {
         const decoded = decodeFunctionData4({ abi: multicall3Abi, data: tx.input });
         const inner = decoded.args[0];
-        for (const c of inner) if (getAddress12(c.target) === getAddress12(vault)) calls.push({ to: vault, data: c.callData });
+        for (const c of inner) if (getAddress13(c.target) === getAddress13(vault)) calls.push({ to: vault, data: c.callData });
       } catch {
       }
     }
@@ -14856,7 +15007,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 && getAddress12(record.token) === getAddress12(token)) out.push(record);
+          if (record.chainId === chainId && getAddress13(record.token) === getAddress13(token)) out.push(record);
         }
         return out.sort((x, y) => x.createdAt - y.createdAt);
       }
@@ -14904,8 +15055,8 @@ var init_channels = __esm({
           vault,
           channel: opening.channel,
           config: opening.config,
-          payee: getAddress12(o.receiverAuthorizer),
-          voucherKey: getAddress12(o.payerAuthorizer),
+          payee: getAddress13(o.receiverAuthorizer),
+          voucherKey: getAddress13(o.payerAuthorizer),
           deposit: o.amount.toString(),
           gracePeriod: o.withdrawDelay,
           recipients,
@@ -14941,7 +15092,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 = getAddress12(input.payee);
+          const payee = getAddress13(input.payee);
           const deposit = parseTokenAmount(input.deposit);
           if (deposit === 0n) throw new RangeError("deposit must be greater than zero");
           const gracePeriod = parseGracePeriod(input.gracePeriod);
@@ -14950,8 +15101,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 ? 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 receiver = input.receiver !== void 0 ? getAddress13(input.receiver) : await splitAddress(this.#client, this.#config, payee, recipients);
+          if (receiver === getAddress13("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 };
@@ -14995,7 +15146,7 @@ var init_channels = __esm({
             const view2 = {
               channel: record.channel,
               payee: record.payee,
-              receiver: getAddress12(record.config.receiver),
+              receiver: getAddress13(record.config.receiver),
               gracePeriod: record.gracePeriod,
               voucherKey: record.voucherKey,
               closeRequested: record.closeRequested,
@@ -15032,11 +15183,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 || getAddress12(cfg.payer) !== vault || getAddress12(cfg.token) !== d.token) {
+            if (channelId(cfg, this.#config.chainId, d.batchSettlement).toLowerCase() !== channel || getAddress13(cfg.payer) !== vault || getAddress13(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 !== getAddress12(cfg.payerAuthorizer)) throw new Error(`channel ${channel} uses a voucher key this machine cannot derive`);
+            if (voucher.address !== getAddress13(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,
@@ -15114,7 +15265,7 @@ var init_channels = __esm({
           sent,
           ...extra
         });
-        if (getAddress12(record.config.payer) !== getAddress12(record.vault)) throw new Error(`channel ${channel} does not belong to this vault's record`);
+        if (getAddress13(record.config.payer) !== getAddress13(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);
@@ -15129,7 +15280,7 @@ var init_channels = __esm({
           try {
             if (status === "open") {
               const voucher = this.voucherSigner(record);
-              if (voucher.address !== getAddress12(record.config.payerAuthorizer)) throw new Error(`the voucher key of channel ${channel} could not be derived`);
+              if (voucher.address !== getAddress13(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;
@@ -15319,14 +15470,14 @@ var init_passkey = __esm({
 });
 
 // ../core/src/keys.ts
-import { bytesToHex as bytesToHex9, getAddress as getAddress13, hexToBytes as hexToBytes7 } from "viem";
+import { bytesToHex as bytesToHex9, getAddress as getAddress14, 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(getAddress13(token));
+  return hexToBytes7(getAddress14(token));
 }
 function u64Be(value) {
   if (value < 0n || value > U64_MAX5) throw new RangeError("index out of range");
@@ -15419,7 +15570,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}-${getAddress13(token)}-${index}`);
+        const folder = this.#root.folder(PRIVATE_DIR).folder(`${chainId}-${getAddress14(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 });
       }
@@ -15430,7 +15581,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}-${getAddress13(token)}`);
+        const folder = this.#root.folder(CREATOR_DIR).folder(`${chainId}-${getAddress14(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 });
       }
@@ -15528,13 +15679,13 @@ var init_keys = __esm({
 });
 
 // ../core/src/pools.ts
-import { getAddress as getAddress14, isAddress as isAddress7, zeroAddress as zeroAddress7 } from "viem";
+import { getAddress as getAddress15, 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 getAddress14(text2);
+  return getAddress15(text2);
 }
 async function readLaunchedPool(client, lp, tokenText) {
   const token = launchedTokenAddress(tokenText);
@@ -15547,7 +15698,7 @@ async function readLaunchedPool(client, lp, tokenText) {
   return { token, id, key, config };
 }
 function quoteOfPool(pool) {
-  return getAddress14(pool.config.tokenIs0 ? pool.key.currency1 : pool.key.currency0);
+  return getAddress15(pool.config.tokenIs0 ? pool.key.currency1 : pool.key.currency0);
 }
 async function readPoolView(client, lp, tokenText) {
   const pool = await readLaunchedPool(client, lp, tokenText);
@@ -15581,7 +15732,7 @@ async function readPoolView(client, lp, tokenText) {
     name,
     symbol,
     quote,
-    creatorVault: getAddress14(c.creatorVault),
+    creatorVault: getAddress15(c.creatorVault),
     graduated: state.graduated,
     tokensSold: formatUnitsAmount(state.tokensSold < 0n ? 0n : state.tokensSold, 18),
     quoteRaised: fmtQuote(state.quoteRaised),
@@ -15593,7 +15744,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: getAddress14(c.dividendToken) === zeroAddress7 ? null : getAddress14(c.dividendToken),
+    dividendToken: getAddress15(c.dividendToken) === zeroAddress7 ? null : getAddress15(c.dividendToken),
     launchedAt: iso(BigInt(c.launchedAt)),
     airdrop: {
       round: round.number,
@@ -15604,7 +15755,7 @@ async function readPoolView(client, lp, tokenText) {
       available: formatUnitsAmount(available, 18),
       nextRoundAmount: formatUnitsAmount(nextAmount, 18)
     },
-    creatorShares: shares[0].map((recipient, i) => ({ recipient: getAddress14(recipient), bps: Number(shares[1][i]) })),
+    creatorShares: shares[0].map((recipient, i) => ({ recipient: getAddress15(recipient), bps: Number(shares[1][i]) })),
     rules: {
       quoteDecimals,
       supply: formatUnitsAmount(state.supply, 18),
@@ -15777,7 +15928,7 @@ var init_pending = __esm({
 });
 
 // ../core/src/vault.ts
-import { bytesToHex as bytesToHex10, encodeAbiParameters as encodeAbiParameters5, encodeFunctionData as encodeFunctionData7, getAddress as getAddress15, isAddress as isAddress8, keccak256 as keccak25610, zeroAddress as zeroAddress9 } from "viem";
+import { bytesToHex as bytesToHex10, encodeAbiParameters as encodeAbiParameters6, encodeFunctionData as encodeFunctionData7, getAddress as getAddress16, isAddress as isAddress8, keccak256 as keccak25611, zeroAddress as zeroAddress9 } from "viem";
 function spendGas(calls) {
   return calls.reduce((gas, c) => gas + reservedSwapGas(c), VAULT_SPEND_GAS);
 }
@@ -15822,9 +15973,9 @@ var init_vault = __esm({
         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 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"}`);
+        if (vaultToken !== null && getAddress16(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 : getAddress15(vaultToken);
+        this.token = vaultToken === null ? config.deployment.token : getAddress16(vaultToken);
         this.privateIndex = privateIndex;
         this.#client = client;
         this.#transport = transport;
@@ -15839,7 +15990,7 @@ var init_vault = __esm({
       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 = getAddress15(crank);
+        this.#initCrank = getAddress16(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() {
@@ -15879,10 +16030,10 @@ var init_vault = __esm({
           return null;
         }
         const r = JSON.parse(text2);
-        if (r.chainId !== this.#config.chainId || typeof r.token !== "string" || getAddress15(r.token) !== this.token || typeof r.vault !== "string" || !isAddress8(r.vault, { strict: false })) {
+        if (r.chainId !== this.#config.chainId || typeof r.token !== "string" || getAddress16(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 = getAddress15(r.vault);
+        this.#adopted = getAddress16(r.vault);
         return this.#adopted;
       }
       async vaultAddress() {
@@ -16134,7 +16285,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 || getAddress15(devBuy) !== lp.devBuy) throw new Error(`the vault signed a DevBuy for ${devBuy}, not this deployment's OstraDevBuy`);
+          if (lp === void 0 || getAddress16(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 });
@@ -16237,7 +16388,7 @@ 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 = getAddress15(destinationText);
+          const destination = getAddress16(destinationText);
           if (destination === zeroAddress9) throw new RangeError("the destination must not be the zero address");
           await this.#checkToken();
           const vault = await this.vaultAddress();
@@ -16288,7 +16439,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 (getAddress15(open3.receiverAuthorizer) === vault || getAddress15(open3.receiver) === vault) throw new Error("the channel would pay this agent's own vault");
+          if (getAddress16(open3.receiverAuthorizer) === vault || getAddress16(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) => {
@@ -16362,7 +16513,7 @@ 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 = getAddress15(crankText);
+          const crank = getAddress16(crankText);
           const target = crank === zeroAddress9 ? null : crank;
           const vault = await this.vaultAddress();
           if (await this.#read(vault) === null) throw new Error(this.#missing());
@@ -16450,7 +16601,7 @@ 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 = getAddress15(guardianText);
+        const guardian = getAddress16(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 }),
@@ -16496,7 +16647,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 = getAddress15(vaultText);
+        const target = getAddress16(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(
@@ -16509,7 +16660,7 @@ the signed operation is kept; the next call on this vault sends it again before
             if (!await read("isGuardian", [vault])) throw new Error(`this vault ${vault} is not a guardian of ${target}`);
             const r = await readRecovery(this.#client, target);
             if (r.threshold === 0) throw new Error(`${target} has recovery turned off`);
-            const proposal = keccak25610(encodeAbiParameters5([{ type: "uint32" }, { type: "bytes32" }], [r.round, newKeyRoot]));
+            const proposal = keccak25611(encodeAbiParameters6([{ type: "uint32" }, { type: "bytes32" }], [r.round, newKeyRoot]));
             return await read("supportedBy", [proposal, vault]);
           },
           via
@@ -16525,7 +16676,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 = getAddress15(vaultText);
+          const vault = getAddress16(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();
@@ -16583,7 +16734,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 getAddress16, isAddress as isAddress9, parseAbiItem as parseAbiItem2, zeroAddress as zeroAddress10 } from "viem";
+import { bytesToHex as bytesToHex11, decodeEventLog as decodeEventLog3, encodeFunctionData as encodeFunctionData8, getAddress as getAddress17, 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\//, "");
@@ -16620,7 +16771,7 @@ function nowIso(seconds) {
 }
 function address2(text2, what) {
   if (!isAddress9(text2, { strict: false })) throw new RangeError(`${what} ${text2} is not an address`);
-  return getAddress16(text2);
+  return getAddress17(text2);
 }
 function slippage(bps) {
   const s = bps ?? QUOTE_DEFAULT_SLIPPAGE_BPS;
@@ -16723,8 +16874,8 @@ var init_launchpad = __esm({
        */
       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`);
+        if (v !== null && v.token !== getAddress17(paid)) {
+          throw new Error(`${to} is an Ostra vault in ${v.token}: a vault only moves its own token, so ${what} in ${getAddress17(paid)} would be stuck there for good; nothing was signed`);
         }
       }
       /** The token a pair's vaults hold: the pair's own; WETH for ETH. */
@@ -16816,9 +16967,9 @@ var init_launchpad = __esm({
         const pool = await this.#pool(tokenText);
         const s = await this.tokenVault(pool.token).state();
         let dividends = null;
-        if (getAddress16(pool.config.dividendToken) !== zeroAddress10) {
+        if (getAddress17(pool.config.dividendToken) !== zeroAddress10) {
           const owed = await this.#client.readContract({ address: pool.token, abi: ostraTokenAbi, functionName: "dividendOf", args: [s.vault] });
-          const decimals = getAddress16(pool.config.dividendToken) === this.#usdg() ? TOKEN_DECIMALS : await tokenDecimals(this.#client, getAddress16(pool.config.dividendToken));
+          const decimals = getAddress17(pool.config.dividendToken) === this.#usdg() ? TOKEN_DECIMALS : await tokenDecimals(this.#client, getAddress17(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 };
@@ -16846,7 +16997,7 @@ var init_launchpad = __esm({
         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, OSTRA or a listed stock token); nothing was signed`);
         const referrer = a.referrer === void 0 ? void 0 : address2(a.referrer, "referrer");
-        const quoteIs0 = getAddress16(pool.key.currency0) === quote;
+        const quoteIs0 = getAddress17(pool.key.currency0) === quote;
         const buying = a.side === "buy";
         const quoteVault = this.tokenVault(quote);
         const from = buying ? quoteVault : this.tokenVault(pool.token);
@@ -16877,7 +17028,7 @@ var init_launchpad = __esm({
       async #swapOutcome(txHash, vault) {
         const receipt = await this.#client.getTransactionReceipt({ hash: txHash });
         for (const log2 of receipt.logs) {
-          if (getAddress16(log2.address) !== vault) continue;
+          if (getAddress17(log2.address) !== vault) continue;
           try {
             const e = decodeEventLog3({ abi: ostraVaultAbi, topics: log2.topics, data: log2.data });
             if (e.eventName === "Swapped") {
@@ -16969,7 +17120,7 @@ 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 = getAddress16(pool.config.dividendToken);
+        const dividendToken = getAddress17(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();
@@ -17077,7 +17228,7 @@ var init_launchpad = __esm({
           creatorVault,
           startTick
         });
-        const token = getAddress16(await this.#client.readContract({ address: lp.devBuy, abi: ostraDevBuyAbi, functionName: "tokenAddressFromVault", args: [p] }));
+        const token = getAddress17(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) {
@@ -17085,7 +17236,7 @@ var init_launchpad = __esm({
           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 = getAddress16(p.dividendToken);
+          const dividendToken = getAddress17(p.dividendToken);
           dev = {
             quoteIn,
             beneficiary: tokenVault,
@@ -17123,14 +17274,14 @@ var init_launchpad = __esm({
         let bought = null;
         for (const log2 of receipt.logs) {
           try {
-            if (getAddress16(log2.address) === lp.launchpad) {
+            if (getAddress17(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 (getAddress16(log2.address) === lp.devBuy) {
+            } else if (getAddress17(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: getAddress16(g.vesting) };
+                bought = { ...g, vesting: getAddress17(g.vesting) };
               }
             }
           } catch {
@@ -17167,7 +17318,7 @@ var init_launchpad = __esm({
         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}`);
+        if (getAddress17(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 };
       }
       /**
@@ -17220,7 +17371,7 @@ var init_launchpad = __esm({
         if (amountIn === 0n) throw new RangeError("amount must be greater than zero");
         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 quoteIs0 = getAddress17(pool.key.currency0) === pair3.address;
         const q = await quoteVaultSwap(this.#client, this.#config.deployment, {
           vault: s.vault,
           relayer: await sender.payer(),
@@ -17306,7 +17457,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) => getAddress16(c.account) === account);
+          const claim = JSON.parse(text2).claims.find((c) => getAddress17(c.account) === account);
           if (claim === void 0) throw new Error(`${account} is not in round ${r.number}`);
           amount = BigInt(claim.amount);
           proof = claim.proof;
@@ -17341,7 +17492,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 = getAddress16(v);
+          vesting = getAddress17(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`);
@@ -17352,8 +17503,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, 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) };
+        const held = await tokenBalance(this.#client, getAddress17(terms.token), vesting);
+        return { vesting, beneficiary: getAddress17(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) {
@@ -17390,7 +17541,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 (getAddress16(index.launchpad) !== getAddress16(lp.launchpad)) index = { version: 1, launchpad: lp.launchpad, scannedTo: (BigInt(this.#config.deployment.fromBlock) - 1n).toString(), launches: [] };
+        if (getAddress17(index.launchpad) !== getAddress17(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;
@@ -17399,7 +17550,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: 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.launches.push({ token: getAddress17(l.args.token), poolId: l.args.poolId, creatorVault: getAddress17(l.args.creatorVault), quote: getAddress17(l.args.quote), block: l.blockNumber.toString(), txHash: l.transactionHash });
           }
           index.scannedTo = to.toString();
         }
@@ -17499,7 +17650,7 @@ var init_launchpad = __esm({
         const receipt = await this.#client.getTransactionReceipt({ hash: r.txHash });
         let agentId;
         for (const log2 of receipt.logs) {
-          if (getAddress16(log2.address) !== vault) continue;
+          if (getAddress17(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();
@@ -17588,17 +17739,17 @@ var init_launchpad = __esm({
 });
 
 // ../core/src/pay.ts
-import { getAddress as getAddress17, isAddress as isAddress10 } from "viem";
+import { getAddress as getAddress18, 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 }) || getAddress17(r.asset) !== token) return `in ${r.asset} (this agent pays in ${token})`;
+  if (!isAddress10(r.asset, { strict: false }) || getAddress18(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;
+var PAY_CHANNEL_DEPOSIT, PAY_MAX_BODY_CHARS, REQUEST_TIMEOUT_MS3, MIN_LIFE_LEFT_SECONDS, now2, PayService;
 var init_pay = __esm({
   "../core/src/pay.ts"() {
     "use strict";
@@ -17609,7 +17760,7 @@ var init_pay = __esm({
     init_channels();
     PAY_CHANNEL_DEPOSIT = 1000000n;
     PAY_MAX_BODY_CHARS = 65536;
-    REQUEST_TIMEOUT_MS2 = 12e4;
+    REQUEST_TIMEOUT_MS3 = 12e4;
     MIN_LIFE_LEFT_SECONDS = 300;
     now2 = () => Math.floor(Date.now() / 1e3);
     PayService = class {
@@ -17635,23 +17786,23 @@ var init_pay = __esm({
             method: input.method ?? "GET",
             headers: { ...input.headers ?? {}, ...headers },
             ...input.body === void 0 ? {} : { body: input.body },
-            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2),
+            signal: AbortSignal.timeout(input.timeoutMs ?? REQUEST_TIMEOUT_MS3),
             redirect: "manual"
           });
         } catch (err) {
           throw new Error(`${input.url} cannot be reached: ${err.message}`);
         }
       }
-      async #answer(res, paid, record, note) {
+      async #answer(res, paid, record, note, maxBodyChars = PAY_MAX_BODY_CHARS) {
         const text2 = await res.text();
-        const truncated = text2.length > PAY_MAX_BODY_CHARS;
+        const truncated = text2.length > maxBodyChars;
         return {
           status: res.status,
           paid: paid === null ? null : formatTokenAmount(paid),
           channel: record === null ? null : record.channel,
           channelLeft: record === null ? null : formatTokenAmount(payCapacity(record)),
           contentType: res.headers.get("content-type"),
-          body: truncated ? text2.slice(0, PAY_MAX_BODY_CHARS) : text2,
+          body: truncated ? text2.slice(0, maxBodyChars) : text2,
           truncated,
           ...note === void 0 ? {} : { note }
         };
@@ -17660,7 +17811,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 (getAddress17(r.payee) !== payee || getAddress17(r.config.receiver) !== receiver || r.gracePeriod !== withdrawDelay) continue;
+          if (getAddress18(r.payee) !== payee || getAddress18(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;
@@ -17671,10 +17822,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 !== getAddress17(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 !== getAddress18(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: getAddress17(r.config.payer),
+          address: getAddress18(r.config.payer),
           signTypedData: () => Promise.reject(new Error("a vault never signs typed data")),
           readContract: (args) => client.readContract(args)
         };
@@ -17719,7 +17870,7 @@ var init_pay = __esm({
           if (url.protocol !== "https:" && url.protocol !== "http:") throw new RangeError("pay sends http(s) requests only");
           const maxPrice = parseTokenAmount(input.maxPrice);
           const first = await this.#fetch(input);
-          if (first.status !== 402) return this.#answer(first, null, null);
+          if (first.status !== 402) return this.#answer(first, null, null, void 0, input.maxBodyChars);
           let firstBody = null;
           try {
             firstBody = JSON.parse(await first.clone().text());
@@ -17743,13 +17894,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 = getAddress17(extra.receiverAuthorizer);
+          const payee = getAddress18(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 = getAddress17(offer.payTo);
+          const receiver = getAddress18(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");
@@ -17805,12 +17956,12 @@ var init_pay = __esm({
             break;
           }
           if (answer.status === 402) {
-            return this.#answer(answer, null, r, "the seller did not take the voucher; what the voucher signed stays recorded against the channel");
+            return this.#answer(answer, null, r, "the seller did not take the voucher; what the voucher signed stays recorded against the channel", input.maxBodyChars);
           }
           const done = await this.#channels.updatePayRecord(r.salt, (rec) => {
             rec.pay.payments.push({ url: input.url, amount: paid.toString(), transaction: answer.headers.get("payment-response") ?? "", at: now2() });
           });
-          return this.#answer(answer, paid, done, opened ? `a channel to the seller was opened with a deposit of ${formatTokenAmount(BigInt(done.deposit))}; later payments to the seller use it` : void 0);
+          return this.#answer(answer, paid, done, opened ? `a channel to the seller was opened with a deposit of ${formatTokenAmount(BigInt(done.deposit))}; later payments to the seller use it` : void 0, input.maxBodyChars);
         });
       }
     };
@@ -20686,7 +20837,7 @@ var init_abi2 = __esm({
 });
 
 // ../../ostra-swap/sdk/src/constants.ts
-var LOG_WINDOW_BLOCKS2, USDG2, WETH2, HUBS, ETH, UNISWAP_V3_FACTORY, UNISWAP_V3_QUOTER_V2, V3_FEE_TIERS, UNISWAP_V4_POOL_MANAGER2, UNISWAP_V4_QUOTER, MULTICALL32, OSTRA_HOOK, PONS_HOOK, ROUTABLE_HOOKS, FEE_TIERS, COMMAND, V4_ACTION, CONTRACT_BALANCE, MSG_SENDER, ADDRESS_THIS, OPEN_DELTA, QUOTE_GAS_LIMIT, QUOTES_PER_CALL, QUOTE_GAS_LIMIT_RETRY, QUOTES_PER_RETRY_CALL, QUOTE_BATCH_OVERHEAD_GAS, V3_MIN_SQRT_PRICE_LIMIT, V3_MAX_SQRT_PRICE_LIMIT, DEFAULT_SLIPPAGE_BPS, MAX_SLIPPAGE_BPS, DEFAULT_ORDER_TTL_SECONDS;
+var LOG_WINDOW_BLOCKS2, USDG2, WETH2, HUBS, ETH, UNISWAP_V3_FACTORY, UNISWAP_V3_QUOTER_V2, V3_FEE_TIERS, UNISWAP_V4_POOL_MANAGER2, UNISWAP_V4_QUOTER, MULTICALL32, OSTRA_HOOK, PONS_HOOK2, ROUTABLE_HOOKS, FEE_TIERS, COMMAND, V4_ACTION, CONTRACT_BALANCE, MSG_SENDER, ADDRESS_THIS, OPEN_DELTA, QUOTE_GAS_LIMIT, QUOTES_PER_CALL, QUOTE_GAS_LIMIT_RETRY, QUOTES_PER_RETRY_CALL, QUOTE_BATCH_OVERHEAD_GAS, V3_MIN_SQRT_PRICE_LIMIT, V3_MAX_SQRT_PRICE_LIMIT, DEFAULT_SLIPPAGE_BPS, MAX_SLIPPAGE_BPS, DEFAULT_ORDER_TTL_SECONDS;
 var init_constants2 = __esm({
   "../../ostra-swap/sdk/src/constants.ts"() {
     "use strict";
@@ -20703,8 +20854,8 @@ var init_constants2 = __esm({
     UNISWAP_V4_QUOTER = "0x8Dc178eFB8111BB0973Dd9d722ebeFF267c98F94";
     MULTICALL32 = "0xcA11bde05977b3631167028862bE2a173976CA11";
     OSTRA_HOOK = "0x63A784afb8905452aDceC471a45E555F5caE68cC";
-    PONS_HOOK = "0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044";
-    ROUTABLE_HOOKS = ["0x0000000000000000000000000000000000000000", OSTRA_HOOK, PONS_HOOK];
+    PONS_HOOK2 = "0xE5e702641Ea86F4ae6cC3cDaeD2B886f976Be044";
+    ROUTABLE_HOOKS = ["0x0000000000000000000000000000000000000000", OSTRA_HOOK, PONS_HOOK2];
     FEE_TIERS = [
       { minLocked: 500000n * 10n ** 18n, bps: 0 },
       { minLocked: 250000n * 10n ** 18n, bps: 10 },
@@ -20827,13 +20978,13 @@ var init_uniswap = __esm({
 });
 
 // ../../ostra-swap/sdk/src/legs.ts
-import { concatHex, encodeAbiParameters as encodeAbiParameters6, encodePacked as encodePacked4, getAddress as getAddress18, toHex as toHex2 } from "viem";
+import { concatHex, encodeAbiParameters as encodeAbiParameters7, encodePacked as encodePacked4, getAddress as getAddress19, toHex as toHex3 } from "viem";
 function legFor(pool, tokenIn, tokenOut, recipient = MSG_SENDER) {
-  const inAddr = getAddress18(tokenIn);
-  const outAddr = getAddress18(tokenOut);
+  const inAddr = getAddress19(tokenIn);
+  const outAddr = getAddress19(tokenOut);
   if (pool.kind === "v3") {
     const path = encodePacked4(["address", "uint24", "address"], [inAddr, pool.fee, outAddr]);
-    const input = encodeAbiParameters6(
+    const input = encodeAbiParameters7(
       [{ type: "address" }, { type: "uint256" }, { type: "uint256" }, { type: "bytes" }, { type: "bool" }, { type: "uint256[]" }],
       [recipient, CONTRACT_BALANCE, 0n, path, false, []]
     );
@@ -20843,20 +20994,20 @@ function legFor(pool, tokenIn, tokenOut, recipient = MSG_SENDER) {
   const asCurrency = (t) => t === WETH2 && (k.currency0 === ETH || k.currency1 === ETH) ? ETH : t;
   const currencyIn = asCurrency(inAddr);
   const currencyOut = asCurrency(outAddr);
-  const zeroForOne = currencyIn === getAddress18(k.currency0);
-  if (!zeroForOne && currencyIn !== getAddress18(k.currency1)) throw new Error(`${tokenIn} is not in the pool ${pool.id}`);
-  if (currencyOut !== getAddress18(zeroForOne ? k.currency1 : k.currency0)) throw new Error(`${tokenOut} is not the other side of the pool ${pool.id}`);
-  const settle = encodeAbiParameters6([{ type: "address" }, { type: "uint256" }, { type: "bool" }], [currencyIn, CONTRACT_BALANCE, false]);
-  const swap = encodeAbiParameters6(
+  const zeroForOne = currencyIn === getAddress19(k.currency0);
+  if (!zeroForOne && currencyIn !== getAddress19(k.currency1)) throw new Error(`${tokenIn} is not in the pool ${pool.id}`);
+  if (currencyOut !== getAddress19(zeroForOne ? k.currency1 : k.currency0)) throw new Error(`${tokenOut} is not the other side of the pool ${pool.id}`);
+  const settle = encodeAbiParameters7([{ type: "address" }, { type: "uint256" }, { type: "bool" }], [currencyIn, CONTRACT_BALANCE, false]);
+  const swap = encodeAbiParameters7(
     [exactInputSingleParam],
     [{ poolKey: k, zeroForOne, amountIn: OPEN_DELTA, amountOutMinimum: 0n, minHopPriceX36: 0n, hookData: "0x" }]
   );
   if (recipient === ADDRESS_THIS && currencyOut === ETH) throw new Error("a leg kept in the Universal Router pays an ERC-20, not native ETH");
-  const take = encodeAbiParameters6([{ type: "address" }, { type: "address" }, { type: "uint256" }], [currencyOut, recipient, OPEN_DELTA]);
+  const take = encodeAbiParameters7([{ type: "address" }, { type: "address" }, { type: "uint256" }], [currencyOut, recipient, OPEN_DELTA]);
   const actions = concatHex([byte(V4_ACTION.SETTLE), byte(V4_ACTION.SWAP_EXACT_IN_SINGLE), byte(V4_ACTION.TAKE)]);
-  const v4Input = encodeAbiParameters6([{ type: "bytes" }, { type: "bytes[]" }], [actions, [settle, swap, take]]);
+  const v4Input = encodeAbiParameters7([{ type: "bytes" }, { type: "bytes[]" }], [actions, [settle, swap, take]]);
   if (currencyIn === ETH) {
-    const unwrap = encodeAbiParameters6([{ type: "address" }, { type: "uint256" }], [ADDRESS_THIS, 0n]);
+    const unwrap = encodeAbiParameters7([{ type: "address" }, { type: "uint256" }], [ADDRESS_THIS, 0n]);
     return { commands: concatHex([byte(COMMAND.UNWRAP_WETH), byte(COMMAND.V4_SWAP)]), inputs: [unwrap, v4Input] };
   }
   return { commands: byte(COMMAND.V4_SWAP), inputs: [v4Input] };
@@ -20869,15 +21020,15 @@ var init_legs = __esm({
     init_constants2();
     init_uniswap();
     NO_LEG = { commands: "0x", inputs: [] };
-    byte = (n) => toHex2(n, { size: 1 });
+    byte = (n) => toHex3(n, { size: 1 });
   }
 });
 
 // ../../ostra-swap/sdk/src/pools.ts
-import { encodeAbiParameters as encodeAbiParameters7, encodeFunctionData as encodeFunctionData9, decodeFunctionResult as decodeFunctionResult2, getAddress as getAddress19, hexToBigInt, keccak256 as keccak25611, toHex as toHex3, zeroAddress as zeroAddress11 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters8, encodeFunctionData as encodeFunctionData9, decodeFunctionResult as decodeFunctionResult2, getAddress as getAddress20, hexToBigInt as hexToBigInt2, keccak256 as keccak25612, toHex as toHex4, zeroAddress as zeroAddress11 } from "viem";
 function stateSlot(id, offset) {
-  const base = hexToBigInt(keccak25611(encodeAbiParameters7([{ type: "bytes32" }, { type: "uint256" }], [id, POOLS_SLOT2])));
-  return toHex3(base + offset, { size: 32 });
+  const base = hexToBigInt2(keccak25612(encodeAbiParameters8([{ type: "bytes32" }, { type: "uint256" }], [id, POOLS_SLOT3])));
+  return toHex4(base + offset, { size: 32 });
 }
 async function initializeLogs(logsClient, c0, c1, from, to) {
   try {
@@ -20889,7 +21040,7 @@ async function initializeLogs(logsClient, c0, c1, from, to) {
   }
 }
 function hubCurrencies(hub) {
-  return getAddress19(hub) === WETH2 ? [WETH2, ETH] : [getAddress19(hub)];
+  return getAddress20(hub) === WETH2 ? [WETH2, ETH] : [getAddress20(hub)];
 }
 async function aggregate(client, calls) {
   if (calls.length === 0) return [];
@@ -20899,8 +21050,8 @@ async function aggregate(client, calls) {
   return decodeFunctionResult2({ abi: multicall3Abi2, functionName: "aggregate3", data: ret });
 }
 async function hubPools(client, logsClient, index, token, hub) {
-  const t = getAddress19(token);
-  const h = getAddress19(hub);
+  const t = getAddress20(token);
+  const h = getAddress20(hub);
   if (t === h) return [];
   const out = [];
   const found = await aggregate(
@@ -20911,7 +21062,7 @@ async function hubPools(client, logsClient, index, token, hub) {
   found.forEach((r, i) => {
     if (!r.success) return;
     const address6 = decodeFunctionResult2({ abi: v3FactoryAbi, functionName: "getPool", data: r.returnData });
-    if (address6 !== zeroAddress11) v3.push({ address: getAddress19(address6), fee: V3_FEE_TIERS[i] });
+    if (address6 !== zeroAddress11) v3.push({ address: getAddress20(address6), fee: V3_FEE_TIERS[i] });
   });
   const v3Liquidity = await aggregate(client, v3.map((p) => ({ target: p.address, callData: encodeFunctionData9({ abi: v3PoolAbi, functionName: "liquidity" }) })));
   v3.forEach((p, i) => {
@@ -20922,27 +21073,27 @@ async function hubPools(client, logsClient, index, token, hub) {
   });
   const records = [];
   for (const side of hubCurrencies(h)) {
-    for (const p of await index.v4PoolsOfPair(logsClient, t, side)) if (ROUTABLE_HOOKS.includes(getAddress19(p.key.hooks))) records.push(p);
+    for (const p of await index.v4PoolsOfPair(logsClient, t, side)) if (ROUTABLE_HOOKS.includes(getAddress20(p.key.hooks))) records.push(p);
   }
   if (records.length > 0) {
-    const slots = records.map((p) => stateSlot(p.id, LIQUIDITY_OFFSET));
+    const slots = records.map((p) => stateSlot(p.id, LIQUIDITY_OFFSET2));
     const values = await client.readContract({ address: UNISWAP_V4_POOL_MANAGER2, abi: poolManagerAbi, functionName: "extsload", args: [slots] });
     records.forEach((p, i) => {
       const v = values[i];
-      if (v !== void 0 && hexToBigInt(v) % (1n << 128n) > 0n) out.push({ kind: "v4", id: p.id, key: p.key });
+      if (v !== void 0 && hexToBigInt2(v) % (1n << 128n) > 0n) out.push({ kind: "v4", id: p.id, key: p.key });
     });
   }
   return out;
 }
-var POOLS_SLOT2, LIQUIDITY_OFFSET, PoolIndex;
+var POOLS_SLOT3, LIQUIDITY_OFFSET2, PoolIndex;
 var init_pools2 = __esm({
   "../../ostra-swap/sdk/src/pools.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_constants2();
     init_uniswap();
-    POOLS_SLOT2 = 6n;
-    LIQUIDITY_OFFSET = 3n;
+    POOLS_SLOT3 = 6n;
+    LIQUIDITY_OFFSET2 = 3n;
     PoolIndex = class {
       #data;
       constructor(data) {
@@ -20958,7 +21109,7 @@ var init_pools2 = __esm({
        * that serves LOG_WINDOW_BLOCKS per request).
        */
       async v4PoolsOfPair(logsClient, a, b) {
-        const [c0, c1] = BigInt(getAddress19(a)) < BigInt(getAddress19(b)) ? [getAddress19(a), getAddress19(b)] : [getAddress19(b), getAddress19(a)];
+        const [c0, c1] = BigInt(getAddress20(a)) < BigInt(getAddress20(b)) ? [getAddress20(a), getAddress20(b)] : [getAddress20(b), getAddress20(a)];
         const pairKey = `${c0}-${c1}`;
         const entry = this.#data.tokens[pairKey] ?? { searchedTo: "-1", pools: [] };
         const head = await logsClient.getBlockNumber();
@@ -20970,7 +21121,7 @@ var init_pools2 = __esm({
             const x = l.args;
             if (x.id === void 0 || x.fee === void 0 || x.tickSpacing === void 0 || x.hooks === void 0 || seen.has(x.id)) continue;
             seen.add(x.id);
-            entry.pools.push({ id: x.id, key: { currency0: c0, currency1: c1, fee: x.fee, tickSpacing: x.tickSpacing, hooks: getAddress19(x.hooks) } });
+            entry.pools.push({ id: x.id, key: { currency0: c0, currency1: c1, fee: x.fee, tickSpacing: x.tickSpacing, hooks: getAddress20(x.hooks) } });
           }
           entry.searchedTo = to.toString();
           from = to + 1n;
@@ -20983,9 +21134,9 @@ var init_pools2 = __esm({
 });
 
 // ../../ostra-swap/sdk/src/route.ts
-import { decodeAbiParameters as decodeAbiParameters3, decodeFunctionResult as decodeFunctionResult3, encodeDeployData as encodeDeployData2, encodeFunctionData as encodeFunctionData10, getAddress as getAddress20 } from "viem";
+import { decodeAbiParameters as decodeAbiParameters3, decodeFunctionResult as decodeFunctionResult3, encodeDeployData as encodeDeployData2, encodeFunctionData as encodeFunctionData10, getAddress as getAddress21 } from "viem";
 function routedToken(token) {
-  const t = getAddress20(token);
+  const t = getAddress21(token);
   return t === ETH ? WETH2 : t;
 }
 function quoteCall(pool, tokenIn, tokenOut, amountIn) {
@@ -21083,8 +21234,8 @@ async function findRoute(r) {
     }
     if (best === null || expectedOut > best.expectedOut) {
       best = {
-        tokenIn: getAddress20(r.tokenIn),
-        tokenOut: getAddress20(r.tokenOut),
+        tokenIn: getAddress21(r.tokenIn),
+        tokenOut: getAddress21(r.tokenOut),
         amountIn: r.amountIn,
         hub,
         legIn,
@@ -21133,7 +21284,7 @@ var init_route = __esm({
 });
 
 // ../../ostra-swap/sdk/src/orders.ts
-import { encodeAbiParameters as encodeAbiParameters8, encodeFunctionData as encodeFunctionData11, getAddress as getAddress21, getContractAddress as getContractAddress3, isAddress as isAddress11, keccak256 as keccak25612, toHex as toHex4 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters9, encodeFunctionData as encodeFunctionData11, getAddress as getAddress22, getContractAddress as getContractAddress3, isAddress as isAddress11, keccak256 as keccak25613, toHex as toHex5 } from "viem";
 function parseSwapDeployment(json) {
   const r = json;
   if (r === null || typeof r !== "object") throw new Error("the deployment record is not a JSON object");
@@ -21142,22 +21293,22 @@ function parseSwapDeployment(json) {
   const addr2 = (name) => {
     const v = r[name];
     if (typeof v !== "string" || !isAddress11(v, { strict: false })) throw new Error(`the deployment record has no ${name} address`);
-    return getAddress21(v);
+    return getAddress22(v);
   };
   return { chainId: r.chainId, fromBlock: r.fromBlock, router: addr2("router"), stake: addr2("stake"), buyback: addr2("buyback"), spendVerifier: addr2("spendVerifier"), privatePool: addr2("privatePool") };
 }
 function routeHash(hub, legIn, legOut) {
-  return keccak25612(encodeAbiParameters8([{ type: "address" }, legParam, legParam], [getAddress21(hub), legIn, legOut]));
+  return keccak25613(encodeAbiParameters9([{ type: "address" }, legParam, legParam], [getAddress22(hub), legIn, legOut]));
 }
 function orderHash(order) {
-  return keccak25612(encodeAbiParameters8([orderParam], [order]));
+  return keccak25613(encodeAbiParameters9([orderParam], [order]));
 }
 function escrowAddress(router, order) {
-  return getContractAddress3({ opcode: "CREATE2", from: getAddress21(router), salt: orderHash(order), bytecode: OSTRA_SWAP_ESCROW_CREATION_CODE });
+  return getContractAddress3({ opcode: "CREATE2", from: getAddress22(router), salt: orderHash(order), bytecode: OSTRA_SWAP_ESCROW_CREATION_CODE });
 }
 function orderFor(route, vault, vaultToken, recipient, now3, salt, ttlSeconds = DEFAULT_ORDER_TTL_SECONDS) {
   if (route.tokenIn === ETH || route.tokenOut === ETH) throw new Error("a vault swaps ERC-20 tokens: WETH, not native ETH");
-  if (getAddress21(vaultToken) !== getAddress21(route.tokenIn)) throw new Error(`the vault holds ${vaultToken}, not the route's tokenIn ${route.tokenIn}`);
+  if (getAddress22(vaultToken) !== getAddress22(route.tokenIn)) throw new Error(`the vault holds ${vaultToken}, not the route's tokenIn ${route.tokenIn}`);
   if (!/^0x[0-9a-fA-F]{64}$/.test(salt)) throw new Error("the salt is 32 bytes");
   const { legIn, legOut } = routeLegs(route);
   return {
@@ -21165,8 +21316,8 @@ function orderFor(route, vault, vaultToken, recipient, now3, salt, ttlSeconds =
     tokenOut: route.tokenOut,
     amountIn: route.amountIn,
     minOut: route.minOut,
-    recipient: getAddress21(recipient),
-    refundTo: getAddress21(vault),
+    recipient: getAddress22(recipient),
+    refundTo: getAddress22(vault),
     notBefore: 0n,
     deadline: now3 + BigInt(ttlSeconds),
     tranches: 0,
@@ -21178,7 +21329,7 @@ function orderFor(route, vault, vaultToken, recipient, now3, salt, ttlSeconds =
   };
 }
 function randomSalt2() {
-  return toHex4(crypto.getRandomValues(new Uint8Array(32)));
+  return toHex5(crypto.getRandomValues(new Uint8Array(32)));
 }
 function executeEscrowData(order, route) {
   const { legIn, legOut } = routeLegs(route);
@@ -21226,7 +21377,7 @@ var init_orders = __esm({
 });
 
 // ../../ostra-swap/sdk/src/private.ts
-import { encodeAbiParameters as encodeAbiParameters9, encodeFunctionData as encodeFunctionData12, getAbiItem, getAddress as getAddress22, getContractAddress as getContractAddress4, keccak256 as keccak25613, parseEventLogs, toHex as toHex5 } from "viem";
+import { encodeAbiParameters as encodeAbiParameters10, encodeFunctionData as encodeFunctionData12, getAbiItem, getAddress as getAddress23, getContractAddress as getContractAddress4, keccak256 as keccak25614, parseEventLogs, toHex as toHex6 } from "viem";
 function packDigest(elements) {
   if (elements.length !== 8) throw new Error("a digest has 8 field elements");
   let v = 0n;
@@ -21235,7 +21386,7 @@ function packDigest(elements) {
     if (x < 0n || x >= FIELD_P) throw new Error("a digest element is not below P");
     v |= x << BigInt(32 * i);
   });
-  return toHex5(v, { size: 32 });
+  return toHex6(v, { size: 32 });
 }
 function unpackDigest(d) {
   if (!/^0x[0-9a-fA-F]{64}$/.test(d)) throw new Error("a digest is 32 bytes");
@@ -21252,7 +21403,7 @@ function digestOf(v, what) {
 }
 async function noteKeys(prover, sk, rho, asset, amount) {
   if (amount < 0n || amount >= MAX_AMOUNT) throw new Error("an amount is below 2^128");
-  const r = await prover("note", { sk: unpackDigest(sk), rho: unpackDigest(rho), asset: getAddress22(asset), amount: amount.toString() });
+  const r = await prover("note", { sk: unpackDigest(sk), rho: unpackDigest(rho), asset: getAddress23(asset), amount: amount.toString() });
   return { tag: digestOf(r.tag, "tag"), commitment: digestOf(r.commitment, "commitment"), nullifier: digestOf(r.nullifier, "nullifier") };
 }
 async function tagOf(prover, sk, rho) {
@@ -21281,16 +21432,16 @@ async function notePath(prover, trees, note) {
   return { root, path: r.path };
 }
 function unshieldHash(chainId, pool, relayer, deadline, recipient) {
-  return keccak25613(
-    encodeAbiParameters9(
+  return keccak25614(
+    encodeAbiParameters10(
       [{ type: "bytes32" }, { type: "uint256" }, { type: "address" }, { type: "address" }, { type: "uint64" }, { type: "address" }],
-      [UNSHIELD_DOMAIN, BigInt(chainId), getAddress22(pool), getAddress22(relayer), deadline, getAddress22(recipient)]
+      [UNSHIELD_DOMAIN, BigInt(chainId), getAddress23(pool), getAddress23(relayer), deadline, getAddress23(recipient)]
     )
   );
 }
 function swapHash(chainId, pool, relayer, deadline, t) {
-  return keccak25613(
-    encodeAbiParameters9(
+  return keccak25614(
+    encodeAbiParameters10(
       [
         { type: "bytes32" },
         { type: "uint256" },
@@ -21302,7 +21453,7 @@ function swapHash(chainId, pool, relayer, deadline, t) {
         { type: "bytes32" },
         { type: "bytes32" }
       ],
-      [SWAP_DOMAIN, BigInt(chainId), getAddress22(pool), getAddress22(relayer), deadline, getAddress22(t.tokenOut), t.minOut, t.outTag, routeHash(t.hub, t.legIn, t.legOut)]
+      [SWAP_DOMAIN, BigInt(chainId), getAddress23(pool), getAddress23(relayer), deadline, getAddress23(t.tokenOut), t.minOut, t.outTag, routeHash(t.hub, t.legIn, t.legOut)]
     )
   );
 }
@@ -21312,7 +21463,7 @@ function publicValues(asset, v, fee, nullifier, root, changeCommitment, bindHash
   const words = (d) => unpackDigest(d).map((x) => BigInt(x));
   const h = BigInt(bindHash);
   return [
-    ...limbs(BigInt(getAddress22(asset)), 6, 27),
+    ...limbs(BigInt(getAddress23(asset)), 6, 27),
     ...limbs(v, 5, 26),
     ...limbs(fee, 5, 26),
     ...words(nullifier),
@@ -21325,7 +21476,7 @@ async function prove(r, v, bindHash, recipient) {
   const n = r.note;
   if (r.changeRho !== void 0 && r.changeRho.toLowerCase() === n.rho.toLowerCase()) throw new Error("changeRho must be a fresh secret, not the note's rho");
   if (v < 0n || r.fee < 0n || v + r.fee > n.amount) throw new Error(`the note holds ${n.amount}, less than ${v} + ${r.fee}`);
-  if (r.fee !== 0n && getAddress22(r.relayer) === ZERO2) throw new Error("a fee needs a relayer");
+  if (r.fee !== 0n && getAddress23(r.relayer) === ZERO2) throw new Error("a fee needs a relayer");
   if (r.deadline < 0n || r.deadline > MAX_UINT642) throw new Error("the deadline is uint64 unix seconds");
   const keys = await noteKeys(r.prover, r.sk, n.rho, n.asset, n.amount);
   if (keys.commitment.toLowerCase() !== n.commitment.toLowerCase()) throw new Error("the note is not this sk's (or its rho, token or amount is wrong)");
@@ -21333,7 +21484,7 @@ async function prove(r, v, bindHash, recipient) {
   const out = await r.prover("prove", {
     sk: unpackDigest(r.sk),
     rho: unpackDigest(n.rho),
-    asset: getAddress22(n.asset),
+    asset: getAddress23(n.asset),
     amount: n.amount.toString(),
     index: n.index,
     path,
@@ -21346,7 +21497,7 @@ async function prove(r, v, bindHash, recipient) {
   if (typeof out.proof !== "string" || !/^0x[0-9a-f]*$/.test(out.proof) || !Array.isArray(out.public_values) || out.public_values.length !== 48) throw new Error("ostra-prove gave no proof");
   const pv = out.public_values.map((x) => BigInt(x));
   const changeCommitment = packDigest(pv.slice(32, 40));
-  const terms = { asset: getAddress22(n.asset), v, fee: r.fee, nullifier: keys.nullifier, root, changeCommitment, relayer: getAddress22(r.relayer), deadline: r.deadline };
+  const terms = { asset: getAddress23(n.asset), v, fee: r.fee, nullifier: keys.nullifier, root, changeCommitment, relayer: getAddress23(r.relayer), deadline: r.deadline };
   const want = publicValues(terms.asset, v, r.fee, terms.nullifier, root, changeCommitment, bindHash);
   if (want.some((x, i) => x !== pv[i])) throw new Error("the proof's public values are not the spend's");
   const changeRho = digestOf(out.change_rho, "change_rho");
@@ -21356,40 +21507,40 @@ async function prove(r, v, bindHash, recipient) {
   return { terms, proof: out.proof, recipient, change: { rho: changeRho, amount: change, commitment: changeCommitment } };
 }
 async function proveUnshield(r) {
-  if (getAddress22(r.recipient) === ZERO2) throw new Error("an unshield needs a recipient");
-  return prove(r, r.v, unshieldHash(r.chainId, r.pool, r.relayer, r.deadline, r.recipient), getAddress22(r.recipient));
+  if (getAddress23(r.recipient) === ZERO2) throw new Error("an unshield needs a recipient");
+  return prove(r, r.v, unshieldHash(r.chainId, r.pool, r.relayer, r.deadline, r.recipient), getAddress23(r.recipient));
 }
 async function provePrivateSwap(r) {
   const route = r.route;
   if (route.feeBps !== PRIVATE_SWAP_FEE_BPS) throw new Error(`a private swap pays the base fee: find its route with feeBps ${PRIVATE_SWAP_FEE_BPS}`);
   if (route.tokenIn === ETH || route.tokenOut === ETH) throw new Error("notes hold ERC-20 tokens: WETH, not native ETH");
-  if (getAddress22(route.tokenIn) !== getAddress22(r.note.asset)) throw new Error(`the route swaps ${route.tokenIn}, the note holds ${r.note.asset}`);
+  if (getAddress23(route.tokenIn) !== getAddress23(r.note.asset)) throw new Error(`the route swaps ${route.tokenIn}, the note holds ${r.note.asset}`);
   if (r.outRho.toLowerCase() === r.note.rho.toLowerCase()) throw new Error("outRho must be a fresh secret");
   const { legIn, legOut } = routeLegs(route);
-  const swap = { tokenOut: getAddress22(route.tokenOut), minOut: route.minOut, outTag: await tagOf(r.prover, r.sk, r.outRho), hub: getAddress22(route.hub), legIn, legOut };
+  const swap = { tokenOut: getAddress23(route.tokenOut), minOut: route.minOut, outTag: await tagOf(r.prover, r.sk, r.outRho), hub: getAddress23(route.hub), legIn, legOut };
   if (r.changeRho !== void 0 && r.changeRho.toLowerCase() === r.outRho.toLowerCase()) throw new Error("the change and the output share a rho");
   const spend = await prove(r, route.amountIn, swapHash(r.chainId, r.pool, r.relayer, r.deadline, swap), null);
   if (spend.change.rho.toLowerCase() === r.outRho.toLowerCase()) throw new Error("the change and the output share a rho");
   return { spend, swap };
 }
 function shieldEscrowAddress(pool, token, tag) {
-  const salt = keccak25613(encodeAbiParameters9([{ type: "address" }, { type: "bytes32" }], [getAddress22(token), tag]));
-  return getContractAddress4({ opcode: "CREATE2", from: getAddress22(pool), salt, bytecode: OSTRA_SHIELD_ESCROW_CREATION_CODE });
+  const salt = keccak25614(encodeAbiParameters10([{ type: "address" }, { type: "bytes32" }], [getAddress23(token), tag]));
+  return getContractAddress4({ opcode: "CREATE2", from: getAddress23(pool), salt, bytecode: OSTRA_SHIELD_ESCROW_CREATION_CODE });
 }
 function shieldFromEscrowCall(pool, token, tag) {
-  return { to: getAddress22(pool), data: encodeFunctionData12({ abi: ostraPrivatePoolAbi, functionName: "shieldFromEscrow", args: [getAddress22(token), tag] }) };
+  return { to: getAddress23(pool), data: encodeFunctionData12({ abi: ostraPrivatePoolAbi, functionName: "shieldFromEscrow", args: [getAddress23(token), tag] }) };
 }
 function unshieldCall(pool, spend, recipient) {
-  if (spend.recipient === null || spend.recipient !== getAddress22(recipient)) throw new Error("this spend was proved for another recipient (or is a swap)");
-  return { to: getAddress22(pool), data: encodeFunctionData12({ abi: ostraPrivatePoolAbi, functionName: "unshield", args: [spend.terms, getAddress22(recipient), spend.proof] }) };
+  if (spend.recipient === null || spend.recipient !== getAddress23(recipient)) throw new Error("this spend was proved for another recipient (or is a swap)");
+  return { to: getAddress23(pool), data: encodeFunctionData12({ abi: ostraPrivatePoolAbi, functionName: "unshield", args: [spend.terms, getAddress23(recipient), spend.proof] }) };
 }
 function privateSwapCall(pool, spend, swap) {
   if (spend.recipient !== null) throw new Error("this spend was proved for an unshield");
-  return { to: getAddress22(pool), data: encodeFunctionData12({ abi: ostraPrivatePoolAbi, functionName: "privateSwap", args: [spend.terms, swap, spend.proof] }) };
+  return { to: getAddress23(pool), data: encodeFunctionData12({ abi: ostraPrivatePoolAbi, functionName: "privateSwap", args: [spend.terms, swap, spend.proof] }) };
 }
 function poolEvents(receipt, pool) {
   if (receipt.status !== "success") throw new Error("the transaction reverted");
-  return parseEventLogs({ abi: ostraPrivatePoolAbi, logs: receipt.logs.filter((l) => getAddress22(l.address) === getAddress22(pool)) });
+  return parseEventLogs({ abi: ostraPrivatePoolAbi, logs: receipt.logs.filter((l) => getAddress23(l.address) === getAddress23(pool)) });
 }
 function placed(receipt, pool, commitment) {
   for (const e of poolEvents(receipt, pool)) {
@@ -21401,7 +21552,7 @@ async function shieldedNote(prover, sk, rho, receipt, pool) {
   const tag = (await tagOf(prover, sk, rho)).toLowerCase();
   for (const e of poolEvents(receipt, pool)) {
     if (e.eventName !== "Shielded" || e.args.tag.toLowerCase() !== tag) continue;
-    const asset = getAddress22(e.args.token);
+    const asset = getAddress23(e.args.token);
     const keys = await noteKeys(prover, sk, rho, asset, e.args.amount);
     if (keys.commitment.toLowerCase() !== e.args.commitment.toLowerCase()) throw new Error("the shielded commitment is not this note's");
     return { asset, amount: e.args.amount, rho, commitment: e.args.commitment, ...placed(receipt, pool, e.args.commitment) };
@@ -21435,8 +21586,8 @@ var init_private = __esm({
     FIELD_P = 2130706433n;
     TREE_DEPTH = 20;
     PRIVATE_SWAP_FEE_BPS = 20;
-    UNSHIELD_DOMAIN = keccak25613(toHex5("OstraPrivatePool.unshield.v1"));
-    SWAP_DOMAIN = keccak25613(toHex5("OstraPrivatePool.privateSwap.v1"));
+    UNSHIELD_DOMAIN = keccak25614(toHex6("OstraPrivatePool.unshield.v1"));
+    SWAP_DOMAIN = keccak25614(toHex6("OstraPrivatePool.privateSwap.v1"));
     MAX_AMOUNT = 1n << 128n;
     MAX_UINT642 = (1n << 64n) - 1n;
     ZERO2 = "0x0000000000000000000000000000000000000000";
@@ -21449,9 +21600,9 @@ var init_private = __esm({
       constructor(pool, fromBlock, data) {
         if (data !== void 0) {
           if (data.version !== 1) throw new Error("unknown trees version");
-          if (getAddress22(data.pool) !== getAddress22(pool)) throw new Error("these trees are another pool's");
+          if (getAddress23(data.pool) !== getAddress23(pool)) throw new Error("these trees are another pool's");
         }
-        this.#data = data ?? { version: 1, pool: getAddress22(pool), searchedTo: (fromBlock - 1n).toString(), trees: [] };
+        this.#data = data ?? { version: 1, pool: getAddress23(pool), searchedTo: (fromBlock - 1n).toString(), trees: [] };
       }
       data() {
         return this.#data;
@@ -21542,7 +21693,7 @@ var init_private = __esm({
 });
 
 // ../../ostra-swap/sdk/src/reads.ts
-import { getAddress as getAddress23 } from "viem";
+import { getAddress as getAddress24 } from "viem";
 var init_reads2 = __esm({
   "../../ostra-swap/sdk/src/reads.ts"() {
     "use strict";
@@ -21569,9 +21720,9 @@ var init_src2 = __esm({
 });
 
 // ../core/src/private-balance.ts
-import { getAddress as getAddress24, parseAbiItem as parseAbiItem4 } from "viem";
+import { getAddress as getAddress25, parseAbiItem as parseAbiItem4 } from "viem";
 function privateTokens(config) {
-  return [config.deployment.token, WETH, ...LAUNCH_PAIRS.filter((p) => p.kind === "ostra" || p.kind === "stock").map((p) => getAddress24(p.address))];
+  return [config.deployment.token, WETH, ...LAUNCH_PAIRS.filter((p) => p.kind === "ostra" || p.kind === "stock").map((p) => getAddress25(p.address))];
 }
 var PRIVATE_SWAP_DIR, PRIVATE_SHIELD_GAS, PRIVATE_SPEND_DEADLINE_SECONDS, MAX_SLIPPAGE_BPS2, PRIVATE_FEE_GAS, PRIVATE_FEE_MAX_FACTOR, SHIELD_SCAN_GAP, LOGS_CATCH_UP_TRIES, SHIELD_LOG_WAIT_MS, NOTES, TREES, NEXT_RHO, POOL_INDEX, PENDING_PREFIX, shieldedEvent, swappedEvent, unshieldedEvent, address3, PrivateBalanceService;
 var init_private_balance = __esm({
@@ -21605,7 +21756,7 @@ var init_private_balance = __esm({
     unshieldedEvent = parseAbiItem4("event Unshielded(bytes32 indexed nullifier, address indexed recipient, address indexed token, uint256 amount, uint256 fee, address relayer)");
     address3 = (text2, what) => {
       if (!/^0x[0-9a-fA-F]{40}$/.test(text2)) throw new RangeError(`${what} is not an address`);
-      return getAddress24(text2);
+      return getAddress25(text2);
     };
     PrivateBalanceService = class {
       #p;
@@ -21615,7 +21766,7 @@ var init_private_balance = __esm({
       #tail = Promise.resolve();
       constructor(p) {
         this.#p = p;
-        this.#pool = getAddress24(p.swap.privatePool);
+        this.#pool = getAddress25(p.swap.privatePool);
       }
       get pool() {
         return this.#pool;
@@ -21680,27 +21831,37 @@ var init_private_balance = __esm({
           for (const l of await this.#poolLogs(from, to)) {
             if (l.eventName === "Shielded") {
               const tag = l.args.tag.toLowerCase();
-              shielded.set(tag, [...shielded.get(tag) ?? [], { token: getAddress24(l.args.token), amount: l.args.amount, commitment: l.args.commitment }]);
+              shielded.set(tag, [...shielded.get(tag) ?? [], { token: getAddress25(l.args.token), amount: l.args.amount, commitment: l.args.commitment }]);
               notes += 1;
             } else if (l.eventName === "Unshielded") {
               spends.set(l.args.nullifier.toLowerCase(), { kind: "unshield", v: l.args.amount, fee: l.args.fee });
               notes += 1;
             } else {
-              spends.set(l.args.nullifier.toLowerCase(), { kind: "swap", v: l.args.amountIn, fee: l.args.fee, tokenOut: getAddress24(l.args.tokenOut), amountOut: l.args.amountOut, outCommitment: l.args.outCommitment });
+              spends.set(l.args.nullifier.toLowerCase(), { kind: "swap", v: l.args.amountIn, fee: l.args.fee, tokenOut: getAddress25(l.args.tokenOut), amountOut: l.args.amountOut, outCommitment: l.args.outCommitment });
               notes += 2;
             }
           }
         }
         return { shielded, spends, notes };
       }
-      /** The pool's Shielded, Unshielded and PrivateSwapped logs in [from, to]; a range the RPC refuses as too many logs is split in halves. */
+      /**
+       * The pool's Shielded, Unshielded and PrivateSwapped logs in [from, to], one event per request: Robinhood Chain's
+       * public RPC serves LOG_WINDOW_BLOCKS only for one value per topic position, and a request naming the three events
+       * at once over at most 100,000 blocks (measured 23 Oct 2026, error -32602).
+       */
       async #poolLogs(from, to) {
+        const out = [];
+        for (const event of [shieldedEvent, unshieldedEvent, swappedEvent]) out.push(...await this.#eventLogs(event, from, to));
+        return out;
+      }
+      /** The pool's logs of `event` in [from, to]; a range the RPC refuses as too many logs is split in halves. */
+      async #eventLogs(event, from, to) {
         try {
-          return await this.#p.logsClient.getLogs({ address: this.#pool, events: [shieldedEvent, unshieldedEvent, swappedEvent], fromBlock: from, toBlock: to, strict: true });
+          return await this.#p.logsClient.getLogs({ address: this.#pool, event, fromBlock: from, toBlock: to, strict: true });
         } catch (err) {
           if (from >= to || !/exceeds limit|too many|query returned more than/i.test(String(err.message ?? err))) throw err;
           const mid = from + (to - from) / 2n;
-          return [...await this.#poolLogs(from, mid), ...await this.#poolLogs(mid + 1n, to)];
+          return [...await this.#eventLogs(event, from, mid), ...await this.#eventLogs(event, mid + 1n, to)];
         }
       }
       /** Rebuilds the agent's notes from the seed and the pool's events (see the file comment); the notes kept here become the unspent ones found. */
@@ -21784,7 +21945,7 @@ var init_private_balance = __esm({
         const found = new Set(unspent.map((n) => n.commitment.toLowerCase()));
         const local = [];
         for (const n of await this.#notes()) {
-          if (found.has(n.commitment.toLowerCase()) || !tokens.has(getAddress24(n.asset)) || trees.find(n.commitment) === null) continue;
+          if (found.has(n.commitment.toLowerCase()) || !tokens.has(getAddress25(n.asset)) || trees.find(n.commitment) === null) continue;
           const keys = await noteKeys(prover, sk, n.rho, n.asset, BigInt(n.amount));
           if (keys.commitment.toLowerCase() === n.commitment.toLowerCase() && !events.spends.has(keys.nullifier.toLowerCase())) local.push(n);
         }
@@ -21942,7 +22103,7 @@ var init_private_balance = __esm({
         const body = await this.#http("GET", `${url}/v1/private/price?token=${token}&kind=${kind}`);
         const b = body;
         if (typeof b.fee !== "string" || !/^[0-9]+$/.test(b.fee) || typeof b.relayer !== "string") throw new Error("the relayer's private price has no fee or relayer");
-        return { fee: BigInt(b.fee), relayer: getAddress24(b.relayer) };
+        return { fee: BigInt(b.fee), relayer: getAddress25(b.relayer) };
       }
       async #http(method, url, body) {
         let res;
@@ -22195,7 +22356,7 @@ var init_seed_backup = __esm({
 });
 
 // ../core/src/sessions.ts
-import { bytesToHex as bytesToHex12, getAddress as getAddress25, isAddress as isAddress12 } from "viem";
+import { bytesToHex as bytesToHex12, getAddress as getAddress26, isAddress as isAddress12 } from "viem";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 var init_sessions = __esm({
   "../core/src/sessions.ts"() {
@@ -22207,19 +22368,19 @@ var init_sessions = __esm({
 });
 
 // ../core/src/shield.ts
-import { bytesToHex as bytesToHex13, encodeFunctionData as encodeFunctionData13, getAddress as getAddress26, hexToBytes as hexToBytes8, parseSignature } from "viem";
+import { bytesToHex as bytesToHex13, encodeFunctionData as encodeFunctionData13, getAddress as getAddress27, 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}-${getAddress26(token)}-${index}.json`;
+  return `${chainId}-${getAddress27(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 = getAddress26(bytesToHex13(message.subarray(52, 72)));
+  const pool = getAddress27(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));
@@ -22294,7 +22455,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 getAddress26(record.vault) === await this.#vault.vaultAddress();
+        return getAddress27(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) {
@@ -22455,8 +22616,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 = getAddress26(health.aggregator);
-        const accounts = /* @__PURE__ */ new Set([...(record.aggregators ?? []).map((a) => getAddress26(a)), aggregator]);
+        const aggregator = getAddress27(health.aggregator);
+        const accounts = /* @__PURE__ */ new Set([...(record.aggregators ?? []).map((a) => getAddress27(a)), aggregator]);
         if (accounts.size !== (record.aggregators ?? []).length) {
           record.aggregators = [...accounts];
           await this.#save(record);
@@ -22511,11 +22672,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" || getAddress26(terms.pool) !== pool || typeof terms.token !== "string" || getAddress26(terms.token) !== this.#token()) {
+        if (terms.chainId !== this.#config.chainId || typeof terms.pool !== "string" || getAddress27(terms.pool) !== pool || typeof terms.token !== "string" || getAddress27(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 = getAddress26(terms.aggregator);
+        const aggregatorAccount = getAddress27(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();
@@ -22772,7 +22933,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 : getAddress26(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 : getAddress27(r.vault), deposit: r.deposit, leaves: r.leaves, amount: formatTokenAmount(BigInt(r.amount)), status: r.status, batch: r.batch, leavesInPool });
           }
           return out;
         });
@@ -22790,7 +22951,7 @@ var init_storage = __esm({
 });
 
 // ../core/src/swap.ts
-import { decodeEventLog as decodeEventLog4, getAddress as getAddress27 } from "viem";
+import { decodeEventLog as decodeEventLog4, getAddress as getAddress28 } from "viem";
 var SWAP_DIR, ESCROW_SWAP_GAS, DEFAULT_SWAP_SLIPPAGE_BPS, MAX_SWAP_SLIPPAGE_BPS, POOL_INDEX2, ORDER_PREFIX, address4, SwapService;
 var init_swap = __esm({
   "../core/src/swap.ts"() {
@@ -22810,7 +22971,7 @@ var init_swap = __esm({
     ORDER_PREFIX = "order-";
     address4 = (text2, what) => {
       if (!/^0x[0-9a-fA-F]{40}$/.test(text2)) throw new RangeError(`${what} is not an address`);
-      return getAddress27(text2);
+      return getAddress28(text2);
     };
     SwapService = class {
       #p;
@@ -22834,7 +22995,7 @@ var init_swap = __esm({
       async checkToken(token) {
         if (token === ETH) throw new RangeError("an Ostra vault holds WETH, not native ETH: swap WETH");
         if (token === this.#p.config.deployment.token || token === WETH) return;
-        if (LAUNCH_PAIRS.some((p) => (p.kind === "ostra" || p.kind === "stock") && getAddress27(p.address) === token)) return;
+        if (LAUNCH_PAIRS.some((p) => (p.kind === "ostra" || p.kind === "stock") && getAddress28(p.address) === token)) return;
         const lp = this.#p.config.deployment.launchpad;
         if (lp !== void 0) {
           const id = await this.#p.client.readContract({ address: lp.launchpad, abi: ostraLaunchpadAbi, functionName: "poolOf", args: [token] });
@@ -22934,7 +23095,7 @@ var init_swap = __esm({
         let swapped = null;
         let amountOut = 0n;
         for (const log2 of receipt.logs) {
-          if (getAddress27(log2.address) !== getAddress27(this.#p.swap.router)) continue;
+          if (getAddress28(log2.address) !== getAddress28(this.#p.swap.router)) continue;
           try {
             const e = decodeEventLog4({ abi: ostraRouterAbi, topics: log2.topics, data: log2.data });
             if (e.eventName === "EscrowExecuted" && e.args.orderHash.toLowerCase() === hash.toLowerCase()) swapped = e.args.swapped;
@@ -22977,9 +23138,9 @@ var init_swap = __esm({
 });
 
 // ../core/src/unshield.ts
-import { encodeFunctionData as encodeFunctionData14, getAddress as getAddress28 } from "viem";
+import { encodeFunctionData as encodeFunctionData14, getAddress as getAddress29 } from "viem";
 function recordName2(chainId, token, index) {
-  return `${chainId}-${getAddress28(token)}-${index}.json`;
+  return `${chainId}-${getAddress29(token)}-${index}.json`;
 }
 function unshieldDelaySeconds(windowHours) {
   if (!Number.isFinite(windowHours) || windowHours < 0 || windowHours > UNSHIELD_MAX_WINDOW_HOURS) {
@@ -23052,7 +23213,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: getAddress28(r.vault) })));
+        return this.#serial(async () => (await this.#records()).filter((r) => r.status === "spent").map((r) => ({ index: BigInt(r.index), vault: getAddress29(r.vault) })));
       }
       /** The number of the private vault at `vault`, or throws when it is none of this agent's. */
       async indexOf(vault) {
@@ -23151,7 +23312,7 @@ var init_unshield = __esm({
       async #spend(r) {
         const ctx = await this.#context(BigInt(r.index));
         const vault = await ctx.vault.vaultAddress();
-        if (vault !== getAddress28(r.vault)) throw new Error(`private vault ${r.index} is ${vault}, not the recorded ${r.vault}`);
+        if (vault !== getAddress29(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];
@@ -23188,9 +23349,9 @@ var init_unshield = __esm({
 import {
   concatHex as concatHex2,
   decodeErrorResult as decodeErrorResult2,
-  encodeAbiParameters as encodeAbiParameters10,
+  encodeAbiParameters as encodeAbiParameters11,
   encodeFunctionData as encodeFunctionData15,
-  getAddress as getAddress29,
+  getAddress as getAddress30,
   maxUint256,
   parseAbi as parseAbi4,
   zeroAddress as zeroAddress12
@@ -23227,6 +23388,7 @@ var init_src3 = __esm({
   "../core/src/index.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
+    init_ai();
     init_amount();
     init_chain2();
     init_channels();
@@ -23547,7 +23709,7 @@ var init_wasm_prover = __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 getAddress30, http as http2, isAddress as isAddress13 } from "viem";
+import { createPublicClient as createPublicClient2, getAddress as getAddress31, http as http2, isAddress as isAddress13 } from "viem";
 import { privateKeyToAccount as privateKeyToAccount5 } from "viem/accounts";
 function proverOf(c) {
   if (c === null) return null;
@@ -23607,6 +23769,8 @@ var init_agent = __esm({
       shield;
       creatorShield;
       unshield;
+      /** Ostra AI's tasks paid from the vault (null without OSTRA_AI_URL). */
+      ai;
       /** Ostra Swap from the agent's vaults, and its private notes (null without OSTRA_SWAP_DEPLOYMENT). */
       swap;
       privateBalance;
@@ -23629,6 +23793,7 @@ var init_agent = __esm({
         this.relayer?.attachBuyerVault(this.buyer);
         this.channels = new ChannelService(client, config, keys, this.buyer, this.sender);
         this.payments = new PayService(client, config, this.buyer, this.channels);
+        this.ai = config.aiUrl === null ? null : new AiService(config, this.payments, this.buyer);
         this.seller = new VaultService(client, transport, config, keys, this.sender, "seller");
         this.creatorRelayer = config.relayerUrl === null ? null : new RelayerClient(client, config, p.creatorKeys, config.relayerUrl);
         const creatorSender = this.creatorRelayer ?? this.local;
@@ -23662,7 +23827,7 @@ var init_agent = __esm({
       }
       /** The agent's vault for `token`: the buyer vault for USDG, else its token vault (the launchpad's, when there is one). */
       vaultFor(token) {
-        const t = getAddress30(token);
+        const t = getAddress31(token);
         if (t === this.config.deployment.token) return this.buyer;
         if (this.launchpad !== null) return this.launchpad.tokenVault(t);
         let v = this.#tokenVaults.get(t);
@@ -23701,7 +23866,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" || !isAddress13(r.crank, { strict: false })) throw new Error(`${SELLER_RECORD} is not a seller record of chain ${this.config.chainId}`);
-        this.seller.setInitCrank(getAddress30(r.crank));
+        this.seller.setInitCrank(getAddress31(r.crank));
       }
       /** True once accept_payments set the seller vault up. */
       async sellerReady() {
@@ -23721,7 +23886,7 @@ var init_agent = __esm({
         let crank;
         const known = await this.keys.folder.read(SELLER_RECORD);
         if (known !== void 0) {
-          crank = getAddress30(JSON.parse(known).crank);
+          crank = getAddress31(JSON.parse(known).crank);
         } else {
           let res;
           try {
@@ -23731,7 +23896,7 @@ var init_agent = __esm({
           }
           const body = await res.json().catch(() => null);
           if (res.status !== 200 || typeof body?.crank !== "string" || !isAddress13(body.crank, { strict: false })) throw new Error(`the keeper answered ${res.status} without a crank`);
-          crank = getAddress30(body.crank);
+          crank = getAddress31(body.crank);
           this.seller.setInitCrank(crank);
           await this.keys.folder.write(SELLER_RECORD, `${JSON.stringify({ chainId: this.config.chainId, token, crank, merchant })}
 `);
@@ -23877,7 +24042,7 @@ async function loadConfig(env = process.env) {
     keeperUrl: serviceUrl(env, "OSTRA_KEEPER_URL", services?.keeperUrl ?? null),
     relayerUrl: serviceUrl(env, "OSTRA_RELAYER_URL", services?.relayerUrl ?? null),
     aggregatorUrl: serviceUrl(env, "OSTRA_AGGREGATOR_URL", services?.aggregatorUrl ?? null),
-    aiUrl: null
+    aiUrl: serviceUrl(env, "OSTRA_AI_URL", services?.aiUrl ?? null)
   };
 }
 var PROVER_WASM_FILES;
@@ -23895,8 +24060,21 @@ var init_config2 = __esm({
 });
 
 // src/tools.ts
-import { readFile as readFile6, stat as stat4 } from "node:fs/promises";
+import { readFile as readFile6, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join7 } from "node:path";
 import { z } from "zod";
+function imageExt(b) {
+  if (b.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) return "png";
+  if (b[0] === 255 && b[1] === 216 && b[2] === 255) return "jpg";
+  if (b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP") return "webp";
+  if (b.subarray(0, 4).toString("latin1") === "GIF8") return "gif";
+  return "bin";
+}
+function videoExt(b) {
+  if (b.subarray(4, 8).toString("latin1") === "ftyp") return "mp4";
+  if (b.subarray(0, 4).equals(Buffer.from([26, 69, 223, 163]))) return "webm";
+  return "bin";
+}
 async function run2(fn, rpcUrls2) {
   try {
     return { content: [{ type: "text", text: toJson(await fn()) }] };
@@ -23947,6 +24125,60 @@ function registerTools(server, agent) {
     { url: z.string().url(), method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).default("GET"), headers: z.record(z.string(), z.string()).optional(), body: z.string().max(1e6).optional(), maxPrice: usdg, deposit: usdg.optional() },
     (a) => agent.payments.pay({ url: a.url, method: a.method, maxPrice: a.maxPrice, ...a.headers === void 0 ? {} : { headers: a.headers }, ...a.body === void 0 ? {} : { body: a.body }, ...a.deposit === void 0 ? {} : { deposit: a.deposit } })
   );
+  const ai = () => {
+    if (agent.ai === null) throw new Error("Ostra AI is not configured here (OSTRA_AI_URL)");
+    return agent.ai;
+  };
+  const aiDir = join7(agent.config.home, AI_DIR);
+  tool(
+    "ostra_ai",
+    "Runs an AI task on Ostra AI. text: request { messages, max_tokens, and optionally quality (best, balanced or cheapest; default best), privacy (no_training, zdr or standard; default no_training), temperature, top_p, seed, stop, tools, tool_choice, response_format, reasoning }. image: { prompt, and optionally n, quality, aspect_ratio, resolution, seed, background, output_format, image_quality, references }. video: { prompt, duration in seconds, and optionally quality, resolution (such as 480p; models priced per token need one), aspect_ratio, size, frame_images, references, generate_audio, seed }. A text task is read as a stream and answered whole, however long the model takes. No model is named: Ostra chooses one by its quality rating within maxPrice, and a task no model can do within it is refused with the reasons, nothing paid. Paid in USDG from the vault through an x402 channel to Ostra AI, opened when needed with `deposit` (default 1 USDG; its unused deposit comes back to the vault when the channel closes). maxPrice is the most the task may cost; what it did not cost stays as the vault's credit with Ostra AI and pays part of the next task (ostra_ai_credit). Images are saved as files in the agent's directory; a video task answers a job, followed with ostra_ai_job.",
+    { task: z.enum(AI_TASK_KINDS), request: z.record(z.string(), z.unknown()), maxPrice: usdg, deposit: usdg.optional() },
+    async (a) => {
+      const r = await ai().task(a.task, a.request, a.maxPrice, a.deposit);
+      const answer = r.answer;
+      if (a.task !== "image" || answer === null || typeof answer !== "object" || !Array.isArray(answer.images)) return r;
+      await ensurePrivateDir(aiDir);
+      const id = typeof answer.task === "string" && /^[0-9a-f]{1,64}$/.test(answer.task) ? answer.task : String(Date.now());
+      const images = [];
+      for (const [i, img] of answer.images.entries()) {
+        if (typeof img.b64_json !== "string") {
+          images.push({ media_type: img.media_type ?? null, file: null, note: "the answer carried no image data" });
+          continue;
+        }
+        const bytes = Buffer.from(img.b64_json, "base64");
+        const file = join7(aiDir, `${id}-${i}.${imageExt(bytes)}`);
+        await writeFile3(file, bytes, { mode: 384 });
+        images.push({ media_type: img.media_type, file, bytes: bytes.length });
+      }
+      return { ...r, answer: { ...answer, images } };
+    }
+  );
+  tool(
+    "ostra_ai_job",
+    "A video job of ostra_ai: its status until it is final (completed, failed, cancelled or expired; the first final read settles its cost and credits the rest to the vault). With download (default true), a completed job's video is saved as a file in the agent's directory. Free: no payment.",
+    { job: z.string().regex(/^[0-9a-f]{32}$/, "the job ostra_ai answered: 32 hex characters"), download: z.boolean().default(true) },
+    async (a) => {
+      const s = await ai().job(a.job);
+      const answer = s.answer;
+      if (s.status !== 200 || answer === null || typeof answer !== "object") return s;
+      const final = typeof answer.status === "string" && FINAL_JOB.includes(answer.status);
+      if (!a.download || answer.status !== "completed") return { ...answer, final };
+      const res = await fetch(ai().contentUrl(a.job), { signal: AbortSignal.timeout(6e5) });
+      const size = Number(res.headers.get("content-length") ?? "0");
+      if (!res.ok || size > MAX_VIDEO_BYTES) return { ...answer, final, file: null, note: `the video could not be read (${res.status}${size > MAX_VIDEO_BYTES ? `, ${size} bytes` : ""}); ask again` };
+      const bytes = Buffer.from(await res.arrayBuffer());
+      if (bytes.length > MAX_VIDEO_BYTES) return { ...answer, final, file: null, note: `the video is larger than ${MAX_VIDEO_BYTES} bytes` };
+      await ensurePrivateDir(aiDir);
+      const file = join7(aiDir, `${a.job}.${videoExt(bytes)}`);
+      await writeFile3(file, bytes, { mode: 384 });
+      return { ...answer, final, file, bytes: bytes.length };
+    }
+  );
+  tool("ostra_ai_credit", "The vault's credit with Ostra AI: what earlier tasks were paid and did not cost, used first by the next task (USDG).", {}, async () => {
+    const c = await ai().credit();
+    return { payer: c.payer, credit: typeof c.credit === "string" && /^[0-9]+$/.test(c.credit) ? formatTokenAmount(BigInt(c.credit)) : c.credit };
+  });
   tool("accept_payments", "Sets up the seller side: the seller vault with the Ostra keeper's crank (it claims vouchers), and the merchant key for the seller server (merchant/).", {}, () => agent.acceptPayments());
   tool("seller_balance", "The seller vault: balance, nonce, crank.", {}, async () => {
     if (!await agent.sellerReady()) throw new Error("this agent has no seller vault yet; call accept_payments first");
@@ -24060,7 +24292,7 @@ function registerTools(server, agent) {
   );
   tool(
     "launch",
-    "Launches a token on the Ostra launchpad (1 billion supply) paired with USDG (default), ETH, OSTRA 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; OSTRA at Chainlink ETH/USD times its bonding curve's price). 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, OSTRA 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; OSTRA at Chainlink ETH/USD times its price in the pool it graduated to). 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}$/),
@@ -24172,13 +24404,14 @@ function launchOptions(raw) {
   }
   return out;
 }
-var toJson, address5, usdg, units, pair2, slippage2, bytes323, swapToken, tokenAddress, uri, publicFields, BIGINT_FIELDS, ALLOWED_OPTIONS;
+var toJson, address5, usdg, units, pair2, slippage2, bytes323, swapToken, tokenAddress, uri, publicFields, AI_DIR, MAX_VIDEO_BYTES, FINAL_JOB, BIGINT_FIELDS, ALLOWED_OPTIONS;
 var init_tools = __esm({
   "src/tools.ts"() {
     "use strict";
     init_define_OSTRA_PACKAGED();
     init_src3();
     init_src();
+    init_disk();
     toJson = (value) => JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2);
     address5 = 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");
@@ -24203,6 +24436,9 @@ var init_tools = __esm({
       x: z.string().url().max(200).optional().describe("the X (Twitter) profile link"),
       telegram: z.string().url().max(200).optional()
     };
+    AI_DIR = "ai";
+    MAX_VIDEO_BYTES = 512 * 1024 * 1024;
+    FINAL_JOB = ["completed", "failed", "cancelled", "expired"];
     BIGINT_FIELDS = /* @__PURE__ */ new Set(["minDividendBalance", "maxBuy", "maxWallet", "graduationThreshold"]);
     ALLOWED_OPTIONS = /* @__PURE__ */ new Set([
       "tiers",