@subly_fi/pay 0.6.1 → 0.7.0

package/dist/withdraw.js

@@ -1,9 +1,176 @@
+// ../../src/client/signer-env.ts
+import { createKeyPairSignerFromBytes as createKeyPairSignerFromBytes2 } from "@solana/kit";
+
+// ../../src/solana/keys.ts
+import { readFileSync } from "node:fs";
+import bs58 from "bs58";
+import {
+  createKeyPairSignerFromBytes
+} from "@solana/kit";
+function loadSecretKeyBytes(params) {
+  const { base58Secret, jsonFilePath, label } = params;
+  if (base58Secret !== void 0 && base58Secret.length > 0) {
+    const bytes = bs58.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(readFileSync(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/config/vault-catalog.ts
+import { readFileSync as readFileSync2 } 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(readFileSync2(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/client/agent-wallet-signer.ts
 import { signBytes } from "@solana/kit";
-import bs584 from "bs58";
+import bs586 from "bs58";
+import nacl2 from "tweetnacl";
 
 // ../../src/solana/tx.ts
-import bs58 from "bs58";
+import bs582 from "bs58";
 import {
   appendTransactionMessageInstructions,
   compileTransaction,
@@ -46,6 +213,24 @@ function hashStableJson(value) {
 function decodeSerializedTransaction(serializedBase64) {
   return getTransactionDecoder().decode(Buffer.from(serializedBase64, "base64"));
 }
+function attachExternalSignatureToTransaction(params) {
+  if (!(params.signer in params.transaction.signatures)) {
+    throw new Error(
+      `transaction does not expect a signature from ${params.signer}`
+    );
+  }
+  const transaction = Object.freeze({
+    ...params.transaction,
+    signatures: Object.freeze({
+      ...params.transaction.signatures,
+      [params.signer]: params.signature
+    })
+  });
+  return {
+    serializedBase64: getBase64EncodedWireTransaction(transaction),
+    transaction
+  };
+}
 async function addSignaturesToSerializedTransaction(params) {
   const decoded = decodeSerializedTransaction(params.serializedBase64);
   const signed = await partiallySignTransaction(params.signers, decoded);
@@ -59,28 +244,149 @@ function signatureBase58ForSigner(transaction, signer2) {
   if (signature === null || signature === void 0) {
     return null;
   }
-  return bs58.encode(signature);
+  return bs582.encode(signature);
 }
 
-// ../../src/client/transaction-intent-validator.ts
+// ../../src/client/remote-signer-transport.ts
 import bs583 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 SUBLY_VAULT = {
-  name: "Subly USDC Payment Vault Alpha",
-  address: "5kfkpQZ6AkQgizHVThqkxD4J3db2i7pE3mHdPNRbx7jr",
-  programId: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd",
-  usdcMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-  shareMint: "7hGX49So539MU9Rrah8nBNVYXswWVwEJvgWNYeBDYq3a",
-  lookupTable: "7UbXhDnpK7WVnwsfivzQRENoqKqAULQ5s19gS1xJrQEo",
-  farm: "E2Ct77LowkDAH1T9ubwPpb84pU2GSGrUdgH3KeTTpLX"
+import nacl from "tweetnacl";
+var RemoteSigningError = class extends Error {
+  constructor(provider, message, detail = null) {
+    super(`[${provider}] ${message}`);
+    this.provider = provider;
+    this.detail = detail;
+    this.name = "RemoteSigningError";
+  }
+  provider;
+  detail;
 };
-var USDC_DECIMALS = 6;
+function ed25519PublicKeyBytes(provider, walletAddress) {
+  let bytes;
+  try {
+    bytes = bs583.decode(walletAddress);
+  } catch {
+    throw new RemoteSigningError(
+      provider,
+      `wallet address ${walletAddress} is not base58`
+    );
+  }
+  if (bytes.length !== 32) {
+    throw new RemoteSigningError(
+      provider,
+      `wallet address ${walletAddress} is not a 32-byte ed25519 key`
+    );
+  }
+  return bytes;
+}
+function verifiedEd25519Signature(params) {
+  const publicKey2 = ed25519PublicKeyBytes(params.provider, params.walletAddress);
+  const encoded = params.encodedSignature.trim();
+  for (const candidate of decodeSignatureCandidates(encoded)) {
+    if (nacl.sign.detached.verify(params.message, candidate, publicKey2)) {
+      return candidate;
+    }
+  }
+  throw new RemoteSigningError(
+    params.provider,
+    `signature did not verify for wallet ${params.walletAddress}`
+  );
+}
+function decodeSignatureCandidates(encoded) {
+  const candidates = [];
+  const hex = encoded.startsWith("0x") ? encoded.slice(2) : encoded;
+  if (/^[0-9a-fA-F]{128}$/.test(hex)) {
+    candidates.push(Uint8Array.from(Buffer.from(hex, "hex")));
+  }
+  try {
+    const fromBase58 = bs583.decode(encoded);
+    if (fromBase58.length === 64) {
+      candidates.push(fromBase58);
+    }
+  } catch {
+  }
+  if (/^[A-Za-z0-9+/=_-]+$/.test(encoded)) {
+    const fromBase64 = Uint8Array.from(
+      Buffer.from(encoded.replace(/-/g, "+").replace(/_/g, "/"), "base64")
+    );
+    if (fromBase64.length === 64) {
+      candidates.push(fromBase64);
+    }
+  }
+  return candidates;
+}
+async function requestVerifiedTransactionSignature(params) {
+  const { transport } = params;
+  const signedBase64 = await transport.signTransaction(
+    params.serializedTransactionBase64
+  );
+  let returned;
+  try {
+    returned = decodeSerializedTransaction(signedBase64);
+  } catch (error) {
+    throw new RemoteSigningError(
+      transport.provider,
+      "provider returned an undecodable signed transaction",
+      error
+    );
+  }
+  const signature = returned.signatures[transport.walletAddress] ?? null;
+  if (signature === null) {
+    throw new RemoteSigningError(
+      transport.provider,
+      `signed transaction is missing the signature for ${transport.walletAddress}`
+    );
+  }
+  const publicKey2 = params.publicKey ?? ed25519PublicKeyBytes(transport.provider, transport.walletAddress);
+  if (!nacl.sign.detached.verify(params.messageBytes, signature, publicKey2)) {
+    throw new RemoteSigningError(
+      transport.provider,
+      "returned signature does not verify over the requested transaction"
+    );
+  }
+  return signature;
+}
+async function externallySignedAgentTransaction(params) {
+  const original = decodeSerializedTransaction(params.serializedTransaction);
+  const signature = await requestVerifiedTransactionSignature({
+    transport: params.transport,
+    serializedTransactionBase64: params.serializedTransaction,
+    messageBytes: original.messageBytes
+  });
+  const attached = attachExternalSignatureToTransaction({
+    transaction: original,
+    signer: params.transport.walletAddress,
+    signature
+  });
+  return {
+    serializedTransaction: attached.serializedBase64,
+    agentSignature: bs583.encode(signature)
+  };
+}
+async function providerJsonRequest(params) {
+  const response = await params.fetchImpl(`${params.baseUrl}${params.path}`, {
+    method: params.method,
+    headers: { ...params.headers, "content-type": "application/json" },
+    ...params.body === void 0 ? {} : { body: JSON.stringify(params.body) }
+  });
+  let json = null;
+  try {
+    json = await response.json();
+  } catch {
+    json = null;
+  }
+  if (!response.ok) {
+    throw new RemoteSigningError(
+      params.provider,
+      `${params.method} ${params.path} failed with ${response.status}`,
+      json
+    );
+  }
+  return json;
+}
+
+// ../../src/client/transaction-intent-validator.ts
+import bs585 from "bs58";
+import { getCompiledTransactionMessageDecoder } from "@solana/kit";
 
 // ../../src/domain/request-binding.ts
 function computeRequestBindingHash(fields) {
@@ -99,7 +405,7 @@ function computeRequestBindingHash(fields) {
 
 // ../../src/lib/associated-token-account.ts
 import { createHash as createHash2 } from "node:crypto";
-import bs582 from "bs58";
+import bs584 from "bs58";
 var PDA_MARKER = Buffer.from("ProgramDerivedAddress", "utf8");
 var ED25519_P = (1n << 255n) - 19n;
 var ED25519_D = mod(-121665n * modPow(121666n, ED25519_P - 2n, ED25519_P), ED25519_P);
@@ -120,7 +426,7 @@ function deriveAssociatedTokenAddress(params) {
       associatedTokenProgramId
     );
     if (address2 !== null) {
-      return bs582.encode(address2);
+      return bs584.encode(address2);
     }
   }
   throw new Error("Unable to derive associated token account address");
@@ -136,7 +442,7 @@ function createProgramAddress(seeds, programId) {
   return isEd25519Point(digest) ? null : new Uint8Array(digest);
 }
 function decodePublicKey(value, fieldName) {
-  const decoded = bs582.decode(value);
+  const decoded = bs584.decode(value);
   if (decoded.length !== 32) {
     throw new Error(`${fieldName} must be a 32-byte public key`);
   }
@@ -331,13 +637,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.asset !== SUBLY_VAULT.usdcMint) {
+  if (intent.farm !== policy.vault.farm) {
+    reject("farm_mismatch", "Unsupported Kamino farm");
+  }
+  if (intent.asset !== policy.vault.usdcMint) {
     reject("asset_mismatch", "Only USDC payments are supported");
   }
   if (intent.memo !== intent.paymentId) {
@@ -405,7 +714,7 @@ function validatePaymentIntentTransaction(params) {
   expectComputeBudgetPair(ixs, policy);
   expectCreateTemporaryAccount(ixs, intent, policy);
   expectInitializeTemporaryAccount(ixs, intent);
-  consumeFarmInstructions(ixs, intent.wallet);
+  consumeFarmInstructions(ixs, intent);
   expectKvaultWithdraw(ixs, {
     wallet: intent.wallet,
     vault: intent.vault,
@@ -453,7 +762,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 }
@@ -476,6 +785,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");
         }
@@ -526,7 +838,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
@@ -548,13 +860,27 @@ function validateWithdrawalIntentTransaction(params) {
     reject("fee_payer_mismatch", "Transaction fee payer is not the Subly sponsor");
   }
   let sawWithdraw = false;
+  let farmUserState = null;
+  let farmInstructionCount = 0;
   for (const ix of decoded.instructions) {
     switch (ix.programAddress) {
       case COMPUTE_BUDGET_PROGRAM_ID:
         validateComputeBudgetInstruction(ix, policy);
         break;
       case MEMO_PROGRAM_ID:
+        break;
       case KAMINO_FARMS_PROGRAM_ID:
+        farmInstructionCount += 1;
+        if (farmInstructionCount === 1) {
+          farmUserState = validateFarmUnstakeInstruction(ix, intent);
+        } else if (farmInstructionCount === 2) {
+          validateFarmWithdrawInstruction(ix, intent, farmUserState);
+        } else {
+          reject(
+            "farm_instruction_mismatch",
+            "Withdrawal may contain only one farm unstake and one farm withdrawal"
+          );
+        }
         break;
       case ASSOCIATED_TOKEN_PROGRAM_ID2:
         expectAtaCreateForOwner(ix, intent.wallet);
@@ -575,6 +901,12 @@ function validateWithdrawalIntentTransaction(params) {
         break;
       }
       case KVAULT_PROGRAM_ID: {
+        if (sawWithdraw) {
+          reject(
+            "withdraw_mismatch",
+            "Withdrawal may contain only one KVault withdraw instruction"
+          );
+        }
         validateKvaultWithdrawInstruction(ix, {
           wallet: intent.wallet,
           vault: intent.vault,
@@ -597,20 +929,30 @@ function validateWithdrawalIntentTransaction(params) {
   if (!sawWithdraw) {
     reject("missing_instruction", "Withdrawal transaction has no KVault withdraw");
   }
+  if (farmInstructionCount === 1) {
+    reject(
+      "farm_instruction_mismatch",
+      "A farm unstake must be followed by a farm withdrawal"
+    );
+  }
 }
-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.asset !== SUBLY_VAULT.usdcMint) {
+  if (intent.farm !== vault.farm) {
+    reject("farm_mismatch", "Unsupported Kamino farm");
+  }
+  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
@@ -677,7 +1019,7 @@ function expectCreateTemporaryAccount(ixs, intent, policy) {
   }
   const lamports = readU64LE(ix.data, 4);
   const space = readU64LE(ix.data, 12);
-  const owner = bs583.encode(ix.data.subarray(20, 52));
+  const owner = bs585.encode(ix.data.subarray(20, 52));
   if (space !== 165n) {
     reject("temp_account_mismatch", "Temporary account space must be 165 bytes");
   }
@@ -699,7 +1041,7 @@ function expectInitializeTemporaryAccount(ixs, intent) {
   if (ix === void 0 || ix.programAddress !== SPL_TOKEN_PROGRAM_ID || ix.data[0] !== 18) {
     reject("temp_account_mismatch", "Expected InitializeAccount3 instruction");
   }
-  const owner = bs583.encode(ix.data.subarray(1, 33));
+  const owner = bs585.encode(ix.data.subarray(1, 33));
   if (owner !== intent.wallet) {
     reject(
       "temp_account_mismatch",
@@ -713,15 +1055,90 @@ function expectInitializeTemporaryAccount(ixs, intent) {
     reject("temp_account_mismatch", "Temporary account mint must be USDC");
   }
 }
-function consumeFarmInstructions(ixs, wallet) {
-  while (ixs[0] !== void 0 && ixs[0].programAddress === KAMINO_FARMS_PROGRAM_ID) {
-    const ix = ixs.shift();
-    if (!ix.accounts.includes(wallet)) {
-      reject(
-        "farm_instruction_mismatch",
-        "Farm unstake instruction does not reference the agent wallet"
-      );
-    }
+function consumeFarmInstructions(ixs, intent) {
+  if (ixs[0]?.programAddress !== KAMINO_FARMS_PROGRAM_ID) {
+    return;
+  }
+  const unstake = ixs.shift();
+  const userState = validateFarmUnstakeInstruction(unstake, intent);
+  if (ixs[0]?.programAddress !== KAMINO_FARMS_PROGRAM_ID) {
+    reject(
+      "farm_instruction_mismatch",
+      "A farm unstake must be followed by a farm withdrawal"
+    );
+  }
+  const withdraw = ixs.shift();
+  validateFarmWithdrawInstruction(withdraw, intent, userState);
+  if (ixs[0]?.programAddress === KAMINO_FARMS_PROGRAM_ID) {
+    reject(
+      "farm_instruction_mismatch",
+      "Payment may contain only one farm unstake and one farm withdrawal"
+    );
+  }
+}
+var KAMINO_FARMS_UNSTAKE_DISCRIMINATOR = Uint8Array.from([
+  90,
+  95,
+  107,
+  42,
+  205,
+  124,
+  50,
+  225
+]);
+var KAMINO_FARMS_WITHDRAW_UNSTAKED_DISCRIMINATOR = Uint8Array.from([
+  36,
+  102,
+  187,
+  49,
+  220,
+  36,
+  132,
+  67
+]);
+function validateFarmUnstakeInstruction(ix, intent) {
+  if (ix.programAddress !== KAMINO_FARMS_PROGRAM_ID || !bytesStartWith(ix.data, KAMINO_FARMS_UNSTAKE_DISCRIMINATOR) || ix.data.length !== 24 || readU128LE(ix.data, 8) <= 0n) {
+    reject(
+      "farm_instruction_mismatch",
+      "Expected a non-zero Kamino farm unstake instruction"
+    );
+  }
+  if (ix.accounts.length !== 4) {
+    reject(
+      "farm_instruction_mismatch",
+      "Farm unstake account list is not canonical"
+    );
+  }
+  if (ix.accounts[0] !== intent.wallet) {
+    reject("farm_instruction_mismatch", "Farm unstake owner must be the agent wallet");
+  }
+  if (ix.accounts[2] !== intent.farm) {
+    reject("farm_instruction_mismatch", "Farm unstake target is not the approved farm");
+  }
+  return ix.accounts[1];
+}
+function validateFarmWithdrawInstruction(ix, intent, expectedUserState) {
+  if (ix.programAddress !== KAMINO_FARMS_PROGRAM_ID || !bytesStartWith(ix.data, KAMINO_FARMS_WITHDRAW_UNSTAKED_DISCRIMINATOR) || ix.data.length !== 8) {
+    reject(
+      "farm_instruction_mismatch",
+      "Expected a canonical Kamino farm withdrawal instruction"
+    );
+  }
+  if (ix.accounts.length !== 7) {
+    reject(
+      "farm_instruction_mismatch",
+      "Farm withdrawal account list is not canonical"
+    );
+  }
+  const expectedSharesAta = deriveAssociatedTokenAddress({
+    owner: intent.wallet,
+    mint: intent.shareMint
+  });
+  if (ix.accounts[0] !== intent.wallet || ix.accounts[1] !== expectedUserState || ix.accounts[2] !== intent.farm || ix.accounts[3] !== expectedSharesAta || ix.accounts[6] !== SPL_TOKEN_PROGRAM_ID) {
+    reject(
+      "farm_instruction_mismatch",
+      "Farm withdrawal must return the approved vault shares to the agent wallet"
+    );
   }
 }
 function expectKvaultWithdraw(ixs, expectation) {
@@ -856,6 +1273,16 @@ function readU32LE(data, offset) {
   }
   return Buffer.from(data.subarray(offset, offset + 4)).readUInt32LE(0);
 }
+function readU128LE(data, offset) {
+  if (data.length < offset + 16) {
+    reject("invalid_transaction_encoding", "Instruction data too short for u128");
+  }
+  let value = 0n;
+  for (let index = 0; index < 16; index += 1) {
+    value |= BigInt(data[offset + index]) << BigInt(index * 8);
+  }
+  return value;
+}
 function readShortVec(bytes, startOffset) {
   let value = 0;
   let shift = 0;
@@ -876,55 +1303,57 @@ function readShortVec(bytes, startOffset) {
 }
 
 // ../../src/client/agent-wallet-signer.ts
-var LocalKeypairAgentWalletSigner = class {
+var IntentValidatingAgentWalletSigner = class {
+  vault;
   validationMode = "structured_intent_transaction";
-  keyPairSigner;
   validationPolicy;
-  constructor(keyPairSigner2, validationPolicy) {
-    this.keyPairSigner = keyPairSigner2;
-    this.validationPolicy = validationPolicy;
-  }
-  get walletAddress() {
-    return this.keyPairSigner.address;
+  constructor(validationPolicy) {
+    this.vault = Object.freeze({ ...validationPolicy?.vault ?? SUBLY_VAULT });
+    this.validationPolicy = { ...validationPolicy, vault: this.vault };
   }
   async signPayment(params) {
     this.assertIntentWallet(params.intent.wallet);
-    validatePaymentIntentTransaction({
-      ...params,
-      ...this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy }
-    });
+    validatePaymentIntentTransaction({ ...params, ...this.policySpread() });
     return this.sign(params.serializedTransaction);
   }
   async signDeposit(params) {
     this.assertIntentWallet(params.intent.wallet);
-    validateDepositIntentTransaction({
-      ...params,
-      ...this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy }
-    });
+    validateDepositIntentTransaction({ ...params, ...this.policySpread() });
     return this.sign(params.serializedTransaction);
   }
   async signWithdrawal(params) {
     this.assertIntentWallet(params.intent.wallet);
-    validateWithdrawalIntentTransaction({
-      ...params,
-      ...this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy }
-    });
+    validateWithdrawalIntentTransaction({ ...params, ...this.policySpread() });
     return this.sign(params.serializedTransaction);
   }
+  policySpread() {
+    return this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy };
+  }
   assertIntentWallet(wallet) {
-    if (wallet !== this.keyPairSigner.address) {
+    if (wallet !== this.walletAddress) {
       throw new IntentValidationError(
         "wallet_mismatch",
         "Intent wallet does not match this signer's wallet"
       );
     }
   }
+};
+var LocalKeypairAgentWalletSigner = class extends IntentValidatingAgentWalletSigner {
+  provider = "local-keypair";
+  keyPairSigner;
+  constructor(keyPairSigner, validationPolicy) {
+    super(validationPolicy);
+    this.keyPairSigner = keyPairSigner;
+  }
+  get walletAddress() {
+    return this.keyPairSigner.address;
+  }
   async signApiMessage(message) {
     const signature = await signBytes(
       this.keyPairSigner.keyPair.privateKey,
       message
     );
-    return bs584.encode(signature);
+    return bs586.encode(signature);
   }
   async sign(serializedTransaction) {
     const { serializedBase64, transaction } = await addSignaturesToSerializedTransaction({
@@ -944,6 +1373,418 @@ var LocalKeypairAgentWalletSigner = class {
     return { serializedTransaction: serializedBase64, agentSignature };
   }
 };
+var RemoteAgentWalletSigner = class extends IntentValidatingAgentWalletSigner {
+  transport;
+  publicKey;
+  constructor(transport, validationPolicy) {
+    super(validationPolicy);
+    this.transport = transport;
+    this.publicKey = ed25519PublicKeyBytes(
+      transport.provider,
+      transport.walletAddress
+    );
+  }
+  get walletAddress() {
+    return this.transport.walletAddress;
+  }
+  get provider() {
+    return this.transport.provider;
+  }
+  async signApiMessage(message) {
+    const signature = await this.transport.signMessage(message);
+    if (!nacl2.sign.detached.verify(message, signature, this.publicKey)) {
+      throw new RemoteSigningError(
+        this.transport.provider,
+        "message signature did not verify for the agent wallet"
+      );
+    }
+    return bs586.encode(signature);
+  }
+  sign(serializedTransaction) {
+    return externallySignedAgentTransaction({
+      transport: this.transport,
+      serializedTransaction
+    });
+  }
+};
+
+// ../../src/client/signer-transports/circle.ts
+import {
+  constants,
+  createPublicKey,
+  publicEncrypt
+} from "node:crypto";
+var PROVIDER = "circle";
+var DEFAULT_BASE_URL = "https://api.circle.com";
+async function createCircleSignerTransport(config) {
+  if (!/^[0-9a-fA-F]{64}$/.test(config.entitySecret)) {
+    throw new RemoteSigningError(
+      PROVIDER,
+      "entity secret must be 32 bytes of hex (64 hex chars)"
+    );
+  }
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const request = async (method, path, body) => {
+    const json = await providerJsonRequest({
+      provider: PROVIDER,
+      fetchImpl,
+      baseUrl,
+      path,
+      method,
+      headers: { authorization: `Bearer ${config.apiKey}` },
+      body
+    });
+    const data = json?.data;
+    if (data === void 0) {
+      throw new RemoteSigningError(
+        PROVIDER,
+        `${method} ${path} returned no data envelope`,
+        json
+      );
+    }
+    return data;
+  };
+  const walletData = await request("GET", `/v1/w3s/wallets/${config.walletId}`);
+  const wallet = walletData.wallet;
+  if (wallet?.address === void 0) {
+    throw new RemoteSigningError(
+      PROVIDER,
+      `wallet ${config.walletId} has no address`,
+      walletData
+    );
+  }
+  if (wallet.blockchain !== "SOL") {
+    throw new RemoteSigningError(
+      PROVIDER,
+      `wallet ${config.walletId} is on ${String(
+        wallet.blockchain
+      )}, expected SOL (Solana mainnet)`
+    );
+  }
+  const walletAddress = wallet.address;
+  let entityPublicKey = null;
+  const entitySecretCiphertext = async () => {
+    if (entityPublicKey === null) {
+      const data = await request("GET", "/v1/w3s/config/entity/publicKey");
+      const publicKey2 = data.publicKey;
+      if (typeof publicKey2 !== "string") {
+        throw new RemoteSigningError(
+          PROVIDER,
+          "entity public key response has no publicKey",
+          data
+        );
+      }
+      entityPublicKey = createPublicKey(publicKey2);
+    }
+    return publicEncrypt(
+      {
+        key: entityPublicKey,
+        padding: constants.RSA_PKCS1_OAEP_PADDING,
+        oaepHash: "sha256"
+      },
+      Buffer.from(config.entitySecret, "hex")
+    ).toString("base64");
+  };
+  return {
+    provider: PROVIDER,
+    walletAddress,
+    async signMessage(message) {
+      const data = await request("POST", "/v1/w3s/developer/sign/message", {
+        walletId: config.walletId,
+        message: `0x${Buffer.from(message).toString("hex")}`,
+        encodedByHex: true,
+        entitySecretCiphertext: await entitySecretCiphertext()
+      });
+      const signature = data.signature;
+      if (typeof signature !== "string") {
+        throw new RemoteSigningError(
+          PROVIDER,
+          "sign/message returned no signature",
+          data
+        );
+      }
+      return verifiedEd25519Signature({
+        provider: PROVIDER,
+        encodedSignature: signature,
+        message,
+        walletAddress
+      });
+    },
+    async signTransaction(serializedTransactionBase64) {
+      const data = await request(
+        "POST",
+        "/v1/w3s/developer/sign/transaction",
+        {
+          walletId: config.walletId,
+          rawTransaction: serializedTransactionBase64,
+          entitySecretCiphertext: await entitySecretCiphertext()
+        }
+      );
+      const signedTransaction = data.signedTransaction;
+      if (typeof signedTransaction !== "string") {
+        throw new RemoteSigningError(
+          PROVIDER,
+          "sign/transaction returned no signedTransaction",
+          data
+        );
+      }
+      return signedTransaction;
+    }
+  };
+}
+
+// ../../src/client/signer-transports/privy.ts
+import { createPrivateKey, createSign } from "node:crypto";
+var PROVIDER2 = "privy";
+var DEFAULT_BASE_URL2 = "https://api.privy.io";
+function canonicalJson(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(canonicalJson).join(",")}]`;
+  }
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function parseAuthorizationKey(base64Pkcs8) {
+  const stripped = base64Pkcs8.replace(/^wallet-auth:/, "").trim();
+  try {
+    return createPrivateKey({
+      key: Buffer.from(stripped, "base64"),
+      format: "der",
+      type: "pkcs8"
+    });
+  } catch (error) {
+    throw new RemoteSigningError(
+      PROVIDER2,
+      "authorization key is not a base64 PKCS#8 P-256 private key",
+      error
+    );
+  }
+}
+function authorizationSignature(params) {
+  const payload = {
+    version: 1,
+    method: params.method,
+    url: params.url,
+    body: params.body,
+    headers: { "privy-app-id": params.appId }
+  };
+  const signer2 = createSign("sha256");
+  signer2.update(canonicalJson(payload));
+  return signer2.sign(params.key).toString("base64");
+}
+async function createPrivySignerTransport(config) {
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/$/, "");
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const authorizationKey = config.authorizationPrivateKey === void 0 ? null : parseAuthorizationKey(config.authorizationPrivateKey);
+  const baseHeaders = {
+    authorization: `Basic ${Buffer.from(
+      `${config.appId}:${config.appSecret}`
+    ).toString("base64")}`,
+    "privy-app-id": config.appId
+  };
+  const request = async (method, path, body) => {
+    const headers = authorizationKey !== null && method !== "GET" && body !== void 0 ? {
+      ...baseHeaders,
+      "privy-authorization-signature": authorizationSignature({
+        key: authorizationKey,
+        appId: config.appId,
+        method,
+        url: `${baseUrl}${path}`,
+        body
+      })
+    } : baseHeaders;
+    const json = await providerJsonRequest({
+      provider: PROVIDER2,
+      fetchImpl,
+      baseUrl,
+      path,
+      method,
+      headers,
+      body
+    });
+    if (json === null || typeof json !== "object") {
+      throw new RemoteSigningError(
+        PROVIDER2,
+        `${method} ${path} returned a non-JSON body`
+      );
+    }
+    return json;
+  };
+  const rpc2 = async (body) => {
+    const response = await request(
+      "POST",
+      `/v1/wallets/${config.walletId}/rpc`,
+      body
+    );
+    const data = response.data;
+    if (data === null || typeof data !== "object") {
+      throw new RemoteSigningError(PROVIDER2, "rpc returned no data", response);
+    }
+    return data;
+  };
+  const wallet = await request("GET", `/v1/wallets/${config.walletId}`);
+  const walletAddress = wallet.address;
+  if (typeof walletAddress !== "string") {
+    throw new RemoteSigningError(
+      PROVIDER2,
+      `wallet ${config.walletId} has no address`,
+      wallet
+    );
+  }
+  if (wallet.chain_type !== "solana") {
+    throw new RemoteSigningError(
+      PROVIDER2,
+      `wallet ${config.walletId} is ${String(
+        wallet.chain_type
+      )}, expected solana`
+    );
+  }
+  return {
+    provider: PROVIDER2,
+    walletAddress,
+    async signMessage(message) {
+      const data = await rpc2({
+        chain_type: "solana",
+        method: "signMessage",
+        params: {
+          message: Buffer.from(message).toString("base64"),
+          encoding: "base64"
+        }
+      });
+      const signature = data.signature;
+      if (typeof signature !== "string") {
+        throw new RemoteSigningError(
+          PROVIDER2,
+          "signMessage returned no signature",
+          data
+        );
+      }
+      return verifiedEd25519Signature({
+        provider: PROVIDER2,
+        encodedSignature: signature,
+        message,
+        walletAddress
+      });
+    },
+    async signTransaction(serializedTransactionBase64) {
+      const data = await rpc2({
+        chain_type: "solana",
+        method: "signTransaction",
+        params: {
+          transaction: serializedTransactionBase64,
+          encoding: "base64"
+        }
+      });
+      const signedTransaction = data.signed_transaction;
+      if (typeof signedTransaction !== "string") {
+        throw new RemoteSigningError(
+          PROVIDER2,
+          "signTransaction returned no signed_transaction",
+          data
+        );
+      }
+      return signedTransaction;
+    }
+  };
+}
+
+// ../../src/client/signer-env.ts
+async function agentWalletSignerFromEnv(env = process.env) {
+  const nonEmpty = (value) => {
+    const trimmed = value?.trim();
+    return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
+  };
+  const provider = nonEmpty(env.SUBLY_SIGNER_PROVIDER)?.toLowerCase() ?? "local";
+  const pickVar = (name) => nonEmpty(env[`SUBLY_${name}`]) ?? nonEmpty(env[name]);
+  const requireVar = (name) => {
+    const value = pickVar(name);
+    if (value === void 0) {
+      throw new Error(
+        `${name} (or SUBLY_${name}) is required for SUBLY_SIGNER_PROVIDER=${provider}`
+      );
+    }
+    return value;
+  };
+  if (provider === "local") {
+    const localSecretKey = loadSecretKeyBytes({
+      base58Secret: env.SUBLY_DEMO_AGENT_KEYPAIR,
+      jsonFilePath: env.SUBLY_DEMO_AGENT_KEYPAIR_PATH,
+      label: "SUBLY_DEMO_AGENT_KEYPAIR"
+    });
+    return {
+      provider,
+      signer: new LocalKeypairAgentWalletSigner(
+        await createKeyPairSignerFromBytes2(localSecretKey)
+      ),
+      localSecretKey
+    };
+  }
+  if (provider === "circle") {
+    const transport = await createCircleSignerTransport({
+      apiKey: requireVar("CIRCLE_API_KEY"),
+      entitySecret: requireVar("CIRCLE_ENTITY_SECRET"),
+      walletId: requireVar("CIRCLE_WALLET_ID"),
+      baseUrl: pickVar("CIRCLE_BASE_URL")
+    });
+    return { provider, signer: new RemoteAgentWalletSigner(transport), transport };
+  }
+  if (provider === "privy") {
+    const transport = await createPrivySignerTransport({
+      appId: requireVar("PRIVY_APP_ID"),
+      appSecret: requireVar("PRIVY_APP_SECRET"),
+      walletId: requireVar("PRIVY_WALLET_ID"),
+      authorizationPrivateKey: pickVar("PRIVY_AUTHORIZATION_KEY"),
+      baseUrl: pickVar("PRIVY_BASE_URL")
+    });
+    return { provider, signer: new RemoteAgentWalletSigner(transport), transport };
+  }
+  throw new Error(
+    `unknown SUBLY_SIGNER_PROVIDER "${provider}" (expected local, circle, or privy)`
+  );
+}
+
+// ../../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";
@@ -987,8 +1828,8 @@ async function fetchLookupTablesForTransaction(rpc2, serializedTransaction) {
 
 // ../../src/api/wallet-auth.ts
 import { createHash as createHash3 } from "node:crypto";
-import bs585 from "bs58";
-import nacl from "tweetnacl";
+import bs587 from "bs58";
+import nacl3 from "tweetnacl";
 var WALLET_AUTH_WALLET_HEADER = "x-subly-wallet";
 var WALLET_AUTH_SIGNED_AT_HEADER = "x-subly-signed-at";
 var WALLET_AUTH_SIGNATURE_HEADER = "x-subly-signature";
@@ -1008,7 +1849,10 @@ async function walletAuthHeaders(params) {
   const signedAtMs = String(Date.now());
   const message = walletAuthMessage({
     method: params.method,
-    path: new URL(params.url).pathname,
+    path: (() => {
+      const url = new URL(params.url);
+      return url.pathname + url.search;
+    })(),
     rawBody: params.body ?? "",
     signedAtMs
   });
@@ -1035,6 +1879,8 @@ var VaultFlowClientError = class extends Error {
   errorDetails;
 };
 var VaultFlowClient = class {
+  vault;
+  rpc;
   baseUrl;
   signer;
   fetchImpl;
@@ -1042,6 +1888,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;
@@ -1063,6 +1914,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 }
       });
@@ -1076,10 +1928,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,
@@ -1117,12 +1973,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,
@@ -1160,12 +2027,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,
@@ -1191,8 +2058,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",
@@ -1210,7 +2081,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 ?? [];
   }
@@ -1219,16 +2090,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) {
@@ -1375,31 +2251,6 @@ function parseRelayerError(text) {
   }
 }
 
-// ../../src/solana/keys.ts
-import { readFileSync } from "node:fs";
-import bs586 from "bs58";
-import {
-  createKeyPairSignerFromBytes
-} from "@solana/kit";
-async function loadKeyPairSigner(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 createKeyPairSignerFromBytes(bytes);
-  }
-  if (jsonFilePath !== void 0 && jsonFilePath.length > 0) {
-    const raw = JSON.parse(readFileSync(jsonFilePath, "utf8"));
-    if (!Array.isArray(raw) || raw.length !== 64) {
-      throw new Error(`${label} keypair file must be a 64-byte JSON array`);
-    }
-    return createKeyPairSignerFromBytes(Uint8Array.from(raw));
-  }
-  throw new Error(`${label} keypair is not configured`);
-}
-
 // ../../src/solana/rpc.ts
 import { createSolanaRpc } from "@solana/kit";
 function createRpc(url) {
@@ -1430,12 +2281,7 @@ var approvalId = process.argv[3];
 if (approvalId !== void 0 && !/^apr_[0-9a-f]+$/i.test(approvalId)) {
   fail(`unrecognized argument: ${approvalId} (expected apr_<approvalId>)`);
 }
-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 signer = new LocalKeypairAgentWalletSigner(keyPairSigner);
+var { signer } = await agentWalletSignerFromEnv();
 var rpc = createRpc(
   process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com"
 );