@subly_fi/pay 0.2.0 → 0.3.0

package/dist/mcp-server.js

@@ -1,16 +1,8 @@
-// demo/mcp-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/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,
@@ -25,7 +17,7 @@ import {
   setTransactionMessageLifetimeUsingBlockhash
 } from "@solana/kit";
 
-// src/lib/hash.ts
+// ../../src/lib/hash.ts
 import { createHash } from "node:crypto";
 function sha256TaggedHex(data) {
   return `sha256-${createHash("sha256").update(data).digest("hex")}`;
@@ -50,7 +42,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"));
 }
@@ -70,11 +62,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";
@@ -90,7 +82,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,
@@ -105,7 +97,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");
@@ -197,7 +189,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";
@@ -883,7 +875,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;
@@ -953,7 +945,15 @@ var LocalKeypairAgentWalletSigner = class {
   }
 };
 
-// src/api/wallet-auth.ts
+// ../../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/api/wallet-auth.ts
 import { createHash as createHash3 } from "node:crypto";
 import bs585 from "bs58";
 import nacl from "tweetnacl";
@@ -971,7 +971,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({
@@ -987,7 +987,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) {
@@ -1044,187 +1044,7 @@ async function ensureWalletOnboarded(params) {
   await post("sync", `/v1/wallets/${wallet}/sync`, { source: "chain" });
 }
 
-// src/client/standard-x402-factory.ts
-import { createX402Client } from "x402-solana/client";
-
-// src/client/relayer-yield-realizer.ts
-import { address as address2 } from "@solana/kit";
-
-// 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/relayer-yield-realizer.ts
-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 {
-  config;
-  signer;
-  rpc;
-  fetchImpl;
-  lookupTablesFor;
-  constructor(config) {
-    this.config = {
-      facilitatorBaseUrl: config.facilitatorBaseUrl.replace(/\/$/, ""),
-      usdcMint: config.usdcMint ?? SUBLY_VAULT.usdcMint
-    };
-    this.signer = config.signer;
-    this.rpc = config.rpc;
-    this.fetchImpl = config.fetchImpl ?? fetch;
-    this.lookupTablesFor = config.lookupTablesFor ?? ((serializedTransaction) => fetchLookupTablesForTransaction(this.rpc, serializedTransaction));
-  }
-  async ensureUsdcAvailable(input) {
-    const agentAta = deriveAssociatedTokenAddress({
-      owner: this.signer.walletAddress,
-      mint: this.config.usdcMint
-    });
-    const currentBalance = await this.readTokenBalance(agentAta);
-    if (currentBalance >= input.amountRawUsdc) {
-      return { realizedRawUsdc: 0n, txSignature: null };
-    }
-    const shortfallRawUsdc = input.amountRawUsdc - currentBalance;
-    await this.assertSpendableYield(shortfallRawUsdc);
-    const prepared = await this.postJson("/v1/withdrawals/prepare", {
-      wallet: this.signer.walletAddress,
-      amountRawUsdc: shortfallRawUsdc.toString()
-    });
-    const signed = await this.signer.signWithdrawal({
-      intent: prepared.signingIntent,
-      serializedTransaction: prepared.serializedTransaction,
-      lookupTables: await this.lookupTablesFor(prepared.serializedTransaction)
-    });
-    const submitted = await this.postJson("/v1/withdrawals/submit", {
-      withdrawalId: prepared.withdrawalId,
-      serializedTransaction: signed.serializedTransaction,
-      agentSignature: signed.agentSignature
-    });
-    if (submitted.status !== "confirmed" || submitted.txSignature === null) {
-      throw new RelayerRealizeError(
-        "realize_not_confirmed",
-        `yield realize withdrawal did not confirm (status=${submitted.status})`,
-        submitted
-      );
-    }
-    return {
-      realizedRawUsdc: BigInt(submitted.actualWithdrawRawUsdc ?? "0"),
-      txSignature: submitted.txSignature
-    };
-  }
-  /** Refuses to realize more than the ledger's spendable yield (principal). */
-  async assertSpendableYield(shortfallRawUsdc) {
-    const url = `${this.config.facilitatorBaseUrl}/v1/wallets/${this.signer.walletAddress}/budget`;
-    let response;
-    try {
-      response = await this.fetchImpl(url, {
-        headers: await walletAuthHeaders({
-          signer: this.signer,
-          method: "GET",
-          url
-        })
-      });
-    } catch (error) {
-      throw new RelayerRealizeError(
-        "budget_unavailable",
-        "could not read the spendable-yield budget",
-        error
-      );
-    }
-    if (response.status !== 200) {
-      throw new RelayerRealizeError(
-        "budget_unavailable",
-        `budget endpoint returned ${response.status}`
-      );
-    }
-    const body = await response.json();
-    const spendable = BigInt(body.budget?.spendableYieldRawUsdc ?? "0");
-    if (spendable < shortfallRawUsdc) {
-      throw new RelayerRealizeError(
-        "insufficient_yield",
-        `spendable yield ${spendable} cannot cover ${shortfallRawUsdc} raw USDC; the principal is never spent \u2014 wait for more yield`,
-        { spendableYieldRawUsdc: spendable.toString() }
-      );
-    }
-  }
-  async postJson(path, body) {
-    const url = `${this.config.facilitatorBaseUrl}${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) {
-      throw new RelayerRealizeError(
-        path.endsWith("/submit") ? "submit_failed" : "prepare_failed",
-        `${path} failed with ${response.status}: ${text}`
-      );
-    }
-    return JSON.parse(text);
-  }
-  async readTokenBalance(ata) {
-    try {
-      const response = await this.rpc.getTokenAccountBalance(address2(ata), { commitment: "confirmed" }).send();
-      return BigInt(response.value.amount);
-    } catch {
-      return 0n;
-    }
-  }
-};
-
-// src/x402/headers.ts
+// ../../src/x402/headers.ts
 import { z } from "zod";
 var PAYMENT_REQUIRED_HEADER = "payment-required";
 var MAX_HEADER_JSON_BYTES = 16384;
@@ -1291,7 +1111,17 @@ function decodeX402Header(headerValue) {
   }
 }
 
-// src/x402/standard-requirements.ts
+// ../../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/x402/standard-requirements.ts
 import { z as z2 } from "zod";
 var STANDARD_EXACT_SCHEME = "exact";
 var standardExactRequirementSchema = z2.object({
@@ -1373,7 +1203,7 @@ function selectPayableSolanaRequirement(requirements, options) {
   };
 }
 
-// src/client/standard-x402-payer.ts
+// ../../src/client/standard-x402-payer.ts
 var StandardX402PayError = class extends Error {
   constructor(reason, message, detail = null) {
     super(message);
@@ -1486,53 +1316,399 @@ var StandardX402Payer = class {
   }
 };
 
-// src/client/web3-wallet-adapter.ts
-import { Keypair } from "@solana/web3.js";
-function createX402WalletAdapter(secretKey) {
-  if (secretKey.length !== 64) {
-    throw new Error("agent secret key must be 64 bytes");
+// ../../src/client/mcp-payment-server.ts
+var TOOL_NAME = "fetch_with_subly_payment";
+var SERVER_INSTRUCTIONS = `Subly lets an agent pay for ANY standard x402 (HTTP 402) paid API from its wallet's Kamino vault YIELD \u2014 the deposited principal is never spent, and the seller needs no Subly integration.
+
+Before payments can succeed the operator of this server must have, once:
+1. A Solana keypair for the agent wallet. Subly does NOT create wallets; make one with \`solana-keygen new -o agent.json\` (or export a keypair from an existing wallet) and point SUBLY_DEMO_AGENT_KEYPAIR_PATH at it. The private key never leaves that file; this server only signs locally with it.
+2. Funded that wallet with USDC on Solana mainnet (no SOL needed \u2014 realize fees are sponsored) and deposited into the vault (see the project's deposit command). The vault minimum deposit is 1 USDC.
+3. Waited for yield to accrue; a payment needs the seller's price of spendable yield.
+
+Then use fetch_with_subly_payment(url) to GET or POST a paid resource from any x402 seller (e.g. Nansen): it realizes just enough yield to the agent's USDC ATA and pays the seller's standard x402 challenge, returning the body plus the payment details. If it returns insufficient_yield, that is expected \u2014 wait for yield, do not loop.`;
+async function runMcpPaymentServer(config) {
+  const { payer: payer2, signer: signer2, facilitatorBaseUrl: facilitatorBaseUrl2, defaultMaxAmountRawUsdc: defaultMaxAmountRawUsdc2 } = config;
+  const server = new Server(
+    { name: "subly-payments", version: config.serverVersion ?? "0.3.0" },
+    { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, () => ({
+    tools: [
+      {
+        name: TOOL_NAME,
+        description: `Fetch a URL (GET or POST), automatically paying a standard x402 (HTTP 402) challenge from any x402-compatible seller (Nansen, etc.) out of the agent wallet's Kamino vault yield. Subly realizes just enough yield to the agent's USDC ATA (sponsored) and pays the seller's Solana USDC \`exact\` challenge; the seller needs no Subly integration. Returns the response body and, when a payment was made, the payment details (amount, payee, realize tx). Challenges above maxAmountRawUsdc (default ${defaultMaxAmountRawUsdc2} raw = ${formatRawUsdcAmount(
+          defaultMaxAmountRawUsdc2
+        )} USDC) are refused without paying. Payments are refused when the spendable yield budget cannot cover them \u2014 the principal is never spent. Use only for URLs you intend to purchase access to.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "URL to fetch. Must match the seller's resource URL exactly."
+            },
+            method: {
+              type: "string",
+              description: "HTTP method (default GET). Some x402 sellers deliver the paid resource over POST (e.g. an API that takes a JSON body)."
+            },
+            body: {
+              type: "string",
+              description: "Request body sent on both the probe and the paid retry. Provide a JSON string for POST sellers; sent as content-type application/json unless headers override it."
+            },
+            headers: {
+              type: "object",
+              description: "Extra request headers (object of string values), merged into both the probe and the paid retry.",
+              additionalProperties: { type: "string" }
+            },
+            maxAmountRawUsdc: {
+              type: "string",
+              description: 'Refuse (without paying) any challenge above this amount in raw USDC units (6 decimals, e.g. "10000" = 0.01 USDC). Defaults to the server-side cap.'
+            }
+          },
+          required: ["url"]
+        },
+        annotations: {
+          title: "Fetch with Subly payment",
+          readOnlyHint: false,
+          destructiveHint: true,
+          idempotentHint: false,
+          openWorldHint: true
+        }
+      }
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name !== TOOL_NAME) {
+      return {
+        content: [{ type: "text", text: `unknown tool: ${request.params.name}` }],
+        isError: true
+      };
+    }
+    const args = request.params.arguments ?? {};
+    const url = args.url;
+    if (typeof url !== "string" || url.length === 0) {
+      return {
+        content: [{ type: "text", text: "missing required argument: url" }],
+        isError: true
+      };
+    }
+    let maxAmountRawUsdc;
+    if (args.maxAmountRawUsdc !== void 0) {
+      const raw = args.maxAmountRawUsdc;
+      try {
+        if (typeof raw !== "string" && typeof raw !== "number") {
+          throw new TypeError("not a string or number");
+        }
+        maxAmountRawUsdc = BigInt(raw);
+      } catch {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "maxAmountRawUsdc must be an integer raw USDC amount"
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    const method = typeof args.method === "string" ? args.method : void 0;
+    const body = typeof args.body === "string" ? args.body : void 0;
+    const headers = args.headers !== null && typeof args.headers === "object" && !Array.isArray(args.headers) ? Object.fromEntries(
+      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 }
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      if (error instanceof StandardX402PayError) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  paid: false,
+                  refused: true,
+                  reason: error.reason,
+                  message: error.message,
+                  detail: error.detail
+                },
+                null,
+                2
+              )
+            }
+          ],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: error instanceof Error ? error.message : String(error)
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  try {
+    await ensureWalletOnboarded({ facilitatorBaseUrl: facilitatorBaseUrl2, 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 keypair = Keypair.fromSecretKey(secretKey);
-  return {
-    address: keypair.publicKey.toBase58(),
-    signTransaction: async (tx) => {
-      tx.sign([keypair]);
-      return tx;
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(
+    `[subly-mcp] ready: agent wallet ${signer2.walletAddress}, relayer ${facilitatorBaseUrl2}, default cap ${formatRawUsdcAmount(defaultMaxAmountRawUsdc2)} USDC`
+  );
+}
+
+// ../../src/client/relayer-yield-realizer.ts
+import { address as address2 } from "@solana/kit";
+
+// ../../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/standard-x402-factory.ts
-function createStandardX402Payer(config) {
+// ../../src/client/relayer-yield-realizer.ts
+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 {
+  config;
+  signer;
+  rpc;
+  fetchImpl;
+  lookupTablesFor;
+  constructor(config) {
+    this.config = {
+      facilitatorBaseUrl: config.facilitatorBaseUrl.replace(/\/$/, ""),
+      usdcMint: config.usdcMint ?? SUBLY_VAULT.usdcMint,
+      forceRealizeFullAmount: config.forceRealizeFullAmount ?? false
+    };
+    this.signer = config.signer;
+    this.rpc = config.rpc;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+    this.lookupTablesFor = config.lookupTablesFor ?? ((serializedTransaction) => fetchLookupTablesForTransaction(this.rpc, serializedTransaction));
+  }
+  async ensureUsdcAvailable(input) {
+    const agentAta = deriveAssociatedTokenAddress({
+      owner: this.signer.walletAddress,
+      mint: this.config.usdcMint
+    });
+    let shortfallRawUsdc;
+    if (this.config.forceRealizeFullAmount) {
+      shortfallRawUsdc = input.amountRawUsdc;
+    } else {
+      const currentBalance = await this.readTokenBalance(agentAta);
+      if (currentBalance >= input.amountRawUsdc) {
+        return { realizedRawUsdc: 0n, txSignature: null };
+      }
+      shortfallRawUsdc = input.amountRawUsdc - currentBalance;
+    }
+    await this.assertSpendableYield(shortfallRawUsdc);
+    const prepared = await this.postJson("/v1/withdrawals/prepare", {
+      wallet: this.signer.walletAddress,
+      amountRawUsdc: shortfallRawUsdc.toString()
+    });
+    const signed = await this.signer.signWithdrawal({
+      intent: prepared.signingIntent,
+      serializedTransaction: prepared.serializedTransaction,
+      lookupTables: await this.lookupTablesFor(prepared.serializedTransaction)
+    });
+    let settled = await this.postJson("/v1/withdrawals/submit", {
+      withdrawalId: prepared.withdrawalId,
+      serializedTransaction: signed.serializedTransaction,
+      agentSignature: signed.agentSignature
+    });
+    if (settled.status === "submitted") {
+      settled = await this.pollUntilSettled(prepared.withdrawalId);
+    }
+    if (settled.status !== "confirmed" || settled.txSignature === null) {
+      throw new RelayerRealizeError(
+        "realize_not_confirmed",
+        `yield realize withdrawal did not confirm (status=${settled.status})`,
+        settled
+      );
+    }
+    return {
+      realizedRawUsdc: BigInt(settled.actualWithdrawRawUsdc ?? "0"),
+      txSignature: settled.txSignature
+    };
+  }
+  /** Refuses to realize more than the ledger's spendable yield (principal). */
+  async assertSpendableYield(shortfallRawUsdc) {
+    const url = `${this.config.facilitatorBaseUrl}/v1/wallets/${this.signer.walletAddress}/budget`;
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        headers: await walletAuthHeaders({
+          signer: this.signer,
+          method: "GET",
+          url
+        })
+      });
+    } catch (error) {
+      throw new RelayerRealizeError(
+        "budget_unavailable",
+        "could not read the spendable-yield budget",
+        error
+      );
+    }
+    if (response.status !== 200) {
+      throw new RelayerRealizeError(
+        "budget_unavailable",
+        `budget endpoint returned ${response.status}`
+      );
+    }
+    const body = await response.json();
+    const spendable = BigInt(body.budget?.spendableYieldRawUsdc ?? "0");
+    if (spendable < shortfallRawUsdc) {
+      throw new RelayerRealizeError(
+        "insufficient_yield",
+        `spendable yield ${spendable} cannot cover ${shortfallRawUsdc} raw USDC; the principal is never spent \u2014 wait for more yield`,
+        { spendableYieldRawUsdc: spendable.toString() }
+      );
+    }
+  }
+  /**
+   * Polls GET /v1/withdrawals/:id (which reconciles a submitted intent against
+   * the chain) until it leaves the "submitted" state or the timeout elapses.
+   */
+  async pollUntilSettled(withdrawalId, { timeoutMs = 9e4, intervalMs = 2500 } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    let latest = null;
+    while (Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+      const url = `${this.config.facilitatorBaseUrl}/v1/withdrawals/${withdrawalId}`;
+      const response = await this.fetchImpl(url, {
+        headers: await walletAuthHeaders({
+          signer: this.signer,
+          method: "GET",
+          url
+        })
+      });
+      if (response.status !== 200) {
+        continue;
+      }
+      latest = await response.json();
+      if (latest.status !== "submitted") {
+        return latest;
+      }
+    }
+    return latest ?? {
+      status: "submitted",
+      txSignature: null,
+      actualWithdrawRawUsdc: null
+    };
+  }
+  async postJson(path, body) {
+    const url = `${this.config.facilitatorBaseUrl}${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) {
+      throw new RelayerRealizeError(
+        path.endsWith("/submit") ? "submit_failed" : "prepare_failed",
+        `${path} failed with ${response.status}: ${text}`
+      );
+    }
+    return JSON.parse(text);
+  }
+  async readTokenBalance(ata) {
+    try {
+      const response = await this.rpc.getTokenAccountBalance(address2(ata), { commitment: "confirmed" }).send();
+      return BigInt(response.value.amount);
+    } catch {
+      return 0n;
+    }
+  }
+};
+
+// ../../src/client/relayer-payer.ts
+function createRelayerX402Payer(config) {
   const realizer = new RelayerYieldRealizer({
     facilitatorBaseUrl: config.facilitatorBaseUrl,
     signer: config.signer,
-    rpc: config.rpc
-  });
-  const client = createX402Client({
-    wallet: createX402WalletAdapter(config.agentSecretKey),
-    network: config.network ?? "solana",
-    rpcUrl: config.rpcUrl
+    rpc: config.rpc,
+    forceRealizeFullAmount: config.forceRealizeFullAmount ?? false
   });
-  const x402Fetch = (url, init) => client.fetch(url, init);
   return new StandardX402Payer({
     realizer,
-    x402Fetch,
+    x402Fetch: config.x402Fetch,
     defaultMaxAmountRawUsdc: config.defaultMaxAmountRawUsdc
   });
 }
 
-// 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/solana/keys.ts
+// ../../src/solana/keys.ts
 import { readFileSync } from "node:fs";
 import bs586 from "bs58";
 import {
@@ -1575,18 +1751,35 @@ function loadSecretKeyBytes(params) {
   throw new Error(`${label} keypair is not configured`);
 }
 
-// src/solana/rpc.ts
+// ../../src/solana/rpc.ts
 import { createSolanaRpc } from "@solana/kit";
 function createRpc(url) {
   return createSolanaRpc(url);
 }
 
-// demo/mcp-server.ts
-var TOOL_NAME = "fetch_with_subly_payment";
-var DEFAULT_MAX_AMOUNT_RAW_USDC = 10000n;
+// 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)
+  );
+  const wrapped = wrapFetchWithPaymentFromConfig(fetch, {
+    schemes: [
+      {
+        network: "solana:*",
+        client: new ExactSvmScheme(signer2, { rpcUrl: params.rpcUrl })
+      }
+    ]
+  });
+  return (url, init) => wrapped(url, init);
+}
+
+// src/mcp-server.ts
 var facilitatorBaseUrl = 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 ? DEFAULT_MAX_AMOUNT_RAW_USDC : BigInt(process.env.SUBLY_MCP_MAX_AMOUNT_RAW_USDC);
+var defaultMaxAmountRawUsdc = process.env.SUBLY_MCP_MAX_AMOUNT_RAW_USDC === void 0 ? 10000n : BigInt(process.env.SUBLY_MCP_MAX_AMOUNT_RAW_USDC);
 var keyPairSigner = await loadKeyPairSigner({
   base58Secret: process.env.SUBLY_DEMO_AGENT_KEYPAIR,
   jsonFilePath: process.env.SUBLY_DEMO_AGENT_KEYPAIR_PATH,
@@ -1599,145 +1792,16 @@ var agentSecretKey = loadSecretKeyBytes({
 });
 var signer = new LocalKeypairAgentWalletSigner(keyPairSigner);
 var rpc = createRpc(rpcUrl);
-var payer = createStandardX402Payer({
+var payer = createRelayerX402Payer({
   facilitatorBaseUrl,
   signer,
-  agentSecretKey,
   rpc,
-  rpcUrl,
+  x402Fetch: await createSvmX402Fetch({ agentSecretKey, rpcUrl }),
   defaultMaxAmountRawUsdc
 });
-var SERVER_INSTRUCTIONS = `Subly lets an agent pay for ANY standard x402 (HTTP 402) paid API from its wallet's Kamino vault YIELD \u2014 the deposited principal is never spent, and the seller needs no Subly integration.
-
-Before payments can succeed the operator of this server must have, once:
-1. A Solana keypair for the agent wallet. Subly does NOT create wallets; make one with \`solana-keygen new -o agent.json\` (or export a keypair from an existing wallet) and point SUBLY_DEMO_AGENT_KEYPAIR_PATH at it. The private key never leaves that file; this server only signs locally with it.
-2. Funded that wallet with USDC on Solana mainnet (no SOL needed \u2014 realize fees are sponsored) and deposited into the vault (see the project's deposit command). The vault minimum deposit is 1 USDC.
-3. Waited for yield to accrue; a payment needs the seller's price of spendable yield.
-
-Then use fetch_with_subly_payment(url) to GET a paid resource from any x402 seller (e.g. Nansen): it realizes just enough yield to the agent's USDC ATA and pays the seller's standard x402 challenge, returning the body plus the payment details. If it returns insufficient_yield, that is expected \u2014 wait for yield, do not loop.`;
-var server = new Server(
-  { name: "subly-payments", version: "0.2.0" },
-  { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS }
-);
-server.setRequestHandler(ListToolsRequestSchema, () => ({
-  tools: [
-    {
-      name: TOOL_NAME,
-      description: `GET a URL, automatically paying a standard x402 (HTTP 402) challenge from any x402-compatible seller (Nansen, etc.) out of the agent wallet's Kamino vault yield. Subly realizes just enough yield to the agent's USDC ATA (sponsored) and pays the seller's Solana USDC \`exact\` challenge; the seller needs no Subly integration. Returns the response body and, when a payment was made, the payment details (amount, payee, realize tx). Challenges above maxAmountRawUsdc (default ${defaultMaxAmountRawUsdc} raw = ${formatRawUsdcAmount(
-        defaultMaxAmountRawUsdc
-      )} USDC) are refused without paying. Payments are refused when the spendable yield budget cannot cover them \u2014 the principal is never spent. Use only for URLs you intend to purchase access to.`,
-      inputSchema: {
-        type: "object",
-        properties: {
-          url: {
-            type: "string",
-            description: "URL to fetch (GET). Must match the seller's resource URL exactly."
-          },
-          maxAmountRawUsdc: {
-            type: "string",
-            description: 'Refuse (without paying) any challenge above this amount in raw USDC units (6 decimals, e.g. "10000" = 0.01 USDC). Defaults to the server-side cap.'
-          }
-        },
-        required: ["url"]
-      },
-      annotations: {
-        title: "Fetch with Subly payment",
-        readOnlyHint: false,
-        destructiveHint: true,
-        idempotentHint: false,
-        openWorldHint: true
-      }
-    }
-  ]
-}));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (request.params.name !== TOOL_NAME) {
-    return {
-      content: [
-        { type: "text", text: `unknown tool: ${request.params.name}` }
-      ],
-      isError: true
-    };
-  }
-  const args = request.params.arguments ?? {};
-  const url = args.url;
-  if (typeof url !== "string" || url.length === 0) {
-    return {
-      content: [{ type: "text", text: "missing required argument: url" }],
-      isError: true
-    };
-  }
-  let maxAmountRawUsdc;
-  if (args.maxAmountRawUsdc !== void 0) {
-    const raw = args.maxAmountRawUsdc;
-    try {
-      if (typeof raw !== "string" && typeof raw !== "number") {
-        throw new TypeError("not a string or number");
-      }
-      maxAmountRawUsdc = BigInt(raw);
-    } catch {
-      return {
-        content: [
-          {
-            type: "text",
-            text: "maxAmountRawUsdc must be an integer raw USDC amount"
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  try {
-    const result = await payer.pay({
-      url,
-      ...maxAmountRawUsdc === void 0 ? {} : { maxAmountRawUsdc }
-    });
-    return {
-      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-    };
-  } catch (error) {
-    if (error instanceof StandardX402PayError) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                paid: false,
-                refused: true,
-                reason: error.reason,
-                message: error.message,
-                detail: error.detail
-              },
-              null,
-              2
-            )
-          }
-        ],
-        isError: true
-      };
-    }
-    return {
-      content: [
-        {
-          type: "text",
-          text: error instanceof Error ? error.message : String(error)
-        }
-      ],
-      isError: true
-    };
-  }
+await runMcpPaymentServer({
+  payer,
+  signer,
+  facilitatorBaseUrl,
+  defaultMaxAmountRawUsdc
 });
-try {
-  await ensureWalletOnboarded({ facilitatorBaseUrl, signer });
-  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)}`
-  );
-}
-var transport = new StdioServerTransport();
-await server.connect(transport);
-console.error(
-  `[subly-mcp] ready: agent wallet ${signer.walletAddress}, relayer ${facilitatorBaseUrl}, default cap ${formatRawUsdcAmount(defaultMaxAmountRawUsdc)} USDC`
-);