@subly_fi/pay 0.7.2 → 0.8.0

package/dist/mcp-server.js

@@ -182,1389 +182,1616 @@ var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
 var SUBLY_VAULT = defaultCatalogVault(vaultCatalogFromEnv());
 var USDC_DECIMALS = 6;
 
-// ../../src/lib/associated-token-account.ts
+// ../../src/lib/canonical-json.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// ../../src/lib/hash.ts
 import { createHash } from "node:crypto";
-import bs58 from "bs58";
-var PDA_MARKER = Buffer.from("ProgramDerivedAddress", "utf8");
-var ED25519_P = (1n << 255n) - 19n;
-var ED25519_D = mod(-121665n * modPow(121666n, ED25519_P - 2n, ED25519_P), ED25519_P);
-function deriveAssociatedTokenAddress(params) {
-  const owner = decodePublicKey(params.owner, "owner");
-  const mint = decodePublicKey(params.mint ?? SUBLY_VAULT.usdcMint, "mint");
-  const tokenProgramId = decodePublicKey(
-    params.tokenProgramId ?? SPL_TOKEN_PROGRAM_ID,
-    "tokenProgramId"
-  );
-  const associatedTokenProgramId = decodePublicKey(
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    "associatedTokenProgramId"
-  );
-  for (let bump = 255; bump >= 0; bump -= 1) {
-    const address3 = createProgramAddress(
-      [owner, tokenProgramId, mint, Uint8Array.of(bump)],
-      associatedTokenProgramId
-    );
-    if (address3 !== null) {
-      return bs58.encode(address3);
-    }
-  }
-  throw new Error("Unable to derive associated token account address");
-}
-function createProgramAddress(seeds, programId) {
-  const hash = createHash("sha256");
-  for (const seed of seeds) {
-    hash.update(seed);
-  }
-  hash.update(programId);
-  hash.update(PDA_MARKER);
-  const digest = hash.digest();
-  return isEd25519Point(digest) ? null : new Uint8Array(digest);
+var EMPTY_BODY_HASH = "sha256-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+function sha256TaggedHex(data) {
+  return `sha256-${createHash("sha256").update(data).digest("hex")}`;
 }
