@subly_fi/pay 0.3.0 → 0.4.1

package/README.md

@@ -7,7 +7,10 @@ locally with your own Solana key; Subly never holds it.
 
 Ships one `pay` dispatcher bin with subcommands, all runnable with `npx` (no clone):
 
-- `pay mcp` — an MCP server (Claude Code, Cursor, any MCP client)
+- `pay mcp` — an MCP server (Claude Code, Cursor, any MCP client) exposing
+  the full lifecycle as tools: `deposit_to_subly_vault`,
+  `get_subly_yield_budget`, `fetch_with_subly_payment`,
+  `withdraw_from_subly_vault`
 - `pay fetch <url>` — one-shot: pay for a URL, print the receipt (used by the
   OpenClaw skill)
 - `pay deposit <amountRawUsdc>` / `pay withdraw <amountRawUsdc>` — vault
@@ -23,11 +26,11 @@ export SUBLY_DEMO_AGENT_KEYPAIR_PATH=~/.subly/agent.json
 ```
 
 Send USDC (Solana mainnet) to the printed address — no SOL needed, fees are
-sponsored — then deposit (vault minimum 1 USDC; deposit self-registers the
-wallet):
+sponsored — then deposit (vault minimum is just over 1 USDC: share rounding
+refuses exactly 1.000000; deposit self-registers the wallet):
 
 ```bash
-npx -y @subly_fi/pay deposit 1000000   # 1 USDC
+npx -y @subly_fi/pay deposit 1010000   # 1.01 USDC
 ```
 
 ## Use it
@@ -45,10 +48,14 @@ npx -y @subly_fi/pay fetch https://seller.example.com/api/premium
 | Var | Required | Default |
 |---|---|---|
 | `SUBLY_DEMO_AGENT_KEYPAIR_PATH` | yes (or `SUBLY_DEMO_AGENT_KEYPAIR` base58) | — |
-| `SUBLY_FACILITATOR_URL` | no | `https://api.demo.sublyfi.com` |
+| `SUBLY_RELAYER_URL` | no | `https://api.demo.sublyfi.com` |
 | `SOLANA_RPC_URL` | no | public mainnet RPC |
 | `SUBLY_MCP_MAX_AMOUNT_RAW_USDC` | no | `10000` (0.01 USDC) per-payment cap |
 
 Requests authenticate with a signature from your wallet key — there is no API
-token. The cap and the facilitator's yield-budget check both bound spending;
-the principal is never touched.
+token. `SUBLY_FACILITATOR_URL` is still accepted as a legacy fallback for
+`SUBLY_RELAYER_URL`. Spending is bounded twice: the client cap, and the
+relayer's server-side guard that refuses to realize anything beyond the
+spendable yield — the deposited principal is never touched by a payment.
+(A plain `pay withdraw` is the exit path and may of course move principal
+back to your wallet.)

package/dist/deposit.js

