@subly_fi/pay 0.6.2 → 0.7.0

package/dist/cli.js

@@ -1,28 +1,45 @@
 #!/usr/bin/env node
-// Single dispatcher bin for @subly_fi/pay so `npx -y @subly_fi/pay <subcommand>`
-// resolves cleanly. Subcommands map to the bundled entry points; argv is
-// reshaped so each entry sees its own positional args at the usual index.
+import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-
+const here = dirname(fileURLToPath(import.meta.url));
 const TARGETS = {
-  mcp: "mcp-server.js",
-  fetch: "pay.js",
-  deposit: "deposit.js",
-  withdraw: "withdraw.js",
-  "setup-link": "setup-link.js",
-  "setup-status": "setup-status.js"
+  mcp: "mcp-server.js", fetch: "pay.js", deposit: "deposit.js", withdraw: "withdraw.js",
+  "setup-link": "setup-link.js", "setup-status": "setup-status.js",
+  doctor: "doctor.js", budget: "budget.js", vaults: "vaults.js"
 };
+const HELP = `Subly — x402 payments from Kamino USDC vault yield
+
+Usage: pay <command> [arguments]
+  doctor                         Check configuration, relayer and mainnet RPC (no signing)
+  vaults                         Print the locally trusted vault catalogue (offline)
+  setup-link [options]           Create a human owner approval link
+  setup-status <sessionId|URL>   Read setup completion
+  deposit <rawUSDC> [approvalId] Deposit into the selected vault (real funds)
+  budget                         Refresh and read the selected vault's yield budget
+  withdraw <rawUSDC> [approvalId] Withdraw to the agent wallet (real funds)
+  fetch <URL>                    Pay a compatible x402 API within the configured cap
+  mcp                            Start the stdio MCP server
+  --version                      Print package version
 
+Amounts: 1000000 raw USDC = 1 USDC. Requires Node.js 24+.
+Set SUBLY_RELAYER_URL, SOLANA_RPC_URL and a wallet signer before use.
+Local signer: SUBLY_DEMO_AGENT_KEYPAIR_PATH=/absolute/path/agent.json
+Payment cap: SUBLY_MCP_MAX_AMOUNT_RAW_USDC (default 10000 = 0.01 USDC).
+Run pay setup-link --help for policy options.
+Guide: https://github.com/SublyFi/subly-payment-protocol/tree/main/packages/pay
+`;
 const [sub, ...rest] = process.argv.slice(2);