-function decodePublicKey(value, fieldName) {
-  const decoded = bs58.decode(value);
-  if (decoded.length !== 32) {
-    throw new Error(`${fieldName} must be a 32-byte public key`);
+function stableStringify(value) {
+  if (value === null) {
+    return "null";
   }
-  return decoded;
-}
-function isEd25519Point(bytes) {
-  if (bytes.length !== 32) {
-    return false;
+  if (typeof value === "bigint") {
+    return JSON.stringify(value.toString());
   }
-  const yBytes = Uint8Array.from(bytes);
-  yBytes[31] = yBytes[31] & 127;
-  const y = littleEndianToBigInt(yBytes);
-  if (y >= ED25519_P) {
-    return false;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
   }
-  const ySquared = mod(y * y, ED25519_P);
-  const numerator = mod(ySquared - 1n, ED25519_P);
-  const denominator = mod(ED25519_D * ySquared + 1n, ED25519_P);
-  if (denominator === 0n) {
-    return false;
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
   }
-  const xSquared = mod(
-    numerator * modPow(denominator, ED25519_P - 2n, ED25519_P),
-    ED25519_P
-  );
-  return xSquared === 0n || modPow(xSquared, (ED25519_P - 1n) / 2n, ED25519_P) === 1n;
+  const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
 }
-function littleEndianToBigInt(bytes) {
-  let value = 0n;
-  for (let index = bytes.length - 1; index >= 0; index -= 1) {
-    value = (value << 8n) + BigInt(bytes[index]);
-  }
-  return value;
+function hashStableJson(value) {
+  return sha256TaggedHex(stableStringify(value));
 }
-function mod(value, modulus) {
-  const result = value % modulus;
-  return result >= 0n ? result : result + modulus;
+
+// ../../src/lib/canonical-json.ts
+function canonicalJson(value) {
+  return stableStringify(value);
 }
-function modPow(base, exponent, modulus) {
-  let result = 1n;
-  let nextBase = mod(base, modulus);
-  let nextExponent = exponent;
-  while (nextExponent > 0n) {
-    if ((nextExponent & 1n) === 1n) {
-      result = mod(result * nextBase, modulus);
-    }
-    nextBase = mod(nextBase * nextBase, modulus);
-    nextExponent >>= 1n;
-  }
-  return result;
+function sha256HexOf(data) {
+  return createHash2("sha256").update(data, "utf8").digest("hex");
+}
+function canonicalJsonHash(value) {
+  return sha256HexOf(canonicalJson(value));
 }
 
-// ../../src/domain/withdrawal-rounding.ts
-var WITHDRAWAL_ROUNDING_RAW_USDC = 10n;
-var YIELD_REALIZE_ROUNDING_RAW_USDC = WITHDRAWAL_ROUNDING_RAW_USDC / 2n;
-
-// ../../src/client/withdrawal-preview.ts
-async function assertWithdrawalPreview(input) {
-  const destination = deriveAssociatedTokenAddress({ owner: input.wallet, mint: input.vault.usdcMint });
-  const simulation = await input.rpc.simulateTransaction(
-    input.serializedTransaction,
-    {
-      encoding: "base64",
-      commitment: "confirmed",
-      sigVerify: false,
-      replaceRecentBlockhash: false,
-      innerInstructions: true
-    }
-  ).send({ abortSignal: AbortSignal.timeout(15e3) });
-  if (simulation.value.err !== null) {
-    throw new Error("Withdrawal preview failed on the client RPC; no transaction was signed. Check liquidity, RPC and blockhash, then prepare again.");
-  }
-  let received = 0n;
-  for (const group of simulation.value.innerInstructions ?? []) {
-    for (const instruction of group.instructions) {
-      if (!("parsed" in instruction) || instruction.programId !== SPL_TOKEN_PROGRAM_ID) continue;
-      const parsed = instruction.parsed;
-      if (parsed.type !== "transfer" && parsed.type !== "transferChecked") continue;
-      const info = parsed.info;
-      if (!info || info.destination !== destination && info.source !== destination) continue;
-      const raw = parsed.type === "transferChecked" ? info.tokenAmount?.amount : info.amount;
-      if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
-        throw new Error("Withdrawal preview returned an invalid token amount");
-      }
-      const amount = BigInt(raw);
-      if (info.destination === destination) received += amount;
-      if (info.source === destination) received -= amount;
-    }
+// ../../src/x402/headers.ts
+import { z as z2 } from "zod";
+var PAYMENT_REQUIRED_HEADER = "payment-required";
+var PAYMENT_RESPONSE_HEADER = "payment-response";
+var MAX_HEADER_JSON_BYTES = 16384;
+var X402HeaderError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "X402HeaderError";
+    this.reason = reason;
   }
-  const minimum = input.purpose === "yield_realize" ? input.amountRawUsdc : input.amountRawUsdc - WITHDRAWAL_ROUNDING_RAW_USDC;
-  if (received <= 0n || received > input.amountRawUsdc + WITHDRAWAL_ROUNDING_RAW_USDC || received < minimum) {
-    throw new Error("Withdrawal preview differs from the requested USDC amount; no transaction was signed");
+};
+var sublyPaymentRequirementsSchema = z2.object({
+  scheme: z2.literal(PAYMENT_SCHEME),
+  network: z2.string().min(1),
+  asset: z2.string().min(32),
+  /** Exact seller amount in raw USDC; the scheme settles exactly this. */
+  amountRawUsdc: z2.string().regex(/^[1-9]\d*$/),
+  resource: z2.string().url(),
+  description: z2.string().optional(),
+  mimeType: z2.string().optional(),
+  payTo: z2.string().min(32),
+  maxTimeoutSeconds: z2.number().int().positive(),
+  extra: z2.object({
+    sellerRequestId: z2.string().min(1),
+    seller: z2.string().min(32),
+    sellerUsdcAta: z2.string().min(32),
+    vault: z2.string().min(32),
+    shareMint: z2.string().min(32)
+  })
+}).loose();
+var paymentRequiredSchema = z2.object({
+  x402Version: z2.number().int(),
+  accepts: z2.array(z2.unknown()),
+  error: z2.string().optional()
+}).loose();
+var sublyPaymentPayloadSchema = z2.object({
+  x402Version: z2.number().int(),
+  scheme: z2.literal(PAYMENT_SCHEME),
+  network: z2.string().min(1),
+  payload: z2.object({
+    paymentId: z2.string().min(1),
+    requestBindingHash: z2.string().min(1),
+    preparedMessageHash: z2.string().min(1),
+    serializedTransaction: z2.string().min(1).max(4096),
+    agentSignature: z2.string().min(1).max(128),
+    temporarySettlementSignature: z2.string().min(1).max(128)
+  })
+}).loose();
+function decodeX402Header(headerValue) {
+  if (headerValue.length > Math.ceil(MAX_HEADER_JSON_BYTES * 4 / 3) + 4) {
+    throw new X402HeaderError(
+      "header_too_large",
+      `x402 header exceeds ${MAX_HEADER_JSON_BYTES} encoded bytes`
+    );
   }
-}
-
-// ../../src/client/lookup-tables.ts
-import { fetchAllMaybeAddressLookupTable } from "@solana-program/address-lookup-table";
-import { address, getCompiledTransactionMessageDecoder } from "@solana/kit";
-function lookupTableAddressesForTransaction(serializedTransaction) {
-  const wire = Buffer.from(serializedTransaction, "base64");
-  let offset = 0;
-  let signatureCount = 0;
-  let shift = 0;
-  while (offset < wire.length) {
-    const byte = wire[offset];
-    signatureCount |= (byte & 127) << shift;
-    offset += 1;
-    if ((byte & 128) === 0) {
-      break;
-    }
-    shift += 7;
+  const json = Buffer.from(headerValue, "base64").toString("utf8");
+  try {
+    return JSON.parse(json);
+  } catch {
+    throw new X402HeaderError(
+      "invalid_header_encoding",
+      "x402 header is not base64-encoded JSON"
+    );
   }
-  const messageBytes = wire.subarray(offset + signatureCount * 64);
-  const compiled = getCompiledTransactionMessageDecoder().decode(messageBytes);
-  const lookups = compiled.addressTableLookups ?? [];
-  return lookups.map((lookup) => String(lookup.lookupTableAddress));
 }
-async function fetchLookupTablesForTransaction(rpc2, serializedTransaction) {
-  const addresses = lookupTableAddressesForTransaction(serializedTransaction);
-  if (addresses.length === 0) {
-    return {};
+function requestBodyHashFor(body) {
+  if (body === null || body === void 0 || body.length === 0) {
+    return EMPTY_BODY_HASH;
   }
-  const tables = await fetchAllMaybeAddressLookupTable(
-    rpc2,
-    addresses.map((value) => address(value))
+  return sha256TaggedHex(
+    typeof body === "string" ? Buffer.from(body, "utf8") : Buffer.from(body)
   );
-  const result = {};
-  for (const table of tables) {
-    if (table.exists) {
-      result[table.address] = table.data.addresses.map(String);
-    }
-  }
-  return result;
 }
 
-// ../../src/api/wallet-auth.ts
-import { createHash as createHash2 } from "node:crypto";
-import bs582 from "bs58";
-import nacl from "tweetnacl";
-var WALLET_AUTH_WALLET_HEADER = "x-subly-wallet";
-var WALLET_AUTH_SIGNED_AT_HEADER = "x-subly-signed-at";
-var WALLET_AUTH_SIGNATURE_HEADER = "x-subly-signature";
-function sha256Hex(data) {
-  return createHash2("sha256").update(data, "utf8").digest("hex");
+// ../../src/x402/standard-requirements.ts
+import { z as z3 } from "zod";
+var STANDARD_EXACT_SCHEME = "exact";
+var standardExactRequirementSchema = z3.object({
+  scheme: z3.literal(STANDARD_EXACT_SCHEME),
+  /** CAIP-2 chain id, e.g. "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp". */
+  network: z3.string().min(1),
+  /** SPL mint (Solana) or token contract (EVM); Subly only pays USDC/Solana. */
+  asset: z3.string().min(1),
+  /** Exact price in the asset's atomic units, as a decimal string. */
+  amount: z3.string().regex(/^[1-9]\d*$/),
+  /** Recipient wallet; the transfer destination ATA is derived from it. */
+  payTo: z3.string().min(1),
+  maxTimeoutSeconds: z3.number().int().positive().optional(),
+  extra: z3.object({
+    /** Facilitator address that pays the tx fee (gas sponsorship). */
+    feePayer: z3.string().min(1).optional()
+  }).loose().optional()
+}).loose();
+var standardPaymentRequiredSchema = z3.object({
+  x402Version: z3.number().int(),
+  accepts: z3.array(z3.unknown()),
+  error: z3.string().optional(),
+  resource: z3.object({ url: z3.string().optional() }).loose().optional()
+}).loose();
+var StandardX402ChallengeError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "StandardX402ChallengeError";
+    this.reason = reason;
+  }
+};
+function parseStandardChallenge(challenge) {
+  const parsed = standardPaymentRequiredSchema.safeParse(challenge);
+  if (!parsed.success) {
+    throw new StandardX402ChallengeError(
+      "invalid_payment_required",
+      "Response is not a valid x402 PaymentRequired object"
+    );
+  }
+  const solanaExactRequirements = parsed.data.accepts.flatMap((candidate) => {
+    const requirement = standardExactRequirementSchema.safeParse(candidate);
+    if (!requirement.success) {
+      return [];
+    }
+    return requirement.data.network.startsWith("solana:") ? [requirement.data] : [];
+  });
+  return { paymentRequired: parsed.data, solanaExactRequirements };
 }
-function walletAuthMessage(params) {
-  return new TextEncoder().encode(
-    `subly-api:${params.method.toUpperCase()}:${params.path}:${sha256Hex(
-      params.rawBody
-    )}:${params.signedAtMs}`
-  );
+function decodeStandardPaymentRequiredHeader(headerValue) {
+  let decoded;
+  try {
+    decoded = decodeX402Header(headerValue);
+  } catch (error) {
+    throw new StandardX402ChallengeError(
+      error instanceof X402HeaderError ? error.reason : "invalid_header",
+      "Cannot decode the payment-required header"
+    );
+  }
+  return parseStandardChallenge(decoded);
 }
-
-// ../../src/client/wallet-auth-headers.ts
-async function walletAuthHeaders(params) {
-  const signedAtMs = String(Date.now());
-  const message = walletAuthMessage({
-    method: params.method,
-    path: (() => {
-      const url = new URL(params.url);
-      return url.pathname + url.search;
-    })(),
-    rawBody: params.body ?? "",
-    signedAtMs
-  });
+function selectPayableSolanaRequirement(requirements, options) {
+  const network = options?.network ?? SOLANA_MAINNET_NETWORK;
+  const usdcMint = options?.usdcMint ?? SUBLY_VAULT.usdcMint;
+  const matchingRequirements = requirements.filter(
+    (candidate) => candidate.network === network && candidate.asset === usdcMint
+  );
+  if (matchingRequirements.length === 0) {
+    throw new StandardX402ChallengeError(
+      "no_payable_requirement",
+      `The challenge has no Solana exact requirement on ${network} paying ${usdcMint}`
+    );
+  }
+  const requirement = matchingRequirements.find(
+    (candidate) => candidate.extra?.feePayer !== void 0
+  ) ?? null;
+  if (requirement === null) {
+    throw new StandardX402ChallengeError(
+      "missing_svm_fee_payer",
+      "The Solana exact requirement does not include extra.feePayer, which the official @x402/svm client requires for gas sponsorship"
+    );
+  }
+  const feePayer = requirement.extra?.feePayer;
+  if (feePayer === void 0) {
+    throw new StandardX402ChallengeError(
+      "missing_svm_fee_payer",
+      "The Solana exact requirement does not include extra.feePayer, which the official @x402/svm client requires for gas sponsorship"
+    );
+  }
   return {
-    [WALLET_AUTH_WALLET_HEADER]: params.signer.walletAddress,
-    [WALLET_AUTH_SIGNED_AT_HEADER]: signedAtMs,
-    [WALLET_AUTH_SIGNATURE_HEADER]: await params.signer.signApiMessage(message)
+    requirement,
+    amountRawUsdc: BigInt(requirement.amount),
+    payTo: requirement.payTo,
+    feePayer
   };
 }
+function standardRequirementMatchesSelected(candidate, selected2) {
+  const parsed = standardExactRequirementSchema.safeParse(candidate);
+  return parsed.success && stableJson(parsed.data) === stableJson(selected2.requirement);
+}
+function stableJson(value) {
+  return JSON.stringify(sortJson(value));
+}
+function sortJson(value) {
+  if (Array.isArray(value)) {
+    return value.map(sortJson);
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, sortJson(entry)])
+    );
+  }
+  return value;
+}
 
-// ../../src/client/vault-flows.ts
-var VaultFlowClientError = class extends Error {
-  constructor(step, message, detail = null, code = null, errorDetails = null) {
+// ../../src/client/standard-x402-payer.ts
+var StandardX402PayError = class extends Error {
+  constructor(reason, message, detail = null) {
     super(message);
-    this.step = step;
+    this.reason = reason;
     this.detail = detail;
-    this.code = code;
-    this.errorDetails = errorDetails;
-    this.name = "VaultFlowClientError";
+    this.name = "StandardX402PayError";
   }
-  step;
+  reason;
   detail;
-  code;
-  errorDetails;
 };
-var VaultFlowClient = class {
-  vault;
-  rpc;
-  baseUrl;
-  signer;
-  fetchImpl;
-  lookupTablesFor;
-  pollTimeoutMs;
-  pollIntervalMs;
+var StandardX402Payer = class {
+  realizer;
+  x402Fetch;
+  probeFetch;
+  defaultMaxAmountRawUsdc;
+  network;
+  usdcMint;
+  stateStore;
+  pending = /* @__PURE__ */ new Map();
+  inFlight = /* @__PURE__ */ new Map();
+  nowMs;
   constructor(config) {
-    this.rpc = config.rpc;
-    this.vault = config.vault ?? config.signer.vault ?? SUBLY_VAULT;
-    if (config.signer.vault && config.signer.vault.address !== this.vault.address) {
-      throw new Error("Vault flow client and signer must select the same vault");
-    }
-    this.baseUrl = config.relayerBaseUrl.replace(/\/$/, "");
-    this.signer = config.signer;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-    this.lookupTablesFor = config.lookupTablesFor ?? ((serializedTransaction) => fetchLookupTablesForTransaction(config.rpc, serializedTransaction));
-    this.pollTimeoutMs = config.pollTimeoutMs ?? 9e4;
-    this.pollIntervalMs = config.pollIntervalMs ?? 2500;
-  }
-  /**
-   * Moves USDC from the agent wallet into the vault (fee sponsored). Under
-   * depositPolicy "owner_approval_required" the relayer refuses to prepare
-   * without an owner approval; when the caller passes none, an already
-   * APPROVED deposit approval for this exact amount (e.g. the mandate's
-   * initialDeposit — "one Face ID covers mandate + first deposit") is looked
-   * up and used automatically before surfacing deposit_approval_required.
-   */
-  async deposit(input) {
-    let approvalId = input.approvalId;
-    let prepared;
-    try {
-      prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
-        wallet: this.signer.walletAddress,
-        vault: this.vault.address,
-        amountRawUsdc: input.amountRawUsdc.toString(),
-        ...approvalId === void 0 ? {} : { approvalId }
-      });
-    } catch (error) {
-      if (!(error instanceof VaultFlowClientError) || error.code !== "deposit_approval_required" || approvalId !== void 0) {
-        throw error;
-      }
-      approvalId = await this.findApprovedDepositApproval(input.amountRawUsdc);
-      if (approvalId === void 0) {
-        throw error;
+    this.realizer = config.realizer;
+    this.x402Fetch = config.x402Fetch;
+    this.probeFetch = config.probeFetch ?? fetch;
+    this.defaultMaxAmountRawUsdc = config.defaultMaxAmountRawUsdc;
+    this.network = config.network ?? SOLANA_MAINNET_NETWORK;
+    this.usdcMint = config.usdcMint ?? SUBLY_VAULT.usdcMint;
+    this.stateStore = config.stateStore ?? null;
+    this.nowMs = config.nowMs ?? (() => Date.now());
+    if (this.stateStore !== null) {
+      for (const record of this.stateStore.load()) {
+        this.pending.set(record.key, record);
       }
-      prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
-        wallet: this.signer.walletAddress,
-        vault: this.vault.address,
-        amountRawUsdc: input.amountRawUsdc.toString(),
-        approvalId
-      });
-    }
-    if (prepared.signingIntent?.wallet !== this.signer.walletAddress || prepared.signingIntent.vault !== this.vault.address || prepared.signingIntent.amountRawUsdc !== input.amountRawUsdc.toString()) {
-      throw new VaultFlowClientError("prepare", "Prepared deposit differs from the requested wallet, vault or amount");
     }
-    const signed = await this.signer.signDeposit({
-      intent: prepared.signingIntent,
-      serializedTransaction: prepared.serializedTransaction,
-      lookupTables: await this.lookupTablesFor(prepared.serializedTransaction)
-    });
-    let outcome = await this.postJson("submit", "/v1/deposits/submit", {
-      depositId: prepared.depositId,
-      serializedTransaction: signed.serializedTransaction,
-      agentSignature: signed.agentSignature
+  }
+  pay(input, realizer = this.realizer) {
+    const method = (input.method ?? "GET").toUpperCase();
+    const requestBodyHash = requestBodyHashFor(input.body ?? null);
+    const pendingKey = pendingPaymentKey({
+      url: input.url,
+      method,
+      requestBodyHash
     });
-    if (outcome.status === "submitted") {
-      outcome = await this.pollUntilTerminal(
-        `/v1/deposits/${prepared.depositId}`,
-        outcome
-      );
+    const existingFlow = this.inFlight.get(pendingKey);
+    if (existingFlow !== void 0) {
+      return existingFlow;
     }
-    return {
-      depositId: prepared.depositId,
-      status: outcome.status,
-      txSignature: outcome.txSignature ?? null,
-      actualDepositRawUsdc: outcome.actualDepositRawUsdc ?? null,
-      sharesMintedRaw: outcome.sharesMintedRaw ?? null,
-      errorCode: outcome.errorCode ?? null
+    const run = async () => {
+      if (this.stateStore?.withExclusiveLock) {
+        this.pending.clear();
+        for (const record of this.stateStore.load()) this.pending.set(record.key, record);
+      }
+      return this.run(input, { method, requestBodyHash, pendingKey }, realizer);
     };
+    const flow = (this.stateStore?.withExclusiveLock ? this.stateStore.withExclusiveLock(run) : run()).finally(() => {
+      this.inFlight.delete(pendingKey);
+    });
+    this.inFlight.set(pendingKey, flow);
+    return flow;
   }
-  /**
-   * Moves USDC from the vault back to the agent wallet's USDC ATA (fee
-   * sponsored). A plain withdrawal is the exit path and MAY spend principal;
-   * with purpose "yield_realize" the relayer refuses anything beyond the
-   * spendable yield (the payment path, via RelayerYieldRealizer).
-   */
-  async withdraw(input) {
-    const prepared = await this.postJson(
-      "prepare",
-      "/v1/withdrawals/prepare",
-      {
-        wallet: this.signer.walletAddress,
-        vault: this.vault.address,
-        amountRawUsdc: input.amountRawUsdc.toString(),
-        ...input.purpose === void 0 ? {} : { purpose: input.purpose },
-        ...input.payment === void 0 ? {} : { payment: input.payment },
-        ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId }
+  async run(input, computed, realizer) {
+    const { method, requestBodyHash, pendingKey } = computed;
+    const existingPending = this.pending.get(pendingKey);
+    const resuming = existingPending?.recovery !== void 0 && existingPending.status !== "external_outcome_unknown";
+    const requestHeadersHash = canonicalJsonHash(input.headers ?? {});
+    if (resuming) {
+      const recovery = existingPending.recovery;
+      if (canonicalJsonHash(recovery.context) !== canonicalJsonHash(realizer.realizationContext ?? null) || recovery.requestHeadersHash !== requestHeadersHash || existingPending.url !== input.url || existingPending.method !== method || existingPending.requestBodyHash !== requestBodyHash) {
+        throw new StandardX402PayError(
+          "payment_outcome_unknown",
+          "The pending realization belongs to a different wallet, vault, relayer or request; refusing to resume or discard it.",
+          publicPendingPayment(existingPending)
+        );
+      }
+      if (existingPending.status === "realizing" && recovery.prepared === void 0) {
+        throw new StandardX402PayError(
+          "payment_outcome_unknown",
+          "Realization was interrupted before its withdrawal ID was saved. Reconcile the original operation before retrying; forceNewPayment cannot discard an incomplete realization.",
+          publicPendingPayment(existingPending)
+        );
+      }
+    } else if (existingPending !== void 0) {
+      if (input.forceNewPayment !== true || existingPending.status === "realizing") {
+        throw new StandardX402PayError(
+          "payment_outcome_unknown",
+          "A previous payment or realization has an unknown outcome. Verify it before purchasing again.",
+          publicPendingPayment(existingPending)
+        );
+      }
+      try {
+        this.untrack(pendingKey);
+      } catch (error) {
+        throw new StandardX402PayError(
+          "state_persist_failed",
+          "Could not clear the previous pending x402 marker before forcing a new payment",
+          error
+        );
       }
-    );
-    if (prepared.signingIntent?.wallet !== this.signer.walletAddress || prepared.signingIntent.vault !== this.vault.address || prepared.requestedWithdrawRawUsdc !== input.amountRawUsdc.toString() || prepared.purpose !== (input.purpose ?? "normal") || input.purpose === "yield_realize" && prepared.signingIntent.allowFullExit) {
-      throw new VaultFlowClientError("prepare", "Prepared withdrawal differs from the requested operation");
     }
-    await assertWithdrawalPreview({
-      rpc: this.rpc,
-      serializedTransaction: prepared.serializedTransaction,
-      wallet: this.signer.walletAddress,
-      vault: this.vault,
-      amountRawUsdc: input.amountRawUsdc,
-      ...input.purpose === void 0 ? {} : { purpose: input.purpose }
-    });
-    const signed = await this.signer.signWithdrawal({
-      intent: prepared.signingIntent,
-      serializedTransaction: prepared.serializedTransaction,
-      lookupTables: await this.lookupTablesFor(prepared.serializedTransaction)
-    });
-    let outcome = await this.postJson("submit", "/v1/withdrawals/submit", {
-      withdrawalId: prepared.withdrawalId,
-      serializedTransaction: signed.serializedTransaction,
-      agentSignature: signed.agentSignature
-    });
-    if (outcome.status === "submitted") {
-      outcome = await this.pollUntilTerminal(
-        `/v1/withdrawals/${prepared.withdrawalId}`,
-        outcome
+    const init = {
+      method,
+      ...input.body === void 0 ? {} : { body: input.body },
+      ...input.headers === void 0 ? {} : { headers: input.headers }
+    };
+    const probe = await this.probeFetch(input.url, init);
+    if (probe.status !== 402) {
+      if (resuming) {
+        throw new StandardX402PayError(
+          "payment_outcome_unknown",
+          "The seller no longer offers the original payment challenge; the saved realization is retained for reconciliation.",
+          publicPendingPayment(existingPending)
+        );
+      }
+      return { paid: false, status: probe.status, body: await probe.text() };
+    }
+    const selected2 = await this.selectRequirement(probe);
+    if (resuming && (!standardRequirementMatchesSelected(existingPending.recovery.requirement, selected2) || existingPending.amountRawUsdc !== selected2.amountRawUsdc.toString() || existingPending.payTo !== selected2.payTo || existingPending.feePayer !== selected2.feePayer)) {
+      throw new StandardX402PayError(
+        "payment_outcome_unknown",
+        "The seller's payment challenge differs from the saved realization; refusing to fund a different payment.",
+        publicPendingPayment(existingPending)
       );
     }
-    return {
-      withdrawalId: prepared.withdrawalId,
-      status: outcome.status,
-      txSignature: outcome.txSignature ?? null,
-      destinationUsdcAta: prepared.destinationUsdcAta,
-      actualWithdrawRawUsdc: outcome.actualWithdrawRawUsdc ?? null,
-      actualSharesBurnedRaw: outcome.actualSharesBurnedRaw ?? null,
-      errorCode: outcome.errorCode ?? null
+    const cap = input.maxAmountRawUsdc ?? this.defaultMaxAmountRawUsdc;
+    if (selected2.amountRawUsdc > cap) {
+      throw new StandardX402PayError(
+        "amount_exceeds_client_cap",
+        `the challenge demands ${selected2.amountRawUsdc} raw USDC, above the client cap of ${cap}; no new payment was attempted`,
+        { amountRawUsdc: selected2.amountRawUsdc.toString(), payTo: selected2.payTo }
+      );
+    }
+    const payment = {
+      payTo: selected2.payTo,
+      amountRawUsdc: selected2.amountRawUsdc.toString(),
+      resourceUrlHash: sha256HexOf(input.url),
+      method
     };
-  }
-  /**
-   * Reads the yield budget. Syncs the relayer's ledger from chain first (so
-   * yield accrued since the last sync shows up); the sync is best-effort and
-   * on failure the last-synced view is returned.
-   */
-  async getBudget(options = {}) {
-    if (options.refreshFromChain !== false) {
+    let pendingRecord = resuming ? existingPending : {
+      key: pendingKey,
+      url: input.url,
+      method,
+      requestBodyHash,
+      amountRawUsdc: selected2.amountRawUsdc.toString(),
+      payTo: selected2.payTo,
+      feePayer: selected2.feePayer,
+      realizedRawUsdc: "0",
+      realizeTxSignature: null,
+      status: "realizing",
+      createdAtMs: this.nowMs(),
+      updatedAtMs: this.nowMs(),
+      ...realizer.realizationContext === void 0 ? {} : {
+        recovery: {
+          version: 1,
+          context: { ...realizer.realizationContext },
+          requestHeadersHash,
+          requirement: structuredClone(selected2.requirement)
+        }
+      }
+    };
+    if (!resuming) this.persistCheckpoint(pendingRecord);
+    let realized;
+    if (resuming && pendingRecord.status === "realized") {
+      realized = {
+        realizedRawUsdc: BigInt(pendingRecord.realizedRawUsdc),
+        txSignature: pendingRecord.realizeTxSignature,
+        withdrawalId: pendingRecord.recovery?.prepared?.withdrawalId ?? null
+      };
+    } else {
       try {
-        await this.postJson(
-          "sync",
-          `/v1/wallets/${this.signer.walletAddress}/sync`,
-          { source: "chain", vault: this.vault.address }
+        if (resuming) {
+          if (realizer.resumeUsdcAvailable === void 0) {
+            throw new Error("This realizer cannot reconcile the saved withdrawal");
+          }
+          realized = await realizer.resumeUsdcAvailable({
+            amountRawUsdc: selected2.amountRawUsdc,
+            payment,
+            prepared: pendingRecord.recovery.prepared
+          });
+        } else {
+          realized = await realizer.ensureUsdcAvailable({
+            amountRawUsdc: selected2.amountRawUsdc,
+            payment,
+            ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId },
+            onPrepared: async (prepared) => {
+              if (pendingRecord.recovery === void 0) {
+                throw new StandardX402PayError("state_persist_failed", "Cannot save a withdrawal without a pinned funding context");
+              }
+              const checkpoint = {
+                ...pendingRecord,
+                updatedAtMs: this.nowMs(),
+                recovery: { ...pendingRecord.recovery, prepared: structuredClone(prepared) }
+              };
+              this.persistCheckpoint(checkpoint);
+              pendingRecord = checkpoint;
+            }
+          });
+        }
+      } catch (error) {
+        if (error instanceof StandardX402PayError && error.reason === "state_persist_failed") throw error;
+        const failure = error;
+        const safeToRetry = !resuming && (failure.realizationSafeToRetry === true || failure.code === "approval_required" && pendingRecord.recovery?.prepared === void 0);
+        if (safeToRetry) {
+          try {
+            this.untrack(pendingKey);
+          } catch (persistError) {
+            throw new StandardX402PayError("state_persist_failed", "Could not clear the safely refused realization", persistError);
+          }
+        }
+        if (safeToRetry && failure.code === "approval_required") {
+          throw new StandardX402PayError(
+            "approval_required",
+            "This payment needs the owner's approval; nothing was paid. Ask the owner to open approveUrl, then retry the same call with approvalId.",
+            failure.detail ?? null
+          );
+        }
+        throw new StandardX402PayError(
+          safeToRetry ? "realize_failed" : "payment_outcome_unknown",
+          safeToRetry ? "Yield realization failed before submission; no payment was attempted." : "The original yield realization has not been confirmed. Its saved withdrawal must be reconciled before any new withdrawal or payment.",
+          { error, pendingPayment: safeToRetry ? null : publicPendingPayment(pendingRecord) }
         );
-      } catch {
       }
     }
-    const url = `${this.baseUrl}/v1/wallets/${this.signer.walletAddress}/budget?vault=${this.vault.address}`;
-    const response = await this.fetchImpl(url, {
-      headers: await walletAuthHeaders({
-        signer: this.signer,
-        method: "GET",
-        url
-      })
-    });
-    const text = await response.text();
-    if (response.status !== 200) {
-      throw new VaultFlowClientError(
-        "budget",
-        `budget endpoint returned ${response.status}: ${text}`
+    pendingRecord = {
+      ...pendingRecord,
+      status: "realized",
+      realizedRawUsdc: realized.realizedRawUsdc.toString(),
+      realizeTxSignature: realized.txSignature,
+      updatedAtMs: this.nowMs()
+    };
+    this.persistCheckpoint(pendingRecord);
+    if (realized.realizedRawUsdc < selected2.amountRawUsdc) {
+      throw new StandardX402PayError(
+        "realize_underfunded",
+        "The confirmed withdrawal did not cover the exact API price. No external payment was attempted; reconcile the recorded withdrawal before retrying.",
+        { pendingPayment: publicPendingPayment(pendingRecord) }
       );
     }
-    let parsed;
+    this.persistCheckpoint({
+      ...pendingRecord,
+      status: "external_outcome_unknown",
+      updatedAtMs: this.nowMs()
+    });
+    let response;
     try {
-      parsed = JSON.parse(text);
-    } catch {
-      throw new VaultFlowClientError(
-        "budget",
-        "budget endpoint returned 200 with a non-JSON body",
-        text
+      response = await this.x402Fetch(input.url, init, selected2);
+    } catch (error) {
+      const persistError = this.tryMarkUnknown(pendingKey, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw new StandardX402PayError(
+        "payment_outcome_unknown",
+        `the x402 payment attempt failed after yield was realized; verify whether it settled before paying again: ${error instanceof Error ? error.message : String(error)}`,
+        { error, persistError }
       );
     }
-    const body = parsed;
-    if (body.position?.vault !== void 0 && body.position.vault !== this.vault.address) {
-      throw new VaultFlowClientError("budget", "Relayer returned the budget for a different vault");
+    const bodyText = await response.text();
+    const receipt = readSettlementReceipt(response);
+    if (response.status < 200 || response.status >= 300 || receipt.status === "failed" || receipt.status === "invalid") {
+      const persistError = this.tryMarkUnknown(pendingKey, {
+        status: response.status,
+        body: bodyText,
+        receiptStatus: receipt.status
+      });
+      throw new StandardX402PayError(
+        "payment_outcome_unknown",
+        `the x402 payment attempt returned HTTP ${response.status} with a ${receipt.status} receipt; verify whether it settled before paying again`,
+        { status: response.status, body: bodyText, receiptStatus: receipt.status, persistError }
+      );
+    }
+    this.clearDelivered(pendingKey);
+    const paymentTxSignature = receipt.txSignature;
+    if (paymentTxSignature !== null && typeof realized.withdrawalId === "string" && realizer.reportPayment !== void 0) {
+      try {
+        await realizer.reportPayment({
+          withdrawalId: realized.withdrawalId,
+          paymentTxSignature
+        });
+      } catch (error) {
+        console.error(
+          `[subly-x402] payment report-back failed (audit only, payment ok): ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
     }
     return {
-      wallet: this.signer.walletAddress,
-      vault: this.vault.address,
-      principalBasisRawUsdc: body.position?.principalBasisRawUsdc ?? "0",
-      positionValueRawUsdc: body.budget?.positionValueRawUsdc ?? "0",
-      grossYieldRawUsdc: body.budget?.grossYieldRawUsdc ?? "0",
-      spendableYieldRawUsdc: body.budget?.spendableYieldRawUsdc ?? "0"
+      paid: true,
+      ...realizer.vault === void 0 ? {} : { fundingVault: realizer.vault },
+      status: response.status,
+      body: bodyText,
+      payment: {
+        amountRawUsdc: selected2.amountRawUsdc.toString(),
+        payTo: selected2.payTo,
+        feePayer: selected2.feePayer,
+        realizedRawUsdc: realized.realizedRawUsdc.toString(),
+        realizeTxSignature: realized.txSignature,
+        paymentTxSignature
+      }
     };
   }
-  /** Best-effort audit link: reports the x402 payment tx a realize funded. */
-  async reportPayment(input) {
-    await this.postJson("submit", "/v1/payments/report", {
-      wallet: this.signer.walletAddress,
-      withdrawalId: input.withdrawalId,
-      paymentTxSignature: input.paymentTxSignature
-    });
-  }
-  /** Wallet's approvals as the relayer sees them (optionally by status). */
-  async listApprovals(status) {
-    const body = await this.getJson(
-      `/v1/wallets/${this.signer.walletAddress}/approvals${`?vault=${this.vault.address}${status === void 0 ? "" : `&status=${encodeURIComponent(status)}`}`}`
-    );
-    return body.approvals ?? [];
-  }
-  /**
-   * Creates the owner-onboarding setup link (wallet-auth pins the agreed
-   * policy + initial deposit). Paste `setupUrl` into the chat verbatim.
-   */
-  async createSetupSession(input) {
-    const session = await this.postJson(
-      "prepare",
-      `/v1/wallets/${this.signer.walletAddress}/setup-sessions`,
-      {
-        vault: this.vault.address,
-        ...input.policy === void 0 ? {} : { policy: input.policy },
-        ...input.enforcementMode === void 0 ? {} : { enforcementMode: input.enforcementMode },
-        ...input.mandateTtlDays === void 0 ? {} : { mandateTtlDays: input.mandateTtlDays },
-        ...input.initialDepositRawUsdc === void 0 ? {} : { initialDepositRawUsdc: input.initialDepositRawUsdc }
+  /** Reads the challenge from the header (preferred) or the JSON body. */
+  async selectRequirement(probe) {
+    const header = probe.headers.get(PAYMENT_REQUIRED_HEADER);
+    let requirements;
+    try {
+      if (header !== null) {
+        requirements = decodeStandardPaymentRequiredHeader(header).solanaExactRequirements;
+      } else {
+        requirements = parseStandardChallenge(
+          await probe.json()
+        ).solanaExactRequirements;
       }
-    );
-    if (session.vault !== this.vault.address || session.wallet !== this.signer.walletAddress) {
-      throw new VaultFlowClientError("prepare", "Relayer returned a setup session for a different wallet or vault");
+    } catch (error) {
+      throw new StandardX402PayError(
+        error instanceof StandardX402ChallengeError ? error.reason : "invalid_challenge",
+        "could not parse the x402 402 challenge",
+        error
+      );
     }
-    return session;
-  }
-  /** Polls a setup session (public capability URL — no auth needed). */
-  async getSetupSession(sessionId) {
-    const url = `${this.baseUrl}/v1/setup-sessions/${encodeURIComponent(sessionId)}`;
-    const response = await this.fetchImpl(url);
-    const text = await response.text();
-    if (response.status !== 200) {
-      const parsed = parseRelayerError(text);
-      throw new VaultFlowClientError(
-        "read",
-        parsed.message ?? `setup session read failed with ${response.status}`,
-        text,
-        parsed.code,
-        parsed.details
+    try {
+      return selectPayableSolanaRequirement(requirements, {
+        network: this.network,
+        usdcMint: this.usdcMint
+      });
+    } catch (error) {
+      throw new StandardX402PayError(
+        "no_payable_requirement",
+        error instanceof Error ? error.message : String(error),
+        error
       );
     }
-    return JSON.parse(text);
   }
-  /**
-   * Finds an APPROVED, unconsumed deposit approval bound to exactly this
-   * amount — the shape the mandate's initialDeposit approval has.
-   */
-  async findApprovedDepositApproval(amountRawUsdc) {
+  persistCheckpoint(record) {
     try {
-      const approvals = await this.listApprovals("approved");
-      const match = approvals.find((approval) => {
-        const binding = approval.binding;
-        return binding?.kind === "deposit" && binding.amountRawUsdc === amountRawUsdc.toString();
-      });
-      return match?.approvalId;
-    } catch {
-      return void 0;
+      this.track(record);
+    } catch (error) {
+      throw new StandardX402PayError(
+        "state_persist_failed",
+        "Could not persist payment recovery state; refusing the next financial operation.",
+        { error, pendingPayment: publicPendingPayment(record) }
+      );
     }
   }
-  /**
-   * Polls the reconciling GET endpoint until the intent leaves "submitted"
-   * (each read looks the tx up on-chain) or the timeout elapses.
-   */
-  async pollUntilTerminal(path, last) {
-    const deadline = Date.now() + this.pollTimeoutMs;
-    let latest = last;
-    while (Date.now() < deadline) {
-      await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
-      const url = `${this.baseUrl}${path}`;
-      const response = await this.fetchImpl(url, {
-        headers: await walletAuthHeaders({
-          signer: this.signer,
-          method: "GET",
-          url
-        })
-      });
-      if (response.status !== 200) {
-        continue;
-      }
-      try {
-        latest = await response.json();
-      } catch {
-        continue;
-      }
-      if (latest.status !== "submitted") {
-        return latest;
+  track(record) {
+    const previous = this.pending.get(record.key);
+    this.pending.set(record.key, record);
+    try {
+      this.persist();
+    } catch (error) {
+      if (previous === void 0) {
+        this.pending.delete(record.key);
+      } else {
+        this.pending.set(record.key, previous);
       }
+      throw error;
     }
-    return latest;
   }
-  async postJson(step, path, body) {
-    const url = `${this.baseUrl}${path}`;
-    const serialized = JSON.stringify(body);
-    const response = await this.fetchImpl(url, {
-      method: "POST",
-      headers: {
-        ...await walletAuthHeaders({
-          signer: this.signer,
-          method: "POST",
-          url,
-          body: serialized
-        }),
-        "content-type": "application/json"
-      },
-      body: serialized
-    });
-    const text = await response.text();
-    if (response.status !== 200) {
-      const parsed = parseRelayerError(text);
-      throw new VaultFlowClientError(
-        step,
-        parsed.message === null ? `${path} failed with ${response.status}: ${text}` : `${path} failed (${parsed.code ?? response.status}): ${parsed.message}`,
-        text,
-        parsed.code,
-        parsed.details
-      );
+  markUnknown(key, detail) {
+    const current = this.pending.get(key);
+    if (current === void 0) {
+      return;
     }
+    const next = {
+      ...current,
+      status: "external_outcome_unknown",
+      updatedAtMs: this.nowMs(),
+      detail
+    };
+    this.pending.set(key, next);
     try {
-      return JSON.parse(text);
-    } catch {
-      throw new VaultFlowClientError(
-        step,
-        `${path} returned 200 with a non-JSON body`,
-        text
-      );
+      this.persist();
+    } catch (error) {
+      this.pending.set(key, current);
+      throw error;
     }
   }
-  async getJson(path) {
-    const url = `${this.baseUrl}${path}`;
-    const response = await this.fetchImpl(url, {
-      headers: await walletAuthHeaders({
-        signer: this.signer,
-        method: "GET",
-        url
-      })
-    });
-    const text = await response.text();
-    if (response.status !== 200) {
-      const parsed = parseRelayerError(text);
-      throw new VaultFlowClientError(
-        "read",
-        parsed.message === null ? `${path} failed with ${response.status}: ${text}` : `${path} failed (${parsed.code ?? response.status}): ${parsed.message}`,
-        text,
-        parsed.code,
-        parsed.details
-      );
+  tryMarkUnknown(key, detail) {
+    try {
+      this.markUnknown(key, detail);
+      return null;
+    } catch (error) {
+      return error;
     }
+  }
+  untrack(key) {
+    const previous = this.pending.get(key);
+    const existed = previous !== void 0;
+    this.pending.delete(key);
     try {
-      return JSON.parse(text);
-    } catch {
-      throw new VaultFlowClientError(
-        "read",
-        `${path} returned 200 with a non-JSON body`,
-        text
+      this.persist();
+    } catch (error) {
+      if (existed) {
+        this.pending.set(key, previous);
+      }
+      throw error;
+    }
+  }
+  clearDelivered(key) {
+    const previous = this.pending.get(key);
+    this.pending.delete(key);
+    try {
+      this.persist();
+    } catch (error) {
+      if (previous !== void 0) {
+        this.pending.set(key, previous);
+      }
+      console.error(
+        `[subly-x402] payment delivered but pending marker could not be cleared: ${error instanceof Error ? error.message : String(error)}`
       );
     }
   }
+  persist() {
+    if (this.stateStore === null) {
+      return;
+    }
+    this.stateStore.save([...this.pending.values()]);
+  }
 };
-function parseRelayerError(text) {
+function publicPendingPayment(record) {
+  return {
+    url: record.url,
+    method: record.method,
+    requestBodyHash: record.requestBodyHash,
+    amountRawUsdc: record.amountRawUsdc,
+    payTo: record.payTo,
+    feePayer: record.feePayer,
+    realizedRawUsdc: record.realizedRawUsdc,
+    realizeTxSignature: record.realizeTxSignature,
+    status: record.status,
+    createdAtMs: record.createdAtMs,
+    updatedAtMs: record.updatedAtMs,
+    withdrawalId: record.recovery?.prepared?.withdrawalId ?? null,
+    fundingSource: record.recovery?.context ?? null
+  };
+}
+function pendingPaymentKey(input) {
+  return `${input.method}:${input.url}:${input.requestBodyHash}`;
+}
+function readSettlementReceipt(response) {
+  const header = response.headers.get(PAYMENT_RESPONSE_HEADER) ?? response.headers.get("x-payment-response");
+  if (header === null) {
+    return { status: "absent", txSignature: null };
+  }
   try {
-    const parsed = JSON.parse(text);
-    return {
-      code: typeof parsed.error?.code === "string" ? parsed.error.code : null,
-      message: typeof parsed.error?.message === "string" ? parsed.error.message : null,
-      details: parsed.error?.details ?? null
-    };
+    const decoded = decodeX402Header(header);
+    if (decoded === null || typeof decoded !== "object" || Array.isArray(decoded) || !("success" in decoded) || typeof decoded.success !== "boolean") {
+      return { status: "invalid", txSignature: null };
+    }
+    if (!decoded.success) return { status: "failed", txSignature: null };
+    const receipt = decoded;
+    if (typeof receipt.transaction === "string" && receipt.transaction.length > 0) {
+      return { status: "success", txSignature: receipt.transaction };
+    }
+    if (typeof receipt.txHash === "string" && receipt.txHash.length > 0) {
+      return { status: "success", txSignature: receipt.txHash };
+    }
+    return { status: "invalid", txSignature: null };
   } catch {
-    return { code: null, message: null, details: null };
+    return { status: "invalid", txSignature: null };
   }
 }
 
-// ../../src/client/relayer-yield-realizer.ts
-var REALIZE_OVERHEAD_RAW_USDC = 2500n;
-var RelayerRealizeError = class extends Error {
-  constructor(code, message, detail = null) {
-    super(message);
-    this.code = code;
-    this.detail = detail;
-    this.name = "RelayerRealizeError";
-  }
-  code;
-  detail;
-};
-var RelayerYieldRealizer = class {
-  get vault() {
-    return this.vaultFlows.vault.address;
-  }
-  vaultFlows;
-  constructor(config) {
-    this.vaultFlows = new VaultFlowClient({
-      relayerBaseUrl: config.relayerBaseUrl,
-      signer: config.signer,
-      rpc: config.rpc,
-      ...config.fetchImpl === void 0 ? {} : { fetchImpl: config.fetchImpl },
-      ...config.lookupTablesFor === void 0 ? {} : { lookupTablesFor: config.lookupTablesFor }
-    });
-  }
-  async ensureUsdcAvailable(input) {
-    const shortfallRawUsdc = input.amountRawUsdc;
-    await this.assertSpendableYield(shortfallRawUsdc);
-    let outcome;
-    try {
-      outcome = await this.vaultFlows.withdraw({
-        amountRawUsdc: shortfallRawUsdc,
-        // The relayer refuses to prepare this withdrawal beyond the spendable
-        // yield — the principal-protection guard the client cannot bypass.
-        purpose: "yield_realize",
-        // Declares what is being paid so the relayer's spending-mandate layer
-        // can enforce caps/payee and keep the mandate → payment audit chain.
-        ...input.payment === void 0 ? {} : { payment: input.payment },
-        ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId }
-      });
-    } catch (error) {
-      throw this.mapWithdrawError(error);
-    }
-    if (outcome.status !== "confirmed" || outcome.txSignature === null) {
-      throw new RelayerRealizeError(
-        "realize_not_confirmed",
-        `yield realize withdrawal did not confirm (status=${outcome.status})`,
-        outcome
-      );
+// ../../src/lib/associated-token-account.ts
+import { createHash as createHash3 } from "node:crypto";
+import bs58 from "bs58";
+var PDA_MARKER = Buffer.from("ProgramDerivedAddress", "utf8");
+var ED25519_P = (1n << 255n) - 19n;
+var ED25519_D = mod(-121665n * modPow(121666n, ED25519_P - 2n, ED25519_P), ED25519_P);
+function deriveAssociatedTokenAddress(params) {
+  const owner = decodePublicKey(params.owner, "owner");
+  const mint = decodePublicKey(params.mint ?? SUBLY_VAULT.usdcMint, "mint");
+  const tokenProgramId = decodePublicKey(
+    params.tokenProgramId ?? SPL_TOKEN_PROGRAM_ID,
+    "tokenProgramId"
+  );
+  const associatedTokenProgramId = decodePublicKey(
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    "associatedTokenProgramId"
+  );
+  for (let bump = 255; bump >= 0; bump -= 1) {
+    const address3 = createProgramAddress(
+      [owner, tokenProgramId, mint, Uint8Array.of(bump)],
+      associatedTokenProgramId
+    );
+    if (address3 !== null) {
+      return bs58.encode(address3);
     }
-    return {
-      realizedRawUsdc: BigInt(outcome.actualWithdrawRawUsdc ?? "0"),
-      txSignature: outcome.txSignature,
-      withdrawalId: outcome.withdrawalId
-    };
   }
-  /**
-   * Best-effort report-back of the x402 payment tx this realize funded —
-   * closes the relayer's mandate → realize → payment audit chain. Callers
-   * must never let a failure here affect the payment result.
-   */
-  async reportPayment(input) {
-    await this.vaultFlows.reportPayment(input);
+  throw new Error("Unable to derive associated token account address");
+}
+function createProgramAddress(seeds, programId) {
+  const hash = createHash3("sha256");
+  for (const seed of seeds) {
+    hash.update(seed);
   }
-  /**
-   * Refuses to realize more than the ledger's spendable yield (principal).
-   * getBudget syncs the relayer's ledger from chain first (best-effort), so a
-   * long-running client sees yield as it accrues instead of a frozen view.
-   */
-  async assertSpendableYield(shortfallRawUsdc) {
-    let spendable;
-    try {
-      const budget = await this.vaultFlows.getBudget();
-      spendable = BigInt(budget.spendableYieldRawUsdc);
-    } catch (error) {
-      throw new RelayerRealizeError(
-        "budget_unavailable",
-        "could not read the spendable-yield budget",
-        error
-      );
-    }
-    const requiredRawUsdc = shortfallRawUsdc + REALIZE_OVERHEAD_RAW_USDC;
-    if (spendable < requiredRawUsdc) {
-      throw new RelayerRealizeError(
-        "insufficient_yield",
-        `spendable yield ${spendable} cannot cover ${shortfallRawUsdc} raw USDC plus the ${REALIZE_OVERHEAD_RAW_USDC} raw fee headroom; the principal is never spent \u2014 wait for more yield`,
-        { spendableYieldRawUsdc: spendable.toString() }
-      );
-    }
+  hash.update(programId);
+  hash.update(PDA_MARKER);
+  const digest = hash.digest();
+  return isEd25519Point(digest) ? null : new Uint8Array(digest);
+}
+function decodePublicKey(value, fieldName) {
+  const decoded = bs58.decode(value);
+  if (decoded.length !== 32) {
+    throw new Error(`${fieldName} must be a 32-byte public key`);
   }
-  mapWithdrawError(error) {
-    if (!(error instanceof VaultFlowClientError)) {
-      return new RelayerRealizeError(
-        "prepare_failed",
-        `yield realize failed: ${error instanceof Error ? error.message : String(error)}`,
-        error
-      );
-    }
-    const serverCode = error.code ?? errorCodeFrom(error.detail);
-    if (serverCode === "approval_required") {
-      return new RelayerRealizeError(
-        "approval_required",
-        "this payment exceeds the owner-approval threshold; nothing was realized or paid. Ask the owner to approve, then retry with the approvalId",
-        error.errorDetails ?? error.detail
-      );
-    }
-    if (serverCode === "insufficient_yield" || serverCode === "post_state_principal_invariant_failed") {
-      return new RelayerRealizeError(
-        "insufficient_yield",
-        "the relayer refused to realize beyond the spendable yield; the principal is never spent \u2014 wait for more yield",
-        error.detail
-      );
-    }
-    return new RelayerRealizeError(
-      error.step === "submit" ? "submit_failed" : "prepare_failed",
-      error.message,
-      error.detail
-    );
+  return decoded;
+}
+function isEd25519Point(bytes) {
+  if (bytes.length !== 32) {
+    return false;
   }
-};
-function errorCodeFrom(detail) {
-  if (typeof detail !== "string") {
-    return null;
+  const yBytes = Uint8Array.from(bytes);
+  yBytes[31] = yBytes[31] & 127;
+  const y = littleEndianToBigInt(yBytes);
+  if (y >= ED25519_P) {
+    return false;
   }
-  try {
-    const parsed = JSON.parse(detail);
-    return typeof parsed.error?.code === "string" ? parsed.error.code : null;
-  } catch {
-    return null;
+  const ySquared = mod(y * y, ED25519_P);
+  const numerator = mod(ySquared - 1n, ED25519_P);
+  const denominator = mod(ED25519_D * ySquared + 1n, ED25519_P);
+  if (denominator === 0n) {
+    return false;
   }
+  const xSquared = mod(
+    numerator * modPow(denominator, ED25519_P - 2n, ED25519_P),
+    ED25519_P
+  );
+  return xSquared === 0n || modPow(xSquared, (ED25519_P - 1n) / 2n, ED25519_P) === 1n;
 }
-
-// src/mcp-server.ts
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
-
-// ../../src/client/mcp-payment-server.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
-
-// ../../src/client/onboarding.ts
-var SELF_SERVE_POLICY_ID = "self-serve";
-var OnboardingError = class extends Error {
-  constructor(step, message, detail = null) {
-    super(message);
-    this.step = step;
-    this.detail = detail;
-    this.name = "OnboardingError";
+function littleEndianToBigInt(bytes) {
+  let value = 0n;
+  for (let index = bytes.length - 1; index >= 0; index -= 1) {
+    value = (value << 8n) + BigInt(bytes[index]);
   }
-  step;
-  detail;
-};
-async function ensureWalletOnboarded(params) {
-  const fetchImpl = params.fetchImpl ?? fetch;
-  const baseUrl = params.relayerBaseUrl.replace(/\/$/, "");
-  const post = async (step, path, body) => {
-    const url = `${baseUrl}${path}`;
-    const serialized = JSON.stringify(body);
-    const response = await fetchImpl(url, {
-      method: "POST",
-      headers: {
-        ...await walletAuthHeaders({
-          signer: params.signer,
-          method: "POST",
-          url,
-          body: serialized
-        }),
-        "content-type": "application/json"
-      },
-      body: serialized
-    });
-    if (response.status !== 200) {
-      let detail = null;
-      try {
-        detail = await response.json();
-      } catch {
-        detail = null;
-      }
-      throw new OnboardingError(
-        step,
-        `wallet onboarding ${step} failed with ${response.status}`,
-        detail
-      );
+  return value;
+}
+function mod(value, modulus) {
+  const result = value % modulus;
+  return result >= 0n ? result : result + modulus;
+}
+function modPow(base, exponent, modulus) {
+  let result = 1n;
+  let nextBase = mod(base, modulus);
+  let nextExponent = exponent;
+  while (nextExponent > 0n) {
+    if ((nextExponent & 1n) === 1n) {
+      result = mod(result * nextBase, modulus);
     }
-  };
-  const wallet = params.signer.walletAddress;
-  const vault = params.vault ?? params.signer.vault?.address ?? SUBLY_VAULT.address;
-  await post("register", "/v1/wallets/agent", {
-    wallet,
-    vault,
-    signingPolicyId: SELF_SERVE_POLICY_ID,
-    signingMode: "non_interactive",
-    signerValidationMode: params.signer.validationMode,
-    signerProvider: params.signer.provider ?? "local-keypair",
-    activateForPayments: true
-  });
-  await post("sync", `/v1/wallets/${wallet}/sync`, { source: "chain", vault });
+    nextBase = mod(nextBase * nextBase, modulus);
+    nextExponent >>= 1n;
+  }
+  return result;
 }
 
-// ../../src/x402/headers.ts
-import { z as z2 } from "zod";
+// ../../src/domain/withdrawal-rounding.ts
+var WITHDRAWAL_ROUNDING_RAW_USDC = 10n;
+var YIELD_REALIZE_ROUNDING_RAW_USDC = WITHDRAWAL_ROUNDING_RAW_USDC / 2n;
 
-// ../../src/lib/hash.ts
-import { createHash as createHash3 } from "node:crypto";
-var EMPTY_BODY_HASH = "sha256-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
-function sha256TaggedHex(data) {
-  return `sha256-${createHash3("sha256").update(data).digest("hex")}`;
-}
-function stableStringify(value) {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "bigint") {
-    return JSON.stringify(value.toString());
+// ../../src/client/withdrawal-preview.ts
+async function assertWithdrawalPreview(input) {
+  const destination = deriveAssociatedTokenAddress({ owner: input.wallet, mint: input.vault.usdcMint });
+  const simulation = await input.rpc.simulateTransaction(
+    input.serializedTransaction,
+    {
+      encoding: "base64",
+      commitment: "confirmed",
+      sigVerify: false,
+      replaceRecentBlockhash: false,
+      innerInstructions: true
+    }
+  ).send({ abortSignal: AbortSignal.timeout(15e3) });
+  if (simulation.value.err !== null) {
+    throw new Error("Withdrawal preview failed on the client RPC; no transaction was signed. Check liquidity, RPC and blockhash, then prepare again.");
   }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return JSON.stringify(value);
+  let received = 0n;
+  for (const group of simulation.value.innerInstructions ?? []) {
+    for (const instruction of group.instructions) {
+      if (!("parsed" in instruction) || instruction.programId !== SPL_TOKEN_PROGRAM_ID) continue;
+      const parsed = instruction.parsed;
+      if (parsed.type !== "transfer" && parsed.type !== "transferChecked") continue;
+      const info = parsed.info;
+      if (!info || info.destination !== destination && info.source !== destination) continue;
+      const raw = parsed.type === "transferChecked" ? info.tokenAmount?.amount : info.amount;
+      if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
+        throw new Error("Withdrawal preview returned an invalid token amount");
+      }
+      const amount = BigInt(raw);
+      if (info.destination === destination) received += amount;
+      if (info.source === destination) received -= amount;
+    }
   }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  const minimum = input.purpose === "yield_realize" ? input.amountRawUsdc : input.amountRawUsdc - WITHDRAWAL_ROUNDING_RAW_USDC;
+  if (received <= 0n || received > input.amountRawUsdc + WITHDRAWAL_ROUNDING_RAW_USDC || received < minimum) {
+    throw new Error("Withdrawal preview differs from the requested USDC amount; no transaction was signed");
   }
-  const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
-  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
-}
-function hashStableJson(value) {
-  return sha256TaggedHex(stableStringify(value));
 }
 
-// ../../src/x402/headers.ts
-var PAYMENT_REQUIRED_HEADER = "payment-required";
-var PAYMENT_RESPONSE_HEADER = "payment-response";
-var MAX_HEADER_JSON_BYTES = 16384;
-var X402HeaderError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "X402HeaderError";
-    this.reason = reason;
-  }
-};
-var sublyPaymentRequirementsSchema = z2.object({
-  scheme: z2.literal(PAYMENT_SCHEME),
-  network: z2.string().min(1),
-  asset: z2.string().min(32),
-  /** Exact seller amount in raw USDC; the scheme settles exactly this. */
-  amountRawUsdc: z2.string().regex(/^[1-9]\d*$/),
-  resource: z2.string().url(),
-  description: z2.string().optional(),
-  mimeType: z2.string().optional(),
-  payTo: z2.string().min(32),
-  maxTimeoutSeconds: z2.number().int().positive(),
-  extra: z2.object({
-    sellerRequestId: z2.string().min(1),
-    seller: z2.string().min(32),
-    sellerUsdcAta: z2.string().min(32),
-    vault: z2.string().min(32),
-    shareMint: z2.string().min(32)
-  })
-}).loose();
-var paymentRequiredSchema = z2.object({
-  x402Version: z2.number().int(),
-  accepts: z2.array(z2.unknown()),
-  error: z2.string().optional()
-}).loose();
-var sublyPaymentPayloadSchema = z2.object({
-  x402Version: z2.number().int(),
-  scheme: z2.literal(PAYMENT_SCHEME),
-  network: z2.string().min(1),
-  payload: z2.object({
-    paymentId: z2.string().min(1),
-    requestBindingHash: z2.string().min(1),
-    preparedMessageHash: z2.string().min(1),
-    serializedTransaction: z2.string().min(1).max(4096),
-    agentSignature: z2.string().min(1).max(128),
-    temporarySettlementSignature: z2.string().min(1).max(128)
-  })
-}).loose();
-function decodeX402Header(headerValue) {
-  if (headerValue.length > Math.ceil(MAX_HEADER_JSON_BYTES * 4 / 3) + 4) {
-    throw new X402HeaderError(
-      "header_too_large",
-      `x402 header exceeds ${MAX_HEADER_JSON_BYTES} encoded bytes`
-    );
-  }
-  const json = Buffer.from(headerValue, "base64").toString("utf8");
-  try {
-    return JSON.parse(json);
-  } catch {
-    throw new X402HeaderError(
-      "invalid_header_encoding",
-      "x402 header is not base64-encoded JSON"
-    );
+// ../../src/client/lookup-tables.ts
+import { fetchAllMaybeAddressLookupTable } from "@solana-program/address-lookup-table";
+import { address, getCompiledTransactionMessageDecoder } from "@solana/kit";
+function lookupTableAddressesForTransaction(serializedTransaction) {
+  const wire = Buffer.from(serializedTransaction, "base64");
+  let offset = 0;
+  let signatureCount = 0;
+  let shift = 0;
+  while (offset < wire.length) {
+    const byte = wire[offset];
+    signatureCount |= (byte & 127) << shift;
+    offset += 1;
+    if ((byte & 128) === 0) {
+      break;
+    }
+    shift += 7;
   }
+  const messageBytes = wire.subarray(offset + signatureCount * 64);
+  const compiled = getCompiledTransactionMessageDecoder().decode(messageBytes);
+  const lookups = compiled.addressTableLookups ?? [];
+  return lookups.map((lookup) => String(lookup.lookupTableAddress));
 }
-function requestBodyHashFor(body) {
-  if (body === null || body === void 0 || body.length === 0) {
-    return EMPTY_BODY_HASH;
+async function fetchLookupTablesForTransaction(rpc2, serializedTransaction) {
+  const addresses = lookupTableAddressesForTransaction(serializedTransaction);
+  if (addresses.length === 0) {
+    return {};
   }
-  return sha256TaggedHex(
-    typeof body === "string" ? Buffer.from(body, "utf8") : Buffer.from(body)
+  const tables = await fetchAllMaybeAddressLookupTable(
+    rpc2,
+    addresses.map((value) => address(value))
   );
+  const result = {};
+  for (const table of tables) {
+    if (table.exists) {
+      result[table.address] = table.data.addresses.map(String);
+    }
+  }
+  return result;
 }
 
-// ../../src/client/paid-fetch.ts
-function formatRawUsdcAmount(raw) {
-  const value = BigInt(raw);
-  const negative = value < 0n;
-  const abs = negative ? -value : value;
-  const whole = abs / 1000000n;
-  const frac = (abs % 1000000n).toString().padStart(6, "0");
-  return `${negative ? "-" : ""}${whole}.${frac}`;
-}
-
-// ../../src/lib/canonical-json.ts
+// ../../src/api/wallet-auth.ts
 import { createHash as createHash4 } from "node:crypto";
-function sha256HexOf(data) {
+import bs582 from "bs58";
+import nacl from "tweetnacl";
+var WALLET_AUTH_WALLET_HEADER = "x-subly-wallet";
+var WALLET_AUTH_SIGNED_AT_HEADER = "x-subly-signed-at";
+var WALLET_AUTH_SIGNATURE_HEADER = "x-subly-signature";
+function sha256Hex(data) {
   return createHash4("sha256").update(data, "utf8").digest("hex");
 }
+function walletAuthMessage(params) {
+  return new TextEncoder().encode(
+    `subly-api:${params.method.toUpperCase()}:${params.path}:${sha256Hex(
+      params.rawBody
+    )}:${params.signedAtMs}`
+  );
+}
 
-// ../../src/x402/standard-requirements.ts
-import { z as z3 } from "zod";
-var STANDARD_EXACT_SCHEME = "exact";
-var standardExactRequirementSchema = z3.object({
-  scheme: z3.literal(STANDARD_EXACT_SCHEME),
-  /** CAIP-2 chain id, e.g. "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp". */
-  network: z3.string().min(1),
-  /** SPL mint (Solana) or token contract (EVM); Subly only pays USDC/Solana. */
-  asset: z3.string().min(1),
-  /** Exact price in the asset's atomic units, as a decimal string. */
-  amount: z3.string().regex(/^[1-9]\d*$/),
-  /** Recipient wallet; the transfer destination ATA is derived from it. */
-  payTo: z3.string().min(1),
-  maxTimeoutSeconds: z3.number().int().positive().optional(),
-  extra: z3.object({
-    /** Facilitator address that pays the tx fee (gas sponsorship). */
-    feePayer: z3.string().min(1).optional()
-  }).loose().optional()
-}).loose();
-var standardPaymentRequiredSchema = z3.object({
-  x402Version: z3.number().int(),
-  accepts: z3.array(z3.unknown()),
-  error: z3.string().optional(),
-  resource: z3.object({ url: z3.string().optional() }).loose().optional()
-}).loose();
-var StandardX402ChallengeError = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.name = "StandardX402ChallengeError";
-    this.reason = reason;
-  }
-};
-function parseStandardChallenge(challenge) {
-  const parsed = standardPaymentRequiredSchema.safeParse(challenge);
-  if (!parsed.success) {
-    throw new StandardX402ChallengeError(
-      "invalid_payment_required",
-      "Response is not a valid x402 PaymentRequired object"
-    );
-  }
-  const solanaExactRequirements = parsed.data.accepts.flatMap((candidate) => {
-    const requirement = standardExactRequirementSchema.safeParse(candidate);
-    if (!requirement.success) {
-      return [];
-    }
-    return requirement.data.network.startsWith("solana:") ? [requirement.data] : [];
+// ../../src/client/wallet-auth-headers.ts
+async function walletAuthHeaders(params) {
+  const signedAtMs = String(Date.now());
+  const message = walletAuthMessage({
+    method: params.method,
+    path: (() => {
+      const url = new URL(params.url);
+      return url.pathname + url.search;
+    })(),
+    rawBody: params.body ?? "",
+    signedAtMs
   });
-  return { paymentRequired: parsed.data, solanaExactRequirements };
-}
-function decodeStandardPaymentRequiredHeader(headerValue) {
-  let decoded;
-  try {
-    decoded = decodeX402Header(headerValue);
-  } catch (error) {
-    throw new StandardX402ChallengeError(
-      error instanceof X402HeaderError ? error.reason : "invalid_header",
-      "Cannot decode the payment-required header"
-    );
-  }
-  return parseStandardChallenge(decoded);
-}
-function selectPayableSolanaRequirement(requirements, options) {
-  const network = options?.network ?? SOLANA_MAINNET_NETWORK;
-  const usdcMint = options?.usdcMint ?? SUBLY_VAULT.usdcMint;
-  const matchingRequirements = requirements.filter(
-    (candidate) => candidate.network === network && candidate.asset === usdcMint
-  );
-  if (matchingRequirements.length === 0) {
-    throw new StandardX402ChallengeError(
-      "no_payable_requirement",
-      `The challenge has no Solana exact requirement on ${network} paying ${usdcMint}`
-    );
-  }
-  const requirement = matchingRequirements.find(
-    (candidate) => candidate.extra?.feePayer !== void 0
-  ) ?? null;
-  if (requirement === null) {
-    throw new StandardX402ChallengeError(
-      "missing_svm_fee_payer",
-      "The Solana exact requirement does not include extra.feePayer, which the official @x402/svm client requires for gas sponsorship"
-    );
-  }
-  const feePayer = requirement.extra?.feePayer;
-  if (feePayer === void 0) {
-    throw new StandardX402ChallengeError(
-      "missing_svm_fee_payer",
-      "The Solana exact requirement does not include extra.feePayer, which the official @x402/svm client requires for gas sponsorship"
-    );
-  }
   return {
-    requirement,
-    amountRawUsdc: BigInt(requirement.amount),
-    payTo: requirement.payTo,
-    feePayer
+    [WALLET_AUTH_WALLET_HEADER]: params.signer.walletAddress,
+    [WALLET_AUTH_SIGNED_AT_HEADER]: signedAtMs,
+    [WALLET_AUTH_SIGNATURE_HEADER]: await params.signer.signApiMessage(message)
   };
 }
-function standardRequirementMatchesSelected(candidate, selected2) {
-  const parsed = standardExactRequirementSchema.safeParse(candidate);
-  return parsed.success && stableJson(parsed.data) === stableJson(selected2.requirement);
-}
-function stableJson(value) {
-  return JSON.stringify(sortJson(value));
+
+// ../../src/client/vault-flows.ts
+var VaultFlowClientError = class extends Error {
+  constructor(step, message, detail = null, code = null, errorDetails = null) {
+    super(message);
+    this.step = step;
+    this.detail = detail;
+    this.code = code;
+    this.errorDetails = errorDetails;
+    this.name = "VaultFlowClientError";
+  }
+  step;
+  detail;
+  code;
+  errorDetails;
+};
+function vaultOperationKind(intentId) {
+  if (/^dep_[0-9a-f]{32}$/.test(intentId)) return "deposit";
+  if (/^wdr_[0-9a-f]{32}$/.test(intentId)) return "withdrawal";
+  throw new VaultFlowClientError("read", "intentId must be the original dep_ or wdr_ ID followed by 32 lowercase hexadecimal characters");
 }
-function sortJson(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJson);
+var VaultFlowClient = class {
+  vault;
+  rpc;
+  baseUrl;
+  signer;
+  fetchImpl;
+  lookupTablesFor;
+  pollTimeoutMs;
+  pollIntervalMs;
+  constructor(config) {
+    this.rpc = config.rpc;
+    this.vault = config.vault ?? config.signer.vault ?? SUBLY_VAULT;
+    if (config.signer.vault && config.signer.vault.address !== this.vault.address) {
+      throw new Error("Vault flow client and signer must select the same vault");
+    }
+    this.baseUrl = config.relayerBaseUrl.replace(/\/$/, "");
+    this.signer = config.signer;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+    this.lookupTablesFor = config.lookupTablesFor ?? ((serializedTransaction) => fetchLookupTablesForTransaction(config.rpc, serializedTransaction));
+    this.pollTimeoutMs = config.pollTimeoutMs ?? 9e4;
+    this.pollIntervalMs = config.pollIntervalMs ?? 2500;
+  }
+  /**
+   * Moves USDC from the agent wallet into the vault (fee sponsored). Under
+   * depositPolicy "owner_approval_required" the relayer refuses to prepare
+   * without an owner approval; when the caller passes none, an already
+   * APPROVED deposit approval for this exact amount (e.g. the mandate's
+   * initialDeposit — "one Face ID covers mandate + first deposit") is looked
+   * up and used automatically before surfacing deposit_approval_required.
+   */
+  async deposit(input) {
+    let approvalId = input.approvalId;
+    let prepared;
+    try {
+      prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
+        wallet: this.signer.walletAddress,
+        vault: this.vault.address,
+        amountRawUsdc: input.amountRawUsdc.toString(),
+        ...approvalId === void 0 ? {} : { approvalId }
+      });
+    } catch (error) {
+      if (!(error instanceof VaultFlowClientError) || error.code !== "deposit_approval_required" || approvalId !== void 0) {
+        throw error;
+      }
+      approvalId = await this.findApprovedDepositApproval(input.amountRawUsdc);
+      if (approvalId === void 0) {
+        throw error;
+      }
+      prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
+        wallet: this.signer.walletAddress,
+        vault: this.vault.address,
+        amountRawUsdc: input.amountRawUsdc.toString(),
+        approvalId
+      });
+    }
+    if (prepared.signingIntent?.wallet !== this.signer.walletAddress || prepared.signingIntent.vault !== this.vault.address || prepared.signingIntent.amountRawUsdc !== input.amountRawUsdc.toString()) {
+      throw new VaultFlowClientError("prepare", "Prepared deposit differs from the requested wallet, vault or amount");
+    }
+    const signed = await this.signer.signDeposit({
+      intent: prepared.signingIntent,
+      serializedTransaction: prepared.serializedTransaction,
+      lookupTables: await this.lookupTablesFor(prepared.serializedTransaction)
+    });
+    let outcome = await this.postJson("submit", "/v1/deposits/submit", {
+      depositId: prepared.depositId,
+      serializedTransaction: signed.serializedTransaction,
+      agentSignature: signed.agentSignature
+    });
+    if (outcome.status === "submitted") {
+      outcome = await this.pollUntilTerminal(
+        `/v1/deposits/${prepared.depositId}`,
+        outcome
+      );
+    }
+    return {
+      depositId: prepared.depositId,
+      status: outcome.status,
+      txSignature: outcome.txSignature ?? null,
+      actualDepositRawUsdc: outcome.actualDepositRawUsdc ?? null,
+      sharesMintedRaw: outcome.sharesMintedRaw ?? null,
+      errorCode: outcome.errorCode ?? null
+    };
   }
-  if (value !== null && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => [key, sortJson(entry)])
+  /**
+   * Moves USDC from the vault back to the agent wallet's USDC ATA (fee
+   * sponsored). A plain withdrawal is the exit path and MAY spend principal;
+   * with purpose "yield_realize" the relayer refuses anything beyond the
+   * spendable yield (the payment path, via RelayerYieldRealizer).
+   */
+  async withdraw(input) {
+    const prepared = await this.postJson(
+      "prepare",
+      "/v1/withdrawals/prepare",
+      {
+        wallet: this.signer.walletAddress,
+        vault: this.vault.address,
+        amountRawUsdc: input.amountRawUsdc.toString(),
+        ...input.purpose === void 0 ? {} : { purpose: input.purpose },
+        ...input.payment === void 0 ? {} : { payment: input.payment },
+        ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId }
+      }
     );
+    this.assertPreparedWithdrawal(prepared, input);
+    await input.onPrepared?.(prepared);
+    return this.submitPreparedWithdrawal(prepared, input);
+  }
+  /** Reconcile or submit the original intent; never prepare a replacement. */
+  async resumeWithdrawal(prepared, input) {
+    this.assertPreparedWithdrawal(prepared, input);
+    const current = await this.getJson(
+      `/v1/withdrawals/${encodeURIComponent(prepared.withdrawalId)}`
+    );
+    if (current.withdrawalId !== prepared.withdrawalId || current.wallet !== this.signer.walletAddress || current.vault !== this.vault.address || current.requestedWithdrawRawUsdc !== input.amountRawUsdc.toString() || current.purpose !== (input.purpose ?? "normal") || canonicalJsonHash(current.paymentBinding ?? null) !== canonicalJsonHash(input.payment ?? null) || current.serializedTransaction !== prepared.serializedTransaction || current.preparedMessageHash !== prepared.signingIntent.preparedMessageHash || current.destinationUsdcAta !== prepared.destinationUsdcAta) {
+      throw new VaultFlowClientError("read", "Saved withdrawal differs from the original operation; refusing to resume");
+    }
+    if (current.status === "prepared") {
+      return this.submitPreparedWithdrawal(prepared, input);
+    }
+    if (!["submitted", "confirmed", "failed", "failed_not_submitted", "expired", "quarantined"].includes(current.status)) {
+      throw new VaultFlowClientError("read", "Relayer returned an unknown withdrawal status");
+    }
+    return this.withdrawalOutcome(prepared, current);
   }
-  return value;
-}
-
-// ../../src/client/standard-x402-payer.ts
-var StandardX402PayError = class extends Error {
-  constructor(reason, message, detail = null) {
-    super(message);
-    this.reason = reason;
-    this.detail = detail;
-    this.name = "StandardX402PayError";
-  }
-  reason;
-  detail;
-};
-var StandardX402Payer = class {
-  realizer;
-  x402Fetch;
-  probeFetch;
-  defaultMaxAmountRawUsdc;
-  network;
-  usdcMint;
-  stateStore;
-  pending = /* @__PURE__ */ new Map();
-  inFlight = /* @__PURE__ */ new Map();
-  nowMs;
-  constructor(config) {
-    this.realizer = config.realizer;
-    this.x402Fetch = config.x402Fetch;
-    this.probeFetch = config.probeFetch ?? fetch;
-    this.defaultMaxAmountRawUsdc = config.defaultMaxAmountRawUsdc;
-    this.network = config.network ?? SOLANA_MAINNET_NETWORK;
-    this.usdcMint = config.usdcMint ?? SUBLY_VAULT.usdcMint;
-    this.stateStore = config.stateStore ?? null;
-    this.nowMs = config.nowMs ?? (() => Date.now());
-    if (this.stateStore !== null) {
-      for (const record of this.stateStore.load()) {
-        this.pending.set(record.key, record);
-      }
+  assertPreparedWithdrawal(prepared, input) {
+    if (prepared.signingIntent?.wallet !== this.signer.walletAddress || prepared.signingIntent.vault !== this.vault.address || prepared.requestedWithdrawRawUsdc !== input.amountRawUsdc.toString() || prepared.purpose !== (input.purpose ?? "normal") || input.purpose === "yield_realize" && prepared.signingIntent.allowFullExit) {
+      throw new VaultFlowClientError("prepare", "Prepared withdrawal differs from the requested operation");
+    }
+    if (typeof prepared.withdrawalId !== "string" || prepared.withdrawalId.length === 0) {
+      throw new VaultFlowClientError("prepare", "Prepared withdrawal has no withdrawal ID");
     }
   }
-  pay(input, realizer = this.realizer) {
-    const method = (input.method ?? "GET").toUpperCase();
-    const requestBodyHash = requestBodyHashFor(input.body ?? null);
-    const pendingKey = pendingPaymentKey({
-      url: input.url,
-      method,
-      requestBodyHash
+  async submitPreparedWithdrawal(prepared, input) {
+    await assertWithdrawalPreview({
+      rpc: this.rpc,
+      serializedTransaction: prepared.serializedTransaction,
+      wallet: this.signer.walletAddress,
+      vault: this.vault,
+      amountRawUsdc: input.amountRawUsdc,
+      ...input.purpose === void 0 ? {} : { purpose: input.purpose }
     });
-    const existingFlow = this.inFlight.get(pendingKey);
-    if (existingFlow !== void 0) {
-      return existingFlow;
+    const signed = await this.signer.signWithdrawal({
+      intent: prepared.signingIntent,
+      serializedTransaction: prepared.serializedTransaction,
+      lookupTables: await this.lookupTablesFor(prepared.serializedTransaction)
+    });
+    input.onBeforeSubmit?.();
+    let outcome = await this.postJson("submit", "/v1/withdrawals/submit", {
+      withdrawalId: prepared.withdrawalId,
+      serializedTransaction: signed.serializedTransaction,
+      agentSignature: signed.agentSignature
+    });
+    if (outcome.status === "submitted") {
+      outcome = await this.pollUntilTerminal(
+        `/v1/withdrawals/${prepared.withdrawalId}`,
+        outcome
+      );
     }
-    const run = async () => {
-      if (this.stateStore?.withExclusiveLock) {
-        this.pending.clear();
-        for (const record of this.stateStore.load()) this.pending.set(record.key, record);
-      }
-      return this.run(input, { method, requestBodyHash, pendingKey }, realizer);
+    return this.withdrawalOutcome(prepared, outcome);
+  }
+  withdrawalOutcome(prepared, outcome) {
+    return {
+      withdrawalId: prepared.withdrawalId,
+      status: outcome.status,
+      txSignature: outcome.txSignature ?? null,
+      destinationUsdcAta: prepared.destinationUsdcAta,
+      actualWithdrawRawUsdc: outcome.actualWithdrawRawUsdc ?? null,
+      actualSharesBurnedRaw: outcome.actualSharesBurnedRaw ?? null,
+      errorCode: outcome.errorCode ?? null
     };
-    const flow = (this.stateStore?.withExclusiveLock ? this.stateStore.withExclusiveLock(run) : run()).finally(() => {
-      this.inFlight.delete(pendingKey);
-    });
-    this.inFlight.set(pendingKey, flow);
-    return flow;
   }
-  async run(input, computed, realizer) {
-    const { method, requestBodyHash, pendingKey } = computed;
-    const existingPending = this.pending.get(pendingKey);
-    if (existingPending !== void 0 && input.forceNewPayment !== true) {
-      throw new StandardX402PayError(
-        "payment_outcome_unknown",
-        "a previous external x402 payment for this request has an unknown outcome. Verify whether it settled before purchasing again; to pay again anyway, call with forceNewPayment=true.",
-        existingPending
-      );
+  /** Authenticated read/reconciliation only: never prepare, sign or submit a transaction. */
+  async getOperationStatus(intentId) {
+    const kind = vaultOperationKind(intentId);
+    const raw = await this.getJson(`/v1/${kind === "deposit" ? "deposits" : "withdrawals"}/${intentId}?resubmit=false`);
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      throw new VaultFlowClientError("read", "Relayer returned an invalid operation status");
+    }
+    const record = raw;
+    if (record[kind === "deposit" ? "depositId" : "withdrawalId"] !== intentId || record.wallet !== this.signer.walletAddress || record.vault !== this.vault.address) {
+      throw new VaultFlowClientError("read", "Operation does not match the requested ID, current wallet or selected vault; use the original wallet, vault and relayer");
     }
-    if (existingPending !== void 0 && input.forceNewPayment === true) {
+    const requested = record[kind === "deposit" ? "amountRawUsdc" : "requestedWithdrawRawUsdc"];
+    const actual = record[kind === "deposit" ? "actualDepositRawUsdc" : "actualWithdrawRawUsdc"];
+    if (typeof record.status !== "string" || !["prepared", "submitted", "confirmed", "failed", "expired", "failed_not_submitted"].includes(record.status) || typeof requested !== "string" || !/^\d+$/.test(requested) || actual !== null && (typeof actual !== "string" || !/^\d+$/.test(actual)) || record.txSignature !== null && (typeof record.txSignature !== "string" || record.txSignature.length === 0) || record.errorCode !== null && typeof record.errorCode !== "string" || record.status === "confirmed" && (actual === null || record.txSignature === null)) {
+      throw new VaultFlowClientError("read", "Relayer returned incomplete or invalid operation status fields");
+    }
+    const status = record.status;
+    const nextAction = status === "confirmed" ? "done" : status === "submitted" || status === "prepared" ? "check_again" : "reconcile_with_operator";
+    const message = status === "confirmed" ? `The original ${kind} is confirmed.` : status === "submitted" ? "The original transaction is still confirming. Check this same intent ID again; do not repeat the deposit or withdrawal." : status === "prepared" ? "The original intent is prepared. This status check does not submit it. Check the same ID again or ask the operator to reconcile it before starting another operation." : "The original operation ended without a confirmed result. Reconcile its intent ID and transaction with the operator before starting another operation.";
+    return {
+      intentId,
+      kind,
+      wallet: this.signer.walletAddress,
+      vault: this.vault.address,
+      status,
+      requestedAmountRawUsdc: requested,
+      actualAmountRawUsdc: actual,
+      txSignature: record.txSignature,
+      errorCode: record.errorCode,
+      stillConfirming: status === "submitted",
+      nextAction,
+      message
+    };
+  }
+  /**
+   * Reads the yield budget. Syncs the relayer's ledger from chain first (so
+   * yield accrued since the last sync shows up); the sync is best-effort and
+   * on failure the last-synced view is returned.
+   */
+  async getBudget(options = {}) {
+    if (options.refreshFromChain !== false) {
       try {
-        this.untrack(pendingKey);
-      } catch (error) {
-        throw new StandardX402PayError(
-          "state_persist_failed",
-          "could not clear the previous pending x402 marker before forcing a new payment",
-          error
+        await this.postJson(
+          "sync",
+          `/v1/wallets/${this.signer.walletAddress}/sync`,
+          { source: "chain", vault: this.vault.address }
         );
+      } catch {
       }
     }
-    const init = {
-      method,
-      ...input.body === void 0 ? {} : { body: input.body },
-      ...input.headers === void 0 ? {} : { headers: input.headers }
+    const url = `${this.baseUrl}/v1/wallets/${this.signer.walletAddress}/budget?vault=${this.vault.address}`;
+    const response = await this.fetchImpl(url, {
+      headers: await walletAuthHeaders({
+        signer: this.signer,
+        method: "GET",
+        url
+      })
+    });
+    const text = await response.text();
+    if (response.status !== 200) {
+      throw new VaultFlowClientError(
+        "budget",
+        `budget endpoint returned ${response.status}: ${text}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        "budget",
+        "budget endpoint returned 200 with a non-JSON body",
+        text
+      );
+    }
+    const body = parsed;
+    if (body.position?.vault !== void 0 && body.position.vault !== this.vault.address) {
+      throw new VaultFlowClientError("budget", "Relayer returned the budget for a different vault");
+    }
+    return {
+      wallet: this.signer.walletAddress,
+      vault: this.vault.address,
+      principalBasisRawUsdc: body.position?.principalBasisRawUsdc ?? "0",
+      positionValueRawUsdc: body.budget?.positionValueRawUsdc ?? "0",
+      grossYieldRawUsdc: body.budget?.grossYieldRawUsdc ?? "0",
+      spendableYieldRawUsdc: body.budget?.spendableYieldRawUsdc ?? "0"
     };
-    const probe = await this.probeFetch(input.url, init);
-    if (probe.status !== 402) {
-      return { paid: false, status: probe.status, body: await probe.text() };
+  }
+  /** Best-effort audit link: reports the x402 payment tx a realize funded. */
+  async reportPayment(input) {
+    await this.postJson("submit", "/v1/payments/report", {
+      wallet: this.signer.walletAddress,
+      withdrawalId: input.withdrawalId,
+      paymentTxSignature: input.paymentTxSignature
+    });
+  }
+  /** Wallet's approvals as the relayer sees them (optionally by status). */
+  async listApprovals(status) {
+    const body = await this.getJson(
+      `/v1/wallets/${this.signer.walletAddress}/approvals${`?vault=${this.vault.address}${status === void 0 ? "" : `&status=${encodeURIComponent(status)}`}`}`
+    );
+    return body.approvals ?? [];
+  }
+  /**
+   * Creates the owner-onboarding setup link (wallet-auth pins the agreed
+   * policy + initial deposit). Paste `setupUrl` into the chat verbatim.
+   */
+  async createSetupSession(input) {
+    const session = await this.postJson(
+      "prepare",
+      `/v1/wallets/${this.signer.walletAddress}/setup-sessions`,
+      {
+        vault: this.vault.address,
+        ...input.policy === void 0 ? {} : { policy: input.policy },
+        ...input.enforcementMode === void 0 ? {} : { enforcementMode: input.enforcementMode },
+        ...input.mandateTtlDays === void 0 ? {} : { mandateTtlDays: input.mandateTtlDays },
+        ...input.initialDepositRawUsdc === void 0 ? {} : { initialDepositRawUsdc: input.initialDepositRawUsdc }
+      }
+    );
+    if (session.vault !== this.vault.address || session.wallet !== this.signer.walletAddress) {
+      throw new VaultFlowClientError("prepare", "Relayer returned a setup session for a different wallet or vault");
     }
-    const selected2 = await this.selectRequirement(probe);
-    const cap = input.maxAmountRawUsdc ?? this.defaultMaxAmountRawUsdc;
-    if (selected2.amountRawUsdc > cap) {
-      throw new StandardX402PayError(
-        "amount_exceeds_client_cap",
-        `the challenge demands ${selected2.amountRawUsdc} raw USDC, above the client cap of ${cap}; nothing was paid`,
-        { amountRawUsdc: selected2.amountRawUsdc.toString(), payTo: selected2.payTo }
+    return session;
+  }
+  /** Polls a setup session (public capability URL — no auth needed). */
+  async getSetupSession(sessionId) {
+    const url = `${this.baseUrl}/v1/setup-sessions/${encodeURIComponent(sessionId)}`;
+    const response = await this.fetchImpl(url);
+    const text = await response.text();
+    if (response.status !== 200) {
+      const parsed = parseRelayerError(text);
+      throw new VaultFlowClientError(
+        "read",
+        parsed.message ?? `setup session read failed with ${response.status}`,
+        text,
+        parsed.code,
+        parsed.details
       );
     }
-    let realized;
+    return JSON.parse(text);
+  }
+  /**
+   * Finds an APPROVED, unconsumed deposit approval bound to exactly this
+   * amount — the shape the mandate's initialDeposit approval has.
+   */
+  async findApprovedDepositApproval(amountRawUsdc) {
     try {
-      realized = await realizer.ensureUsdcAvailable({
-        amountRawUsdc: selected2.amountRawUsdc,
-        payment: {
-          payTo: selected2.payTo,
-          amountRawUsdc: selected2.amountRawUsdc.toString(),
-          resourceUrlHash: sha256HexOf(input.url),
-          method
-        },
-        ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId }
+      const approvals = await this.listApprovals("approved");
+      const match = approvals.find((approval) => {
+        const binding = approval.binding;
+        return binding?.kind === "deposit" && binding.amountRawUsdc === amountRawUsdc.toString();
       });
-    } catch (error) {
-      if (error.code === "approval_required") {
-        throw new StandardX402PayError(
-          "approval_required",
-          "this payment exceeds the owner-approval threshold; NOTHING was paid. Ask the owner to open the approveUrl, then retry the same call with the approvalId",
-          error.detail ?? null
-        );
-      }
-      throw new StandardX402PayError(
-        "realize_failed",
-        `could not realize yield to cover ${selected2.amountRawUsdc} raw USDC: ${error instanceof Error ? error.message : String(error)}`,
-        error
-      );
+      return match?.approvalId;
+    } catch {
+      return void 0;
     }
-    const pendingRecord = {
-      key: pendingKey,
-      url: input.url,
-      method,
-      requestBodyHash,
-      amountRawUsdc: selected2.amountRawUsdc.toString(),
-      payTo: selected2.payTo,
-      feePayer: selected2.feePayer,
-      realizedRawUsdc: realized.realizedRawUsdc.toString(),
-      realizeTxSignature: realized.txSignature,
-      status: "realized",
-      createdAtMs: this.nowMs(),
-      updatedAtMs: this.nowMs()
-    };
-    try {
-      this.track(pendingRecord);
-    } catch (error) {
-      throw new StandardX402PayError(
-        "state_persist_failed",
-        "could not persist the pending x402 marker; refusing to attempt the external payment because a restart would not be double-payment safe",
-        { error, pendingPayment: pendingRecord }
-      );
+  }
+  /**
+   * Polls the reconciling GET endpoint until the intent leaves "submitted"
+   * (each read looks the tx up on-chain) or the timeout elapses.
+   */
+  async pollUntilTerminal(path, last) {
+    const deadline = Date.now() + this.pollTimeoutMs;
+    let latest = last;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, this.pollIntervalMs));
+      const url = `${this.baseUrl}${path}`;
+      const response = await this.fetchImpl(url, {
+        headers: await walletAuthHeaders({
+          signer: this.signer,
+          method: "GET",
+          url
+        })
+      });
+      if (response.status !== 200) {
+        continue;
+      }
+      try {
+        latest = await response.json();
+      } catch {
+        continue;
+      }
+      if (latest.status !== "submitted") {
+        return latest;
+      }
     }
-    if (realized.realizedRawUsdc < selected2.amountRawUsdc) {
-      throw new StandardX402PayError(
-        "realize_underfunded",
-        "The confirmed withdrawal did not cover the exact API price. No external payment was attempted; reconcile the recorded withdrawal before retrying.",
-        { pendingPayment: pendingRecord }
+    return latest;
+  }
+  async postJson(step, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const serialized = JSON.stringify(body);
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        ...await walletAuthHeaders({
+          signer: this.signer,
+          method: "POST",
+          url,
+          body: serialized
+        }),
+        "content-type": "application/json"
+      },
+      body: serialized
+    });
+    const text = await response.text();
+    if (response.status !== 200) {
+      const parsed = parseRelayerError(text);
+      throw new VaultFlowClientError(
+        step,
+        parsed.message === null ? `${path} failed with ${response.status}: ${text}` : `${path} failed (${parsed.code ?? response.status}): ${parsed.message}`,
+        text,
+        parsed.code,
+        parsed.details
       );
     }
-    let response;
     try {
-      response = await this.x402Fetch(input.url, init, selected2);
-    } catch (error) {
-      const persistError = this.tryMarkUnknown(pendingKey, {
-        message: error instanceof Error ? error.message : String(error)
-      });
-      throw new StandardX402PayError(
-        "payment_outcome_unknown",
-        `the x402 payment attempt failed after yield was realized; verify whether it settled before paying again: ${error instanceof Error ? error.message : String(error)}`,
-        { error, persistError }
+      return JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        step,
+        `${path} returned 200 with a non-JSON body`,
+        text
       );
     }
-    const bodyText = await response.text();
+  }
+  async getJson(path) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await this.fetchImpl(url, {
+      headers: await walletAuthHeaders({
+        signer: this.signer,
+        method: "GET",
+        url
+      })
+    });
+    const text = await response.text();
     if (response.status !== 200) {
-      const persistError = this.tryMarkUnknown(pendingKey, {
-        status: response.status,
-        body: bodyText
-      });
-      throw new StandardX402PayError(
-        "payment_outcome_unknown",
-        `the x402 payment attempt returned ${response.status} after yield was realized; verify whether it settled before paying again`,
-        { status: response.status, body: bodyText, persistError }
+      const parsed = parseRelayerError(text);
+      throw new VaultFlowClientError(
+        "read",
+        parsed.message === null ? `${path} failed with ${response.status}: ${text}` : `${path} failed (${parsed.code ?? response.status}): ${parsed.message}`,
+        text,
+        parsed.code,
+        parsed.details
       );
     }
-    this.clearDelivered(pendingKey);
-    const paymentTxSignature = extractSettledPaymentTxSignature(response);
-    if (paymentTxSignature !== null && typeof realized.withdrawalId === "string" && realizer.reportPayment !== void 0) {
-      try {
-        await realizer.reportPayment({
-          withdrawalId: realized.withdrawalId,
-          paymentTxSignature
-        });
-      } catch (error) {
-        console.error(
-          `[subly-x402] payment report-back failed (audit only, payment ok): ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        "read",
+        `${path} returned 200 with a non-JSON body`,
+        text
+      );
     }
+  }
+};
+function parseRelayerError(text) {
+  try {
+    const parsed = JSON.parse(text);
     return {
-      paid: true,
-      ...realizer.vault === void 0 ? {} : { fundingVault: realizer.vault },
-      status: response.status,
-      body: bodyText,
-      payment: {
-        amountRawUsdc: selected2.amountRawUsdc.toString(),
-        payTo: selected2.payTo,
-        feePayer: selected2.feePayer,
-        realizedRawUsdc: realized.realizedRawUsdc.toString(),
-        realizeTxSignature: realized.txSignature,
-        paymentTxSignature
-      }
+      code: typeof parsed.error?.code === "string" ? parsed.error.code : null,
+      message: typeof parsed.error?.message === "string" ? parsed.error.message : null,
+      details: parsed.error?.details ?? null
     };
+  } catch {
+    return { code: null, message: null, details: null };
   }
-  /** Reads the challenge from the header (preferred) or the JSON body. */
-  async selectRequirement(probe) {
-    const header = probe.headers.get(PAYMENT_REQUIRED_HEADER);
-    let requirements;
-    try {
-      if (header !== null) {
-        requirements = decodeStandardPaymentRequiredHeader(header).solanaExactRequirements;
-      } else {
-        requirements = parseStandardChallenge(
-          await probe.json()
-        ).solanaExactRequirements;
-      }
-    } catch (error) {
-      throw new StandardX402PayError(
-        error instanceof StandardX402ChallengeError ? error.reason : "invalid_challenge",
-        "could not parse the x402 402 challenge",
-        error
-      );
-    }
-    try {
-      return selectPayableSolanaRequirement(requirements, {
-        network: this.network,
-        usdcMint: this.usdcMint
-      });
-    } catch (error) {
-      throw new StandardX402PayError(
-        "no_payable_requirement",
-        error instanceof Error ? error.message : String(error),
-        error
-      );
-    }
+}
+
+// ../../src/client/relayer-yield-realizer.ts
+var REALIZE_OVERHEAD_RAW_USDC = 2500n;
+var RelayerRealizeError = class extends Error {
+  constructor(code, message, detail = null, realizationSafeToRetry = false) {
+    super(message);
+    this.code = code;
+    this.detail = detail;
+    this.realizationSafeToRetry = realizationSafeToRetry;
+    this.name = "RelayerRealizeError";
   }
-  track(record) {
-    const previous = this.pending.get(record.key);
-    this.pending.set(record.key, record);
+  code;
+  detail;
+  realizationSafeToRetry;
+};
+var RelayerYieldRealizer = class {
+  get vault() {
+    return this.vaultFlows.vault.address;
+  }
+  realizationContext;
+  vaultFlows;
+  constructor(config) {
+    this.vaultFlows = new VaultFlowClient({
+      relayerBaseUrl: config.relayerBaseUrl,
+      signer: config.signer,
+      rpc: config.rpc,
+      ...config.fetchImpl === void 0 ? {} : { fetchImpl: config.fetchImpl },
+      ...config.lookupTablesFor === void 0 ? {} : { lookupTablesFor: config.lookupTablesFor }
+    });
+    this.realizationContext = Object.freeze({
+      wallet: config.signer.walletAddress,
+      vault: this.vaultFlows.vault.address,
+      relayerBaseUrl: config.relayerBaseUrl.replace(/\/$/, "")
+    });
+  }
+  async ensureUsdcAvailable(input) {
+    const shortfallRawUsdc = input.amountRawUsdc;
+    await this.assertSpendableYield(shortfallRawUsdc);
+    let outcome;
+    let submissionPossible = false;
     try {
-      this.persist();
+      outcome = await this.vaultFlows.withdraw({
+        amountRawUsdc: shortfallRawUsdc,
+        // The relayer refuses to prepare this withdrawal beyond the spendable
+        // yield — the principal-protection guard the client cannot bypass.
+        purpose: "yield_realize",
+        // Declares what is being paid so the relayer's spending-mandate layer
+        // can enforce caps/payee and keep the mandate → payment audit chain.
+        ...input.payment === void 0 ? {} : { payment: input.payment },
+        ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId },
+        ...input.onPrepared === void 0 ? {} : { onPrepared: input.onPrepared },
+        onBeforeSubmit: () => {
+          submissionPossible = true;
+        }
+      });
     } catch (error) {
-      if (previous === void 0) {
-        this.pending.delete(record.key);
-      } else {
-        this.pending.set(record.key, previous);
-      }
-      throw error;
+      if (error instanceof StandardX402PayError) throw error;
+      throw this.mapWithdrawError(error, !submissionPossible);
     }
+    return this.confirmedRealization(outcome);
   }
-  markUnknown(key, detail) {
-    const current = this.pending.get(key);
-    if (current === void 0) {
-      return;
+  async resumeUsdcAvailable(input) {
+    const outcome = await this.vaultFlows.resumeWithdrawal(input.prepared, {
+      amountRawUsdc: input.amountRawUsdc,
+      purpose: "yield_realize",
+      payment: input.payment
+    });
+    return this.confirmedRealization(outcome);
+  }
+  confirmedRealization(outcome) {
+    if (outcome.status !== "confirmed" || outcome.txSignature === null) {
+      throw new RelayerRealizeError(
+        "realize_not_confirmed",
+        `yield realize withdrawal did not confirm (status=${outcome.status})`,
+        outcome
+      );
     }
-    const next = {
-      ...current,
-      status: "external_outcome_unknown",
-      updatedAtMs: this.nowMs(),
-      detail
+    return {
+      realizedRawUsdc: BigInt(outcome.actualWithdrawRawUsdc ?? "0"),
+      txSignature: outcome.txSignature,
+      withdrawalId: outcome.withdrawalId
     };
-    this.pending.set(key, next);
-    try {
-      this.persist();
-    } catch (error) {
-      this.pending.set(key, current);
-      throw error;
-    }
   }
-  tryMarkUnknown(key, detail) {
-    try {
-      this.markUnknown(key, detail);
-      return null;
-    } catch (error) {
-      return error;
-    }
+  /**
+   * Best-effort report-back of the x402 payment tx this realize funded —
+   * closes the relayer's mandate → realize → payment audit chain. Callers
+   * must never let a failure here affect the payment result.
+   */
+  async reportPayment(input) {
+    await this.vaultFlows.reportPayment(input);
   }
-  untrack(key) {
-    const previous = this.pending.get(key);
-    const existed = previous !== void 0;
-    this.pending.delete(key);
+  /**
+   * Refuses to realize more than the ledger's spendable yield (principal).
+   * getBudget syncs the relayer's ledger from chain first (best-effort), so a
+   * long-running client sees yield as it accrues instead of a frozen view.
+   */
+  async assertSpendableYield(shortfallRawUsdc) {
+    let spendable;
     try {
-      this.persist();
+      const budget = await this.vaultFlows.getBudget();
+      spendable = BigInt(budget.spendableYieldRawUsdc);
     } catch (error) {
-      if (existed) {
-        this.pending.set(key, previous);
-      }
-      throw error;
+      throw new RelayerRealizeError(
+        "budget_unavailable",
+        "could not read the spendable-yield budget",
+        error,
+        true
+      );
     }
-  }
-  clearDelivered(key) {
-    const previous = this.pending.get(key);
-    this.pending.delete(key);
-    try {
-      this.persist();
-    } catch (error) {
-      if (previous !== void 0) {
-        this.pending.set(key, previous);
-      }
-      console.error(
-        `[subly-x402] payment delivered but pending marker could not be cleared: ${error instanceof Error ? error.message : String(error)}`
+    const requiredRawUsdc = shortfallRawUsdc + REALIZE_OVERHEAD_RAW_USDC;
+    if (spendable < requiredRawUsdc) {
+      throw new RelayerRealizeError(
+        "insufficient_yield",
+        `spendable yield ${spendable} cannot cover ${shortfallRawUsdc} raw USDC plus the ${REALIZE_OVERHEAD_RAW_USDC} raw fee headroom; the principal is never spent \u2014 wait for more yield`,
+        { spendableYieldRawUsdc: spendable.toString() },
+        true
       );
     }
   }
-  persist() {
-    if (this.stateStore === null) {
-      return;
+  mapWithdrawError(error, safeToRetry) {
+    if (!(error instanceof VaultFlowClientError)) {
+      return new RelayerRealizeError(
+        "prepare_failed",
+        `yield realize failed: ${error instanceof Error ? error.message : String(error)}`,
+        error,
+        safeToRetry
+      );
     }
-    this.stateStore.save([...this.pending.values()]);
+    const serverCode = error.code ?? errorCodeFrom(error.detail);
+    if (serverCode === "approval_required") {
+      return new RelayerRealizeError(
+        "approval_required",
+        "this payment exceeds the owner-approval threshold; nothing was realized or paid. Ask the owner to approve, then retry with the approvalId",
+        error.errorDetails ?? error.detail,
+        safeToRetry
+      );
+    }
+    if (serverCode === "insufficient_yield" || serverCode === "post_state_principal_invariant_failed") {
+      return new RelayerRealizeError(
+        "insufficient_yield",
+        "the relayer refused to realize beyond the spendable yield; the principal is never spent \u2014 wait for more yield",
+        error.detail,
+        safeToRetry
+      );
+    }
+    return new RelayerRealizeError(
+      error.step === "submit" ? "submit_failed" : "prepare_failed",
+      error.message,
+      error.detail,
+      safeToRetry
+    );
   }
 };
-function pendingPaymentKey(input) {
-  return `${input.method}:${input.url}:${input.requestBodyHash}`;
-}
-function extractSettledPaymentTxSignature(response) {
-  const header = response.headers.get(PAYMENT_RESPONSE_HEADER) ?? response.headers.get("x-payment-response");
-  if (header === null || header.length === 0) {
+function errorCodeFrom(detail) {
+  if (typeof detail !== "string") {
     return null;
   }
   try {
-    const decoded = JSON.parse(
-      Buffer.from(header, "base64").toString("utf8")
-    );
-    if (typeof decoded.transaction === "string" && decoded.transaction.length > 0) {
-      return decoded.transaction;
-    }
-    if (typeof decoded.txHash === "string" && decoded.txHash.length > 0) {
-      return decoded.txHash;
-    }
-    return null;
+    const parsed = JSON.parse(detail);
+    return typeof parsed.error?.code === "string" ? parsed.error.code : null;
   } catch {
     return null;
   }
 }
 
+// src/mcp-server.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+
+// ../../src/client/mcp-payment-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// ../../src/client/onboarding.ts
+var SELF_SERVE_POLICY_ID = "self-serve";
+var OnboardingError = class extends Error {
+  constructor(step, message, detail = null) {
+    super(message);
+    this.step = step;
+    this.detail = detail;
+    this.name = "OnboardingError";
+  }
+  step;
+  detail;
+};
+async function ensureWalletOnboarded(params) {
+  const fetchImpl = params.fetchImpl ?? fetch;
+  const baseUrl = params.relayerBaseUrl.replace(/\/$/, "");
+  const post = async (step, path, body) => {
+    const url = `${baseUrl}${path}`;
+    const serialized = JSON.stringify(body);
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        ...await walletAuthHeaders({
+          signer: params.signer,
+          method: "POST",
+          url,
+          body: serialized
+        }),
+        "content-type": "application/json"
+      },
+      body: serialized
+    });
+    if (response.status !== 200) {
+      let detail = null;
+      try {
+        detail = await response.json();
+      } catch {
+        detail = null;
+      }
+      throw new OnboardingError(
+        step,
+        `wallet onboarding ${step} failed with ${response.status}`,
+        detail
+      );
+    }
+  };
+  const wallet = params.signer.walletAddress;
+  const vault = params.vault ?? params.signer.vault?.address ?? SUBLY_VAULT.address;
+  await post("register", "/v1/wallets/agent", {
+    wallet,
+    vault,
+    signingPolicyId: SELF_SERVE_POLICY_ID,
+    signingMode: "non_interactive",
+    signerValidationMode: params.signer.validationMode,
+    signerProvider: params.signer.provider ?? "local-keypair",
+    activateForPayments: true
+  });
+  await post("sync", `/v1/wallets/${wallet}/sync`, { source: "chain", vault });
+}
+
+// ../../src/client/paid-fetch.ts
+function formatRawUsdcAmount(raw) {
+  const value = BigInt(raw);
+  const negative = value < 0n;
+  const abs = negative ? -value : value;
+  const whole = abs / 1000000n;
+  const frac = (abs % 1000000n).toString().padStart(6, "0");
+  return `${negative ? "-" : ""}${whole}.${frac}`;
+}
+
 // ../../src/client/mcp-payment-server.ts
 var TOOL_NAME = "fetch_with_subly_payment";
 var DEPOSIT_TOOL_NAME = "deposit_to_subly_vault";
@@ -1572,6 +1799,7 @@ var WITHDRAW_TOOL_NAME = "withdraw_from_subly_vault";
 var BUDGET_TOOL_NAME = "get_subly_yield_budget";
 var SETUP_TOOL_NAME = "create_subly_setup_link";
 var SETUP_STATUS_TOOL_NAME = "check_subly_setup";
+var OPERATION_STATUS_TOOL_NAME = "check_subly_vault_operation";
 var SERVER_INSTRUCTIONS = `Subly lets an agent pay standard x402 (HTTP 402) paid APIs that offer a Solana USDC exact rail with facilitator feePayer support from its wallet's Kamino vault YIELD \u2014 the relayer limits API spending to recorded yield, and the seller needs no Subly integration. With a configured vault catalog, call list_subly_vaults and select_subly_vault(vaultAddress) for the user's choice before owner setup. All subsequent tools use that vault until changed. Selection never moves existing funds; set up a separate mandate for each vault. Never select or switch vaults automatically based on APY.
 
 One-time setup: the operator needs a Solana agent wallet. Subly does NOT create wallets; either make a local keypair with \`solana-keygen new -o agent.json\` (or export one from an existing wallet) and point SUBLY_DEMO_AGENT_KEYPAIR_PATH at it, or use a custody wallet \u2014 set SUBLY_SIGNER_PROVIDER=circle (Circle developer-controlled wallet: CIRCLE_API_KEY, CIRCLE_ENTITY_SECRET, CIRCLE_WALLET_ID) or =privy (Privy server wallet incl. agentic/owner-key wallets: PRIVY_APP_ID, PRIVY_APP_SECRET, PRIVY_WALLET_ID, plus PRIVY_AUTHORIZATION_KEY for owner-key wallets). With a local keypair the private key never leaves that file; with a custody provider it never enters this machine at all. Then fund the wallet with USDC on Solana mainnet \u2014 a funded relayer sponsors vault transaction fees, which do not require agent SOL.
@@ -1582,15 +1810,39 @@ From there the agent can do everything with these tools:
 1. deposit_to_subly_vault(amountRawUsdc) puts wallet USDC into the vault (the minimum depends on the selected vault) so it starts earning yield. If it returns approvalRequired, paste the approveUrl to the user and retry with the approvalId after they approve; if it returns setupRequired, run the owner onboarding above first.
 2. get_subly_yield_budget() shows the principal, position value, and the spendable yield a payment can use right now.
 3. fetch_with_subly_payment(url) GETs or POSTs a paid resource from a compatible x402 seller (e.g. Nansen): it realizes just enough yield to the agent's USDC ATA and pays the seller's Solana USDC exact challenge, returning the body plus the payment details. If it returns insufficient_yield, that is expected \u2014 yield accrues over time; wait, do not loop. If it returns approvalRequired (payment above the owner's threshold; NOTHING was paid), paste the approveUrl to the user, and once they say they approved, repeat the SAME call adding the approvalId.
-4. withdraw_from_subly_vault(amountRawUsdc) exits: moves vault funds (principal included) back to the agent wallet's USDC account. If the owner's mandate requires withdrawal approval it returns approvalRequired \u2014 same paste-approveUrl-then-retry flow as deposits.`;
+4. withdraw_from_subly_vault(amountRawUsdc) exits: moves vault funds (principal included) back to the agent wallet's USDC account. If the owner's mandate requires withdrawal approval it returns approvalRequired \u2014 same paste-approveUrl-then-retry flow as deposits.
+5. check_subly_vault_operation(intentId) checks the original deposit or withdrawal after a timeout. Use the returned dep_... or wdr_... ID with the same wallet, vault and relayer. It reconciles that original transaction without preparing or sending another. If still confirming, check the same ID later; do not repeat the deposit or withdrawal.`;
 function createMcpPaymentServer(config) {
   const { signer: signer2, relayerBaseUrl: relayerBaseUrl2, defaultMaxAmountRawUsdc: defaultMaxAmountRawUsdc2 } = config;
   const vaultFlows = config.vaultFlows ?? null;
+  const fetchOnboardingAttempts = /* @__PURE__ */ new Map();
+  const fetchInFlight = /* @__PURE__ */ new Map();
   const server = new Server(
     { name: "subly-payments", version: config.serverVersion ?? "0.3.0" },
     { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }
   );
   const vaultTools = vaultFlows === null ? [] : [
+    {
+      name: OPERATION_STATUS_TOOL_NAME,
+      description: "Read and reconcile the original deposit or withdrawal by its dep_... or wdr_... intent ID. Use after submitted/confirmation timeout, with the same wallet, selected vault and relayer. Does not prepare, sign or send a transaction, or refresh the budget. Returns status, amounts, transaction signature and next action.",
+      inputSchema: {
+        type: "object",
+        properties: { intentId: {
+          type: "string",
+          pattern: "^(dep|wdr)_[0-9a-f]{32}$",
+          description: "Original depositId or withdrawalId returned by the operation."
+        } },
+        required: ["intentId"],
+        additionalProperties: false
+      },
+      annotations: {
+        title: "Check Subly deposit or withdrawal",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
     {
       name: SETUP_TOOL_NAME,
       description: "Create the one-time owner setup link for this agent wallet's Subly spending mandate. Use during onboarding (the first deposit conversation): agree the limits and first deposit in chat, call this, and paste the returned setupUrl to the user verbatim \u2014 it expires in 10 minutes and works once. The human opens it on their phone and confirms with Face ID (passkey) or a Solana wallet signature; that single confirmation activates the mandate AND pre-approves the initial deposit. The page is confirm-only: to change values, agree in chat and create a new link.",
@@ -1823,7 +2075,7 @@ function createMcpPaymentServer(config) {
           ...amountField,
           solscanUrl,
           stillConfirming: true,
-          warning: "the transaction was broadcast but had not confirmed before the poll timeout. Do NOT submit this deposit/withdrawal again \u2014 it may still confirm and moving the funds twice is not what the user asked for. Check get_subly_yield_budget in a minute, or the solscanUrl."
+          warning: "the transaction was broadcast but had not confirmed before the poll timeout. Do NOT submit this deposit/withdrawal again \u2014 it may still confirm and moving the funds twice is not what the user asked for. Call check_subly_vault_operation with the original depositId or withdrawalId, keeping the same wallet, selected vault and relayer."
         },
         true
       );
@@ -1855,10 +2107,11 @@ function createMcpPaymentServer(config) {
       DEPOSIT_TOOL_NAME,
       WITHDRAW_TOOL_NAME,
       SETUP_TOOL_NAME,
-      SETUP_STATUS_TOOL_NAME
+      SETUP_STATUS_TOOL_NAME,
+      OPERATION_STATUS_TOOL_NAME
     ];
     if (vaultFlows2 !== null && vaultToolNames.includes(request.params.name)) {
-      const needsChainSync = request.params.name !== SETUP_TOOL_NAME && request.params.name !== SETUP_STATUS_TOOL_NAME;
+      const needsChainSync = request.params.name !== SETUP_TOOL_NAME && request.params.name !== SETUP_STATUS_TOOL_NAME && request.params.name !== OPERATION_STATUS_TOOL_NAME;
       if (needsChainSync) {
         try {
           await ensureWalletOnboarded({ relayerBaseUrl: relayerBaseUrl2, signer: signer3 });
@@ -1866,6 +2119,16 @@ function createMcpPaymentServer(config) {
         }
       }
       const args2 = request.params.arguments ?? {};
+      if (request.params.name === OPERATION_STATUS_TOOL_NAME) {
+        if (typeof args2.intentId !== "string") {
+          return textResult({ ok: false, message: "intentId is required" }, true);
+        }
+        try {
+          return textResult(await vaultFlows2.getOperationStatus(args2.intentId));
+        } catch (error) {
+          return vaultFlowFailure(error);
+        }
+      }
       if (request.params.name === BUDGET_TOOL_NAME) {
         try {
           const budget = await vaultFlows2.getBudget();
@@ -2025,16 +2288,34 @@ function createMcpPaymentServer(config) {
       Object.entries(args.headers).filter(([, v]) => typeof v === "string").map(([k, v]) => [k, v])
     ) : void 0;
     const mergedHeaders = body === void 0 ? headers : { "content-type": "application/json", ...headers ?? {} };
-    try {
-      const result = await payer2.pay({
-        url,
-        ...method === void 0 ? {} : { method },
-        ...body === void 0 ? {} : { body },
-        ...mergedHeaders === void 0 ? {} : { headers: mergedHeaders },
-        ...maxAmountRawUsdc === void 0 ? {} : { maxAmountRawUsdc },
-        ...forceNewPayment ? { forceNewPayment } : {},
-        ...approvalId === void 0 ? {} : { approvalId }
+    const fetchKey = `${(method ?? "GET").toUpperCase()}:${url}:${requestBodyHashFor(body ?? null)}`;
+    let paymentFlow = fetchInFlight.get(fetchKey);
+    if (paymentFlow === void 0) {
+      paymentFlow = (async () => {
+        const onboardingKey = `${signer3.walletAddress}:${vaultFlows2?.vault.address ?? signer3.vault?.address ?? "default"}`;
+        let onboarding = fetchOnboardingAttempts.get(onboardingKey);
+        if (onboarding === void 0) {
+          onboarding = ensureWalletOnboarded({ relayerBaseUrl: relayerBaseUrl2, signer: signer3 }).catch(() => {
+          });
+          fetchOnboardingAttempts.set(onboardingKey, onboarding);
+        }
+        await onboarding;
+        return payer2.pay({
+          url,
+          ...method === void 0 ? {} : { method },
+          ...body === void 0 ? {} : { body },
+          ...mergedHeaders === void 0 ? {} : { headers: mergedHeaders },
+          ...maxAmountRawUsdc === void 0 ? {} : { maxAmountRawUsdc },
+          ...forceNewPayment ? { forceNewPayment } : {},
+          ...approvalId === void 0 ? {} : { approvalId }
+        });
+      })().finally(() => {
+        fetchInFlight.delete(fetchKey);
       });
+      fetchInFlight.set(fetchKey, paymentFlow);
+    }
+    try {
+      const result = await paymentFlow;
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
       };
@@ -2087,14 +2368,6 @@ function createMcpPaymentServer(config) {
 async function runMcpPaymentServer(config) {
   const server = createMcpPaymentServer(config);
   const { signer: signer2, relayerBaseUrl: relayerBaseUrl2, defaultMaxAmountRawUsdc: defaultMaxAmountRawUsdc2 } = config;
-  try {
-    await ensureWalletOnboarded({ relayerBaseUrl: relayerBaseUrl2, signer: signer2 });
-    console.error("[subly-mcp] wallet registered and synced at the relayer");
-  } catch (error) {
-    console.error(
-      `[subly-mcp] wallet onboarding failed (will still serve tools): ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error(
@@ -3400,13 +3673,13 @@ async function createCircleSignerTransport(config) {
 import { createPrivateKey, createSign } from "node:crypto";
 var PROVIDER2 = "privy";
 var DEFAULT_BASE_URL2 = "https://api.privy.io";
-function canonicalJson(value) {
+function canonicalJson2(value) {
   if (Array.isArray(value)) {
-    return `[${value.map(canonicalJson).join(",")}]`;
+    return `[${value.map(canonicalJson2).join(",")}]`;
   }
   if (value !== null && typeof value === "object") {
     const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson2(v)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
@@ -3435,7 +3708,7 @@ function authorizationSignature(params) {
     headers: { "privy-app-id": params.appId }
   };
   const signer2 = createSign("sha256");
-  signer2.update(canonicalJson(payload));
+  signer2.update(canonicalJson2(payload));
   return signer2.sign(params.key).toString("base64");
 }
 async function createPrivySignerTransport(config) {
@@ -3614,7 +3887,7 @@ async function signerBundleForVault(bundle2, vault) {
 }
 
 // ../../src/client/standard-x402-state-store.ts
-import { closeSync, mkdirSync, openSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { closeSync, fsyncSync, mkdirSync, openSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 function fileStandardX402StateStore(path) {
   return {
@@ -3659,6 +3932,9 @@ function fileStandardX402StateStore(path) {
           );
         }
       }
+      if (new Set(parsed.map((record) => record.key)).size !== parsed.length) {
+        throw new Error(`pending payment state has duplicate request keys: ${path}`);
+      }
       return parsed;
     },
     save(records) {
@@ -3668,8 +3944,29 @@ function fileStandardX402StateStore(path) {
         directory,
         `.${basename(path)}.${process.pid}.${Date.now()}.tmp`
       );
-      writeFileSync(tempPath, JSON.stringify(records, null, 2), { mode: 384, flag: "wx" });
-      renameSync(tempPath, path);
+      try {
+        const fd = openSync(tempPath, "wx", 384);
+        try {
+          writeFileSync(fd, JSON.stringify(records, null, 2));
+          fsyncSync(fd);
+        } finally {
+          closeSync(fd);
+        }
+        renameSync(tempPath, path);
+        if (process.platform !== "win32") {
+          const directoryFd = openSync(directory, "r");
+          try {
+            fsyncSync(directoryFd);
+          } finally {
+            closeSync(directoryFd);
+          }
+        }
+      } finally {
+        try {
+          unlinkSync(tempPath);
+        } catch {
+        }
+      }
     }
   };
 }
@@ -3681,7 +3978,20 @@ function isPendingPaymentRecord(value) {
     return false;
   }
   const record = value;
-  return typeof record.key === "string" && typeof record.url === "string" && typeof record.method === "string" && typeof record.requestBodyHash === "string" && typeof record.amountRawUsdc === "string" && typeof record.payTo === "string" && (record.feePayer === null || typeof record.feePayer === "string") && typeof record.realizedRawUsdc === "string" && (record.realizeTxSignature === null || typeof record.realizeTxSignature === "string") && (record.status === "realized" || record.status === "external_outcome_unknown") && typeof record.createdAtMs === "number" && typeof record.updatedAtMs === "number";
+  return typeof record.key === "string" && typeof record.url === "string" && typeof record.method === "string" && typeof record.requestBodyHash === "string" && typeof record.amountRawUsdc === "string" && typeof record.payTo === "string" && (record.feePayer === null || typeof record.feePayer === "string") && typeof record.realizedRawUsdc === "string" && (record.realizeTxSignature === null || typeof record.realizeTxSignature === "string") && (record.status === "realizing" || record.status === "realized" || record.status === "external_outcome_unknown") && (record.recovery === void 0 || isRecoveryRecord(record.recovery) && record.key === `${record.method}:${record.url}:${record.requestBodyHash}` && /^\d+$/.test(String(record.realizedRawUsdc)) && /^\d+$/.test(String(record.amountRawUsdc))) && typeof record.createdAtMs === "number" && typeof record.updatedAtMs === "number";
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isRecoveryRecord(value) {
+  if (!isObject(value) || value.version !== 1 || !isObject(value.context)) return false;
+  const context = value.context;
+  if (!["wallet", "vault", "relayerBaseUrl"].every((key) => typeof context[key] === "string" && context[key] !== "") || typeof value.requestHeadersHash !== "string" || !/^[0-9a-f]{64}$/.test(value.requestHeadersHash) || !standardExactRequirementSchema.safeParse(value.requirement).success) return false;
+  if (value.prepared === void 0) return true;
+  const prepared = value.prepared;
+  if (!isObject(prepared) || !isObject(prepared.signingIntent) || prepared.purpose !== "yield_realize" || !["withdrawalId", "serializedTransaction", "destinationUsdcAta", "requestedWithdrawRawUsdc"].every((key) => typeof prepared[key] === "string" && prepared[key] !== "")) return false;
+  const intent = prepared.signingIntent;
+  return intent.allowFullExit === false && ["wallet", "vault", "farm", "shareMint", "asset", "destinationUsdcAta", "maxSharesToRedeemRaw", "feePayer", "expiresAt", "preparedMessageHash"].every((key) => typeof intent[key] === "string" && intent[key] !== "");
 }
 
 // ../../src/solana/rpc.ts