@@ -48,10 +48,10 @@ function decodeSerializedTransaction(serializedBase64) {
 }
 async function addSignaturesToSerializedTransaction(params) {
   const decoded = decodeSerializedTransaction(params.serializedBase64);
-  const signed2 = await partiallySignTransaction(params.signers, decoded);
+  const signed = await partiallySignTransaction(params.signers, decoded);
   return {
-    serializedBase64: getBase64EncodedWireTransaction(signed2),
-    transaction: signed2
+    serializedBase64: getBase64EncodedWireTransaction(signed),
+    transaction: signed
   };
 }
 function signatureBase58ForSigner(transaction, signer2) {
@@ -993,7 +993,7 @@ var OnboardingError = class extends Error {
 };
 async function ensureWalletOnboarded(params) {
   const fetchImpl = params.fetchImpl ?? fetch;
-  const baseUrl = params.facilitatorBaseUrl.replace(/\/$/, "");
+  const baseUrl = params.relayerBaseUrl.replace(/\/$/, "");
   const post = async (step, path, body) => {
     const url = `${baseUrl}${path}`;
     const serialized = JSON.stringify(body);
@@ -1076,6 +1076,222 @@ async function fetchLookupTablesForTransaction(rpc2, serializedTransaction) {
   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.relayerBaseUrl.replace(/\/$/, "");
+    this.signer = config.signer;
+    this.fetchImpl = config.fetchImpl ?? fetch;
+    this.lookupTablesFor = config.lookupTablesFor ?? ((serializedTransaction) => fetchLookupTablesForTransaction(config.rpc, serializedTransaction));
+    this.pollTimeoutMs = config.pollTimeoutMs ?? 9e4;
+    this.pollIntervalMs = config.pollIntervalMs ?? 2500;
+  }
+  /** Moves USDC from the agent wallet into the vault (fee sponsored). */
+  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 url = `${this.baseUrl}/v1/wallets/${this.signer.walletAddress}/budget`;
+    const response = await this.fetchImpl(url, {
+      headers: await walletAuthHeaders({
+        signer: this.signer,
+        method: "GET",
+        url
+      })
+    });
+    const text = await response.text();
+    if (response.status !== 200) {
+      throw new VaultFlowClientError(
+        "budget",
+        `budget endpoint returned ${response.status}: ${text}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        "budget",
+        "budget endpoint returned 200 with a non-JSON body",
+        text
+      );
+    }
+    const body = parsed;
+    return {
+      wallet: this.signer.walletAddress,
+      principalBasisRawUsdc: body.position?.principalBasisRawUsdc ?? "0",
+      positionValueRawUsdc: body.budget?.positionValueRawUsdc ?? "0",
+      grossYieldRawUsdc: body.budget?.grossYieldRawUsdc ?? "0",
+      spendableYieldRawUsdc: body.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 url = `${this.baseUrl}${path}`;
+      const response = await this.fetchImpl(url, {
+        headers: await walletAuthHeaders({
+          signer: this.signer,
+          method: "GET",
+          url
+        })
+      });
+      if (response.status !== 200) {
+        continue;
+      }
+      try {
+        latest = await response.json();
+      } catch {
+        continue;
+      }
+      if (latest.status !== "submitted") {
+        return latest;
+      }
+    }
+    return latest;
+  }
+  async postJson(step, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const serialized = JSON.stringify(body);
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      headers: {
+        ...await walletAuthHeaders({
+          signer: this.signer,
+          method: "POST",
+          url,
+          body: serialized
+        }),
+        "content-type": "application/json"
+      },
+      body: serialized
+    });
+    const text = await response.text();
+    if (response.status !== 200) {
+      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/solana/keys.ts
 import { readFileSync } from "node:fs";
 import bs586 from "bs58";
@@ -1120,7 +1336,7 @@ function formatRawUsdc(raw) {
 }
 
 // ../../demo/deposit.ts
-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 amountRawUsdc = process.argv[2];
 if (amountRawUsdc === void 0 || !/^[1-9]\d*$/.test(amountRawUsdc)) {
   fail(
@@ -1136,69 +1352,44 @@ var signer = new LocalKeypairAgentWalletSigner(keyPairSigner);
 var rpc = createRpc(
   process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com"
 );
-async function postJson(path, body) {
-  const url = `${facilitatorBaseUrl}${path}`;
-  const serialized = JSON.stringify(body);
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      ...await walletAuthHeaders({
-        signer,
-        method: "POST",
-        url,
-        body: serialized
-      }),
-      "content-type": "application/json"
-    },
-    body: serialized
-  });
-  const text = await response.text();
-  if (response.status !== 200) {
-    fail(`[deposit] ${path} failed with ${response.status}: ${text}`);
-  }
-  return JSON.parse(text);
-}
+var vaultFlows = new VaultFlowClient({
+  relayerBaseUrl,
+  signer,
+  rpc
+});
 console.log(`[deposit] agent wallet: ${signer.walletAddress}`);
-console.log(`[deposit] facilitator:  ${facilitatorBaseUrl}`);
+console.log(`[deposit] relayer:  ${relayerBaseUrl}`);
 console.log("\n[deposit] step 0: ensure the wallet is registered (self-serve)");
-await ensureWalletOnboarded({ facilitatorBaseUrl, signer });
+await ensureWalletOnboarded({ relayerBaseUrl, signer });
 console.log("[deposit] wallet registered and synced");
 console.log(
   `
-[deposit] step 1: prepare deposit of ${formatRawUsdc(amountRawUsdc)} USDC`
+[deposit] step 1: deposit ${formatRawUsdc(amountRawUsdc)} USDC (prepare -> validate intent + sign locally -> sponsor submits)`
 );
-var prepared = await postJson("/v1/deposits/prepare", {
-  wallet: signer.walletAddress,
-  amountRawUsdc
-});
-console.log(`[deposit] prepared (depositId=${prepared.depositId})`);
-console.log(
-  "\n[deposit] step 2: validate the signing intent against the transaction, sign locally"
-);
-var signed = await signer.signDeposit({
-  intent: prepared.signingIntent,
-  serializedTransaction: prepared.serializedTransaction,
-  lookupTables: await fetchLookupTablesForTransaction(
-    rpc,
-    prepared.serializedTransaction
-  )
-});
-console.log("[deposit] agent signature attached");
-console.log("\n[deposit] step 3: submit (sponsor co-signs and broadcasts)");
-var submitted = await postJson("/v1/deposits/submit", {
-  depositId: prepared.depositId,
-  serializedTransaction: signed.serializedTransaction,
-  agentSignature: signed.agentSignature
-});
+var submitted;
+try {
+  submitted = await vaultFlows.deposit({ amountRawUsdc: BigInt(amountRawUsdc) });
+} catch (error) {
+  if (error instanceof VaultFlowClientError) {
+    fail(`[deposit] ${error.step} failed: ${error.message}`);
+  }
+  throw error;
+}
+console.log(`[deposit] depositId: ${submitted.depositId}`);
 console.log(`[deposit] status: ${submitted.status}`);
 if (submitted.txSignature !== null) {
   console.log(
     `[deposit] transaction: https://solscan.io/tx/${submitted.txSignature}`
   );
 }
+if (submitted.status === "submitted") {
+  fail(
+    `[deposit] broadcast but not yet confirmed \u2014 it may still land. Do NOT resubmit; check GET /v1/deposits/${submitted.depositId} (or the tx link above) first`
+  );
+}
 if (submitted.status !== "confirmed") {
   fail(
-    `[deposit] not confirmed (errorCode=${submitted.errorCode}); check GET /v1/deposits/${prepared.depositId} and the facilitator logs`
+    `[deposit] not confirmed (errorCode=${submitted.errorCode}); check GET /v1/deposits/${submitted.depositId} and the relayer logs`
   );
 }
 console.log(