-const target = sub === undefined ? undefined : TARGETS[sub];
-if (target === undefined) {
-  console.error(
-    "usage: pay <mcp|fetch <url>|deposit <amountRawUsdc>|withdraw <amountRawUsdc>|setup-link|setup-status <sessionId|setupUrl>>"
-  );
-  process.exit(1);
+if (sub === "--version" || sub === "-v") {
+  console.log(JSON.parse(readFileSync(join(here, "..", "package.json"), "utf8")).version);
+} else if (!sub || sub === "--help" || sub === "-h" || sub === "help" || rest.includes("--help") || rest.includes("-h")) {
+  console.log(HELP);
+  if (sub === "setup-link") console.log("Policy options: --initial-deposit <rawUSDC> --approval-threshold <rawUSDC> --per-payment-cap <rawUSDC> --daily-api-cap <rawUSDC> --daily-deposit-cap <rawUSDC> --ttl-days <days>");
+} else if (!Object.hasOwn(TARGETS, sub)) {
+  console.error(`Unknown command: ${sub}\nRun pay --help.`);
+  process.exitCode = 1;
+} else {
+  process.argv = [process.argv[0], join(here, TARGETS[sub]), ...rest];
+  try { await import(`./${TARGETS[sub]}`); }
+  catch (error) { console.error(error instanceof Error ? error.message : "Command failed"); process.exitCode = 1; }
 }
-
-const here = dirname(fileURLToPath(import.meta.url));
-process.argv = [process.argv[0], join(here, target), ...rest];
-await import(`./${target}`);

package/dist/deposit.js

@@ -1,3 +1,141 @@
+// ../../src/config/vault-catalog.ts
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+
+// ../../src/lib/solana-address.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var BASE58_LOOKUP = new Map(
+  [...BASE58_ALPHABET].map((character, index) => [character, BigInt(index)])
+);
+function assertSolanaAddress(value, fieldName) {
+  if (value.length < 32 || value.length > 44) {
+    throw new Error(`${fieldName} must be a valid Solana public key`);
+  }
+  if (decodeBase58(value).length !== 32) {
+    throw new Error(`${fieldName} must be a valid Solana public key`);
+  }
+  return value;
+}
+function decodeBase58(value) {
+  if (value.length === 0) {
+    return new Uint8Array();
+  }
+  let decoded = 0n;
+  for (const character of value) {
+    const digit = BASE58_LOOKUP.get(character);
+    if (digit === void 0) {
+      return new Uint8Array();
+    }
+    decoded = decoded * 58n + digit;
+  }
+  const bytes = [];
+  while (decoded > 0n) {
+    bytes.push(Number(decoded & 0xffn));
+    decoded >>= 8n;
+  }
+  for (const character of value) {
+    if (character !== "1") {
+      break;
+    }
+    bytes.push(0);
+  }
+  return Uint8Array.from(bytes.reverse());
+}
+
+// ../../src/config/vault.ts
+var MAINNET_USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var KAMINO_VAULT_PROGRAM_ID = "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd";
+var NO_VAULT_FARM = "11111111111111111111111111111111";
+var DEFAULT_VAULT_CONFIG = Object.freeze({
+  address: "5kfkpQZ6AkQgizHVThqkxD4J3db2i7pE3mHdPNRbx7jr",
+  programId: KAMINO_VAULT_PROGRAM_ID,
+  usdcMint: MAINNET_USDC_MINT,
+  shareMint: "7hGX49So539MU9Rrah8nBNVYXswWVwEJvgWNYeBDYq3a",
+  farm: "E2Ct77LowkDAH1T9ubwPpb84pU2GSGrUdgH3KeTTpLX"
+});
+function vaultConfigFromEnv(env = process.env) {
+  const value = (name) => env[name]?.trim() || void 0;
+  const vaultAddress = value("SUBLY_VAULT_ADDRESS") ?? DEFAULT_VAULT_CONFIG.address;
+  const customVault = vaultAddress !== DEFAULT_VAULT_CONFIG.address;
+  const anchor = (name, fallback) => {
+    const configured = value(name);
+    if (customVault && configured === void 0) {
+      throw new Error(
+        `${name} is required for a custom vault. Generate its settings with npm run configure:vault -- <vault-address>; use ${NO_VAULT_FARM} for a vault without a farm.`
+      );
+    }
+    return assertSolanaAddress(configured ?? fallback, name);
+  };
+  const usdcMint = value("SUBLY_VAULT_USDC_MINT") ?? MAINNET_USDC_MINT;
+  if (usdcMint !== MAINNET_USDC_MINT) {
+    throw new Error(
+      "SUBLY_VAULT_USDC_MINT must be mainnet USDC; other deposit assets are not supported"
+    );
+  }
+  return Object.freeze({
+    address: assertSolanaAddress(vaultAddress, "SUBLY_VAULT_ADDRESS"),
+    programId: KAMINO_VAULT_PROGRAM_ID,
+    usdcMint,
+    shareMint: anchor("SUBLY_VAULT_SHARE_MINT", DEFAULT_VAULT_CONFIG.shareMint),
+    farm: anchor("SUBLY_VAULT_FARM", DEFAULT_VAULT_CONFIG.farm)
+  });
+}
+
+// ../../src/config/vault-catalog.ts
+var publicKey = z.string().refine((value) => {
+  try {
+    assertSolanaAddress(value, "vault catalog address");
+    return true;
+  } catch {
+    return false;
+  }
+}, "Invalid Solana public key");
+var catalogSchema = z.object({
+  version: z.literal(1),
+  defaultVault: publicKey,
+  vaults: z.array(z.object({
+    address: publicKey,
+    programId: z.literal(KAMINO_VAULT_PROGRAM_ID),
+    usdcMint: z.literal(MAINNET_USDC_MINT),
+    shareMint: publicKey,
+    farm: publicKey,
+    name: z.string().min(1).max(128).optional(),
+    depositsEnabled: z.boolean().optional(),
+    extraLookupTables: z.array(publicKey).max(16).optional()
+  }).strict()).min(1).max(100)
+}).strict();
+function parseVaultCatalog(value) {
+  const catalog = catalogSchema.parse(value);
+  const addresses = new Set(catalog.vaults.map((vault) => vault.address));
+  if (addresses.size !== catalog.vaults.length) throw new Error("Duplicate vault in catalog");
+  if (!addresses.has(catalog.defaultVault)) throw new Error("defaultVault must be in the vault catalog");
+  return { ...catalog, vaults: catalog.vaults.map((vault) => Object.freeze(vault)) };
+}
+function vaultCatalogFromEnv(env = process.env) {
+  const path = env.SUBLY_VAULTS_FILE?.trim();
+  if (!path) {
+    const vault = vaultConfigFromEnv(env);
+    return { version: 1, defaultVault: vault.address, vaults: [vault] };
+  }
+  const catalog = parseVaultCatalog(JSON.parse(readFileSync(path, "utf8")));
+  const selected = env.SUBLY_VAULT_ADDRESS?.trim() || catalog.defaultVault;
+  if (!catalog.vaults.some((vault) => vault.address === selected)) {
+    throw new Error("SUBLY_VAULT_ADDRESS must be in SUBLY_VAULTS_FILE");
+  }
+  return { ...catalog, defaultVault: selected };
+}
+function defaultCatalogVault(catalog) {
+  return catalog.vaults.find((vault) => vault.address === catalog.defaultVault);
+}
+
+// ../../src/config/constants.ts
+var PAYMENT_SCHEME = "subly-yield-exact";
+var SOLANA_MAINNET_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var SUBLY_VAULT = defaultCatalogVault(vaultCatalogFromEnv());
+var USDC_DECIMALS = 6;
+
 // ../../src/api/wallet-auth.ts
 import { createHash } from "node:crypto";
 import bs58 from "bs58";
