@subly_fi/pay 0.2.0 → 0.4.0

package/dist/pay.js

@@ -1,11 +1,12 @@
-// demo/pay.ts
-import { readFileSync as readFileSync2, writeFileSync } from "node:fs";
+// src/pay.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
 
-// src/client/agent-wallet-signer.ts
+// ../../src/client/agent-wallet-signer.ts
 import { signBytes } from "@solana/kit";
 import bs584 from "bs58";
 
-// src/solana/tx.ts
+// ../../src/solana/tx.ts
 import bs58 from "bs58";
 import {
   appendTransactionMessageInstructions,
@@ -20,7 +21,7 @@ import {
   setTransactionMessageLifetimeUsingBlockhash
 } from "@solana/kit";
 
-// src/lib/hash.ts
+// ../../src/lib/hash.ts
 import { createHash } from "node:crypto";
 var EMPTY_BODY_HASH = "sha256-e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
 function sha256TaggedHex(data) {
@@ -46,7 +47,7 @@ function hashStableJson(value) {
   return sha256TaggedHex(stableStringify(value));
 }
 
-// src/solana/tx.ts
+// ../../src/solana/tx.ts
 function decodeSerializedTransaction(serializedBase64) {
   return getTransactionDecoder().decode(Buffer.from(serializedBase64, "base64"));
 }
@@ -66,11 +67,11 @@ function signatureBase58ForSigner(transaction, signer2) {
   return bs58.encode(signature);
 }
 
-// src/client/transaction-intent-validator.ts
+// ../../src/client/transaction-intent-validator.ts
 import bs583 from "bs58";
 import { getCompiledTransactionMessageDecoder } from "@solana/kit";
 
-// src/config/constants.ts
+// ../../src/config/constants.ts
 var PAYMENT_SCHEME = "subly-yield-exact";
 var SOLANA_MAINNET_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 var SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
@@ -86,7 +87,7 @@ var SUBLY_VAULT = {
 };
 var USDC_DECIMALS = 6;
 
-// src/domain/request-binding.ts
+// ../../src/domain/request-binding.ts
 function computeRequestBindingHash(fields) {
   return hashStableJson({
     sellerRequestId: fields.sellerRequestId,
@@ -101,7 +102,7 @@ function computeRequestBindingHash(fields) {
   });
 }
 
-// src/lib/associated-token-account.ts
+// ../../src/lib/associated-token-account.ts
 import { createHash as createHash2 } from "node:crypto";
 import bs582 from "bs58";
 var PDA_MARKER = Buffer.from("ProgramDerivedAddress", "utf8");
@@ -193,7 +194,7 @@ function modPow(base, exponent, modulus) {
   return result;
 }
 
-// src/client/transaction-intent-validator.ts
+// ../../src/client/transaction-intent-validator.ts
 var COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
 var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
 var ASSOCIATED_TOKEN_PROGRAM_ID2 = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
@@ -879,7 +880,7 @@ function readShortVec(bytes, startOffset) {
   return null;
 }
 
-// src/client/agent-wallet-signer.ts
+// ../../src/client/agent-wallet-signer.ts
 var LocalKeypairAgentWalletSigner = class {
   validationMode = "structured_intent_transaction";
   keyPairSigner;
@@ -949,47 +950,7 @@ var LocalKeypairAgentWalletSigner = class {
   }
 };
 
-// src/client/lookup-tables.ts
-import { fetchAllMaybeAddressLookupTable } from "@solana-program/address-lookup-table";
-import { address, getCompiledTransactionMessageDecoder as getCompiledTransactionMessageDecoder2 } 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 = getCompiledTransactionMessageDecoder2().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 {};
-  }
-  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/api/wallet-auth.ts
+// ../../src/api/wallet-auth.ts
 import { createHash as createHash3 } from "node:crypto";
 import bs585 from "bs58";
 import nacl from "tweetnacl";
@@ -1007,7 +968,7 @@ function walletAuthMessage(params) {
   );
 }
 
-// src/client/wallet-auth-headers.ts
+// ../../src/client/wallet-auth-headers.ts
 async function walletAuthHeaders(params) {
   const signedAtMs = String(Date.now());
   const message = walletAuthMessage({
@@ -1023,7 +984,7 @@ async function walletAuthHeaders(params) {
   };
 }
 
-// src/client/onboarding.ts
+// ../../src/client/onboarding.ts
 var SELF_SERVE_POLICY_ID = "self-serve";
 var OnboardingError = class extends Error {
   constructor(step, message, detail = null) {
@@ -1038,9 +999,9 @@ var OnboardingError = class extends Error {
 async function ensureWalletOnboarded(params) {
   const fetchImpl = params.fetchImpl ?? fetch;
   const baseUrl = params.facilitatorBaseUrl.replace(/\/$/, "");
-  const post = async (step, path, body) => {
+  const post = async (step, path, body2) => {
     const url2 = `${baseUrl}${path}`;
-    const serialized = JSON.stringify(body);
+    const serialized = JSON.stringify(body2);
     const response = await fetchImpl(url2, {
       method: "POST",
       headers: {
@@ -1080,12 +1041,375 @@ async function ensureWalletOnboarded(params) {
   await post("sync", `/v1/wallets/${wallet}/sync`, { source: "chain" });
 }
 
-// src/x402/headers.ts
+// ../../src/client/lookup-tables.ts
+import { fetchAllMaybeAddressLookupTable } from "@solana-program/address-lookup-table";
+import { address, getCompiledTransactionMessageDecoder as getCompiledTransactionMessageDecoder2 } 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 = getCompiledTransactionMessageDecoder2().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 {};
+  }
+  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/vault-flows.ts
+var VaultFlowClientError = class extends Error {
+  constructor(step, message, detail = null) {
+    super(message);
+    this.step = step;
+    this.detail = detail;
+    this.name = "VaultFlowClientError";
+  }
+  step;
+  detail;
+};
+var VaultFlowClient = class {
+  baseUrl;
+  signer;
+  fetchImpl;
+  lookupTablesFor;
+  pollTimeoutMs;
+  pollIntervalMs;
+  constructor(config) {
+    this.baseUrl = config.facilitatorBaseUrl.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). */
+  async deposit(input) {
+    const prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
+      wallet: this.signer.walletAddress,
+      amountRawUsdc: input.amountRawUsdc.toString()
+    });
+    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
+    };
+  }
+  /**
+   * 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,
+        amountRawUsdc: input.amountRawUsdc.toString(),
+        ...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
+      );
+    }
+    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
+    };
+  }
+  /**
+   * 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 {
+        await this.postJson(
+          "sync",
+          `/v1/wallets/${this.signer.walletAddress}/sync`,
+          { source: "chain" }
+        );
+      } catch {
+      }
+    }
+    const url2 = `${this.baseUrl}/v1/wallets/${this.signer.walletAddress}/budget`;
+    const response = await this.fetchImpl(url2, {
+      headers: await walletAuthHeaders({
+        signer: this.signer,
+        method: "GET",
+        url: url2
+      })
+    });
+    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 body2 = parsed;
+    return {
+      wallet: this.signer.walletAddress,
+      principalBasisRawUsdc: body2.position?.principalBasisRawUsdc ?? "0",
+      positionValueRawUsdc: body2.budget?.positionValueRawUsdc ?? "0",
+      grossYieldRawUsdc: body2.budget?.grossYieldRawUsdc ?? "0",
+      spendableYieldRawUsdc: body2.budget?.spendableYieldRawUsdc ?? "0"
+    };
+  }
+  /**
+   * 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 url2 = `${this.baseUrl}${path}`;
+      const response = await this.fetchImpl(url2, {
+        headers: await walletAuthHeaders({
+          signer: this.signer,
+          method: "GET",
+          url: url2
+        })
+      });
+      if (response.status !== 200) {
+        continue;
+      }
+      try {
+        latest = await response.json();
+      } catch {
+        continue;
+      }
+      if (latest.status !== "submitted") {
+        return latest;
+      }
+    }
+    return latest;
+  }
+  async postJson(step, path, body2) {
+    const url2 = `${this.baseUrl}${path}`;
+    const serialized = JSON.stringify(body2);
+    const response = await this.fetchImpl(url2, {
+      method: "POST",
+      headers: {
+        ...await walletAuthHeaders({
+          signer: this.signer,
+          method: "POST",
+          url: url2,
+          body: serialized
+        }),
+        "content-type": "application/json"
+      },
+      body: serialized
+    });
+    const text = await response.text();
+    if (response.status !== 200) {
+      throw new VaultFlowClientError(
+        step,
+        `${path} failed with ${response.status}: ${text}`,
+        text
+      );
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        step,
+        `${path} returned 200 with a non-JSON body`,
+        text
+      );
+    }
+  }
+};
+
+// ../../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 {
+  vaultFlows;
+  constructor(config) {
+    this.vaultFlows = new VaultFlowClient({
+      facilitatorBaseUrl: config.facilitatorBaseUrl,
+      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"
+      });
+    } 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
+      );
+    }
+    return {
+      realizedRawUsdc: BigInt(outcome.actualWithdrawRawUsdc ?? "0"),
+      txSignature: outcome.txSignature
+    };
+  }
+  /**
+   * 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() }
+      );
+    }
+  }
+  mapWithdrawError(error) {
+    if (!(error instanceof VaultFlowClientError)) {
+      return new RelayerRealizeError(
+        "prepare_failed",
+        `yield realize failed: ${error instanceof Error ? error.message : String(error)}`,
+        error
+      );
+    }
+    const serverCode = errorCodeFrom(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
+    );
+  }
+};
+function errorCodeFrom(detail) {
+  if (typeof detail !== "string") {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(detail);
+    return typeof parsed.error?.code === "string" ? parsed.error.code : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../../src/x402/headers.ts
 import { z } from "zod";
 var PAYMENT_REQUIRED_HEADER = "payment-required";
-var PAYMENT_SIGNATURE_HEADER = "payment-signature";
-var PAYMENT_RESPONSE_HEADER = "payment-response";
-var X402_VERSION = 2;
 var MAX_HEADER_JSON_BYTES = 16384;
 var X402HeaderError = class extends Error {
   reason;
@@ -1132,16 +1456,6 @@ var sublyPaymentPayloadSchema = z.object({
     temporarySettlementSignature: z.string().min(1).max(128)
   })
 }).loose();
-function encodeX402Header(value) {
-  const json = JSON.stringify(value);
-  if (Buffer.byteLength(json, "utf8") > MAX_HEADER_JSON_BYTES) {
-    throw new X402HeaderError(
-      "header_too_large",
-      `x402 header JSON exceeds ${MAX_HEADER_JSON_BYTES} bytes`
-    );
-  }
-  return Buffer.from(json, "utf8").toString("base64");
-}
 function decodeX402Header(headerValue) {
   if (headerValue.length > Math.ceil(MAX_HEADER_JSON_BYTES * 4 / 3) + 4) {
     throw new X402HeaderError(
@@ -1159,285 +1473,466 @@ function decodeX402Header(headerValue) {
     );
   }
 }
-function decodePaymentRequiredHeader(headerValue) {
-  const parsed = paymentRequiredSchema.safeParse(decodeX402Header(headerValue));
+function requestBodyHashFor(body2) {
+  if (body2 === null || body2 === void 0 || body2.length === 0) {
+    return EMPTY_BODY_HASH;
+  }
+  return sha256TaggedHex(
+    typeof body2 === "string" ? Buffer.from(body2, "utf8") : Buffer.from(body2)
+  );
+}
+
+// ../../src/x402/standard-requirements.ts
+import { z as z2 } from "zod";
+var STANDARD_EXACT_SCHEME = "exact";
+var standardExactRequirementSchema = z2.object({
+  scheme: z2.literal(STANDARD_EXACT_SCHEME),
+  /** CAIP-2 chain id, e.g. "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp". */
+  network: z2.string().min(1),
+  /** SPL mint (Solana) or token contract (EVM); Subly only pays USDC/Solana. */
+  asset: z2.string().min(1),
+  /** Exact price in the asset's atomic units, as a decimal string. */
+  amount: z2.string().regex(/^[1-9]\d*$/),
+  /** Recipient wallet; the transfer destination ATA is derived from it. */
+  payTo: z2.string().min(1),
+  maxTimeoutSeconds: z2.number().int().positive().optional(),
+  extra: z2.object({
+    /** Facilitator address that pays the tx fee (gas sponsorship). */
+    feePayer: z2.string().min(1).optional()
+  }).loose().optional()
+}).loose();
+var standardPaymentRequiredSchema = z2.object({
+  x402Version: z2.number().int(),
+  accepts: z2.array(z2.unknown()),
+  error: z2.string().optional(),
+  resource: z2.object({ url: z2.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 X402HeaderError(
+    throw new StandardX402ChallengeError(
       "invalid_payment_required",
-      "PAYMENT-REQUIRED header is not a valid x402 PaymentRequired object"
+      "Response is not a valid x402 PaymentRequired object"
     );
   }
-  const sublyRequirements = parsed.data.accepts.flatMap((candidate) => {
-    const requirement = sublyPaymentRequirementsSchema.safeParse(candidate);
-    return requirement.success ? [requirement.data] : [];
+  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, sublyRequirements };
+  return { paymentRequired: parsed.data, solanaExactRequirements };
 }
-function requestBodyHashFor(body) {
-  if (body === null || body === void 0 || body.length === 0) {
-    return EMPTY_BODY_HASH;
+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 sha256TaggedHex(
-    typeof body === "string" ? Buffer.from(body, "utf8") : Buffer.from(body)
-  );
+  return parseStandardChallenge(decoded);
+}
+function selectPayableSolanaRequirement(requirements, options) {
+  const network = options?.network ?? SOLANA_MAINNET_NETWORK;
+  const usdcMint = options?.usdcMint ?? SUBLY_VAULT.usdcMint;
+  const requirement = requirements.find(
+    (candidate) => candidate.network === network && candidate.asset === usdcMint
+  ) ?? null;
+  if (requirement === null) {
+    throw new StandardX402ChallengeError(
+      "no_payable_requirement",
+      `The challenge has no Solana exact requirement on ${network} paying ${usdcMint}`
+    );
+  }
+  return {
+    requirement,
+    amountRawUsdc: BigInt(requirement.amount),
+    payTo: requirement.payTo,
+    feePayer: requirement.extra?.feePayer ?? null
+  };
+}
+function standardRequirementMatchesSelected(candidate, selected) {
+  const parsed = standardExactRequirementSchema.safeParse(candidate);
+  return parsed.success && stableJson(parsed.data) === stableJson(selected.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/paid-fetch.ts
-var PaidFetchError = class extends Error {
+// ../../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 = "PaidFetchError";
+    this.name = "StandardX402PayError";
   }
   reason;
   detail;
 };
-var DEFAULT_PENDING_TTL_MS = 11e4;
-var DEFAULT_MAX_TRACKED_URLS = 1e3;
-var DEFAULT_MAX_BODY_CHARS = 2e4;
-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}`;
-}
-var PaidFetchService = class {
-  signatureBuilder;
-  fetchImpl;
-  fetchBudget;
-  paymentStatusFor;
+var StandardX402Payer = class {
+  realizer;
+  x402Fetch;
+  probeFetch;
   defaultMaxAmountRawUsdc;
-  pendingTtlMs;
-  maxTrackedUrls;
-  maxBodyChars;
-  nowMs;
+  network;
+  usdcMint;
   stateStore;
   pending = /* @__PURE__ */ new Map();
   inFlight = /* @__PURE__ */ new Map();
+  nowMs;
   constructor(config) {
-    this.signatureBuilder = config.signatureBuilder;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-    this.fetchBudget = config.fetchBudget ?? (async () => null);
-    this.paymentStatusFor = config.paymentStatusFor ?? (async () => "indeterminate");
+    this.realizer = config.realizer;
+    this.x402Fetch = config.x402Fetch;
+    this.probeFetch = config.probeFetch ?? fetch;
     this.defaultMaxAmountRawUsdc = config.defaultMaxAmountRawUsdc;
-    this.pendingTtlMs = config.pendingTtlMs ?? DEFAULT_PENDING_TTL_MS;
-    this.maxTrackedUrls = config.maxTrackedUrls ?? DEFAULT_MAX_TRACKED_URLS;
-    this.maxBodyChars = config.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS;
-    this.nowMs = config.nowMs ?? (() => Date.now());
+    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()) {
-        const { url: url2, ...entry } = record;
-        this.pending.set(url2, entry);
+        this.pending.set(record.key, record);
       }
     }
   }
-  /**
-   * GET the URL, paying a 402 challenge when needed. Concurrent calls for the
-   * same URL share one flow and one result.
-   */
-  paidFetch(params) {
-    const existing = this.inFlight.get(params.url);
-    if (existing !== void 0) {
-      return existing;
+  pay(input) {
+    const method2 = (input.method ?? "GET").toUpperCase();
+    const requestBodyHash = requestBodyHashFor(input.body ?? null);
+    const pendingKey = pendingPaymentKey({
+      url: input.url,
+      method: method2,
+      requestBodyHash
+    });
+    const existingFlow = this.inFlight.get(pendingKey);
+    if (existingFlow !== void 0) {
+      return existingFlow;
     }
-    const flow = this.run(params).finally(() => {
-      this.inFlight.delete(params.url);
+    const flow = this.run(input, {
+      method: method2,
+      requestBodyHash,
+      pendingKey
+    }).finally(() => {
+      this.inFlight.delete(pendingKey);
     });
-    this.inFlight.set(params.url, flow);
+    this.inFlight.set(pendingKey, flow);
     return flow;
   }
-  async run(params) {
-    const { url: url2 } = params;
-    const pending = this.pending.get(url2);
-    if (pending !== void 0) {
-      const expired = this.nowMs() - pending.challengeAtMs > this.pendingTtlMs;
-      if (pending.unresolved || expired) {
-        if (params.forceNewPayment === true) {
-          this.untrack(url2);
-        } else {
-          const outcome = await this.paymentStatusFor(pending.paymentId);
-          if (outcome === "not_settled") {
-            this.untrack(url2);
-          } else if (outcome === "settled") {
-            throw new PaidFetchError(
-              "payment_already_settled",
-              `the previous payment for this URL settled (paymentId=${pending.paymentId}) but the content delivery was lost, and the signature can no longer be retried. Calling again with forceNewPayment=true will PAY A SECOND TIME for the same resource.`,
-              { paymentId: pending.paymentId }
-            );
-          } else {
-            throw new PaidFetchError(
-              "payment_outcome_unknown",
-              `a previously signed payment for this URL (paymentId=${pending.paymentId}) has an unknown outcome. Verify whether it settled before purchasing again; to pay again anyway, call this tool with forceNewPayment=true.`,
-              { paymentId: pending.paymentId }
-            );
-          }
-        }
-      } else {
-        return this.deliver(url2, pending, {
-          retried: true,
-          budgetBefore: null
-        });
+  async run(input, computed) {
+    const { method: method2, 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
+      );
+    }
+    if (existingPending !== void 0 && input.forceNewPayment === true) {
+      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
+        );
       }
     }
-    const challengeAtMs = this.nowMs();
-    const first = await this.fetchImpl(url2);
-    const firstText = await first.text();
-    if (first.status !== 402) {
-      return {
-        paid: false,
-        status: first.status,
-        body: this.truncated(firstText)
-      };
+    const init = {
+      method: method2,
+      ...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) {
+      return { paid: false, status: probe.status, body: await probe.text() };
     }
-    const challengeHeader = first.headers.get(PAYMENT_REQUIRED_HEADER);
-    if (challengeHeader === null) {
-      throw new PaidFetchError(
-        "invalid_challenge",
-        "402 response is missing the PAYMENT-REQUIRED header"
+    const selected = await this.selectRequirement(probe);
+    const cap = input.maxAmountRawUsdc ?? this.defaultMaxAmountRawUsdc;
+    if (selected.amountRawUsdc > cap) {
+      throw new StandardX402PayError(
+        "amount_exceeds_client_cap",
+        `the challenge demands ${selected.amountRawUsdc} raw USDC, above the client cap of ${cap}; nothing was paid`,
+        { amountRawUsdc: selected.amountRawUsdc.toString(), payTo: selected.payTo }
       );
     }
-    const requirement = decodePaymentRequiredHeader(challengeHeader).sublyRequirements[0];
-    if (requirement === void 0) {
-      throw new PaidFetchError(
-        "invalid_challenge",
-        "402 challenge contains no subly-yield-exact requirement"
+    let realized;
+    try {
+      realized = await this.realizer.ensureUsdcAvailable({
+        amountRawUsdc: selected.amountRawUsdc
+      });
+    } catch (error) {
+      throw new StandardX402PayError(
+        "realize_failed",
+        `could not realize yield to cover ${selected.amountRawUsdc} raw USDC: ${error instanceof Error ? error.message : String(error)}`,
+        error
       );
     }
-    const amountRawUsdc = BigInt(requirement.amountRawUsdc);
-    const maxAmountRawUsdc = params.maxAmountRawUsdc ?? this.defaultMaxAmountRawUsdc;
-    if (amountRawUsdc > maxAmountRawUsdc) {
-      throw new PaidFetchError(
-        "amount_exceeds_client_cap",
-        `the challenge demands ${formatRawUsdcAmount(amountRawUsdc)} USDC, above this tool call's cap of ${formatRawUsdcAmount(maxAmountRawUsdc)} USDC; nothing was paid. Raise maxAmountRawUsdc only if this price is expected.`,
-        {
-          amountRawUsdc: requirement.amountRawUsdc,
-          maxAmountRawUsdc: maxAmountRawUsdc.toString(),
-          payTo: requirement.payTo
-        }
+    const pendingRecord = {
+      key: pendingKey,
+      url: input.url,
+      method: method2,
+      requestBodyHash,
+      amountRawUsdc: selected.amountRawUsdc.toString(),
+      payTo: selected.payTo,
+      feePayer: selected.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 }
       );
     }
-    const budgetBefore = await this.fetchBudget();
-    const { headerValue, paymentId } = await this.signatureBuilder.buildPaymentSignatureHeader({
-      paymentRequiredHeader: challengeHeader,
-      httpMethod: "GET",
-      url: url2
-    });
-    const entry = {
-      headerValue,
-      paymentId,
-      amountUsdc: formatRawUsdcAmount(amountRawUsdc),
-      payTo: requirement.payTo,
-      challengeAtMs,
-      unresolved: false
+    let response;
+    try {
+      response = await this.x402Fetch(input.url, init, selected);
+    } 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 bodyText = 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 }
+      );
+    }
+    this.clearDelivered(pendingKey);
+    return {
+      paid: true,
+      status: response.status,
+      body: bodyText,
+      payment: {
+        amountRawUsdc: selected.amountRawUsdc.toString(),
+        payTo: selected.payTo,
+        feePayer: selected.feePayer,
+        realizedRawUsdc: realized.realizedRawUsdc.toString(),
+        realizeTxSignature: realized.txSignature
+      }
     };
-    this.track(url2, entry);
-    return this.deliver(url2, entry, { retried: false, budgetBefore });
   }
-  /**
-   * Sends the signed PAYMENT-SIGNATURE retry. The tracked entry is removed
-   * only on confirmed delivery (200). A fresh 402 proves the signature can no
-   * longer settle, so the entry is kept as an unresolved marker; every other
-   * failure keeps it retryable so the next call reuses the same signature.
-   */
-  async deliver(url2, entry, params) {
-    let second;
-    let secondText;
+  /** 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 {
-      second = await this.fetchImpl(url2, {
-        headers: { [PAYMENT_SIGNATURE_HEADER]: entry.headerValue }
+      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
       });
-      secondText = await second.text();
     } catch (error) {
-      throw new PaidFetchError(
-        "delivery_failed_payment_pending",
-        `delivery request failed in flight (${error instanceof Error ? error.message : String(error)}); the payment (paymentId=${entry.paymentId}) is already signed and may settle. Call this tool again with the same URL to retry delivery with the same payment signature \u2014 do NOT treat this as unpaid.`,
-        { paymentId: entry.paymentId }
+      throw new StandardX402PayError(
+        "no_payable_requirement",
+        error instanceof Error ? error.message : String(error),
+        error
       );
     }
-    if (second.status === 200) {
-      this.untrack(url2);
-      const transaction = receiptTransaction(second.headers);
-      return {
-        paid: true,
-        status: second.status,
-        body: this.truncated(secondText),
-        ...params.retried ? { retriedPendingPayment: true } : {},
-        payment: {
-          amountUsdc: entry.amountUsdc,
-          payTo: entry.payTo,
-          paymentId: entry.paymentId,
-          transaction,
-          solscanUrl: transaction === null ? null : `https://solscan.io/tx/${transaction}`,
-          budgetBefore: params.budgetBefore,
-          budgetAfter: await this.fetchBudget()
-        }
-      };
+  }
+  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;
+    }
+  }
+  markUnknown(key, detail) {
+    const current = this.pending.get(key);
+    if (current === void 0) {
+      return;
     }
-    if (second.status === 402) {
-      entry.unresolved = true;
+    const next = {
+      ...current,
+      status: "external_outcome_unknown",
+      updatedAtMs: this.nowMs(),
+      detail
+    };
+    this.pending.set(key, next);
+    try {
       this.persist();
-      throw new PaidFetchError(
-        "payment_outcome_unknown",
-        `the seller no longer accepts the signed payment (paymentId=${entry.paymentId}); it may or may not have settled. Verify the payment before purchasing again; to pay again anyway, call this tool with forceNewPayment=true.`,
-        { paymentId: entry.paymentId }
-      );
+    } catch (error) {
+      this.pending.set(key, current);
+      throw error;
+    }
+  }
+  tryMarkUnknown(key, detail) {
+    try {
+      this.markUnknown(key, detail);
+      return null;
+    } catch (error) {
+      return error;
     }
-    throw new PaidFetchError(
-      "delivery_failed_payment_pending",
-      `paid delivery failed with ${second.status} (paymentId=${entry.paymentId}); the payment may already have settled. Call this tool again with the same URL to retry delivery with the same payment signature \u2014 do NOT treat this as unpaid.`,
-      {
-        paymentId: entry.paymentId,
-        status: second.status,
-        body: this.truncated(secondText)
-      }
-    );
   }
-  track(url2, entry) {
-    if (!this.pending.has(url2) && this.pending.size >= this.maxTrackedUrls) {
-      const oldest = this.pending.keys().next();
-      if (!oldest.done) {
-        this.pending.delete(oldest.value);
+  untrack(key) {
+    const previous = this.pending.get(key);
+    const existed = previous !== void 0;
+    this.pending.delete(key);
+    try {
+      this.persist();
+    } catch (error) {
+      if (existed) {
+        this.pending.set(key, previous);
       }
+      throw error;
     }
-    this.pending.set(url2, entry);
-    this.persist();
   }
-  untrack(url2) {
-    this.pending.delete(url2);
-    this.persist();
+  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.entries()].map(([url2, entry]) => ({ url: url2, ...entry }))
-    );
-  }
-  truncated(text) {
-    return text.length > this.maxBodyChars ? `${text.slice(0, this.maxBodyChars)}
-... (truncated)` : text;
+    this.stateStore.save([...this.pending.values()]);
   }
 };
-function receiptTransaction(headers) {
-  try {
-    const receiptHeader = headers.get(PAYMENT_RESPONSE_HEADER);
-    if (receiptHeader === null) {
-      return null;
+function pendingPaymentKey(input) {
+  return `${input.method}:${input.url}:${input.requestBodyHash}`;
+}
+
+// ../../src/client/relayer-payer.ts
+function createRelayerX402Payer(config) {
+  const realizer = new RelayerYieldRealizer({
+    facilitatorBaseUrl: config.facilitatorBaseUrl,
+    signer: config.signer,
+    rpc: config.rpc
+  });
+  return new StandardX402Payer({
+    realizer,
+    x402Fetch: config.x402Fetch,
+    defaultMaxAmountRawUsdc: config.defaultMaxAmountRawUsdc,
+    ...config.stateStore === void 0 ? {} : { stateStore: config.stateStore }
+  });
+}
+
+// ../../src/client/standard-x402-state-store.ts
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+function fileStandardX402StateStore(path) {
+  return {
+    load() {
+      let text;
+      try {
+        text = readFileSync(path, "utf8");
+      } catch (error) {
+        if (isMissingFileError(error)) {
+          return [];
+        }
+        throw error;
+      }
+      const parsed = JSON.parse(text);
+      if (!Array.isArray(parsed)) {
+        throw new Error(`pending payment state is not an array: ${path}`);
+      }
+      for (const [index, record] of parsed.entries()) {
+        if (!isPendingPaymentRecord(record)) {
+          throw new Error(
+            `pending payment state has an invalid record at index ${index}: ${path}`
+          );
+        }
+      }
+      return parsed;
+    },
+    save(records) {
+      const directory = dirname(path);
+      mkdirSync(directory, { recursive: true });
+      const tempPath = join(
+        directory,
+        `.${basename(path)}.${process.pid}.${Date.now()}.tmp`
+      );
+      writeFileSync(tempPath, JSON.stringify(records, null, 2));
+      renameSync(tempPath, path);
     }
-    const receipt = decodeX402Header(receiptHeader);
-    return typeof receipt.transaction === "string" && receipt.transaction.length > 0 ? receipt.transaction : null;
-  } catch {
-    return null;
+  };
+}
+function isMissingFileError(error) {
+  return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+function isPendingPaymentRecord(value) {
+  if (value === null || typeof value !== "object") {
+    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";
 }
 
-// src/solana/keys.ts
-import { readFileSync } from "node:fs";
+// ../../src/solana/keys.ts
+import { readFileSync as readFileSync2 } from "node:fs";
 import bs586 from "bs58";
 import {
   createKeyPairSignerFromBytes
@@ -1452,7 +1947,7 @@ async function loadKeyPairSigner(params) {
     return createKeyPairSignerFromBytes(bytes);
   }
   if (jsonFilePath !== void 0 && jsonFilePath.length > 0) {
-    const raw = JSON.parse(readFileSync(jsonFilePath, "utf8"));
+    const raw = JSON.parse(readFileSync2(jsonFilePath, "utf8"));
     if (!Array.isArray(raw) || raw.length !== 64) {
       throw new Error(`${label} keypair file must be a 64-byte JSON array`);
     }
@@ -1460,304 +1955,127 @@ async function loadKeyPairSigner(params) {
   }
   throw new Error(`${label} keypair is not configured`);
 }
+function loadSecretKeyBytes(params) {
+  const { base58Secret, jsonFilePath, label } = params;
+  if (base58Secret !== void 0 && base58Secret.length > 0) {
+    const bytes = bs586.decode(base58Secret);
+    if (bytes.length !== 64) {
+      throw new Error(`${label} base58 secret must decode to 64 bytes`);
+    }
+    return bytes;
+  }
+  if (jsonFilePath !== void 0 && jsonFilePath.length > 0) {
+    const raw = JSON.parse(readFileSync2(jsonFilePath, "utf8"));
+    if (!Array.isArray(raw) || raw.length !== 64) {
+      throw new Error(`${label} keypair file must be a 64-byte JSON array`);
+    }
+    return Uint8Array.from(raw);
+  }
+  throw new Error(`${label} keypair is not configured`);
+}
 
-// src/solana/rpc.ts
+// ../../src/solana/rpc.ts
 import { createSolanaRpc } from "@solana/kit";
 function createRpc(url2) {
   return createSolanaRpc(url2);
 }
 
-// src/x402/client.ts
-var X402ClientError = class extends Error {
-  reason;
-  detail;
-  constructor(reason, message, detail) {
-    super(message);
-    this.name = "X402ClientError";
-    this.reason = reason;
-    this.detail = detail;
-  }
-};
-var SublyX402Client = class {
-  config;
-  signer;
-  lookupTablesFor;
-  fetchImpl;
-  constructor(config) {
-    this.config = {
-      facilitatorBaseUrl: config.facilitatorBaseUrl.replace(/\/$/, ""),
-      network: config.network ?? SOLANA_MAINNET_NETWORK
-    };
-    this.signer = config.signer;
-    this.lookupTablesFor = config.lookupTablesFor ?? null;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-  }
-  /**
-   * Builds the PAYMENT-SIGNATURE header for a 402 challenge. The request
-   * method, URL, and body must be exactly the request being retried; they are
-   * bound into the payment and verified again by the seller and facilitator.
-   */
-  async buildPaymentSignatureHeader(input) {
-    const requirement = this.selectRequirement(input.paymentRequiredHeader);
-    if (requirement.resource !== input.url) {
-      throw new X402ClientError(
-        "resource_mismatch",
-        "PAYMENT-REQUIRED resource does not match the request URL"
-      );
-    }
-    const requestBodyHash = requestBodyHashFor(input.body);
-    const prepared = await this.preparePayment({
-      requirement,
-      httpMethod: input.httpMethod.toUpperCase(),
-      requestBodyHash
-    });
-    const lookupTables = this.lookupTablesFor === null ? void 0 : await this.lookupTablesFor(prepared.intentJson.serializedTransaction);
-    const signed = await this.signer.signPayment({
-      intent: prepared.intentJson.signingIntent,
-      serializedTransaction: prepared.intentJson.serializedTransaction,
-      lookupTables
-    });
-    const payload = {
-      x402Version: X402_VERSION,
-      scheme: requirement.scheme,
-      network: requirement.network,
-      payload: {
-        paymentId: prepared.paymentId,
-        requestBindingHash: prepared.requestBindingHash,
-        preparedMessageHash: prepared.preparedMessageHash,
-        serializedTransaction: signed.serializedTransaction,
-        agentSignature: signed.agentSignature,
-        temporarySettlementSignature: prepared.temporarySettlementSignature
-      }
-    };
-    return {
-      headerValue: encodeX402Header(payload),
-      paymentId: prepared.paymentId
-    };
-  }
-  /**
-   * Convenience wrapper: performs the request, and on a 402 with a Subly
-   * requirement pays from vault yield and retries once.
-   */
-  async fetchWithPayment(url2, init) {
-    const first = await this.fetchImpl(url2, init);
-    if (first.status !== 402) {
-      return first;
-    }
-    const challenge = first.headers.get(PAYMENT_REQUIRED_HEADER);
-    if (challenge === null) {
-      return first;
-    }
-    const { headerValue } = await this.buildPaymentSignatureHeader({
-      paymentRequiredHeader: challenge,
-      httpMethod: init?.method ?? "GET",
-      url: url2,
-      body: init?.body ?? null
-    });
-    return this.fetchImpl(url2, {
-      ...init,
-      headers: {
-        ...init?.headers,
-        [PAYMENT_SIGNATURE_HEADER]: headerValue
-      }
-    });
-  }
-  selectRequirement(paymentRequiredHeader) {
-    let sublyRequirements;
-    try {
-      sublyRequirements = decodePaymentRequiredHeader(
-        paymentRequiredHeader
-      ).sublyRequirements;
-    } catch (error) {
-      throw new X402ClientError(
-        error instanceof X402HeaderError ? error.reason : "invalid_challenge",
-        "Cannot decode the PAYMENT-REQUIRED header"
-      );
-    }
-    const selected = sublyRequirements.find(
-      (candidate) => candidate.network === this.config.network && candidate.extra.vault === SUBLY_VAULT.address && candidate.extra.shareMint === SUBLY_VAULT.shareMint && candidate.asset === SUBLY_VAULT.usdcMint
-    ) ?? null;
-    if (selected === null) {
-      throw new X402ClientError(
-        "no_supported_requirement",
-        "The 402 challenge contains no supported subly-yield-exact requirement"
-      );
-    }
-    return selected;
-  }
-  async preparePayment(input) {
-    const { requirement } = input;
-    const wallet = this.signer.walletAddress;
-    const prepareUrl = `${this.config.facilitatorBaseUrl}/v1/payments/prepare`;
-    const prepareBody = JSON.stringify({
-      wallet,
-      scheme: requirement.scheme,
-      network: requirement.network,
-      vault: requirement.extra.vault,
-      shareMint: requirement.extra.shareMint,
-      asset: requirement.asset,
-      seller: requirement.extra.seller,
-      sellerRequestId: requirement.extra.sellerRequestId,
-      httpMethod: input.httpMethod,
-      canonicalResourceUrl: requirement.resource,
-      requestBodyHash: input.requestBodyHash,
-      amountRawUsdc: requirement.amountRawUsdc,
-      payTo: requirement.payTo,
-      sellerUsdcAta: requirement.extra.sellerUsdcAta,
-      dustRecipientUsdcAta: deriveAssociatedTokenAddress({
-        owner: wallet,
-        mint: SUBLY_VAULT.usdcMint
-      })
-    });
-    const response = await this.fetchImpl(prepareUrl, {
-      method: "POST",
-      headers: {
-        ...await walletAuthHeaders({
-          signer: this.signer,
-          method: "POST",
-          url: prepareUrl,
-          body: prepareBody
-        }),
-        "content-type": "application/json"
-      },
-      body: prepareBody
+// src/svm-x402-fetch.ts
+import { createKeyPairSignerFromBytes as createKeyPairSignerFromBytes2 } from "@solana/kit";
+import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
+import { ExactSvmScheme, toClientSvmSigner } from "@x402/svm";
+async function createSvmX402Fetch(params) {
+  const signer2 = toClientSvmSigner(
+    await createKeyPairSignerFromBytes2(params.agentSecretKey)
+  );
+  return (url2, init, expected) => {
+    const wrapped = wrapFetchWithPaymentFromConfig(fetch, {
+      schemes: [
+        {
+          network: expected.requirement.network,
+          client: new ExactSvmScheme(signer2, { rpcUrl: params.rpcUrl })
+        }
+      ],
+      paymentRequirementsSelector: (_x402Version, requirements) => selectExpectedRequirement(requirements, expected)
     });
-    const body = await response.json();
-    if (response.status !== 200) {
-      const error = body.error;
-      throw new X402ClientError(
-        typeof error?.code === "string" ? error.code : "prepare_failed",
-        "Payment preparation failed at the facilitator",
-        body
-      );
-    }
-    const prepared = body;
-    if (typeof prepared.paymentId !== "string" || typeof prepared.preparedMessageHash !== "string" || typeof prepared.intentJson?.serializedTransaction !== "string" || typeof prepared.intentJson?.signingIntent !== "object") {
-      throw new X402ClientError(
-        "invalid_prepare_response",
-        "Facilitator prepare response is missing required fields"
-      );
-    }
-    return prepared;
+    return wrapped(url2, init);
+  };
+}
+function selectExpectedRequirement(requirements, expected) {
+  const match = requirements.find(
+    (candidate) => standardRequirementMatchesSelected(candidate, expected)
+  );
+  if (match === void 0) {
+    throw new Error(
+      "x402 challenge changed after preflight; refusing to pay an unchecked requirement"
+    );
   }
-};
+  return match;
+}
 
-// demo/shared.ts
+// src/pay.ts
 function fail(message) {
-  console.error(message);
+  process.stderr.write(`${message}
+`);
   process.exit(1);
 }
-
-// demo/pay.ts
 var url = process.argv[2];
 if (url === void 0 || !/^https?:\/\//.test(url)) {
-  fail("Usage: npm run demo:pay -- <url> [maxAmountRawUsdc]");
+  fail("Usage: pay fetch <url> [maxAmountRawUsdc]");
 }
 var maxAmountArg = process.argv[3];
-var facilitatorBaseUrl = process.env.SUBLY_FACILITATOR_URL ?? "https://api.demo.sublyfi.com";
+var relayerBaseUrl = process.env.SUBLY_RELAYER_URL ?? process.env.SUBLY_FACILITATOR_URL ?? "https://api.demo.sublyfi.com";
 var rpcUrl = process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com";
 var defaultMaxAmountRawUsdc = process.env.SUBLY_MCP_MAX_AMOUNT_RAW_USDC === void 0 ? 10000n : BigInt(process.env.SUBLY_MCP_MAX_AMOUNT_RAW_USDC);
-var pendingStatePath = process.env.SUBLY_MCP_STATE_PATH ?? "demo/env/mcp-pending-payments.json";
+var pendingStatePath = process.env.SUBLY_MCP_STATE_PATH ?? join2(homedir(), ".subly", "standard-x402-pending.json");
 var keyPairSigner = await loadKeyPairSigner({
   base58Secret: process.env.SUBLY_DEMO_AGENT_KEYPAIR,
   jsonFilePath: process.env.SUBLY_DEMO_AGENT_KEYPAIR_PATH,
   label: "SUBLY_DEMO_AGENT_KEYPAIR"
 });
+var agentSecretKey = loadSecretKeyBytes({
+  base58Secret: process.env.SUBLY_DEMO_AGENT_KEYPAIR,
+  jsonFilePath: process.env.SUBLY_DEMO_AGENT_KEYPAIR_PATH,
+  label: "SUBLY_DEMO_AGENT_KEYPAIR"
+});
 var signer = new LocalKeypairAgentWalletSigner(keyPairSigner);
 var rpc = createRpc(rpcUrl);
-async function fetchBudget() {
-  try {
-    const budgetUrl = `${facilitatorBaseUrl}/v1/wallets/${signer.walletAddress}/budget`;
-    const response = await fetch(budgetUrl, {
-      headers: await walletAuthHeaders({ signer, method: "GET", url: budgetUrl })
-    });
-    if (response.status !== 200) {
-      return null;
-    }
-    const body = await response.json();
-    return body.budget === void 0 ? null : {
-      positionValueUsdc: formatRawUsdcAmount(body.budget.positionValueRawUsdc),
-      spendableYieldUsdc: formatRawUsdcAmount(
-        body.budget.spendableYieldRawUsdc
-      )
-    };
-  } catch {
-    return null;
-  }
-}
-async function paymentStatusFor(paymentId) {
-  try {
-    const statusUrl = `${facilitatorBaseUrl}/v1/payments/${paymentId}`;
-    const response = await fetch(statusUrl, {
-      headers: await walletAuthHeaders({ signer, method: "GET", url: statusUrl })
-    });
-    if (response.status !== 200) {
-      return "indeterminate";
-    }
-    const body = await response.json();
-    if (body.status === "settled") {
-      return "settled";
-    }
-    if (body.status === "expired" || body.status === "failed" || body.status === "failed_not_submitted") {
-      return "not_settled";
-    }
-    return "indeterminate";
-  } catch {
-    return "indeterminate";
-  }
-}
-function fileStateStore(path) {
-  return {
-    load() {
-      try {
-        const parsed = JSON.parse(readFileSync2(path, "utf8"));
-        return Array.isArray(parsed) ? parsed : [];
-      } catch {
-        return [];
-      }
-    },
-    save(records) {
-      try {
-        writeFileSync(path, JSON.stringify(records));
-      } catch (error) {
-        console.error(
-          `[subly-pay] failed to persist pending payments: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  };
-}
-var service = new PaidFetchService({
-  signatureBuilder: new SublyX402Client({
-    facilitatorBaseUrl,
-    signer,
-    lookupTablesFor: (serializedTransaction) => fetchLookupTablesForTransaction(rpc, serializedTransaction)
-  }),
+var payer = createRelayerX402Payer({
+  facilitatorBaseUrl: relayerBaseUrl,
+  signer,
+  rpc,
+  x402Fetch: await createSvmX402Fetch({ agentSecretKey, rpcUrl }),
   defaultMaxAmountRawUsdc,
-  fetchBudget,
-  paymentStatusFor,
-  stateStore: fileStateStore(pendingStatePath)
+  stateStore: fileStandardX402StateStore(pendingStatePath)
 });
-console.error(`[subly-pay] agent ${signer.walletAddress} -> ${facilitatorBaseUrl}`);
+var method = process.env.SUBLY_PAY_METHOD;
+var body = process.env.SUBLY_PAY_BODY;
+console.error(`[pay] agent ${signer.walletAddress} -> ${url}`);
 try {
-  await ensureWalletOnboarded({ facilitatorBaseUrl, signer });
+  await ensureWalletOnboarded({ facilitatorBaseUrl: relayerBaseUrl, signer });
 } catch (error) {
   console.error(
-    `[subly-pay] onboarding skipped: ${error instanceof Error ? error.message : String(error)}`
+    `[pay] onboarding skipped: ${error instanceof Error ? error.message : String(error)}`
   );
 }
 try {
-  const result = await service.paidFetch({
+  const result = await payer.pay({
     url,
-    ...maxAmountArg === void 0 ? {} : { maxAmountRawUsdc: BigInt(maxAmountArg) }
+    ...method === void 0 ? {} : { method },
+    ...body === void 0 ? {} : { body, headers: { "content-type": "application/json" } },
+    ...maxAmountArg === void 0 ? {} : { maxAmountRawUsdc: BigInt(maxAmountArg) },
+    ...process.env.SUBLY_PAY_FORCE_NEW_PAYMENT === "1" ? { forceNewPayment: true } : {}
   });
   process.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
+  if (!result.paid) {
+    process.exit(1);
+  }
 } catch (error) {
-  if (error instanceof PaidFetchError) {
+  if (error instanceof StandardX402PayError) {
     process.stdout.write(
       `${JSON.stringify(
-        { paid: false, refused: true, reason: error.reason, message: error.message, detail: error.detail },
+        { paid: false, reason: error.reason, message: error.message },
         null,
         2
       )}
@@ -1765,5 +2083,5 @@ try {
     );
     process.exit(1);
   }
-  fail(`[subly-pay] ${error instanceof Error ? error.message : String(error)}`);
+  fail(`[pay] ${error instanceof Error ? error.message : String(error)}`);
 }