@@ -81,22 +219,24 @@ async function ensureWalletOnboarded(params) {
     }
   };
   const wallet = params.signer.walletAddress;
+  const vault = params.vault ?? params.signer.vault?.address ?? SUBLY_VAULT.address;
   await post("register", "/v1/wallets/agent", {
     wallet,
+    vault,
     signingPolicyId: SELF_SERVE_POLICY_ID,
     signingMode: "non_interactive",
     signerValidationMode: params.signer.validationMode,
     signerProvider: params.signer.provider ?? "local-keypair",
     activateForPayments: true
   });
-  await post("sync", `/v1/wallets/${wallet}/sync`, { source: "chain" });
+  await post("sync", `/v1/wallets/${wallet}/sync`, { source: "chain", vault });
 }
 
 // ../../src/client/signer-env.ts
 import { createKeyPairSignerFromBytes as createKeyPairSignerFromBytes2 } from "@solana/kit";
 
 // ../../src/solana/keys.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import bs582 from "bs58";
 import {
   createKeyPairSignerFromBytes
@@ -111,7 +251,7 @@ function loadSecretKeyBytes(params) {
     return 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`);
     }
@@ -235,10 +375,10 @@ function ed25519PublicKeyBytes(provider, walletAddress) {
   return bytes;
 }
 function verifiedEd25519Signature(params) {
-  const publicKey = ed25519PublicKeyBytes(params.provider, params.walletAddress);
+  const publicKey2 = ed25519PublicKeyBytes(params.provider, params.walletAddress);
   const encoded = params.encodedSignature.trim();
   for (const candidate of decodeSignatureCandidates(encoded)) {
-    if (nacl2.sign.detached.verify(params.message, candidate, publicKey)) {
+    if (nacl2.sign.detached.verify(params.message, candidate, publicKey2)) {
       return candidate;
     }
   }
@@ -292,8 +432,8 @@ async function requestVerifiedTransactionSignature(params) {
       `signed transaction is missing the signature for ${transport.walletAddress}`
     );
   }
-  const publicKey = params.publicKey ?? ed25519PublicKeyBytes(transport.provider, transport.walletAddress);
-  if (!nacl2.sign.detached.verify(params.messageBytes, signature, publicKey)) {
+  const publicKey2 = params.publicKey ?? ed25519PublicKeyBytes(transport.provider, transport.walletAddress);
+  if (!nacl2.sign.detached.verify(params.messageBytes, signature, publicKey2)) {
     throw new RemoteSigningError(
       transport.provider,
       "returned signature does not verify over the requested transaction"
@@ -344,38 +484,6 @@ async function providerJsonRequest(params) {
 import bs586 from "bs58";
 import { getCompiledTransactionMessageDecoder } from "@solana/kit";
 
-// ../../src/config/constants.ts
-var PAYMENT_SCHEME = "subly-yield-exact";
-var SOLANA_MAINNET_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-var SPL_TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-var ASSOCIATED_TOKEN_PROGRAM_ID = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-var envOr = (name, fallback) => {
-  const value = process.env[name]?.trim();
-  return value ? value : fallback;
-};
-var SUBLY_VAULT = {
-  name: "Subly USDC Payment Vault Alpha",
-  address: envOr(
-    "SUBLY_VAULT_ADDRESS",
-    "5kfkpQZ6AkQgizHVThqkxD4J3db2i7pE3mHdPNRbx7jr"
-  ),
-  programId: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd",
-  usdcMint: envOr(
-    "SUBLY_VAULT_USDC_MINT",
-    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
-  ),
-  shareMint: envOr(
-    "SUBLY_VAULT_SHARE_MINT",
-    "7hGX49So539MU9Rrah8nBNVYXswWVwEJvgWNYeBDYq3a"
-  ),
-  lookupTable: "7UbXhDnpK7WVnwsfivzQRENoqKqAULQ5s19gS1xJrQEo",
-  farm: envOr(
-    "SUBLY_VAULT_FARM",
-    "E2Ct77LowkDAH1T9ubwPpb84pU2GSGrUdgH3KeTTpLX"
-  )
-};
-var USDC_DECIMALS = 6;
-
 // ../../src/domain/request-binding.ts
 function computeRequestBindingHash(fields) {
   return hashStableJson({
@@ -625,16 +733,16 @@ function validatePaymentIntentTransaction(params) {
   if (intent.network !== SOLANA_MAINNET_NETWORK) {
     reject("network_mismatch", "Unsupported network");
   }
-  if (intent.vault !== SUBLY_VAULT.address) {
+  if (intent.vault !== policy.vault.address) {
     reject("vault_mismatch", "Unsupported vault");
   }
-  if (intent.shareMint !== SUBLY_VAULT.shareMint) {
+  if (intent.shareMint !== policy.vault.shareMint) {
     reject("share_mint_mismatch", "Unsupported share mint");
   }
-  if (intent.farm !== SUBLY_VAULT.farm) {
+  if (intent.farm !== policy.vault.farm) {
     reject("farm_mismatch", "Unsupported Kamino farm");
   }
-  if (intent.asset !== SUBLY_VAULT.usdcMint) {
+  if (intent.asset !== policy.vault.usdcMint) {
     reject("asset_mismatch", "Only USDC payments are supported");
   }
   if (intent.memo !== intent.paymentId) {
@@ -750,7 +858,7 @@ function validateDepositIntentTransaction(params) {
   if (new Date(intent.expiresAt).getTime() <= now) {
     reject("expired", "Deposit intent has expired");
   }
-  assertVaultIntentTargets(intent);
+  assertVaultIntentTargets(intent, policy.vault);
   const decoded = decodeIntentTransaction({
     serializedTransaction: params.serializedTransaction,
     ...params.lookupTables === void 0 ? {} : { lookupTables: params.lookupTables }
@@ -773,6 +881,9 @@ function validateDepositIntentTransaction(params) {
       case MEMO_PROGRAM_ID:
         break;
       case KVAULT_PROGRAM_ID: {
+        if (sawDeposit) {
+          reject("duplicate_deposit", "A deposit intent authorizes exactly one KVault deposit");
+        }
         if (!bytesStartWith(ix.data, KVAULT_DEPOSIT_DISCRIMINATOR)) {
           reject("unexpected_instruction", "Unexpected KVault instruction in deposit");
         }
@@ -823,7 +934,7 @@ function validateWithdrawalIntentTransaction(params) {
   if (new Date(intent.expiresAt).getTime() <= now) {
     reject("expired", "Withdrawal intent has expired");
   }
-  assertVaultIntentTargets(intent);
+  assertVaultIntentTargets(intent, policy.vault);
   const expectedDestination = deriveAssociatedTokenAddress({
     owner: intent.wallet,
     mint: intent.asset
@@ -921,22 +1032,23 @@ function validateWithdrawalIntentTransaction(params) {
     );
   }
 }
-function assertVaultIntentTargets(intent) {
-  if (intent.vault !== SUBLY_VAULT.address) {
+function assertVaultIntentTargets(intent, vault) {
+  if (intent.vault !== vault.address) {
     reject("vault_mismatch", "Unsupported vault");
   }
-  if (intent.shareMint !== SUBLY_VAULT.shareMint) {
+  if (intent.shareMint !== vault.shareMint) {
     reject("share_mint_mismatch", "Unsupported share mint");
   }
-  if (intent.farm !== SUBLY_VAULT.farm) {
+  if (intent.farm !== vault.farm) {
     reject("farm_mismatch", "Unsupported Kamino farm");
   }
-  if (intent.asset !== SUBLY_VAULT.usdcMint) {
+  if (intent.asset !== vault.usdcMint) {
     reject("asset_mismatch", "Only USDC is supported");
   }
 }
 function resolveIntentValidationPolicy(policy) {
   const resolved = {
+    vault: policy?.vault ?? SUBLY_VAULT,
     maxComputeUnitLimit: policy?.maxComputeUnitLimit ?? DEFAULT_MAX_COMPUTE_UNIT_LIMIT,
     maxComputeUnitPriceMicroLamports: policy?.maxComputeUnitPriceMicroLamports ?? DEFAULT_MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS,
     maxTemporaryAccountLamports: policy?.maxTemporaryAccountLamports ?? MAX_TEMP_ACCOUNT_LAMPORTS
@@ -1288,10 +1400,12 @@ function readShortVec(bytes, startOffset) {
 
 // ../../src/client/agent-wallet-signer.ts
 var IntentValidatingAgentWalletSigner = class {
+  vault;
   validationMode = "structured_intent_transaction";
   validationPolicy;
   constructor(validationPolicy) {
-    this.validationPolicy = validationPolicy;
+    this.vault = Object.freeze({ ...validationPolicy?.vault ?? SUBLY_VAULT });
+    this.validationPolicy = { ...validationPolicy, vault: this.vault };
   }
   async signPayment(params) {
     this.assertIntentWallet(params.intent.wallet);
@@ -1449,15 +1563,15 @@ async function createCircleSignerTransport(config) {
   const entitySecretCiphertext = async () => {
     if (entityPublicKey === null) {
       const data = await request("GET", "/v1/w3s/config/entity/publicKey");
-      const publicKey = data.publicKey;
-      if (typeof publicKey !== "string") {
+      const publicKey2 = data.publicKey;
+      if (typeof publicKey2 !== "string") {
         throw new RemoteSigningError(
           PROVIDER,
           "entity public key response has no publicKey",
           data
         );
       }
-      entityPublicKey = createPublicKey(publicKey);
+      entityPublicKey = createPublicKey(publicKey2);
     }
     return publicEncrypt(
       {
@@ -1729,6 +1843,45 @@ async function agentWalletSignerFromEnv(env = process.env) {
   );
 }
 
+// ../../src/client/withdrawal-preview.ts
+var ROUNDING_RAW_USDC = 10n;
+async function assertWithdrawalPreview(input) {
+  const destination = deriveAssociatedTokenAddress({ owner: input.wallet, mint: input.vault.usdcMint });
+  const simulation = await input.rpc.simulateTransaction(
+    input.serializedTransaction,
+    {
+      encoding: "base64",
+      commitment: "confirmed",
+      sigVerify: false,
+      replaceRecentBlockhash: false,
+      innerInstructions: true
+    }
+  ).send({ abortSignal: AbortSignal.timeout(15e3) });
+  if (simulation.value.err !== null) {
+    throw new Error("Withdrawal preview failed on the client RPC; no transaction was signed. Check liquidity, RPC and blockhash, then prepare again.");
+  }
+  let received = 0n;
+  for (const group of simulation.value.innerInstructions ?? []) {
+    for (const instruction of group.instructions) {
+      if (!("parsed" in instruction) || instruction.programId !== SPL_TOKEN_PROGRAM_ID) continue;
+      const parsed = instruction.parsed;
+      if (parsed.type !== "transfer" && parsed.type !== "transferChecked") continue;
+      const info = parsed.info;
+      if (!info || info.destination !== destination && info.source !== destination) continue;
+      const raw = parsed.type === "transferChecked" ? info.tokenAmount?.amount : info.amount;
+      if (typeof raw !== "string" || !/^\d+$/.test(raw)) {
+        throw new Error("Withdrawal preview returned an invalid token amount");
+      }
+      const amount = BigInt(raw);
+      if (info.destination === destination) received += amount;
+      if (info.source === destination) received -= amount;
+    }
+  }
+  if (received <= 0n || received > input.amountRawUsdc + ROUNDING_RAW_USDC || received < input.amountRawUsdc - ROUNDING_RAW_USDC) {
+    throw new Error("Withdrawal preview differs from the requested USDC amount; no transaction was signed");
+  }
+}
+
 // ../../src/client/lookup-tables.ts
 import { fetchAllMaybeAddressLookupTable } from "@solana-program/address-lookup-table";
 import { address, getCompiledTransactionMessageDecoder as getCompiledTransactionMessageDecoder2 } from "@solana/kit";
@@ -1785,6 +1938,8 @@ var VaultFlowClientError = class extends Error {
   errorDetails;
 };
 var VaultFlowClient = class {
+  vault;
+  rpc;
   baseUrl;
   signer;
   fetchImpl;
@@ -1792,6 +1947,11 @@ var VaultFlowClient = class {
   pollTimeoutMs;
   pollIntervalMs;
   constructor(config) {
+    this.rpc = config.rpc;
+    this.vault = config.vault ?? config.signer.vault ?? SUBLY_VAULT;
+    if (config.signer.vault && config.signer.vault.address !== this.vault.address) {
+      throw new Error("Vault flow client and signer must select the same vault");
+    }
     this.baseUrl = config.relayerBaseUrl.replace(/\/$/, "");
     this.signer = config.signer;
     this.fetchImpl = config.fetchImpl ?? fetch;
@@ -1813,6 +1973,7 @@ var VaultFlowClient = class {
     try {
       prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
         wallet: this.signer.walletAddress,
+        vault: this.vault.address,
         amountRawUsdc: input.amountRawUsdc.toString(),
         ...approvalId2 === void 0 ? {} : { approvalId: approvalId2 }
       });
@@ -1826,10 +1987,14 @@ var VaultFlowClient = class {
       }
       prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
         wallet: this.signer.walletAddress,
+        vault: this.vault.address,
         amountRawUsdc: input.amountRawUsdc.toString(),
         approvalId: approvalId2
       });
     }
+    if (prepared.signingIntent?.wallet !== this.signer.walletAddress || prepared.signingIntent.vault !== this.vault.address || prepared.signingIntent.amountRawUsdc !== input.amountRawUsdc.toString()) {
+      throw new VaultFlowClientError("prepare", "Prepared deposit differs from the requested wallet, vault or amount");
+    }
     const signed = await this.signer.signDeposit({
       intent: prepared.signingIntent,
       serializedTransaction: prepared.serializedTransaction,
@@ -1867,12 +2032,23 @@ var VaultFlowClient = class {
       "/v1/withdrawals/prepare",
       {
         wallet: this.signer.walletAddress,
+        vault: this.vault.address,
         amountRawUsdc: input.amountRawUsdc.toString(),
         ...input.purpose === void 0 ? {} : { purpose: input.purpose },
         ...input.payment === void 0 ? {} : { payment: input.payment },
         ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId }
       }
     );
+    if (prepared.signingIntent?.wallet !== this.signer.walletAddress || prepared.signingIntent.vault !== this.vault.address || prepared.requestedWithdrawRawUsdc !== input.amountRawUsdc.toString() || prepared.purpose !== (input.purpose ?? "normal") || input.purpose === "yield_realize" && prepared.signingIntent.allowFullExit) {
+      throw new VaultFlowClientError("prepare", "Prepared withdrawal differs from the requested operation");
+    }
+    await assertWithdrawalPreview({
+      rpc: this.rpc,
+      serializedTransaction: prepared.serializedTransaction,
+      wallet: this.signer.walletAddress,
+      vault: this.vault,
+      amountRawUsdc: input.amountRawUsdc
+    });
     const signed = await this.signer.signWithdrawal({
       intent: prepared.signingIntent,
       serializedTransaction: prepared.serializedTransaction,
@@ -1910,12 +2086,12 @@ var VaultFlowClient = class {
         await this.postJson(
           "sync",
           `/v1/wallets/${this.signer.walletAddress}/sync`,
-          { source: "chain" }
+          { source: "chain", vault: this.vault.address }
         );
       } catch {
       }
     }
-    const url = `${this.baseUrl}/v1/wallets/${this.signer.walletAddress}/budget`;
+    const url = `${this.baseUrl}/v1/wallets/${this.signer.walletAddress}/budget?vault=${this.vault.address}`;
     const response = await this.fetchImpl(url, {
       headers: await walletAuthHeaders({
         signer: this.signer,
@@ -1941,8 +2117,12 @@ var VaultFlowClient = class {
       );
     }
     const body = parsed;
+    if (body.position?.vault !== void 0 && body.position.vault !== this.vault.address) {
+      throw new VaultFlowClientError("budget", "Relayer returned the budget for a different vault");
+    }
     return {
       wallet: this.signer.walletAddress,
+      vault: this.vault.address,
       principalBasisRawUsdc: body.position?.principalBasisRawUsdc ?? "0",
       positionValueRawUsdc: body.budget?.positionValueRawUsdc ?? "0",
       grossYieldRawUsdc: body.budget?.grossYieldRawUsdc ?? "0",
@@ -1960,7 +2140,7 @@ var VaultFlowClient = class {
   /** Wallet's approvals as the relayer sees them (optionally by status). */
   async listApprovals(status) {
     const body = await this.getJson(
-      `/v1/wallets/${this.signer.walletAddress}/approvals${status === void 0 ? "" : `?status=${encodeURIComponent(status)}`}`
+      `/v1/wallets/${this.signer.walletAddress}/approvals${`?vault=${this.vault.address}${status === void 0 ? "" : `&status=${encodeURIComponent(status)}`}`}`
     );
     return body.approvals ?? [];
   }
@@ -1969,16 +2149,21 @@ var VaultFlowClient = class {
    * policy + initial deposit). Paste `setupUrl` into the chat verbatim.
    */
   async createSetupSession(input) {
-    return await this.postJson(
+    const session = await this.postJson(
       "prepare",
       `/v1/wallets/${this.signer.walletAddress}/setup-sessions`,
       {
+        vault: this.vault.address,
         ...input.policy === void 0 ? {} : { policy: input.policy },
         ...input.enforcementMode === void 0 ? {} : { enforcementMode: input.enforcementMode },
         ...input.mandateTtlDays === void 0 ? {} : { mandateTtlDays: input.mandateTtlDays },
         ...input.initialDepositRawUsdc === void 0 ? {} : { initialDepositRawUsdc: input.initialDepositRawUsdc }
       }
     );
+    if (session.vault !== this.vault.address || session.wallet !== this.signer.walletAddress) {
+      throw new VaultFlowClientError("prepare", "Relayer returned a setup session for a different wallet or vault");
+    }
+    return session;
   }
   /** Polls a setup session (public capability URL — no auth needed). */
   async getSetupSession(sessionId) {