@subly_fi/pay 0.5.0 → 0.6.1

package/dist/setup-link.js

@@ -0,0 +1,1502 @@
+// ../../src/client/agent-wallet-signer.ts
+import { signBytes } from "@solana/kit";
+import bs584 from "bs58";
+
+// ../../src/solana/tx.ts
+import bs58 from "bs58";
+import {
+  appendTransactionMessageInstructions,
+  compileTransaction,
+  compressTransactionMessageUsingAddressLookupTables,
+  createTransactionMessage,
+  getBase64EncodedWireTransaction,
+  getTransactionDecoder,
+  partiallySignTransaction,
+  pipe,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash
+} from "@solana/kit";
+
+// ../../src/lib/hash.ts
+import { createHash } from "node:crypto";
+function sha256TaggedHex(data) {
+  return `sha256-${createHash("sha256").update(data).digest("hex")}`;
+}
+function stableStringify(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "bigint") {
+    return JSON.stringify(value.toString());
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const keys = Object.keys(value).filter((key) => value[key] !== void 0).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+function hashStableJson(value) {
+  return sha256TaggedHex(stableStringify(value));
+}
+
+// ../../src/solana/tx.ts
+function decodeSerializedTransaction(serializedBase64) {
+  return getTransactionDecoder().decode(Buffer.from(serializedBase64, "base64"));
+}
+async function addSignaturesToSerializedTransaction(params) {
+  const decoded = decodeSerializedTransaction(params.serializedBase64);
+  const signed = await partiallySignTransaction(params.signers, decoded);
+  return {
+    serializedBase64: getBase64EncodedWireTransaction(signed),
+    transaction: signed
+  };
+}
+function signatureBase58ForSigner(transaction, signer2) {
+  const signature = transaction.signatures[signer2];
+  if (signature === null || signature === void 0) {
+    return null;
+  }
+  return bs58.encode(signature);
+}
+
+// ../../src/client/transaction-intent-validator.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"
+};
+var USDC_DECIMALS = 6;
+
+// ../../src/domain/request-binding.ts
+function computeRequestBindingHash(fields) {
+  return hashStableJson({
+    sellerRequestId: fields.sellerRequestId,
+    httpMethod: fields.httpMethod.toUpperCase(),
+    canonicalResourceUrl: fields.canonicalResourceUrl,
+    requestBodyHash: fields.requestBodyHash,
+    seller: fields.seller,
+    asset: fields.asset,
+    amountRawUsdc: fields.amountRawUsdc,
+    payTo: fields.payTo,
+    sellerUsdcAta: fields.sellerUsdcAta
+  });
+}
+
+// ../../src/lib/associated-token-account.ts
+import { createHash as createHash2 } from "node:crypto";
+import bs582 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);
+function deriveAssociatedTokenAddress(params) {
+  const owner = decodePublicKey(params.owner, "owner");
+  const mint = decodePublicKey(params.mint ?? SUBLY_VAULT.usdcMint, "mint");
+  const tokenProgramId = decodePublicKey(
+    params.tokenProgramId ?? SPL_TOKEN_PROGRAM_ID,
+    "tokenProgramId"
+  );
+  const associatedTokenProgramId = decodePublicKey(
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    "associatedTokenProgramId"
+  );
+  for (let bump = 255; bump >= 0; bump -= 1) {
+    const address2 = createProgramAddress(
+      [owner, tokenProgramId, mint, Uint8Array.of(bump)],
+      associatedTokenProgramId
+    );
+    if (address2 !== null) {
+      return bs582.encode(address2);
+    }
+  }
+  throw new Error("Unable to derive associated token account address");
+}
+function createProgramAddress(seeds, programId) {
+  const hash = createHash2("sha256");
+  for (const seed of seeds) {
+    hash.update(seed);
+  }
+  hash.update(programId);
+  hash.update(PDA_MARKER);
+  const digest = hash.digest();
+  return isEd25519Point(digest) ? null : new Uint8Array(digest);
+}
+function decodePublicKey(value, fieldName) {
+  const decoded = bs582.decode(value);
+  if (decoded.length !== 32) {
+    throw new Error(`${fieldName} must be a 32-byte public key`);
+  }
+  return decoded;
+}
+function isEd25519Point(bytes) {
+  if (bytes.length !== 32) {
+    return false;
+  }
+  const yBytes = Uint8Array.from(bytes);
+  yBytes[31] = yBytes[31] & 127;
+  const y = littleEndianToBigInt(yBytes);
+  if (y >= ED25519_P) {
+    return false;
+  }
+  const ySquared = mod(y * y, ED25519_P);
+  const numerator = mod(ySquared - 1n, ED25519_P);
+  const denominator = mod(ED25519_D * ySquared + 1n, ED25519_P);
+  if (denominator === 0n) {
+    return false;
+  }
+  const xSquared = mod(
+    numerator * modPow(denominator, ED25519_P - 2n, ED25519_P),
+    ED25519_P
+  );
+  return xSquared === 0n || modPow(xSquared, (ED25519_P - 1n) / 2n, ED25519_P) === 1n;
+}
+function littleEndianToBigInt(bytes) {
+  let value = 0n;
+  for (let index = bytes.length - 1; index >= 0; index -= 1) {
+    value = (value << 8n) + BigInt(bytes[index]);
+  }
+  return value;
+}
+function mod(value, modulus) {
+  const result = value % modulus;
+  return result >= 0n ? result : result + modulus;
+}
+function modPow(base, exponent, modulus) {
+  let result = 1n;
+  let nextBase = mod(base, modulus);
+  let nextExponent = exponent;
+  while (nextExponent > 0n) {
+    if ((nextExponent & 1n) === 1n) {
+      result = mod(result * nextBase, modulus);
+    }
+    nextBase = mod(nextBase * nextBase, modulus);
+    nextExponent >>= 1n;
+  }
+  return result;
+}
+
+// ../../src/client/transaction-intent-validator.ts
+var COMPUTE_BUDGET_PROGRAM_ID = "ComputeBudget111111111111111111111111111111";
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+var ASSOCIATED_TOKEN_PROGRAM_ID2 = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var MEMO_PROGRAM_ID = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+var KVAULT_PROGRAM_ID = "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd";
+var KAMINO_FARMS_PROGRAM_ID = "FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr";
+var KVAULT_WITHDRAW_DISCRIMINATOR = Uint8Array.from([
+  183,
+  18,
+  70,
+  156,
+  148,
+  109,
+  161,
+  34
+]);
+var KVAULT_WITHDRAW_FROM_AVAILABLE_DISCRIMINATOR = Uint8Array.from([
+  19,
+  131,
+  112,
+  155,
+  170,
+  220,
+  34,
+  57
+]);
+var KVAULT_DEPOSIT_DISCRIMINATOR = Uint8Array.from([
+  242,
+  35,
+  198,
+  137,
+  82,
+  225,
+  242,
+  182
+]);
+var U64_MAX = 18446744073709551615n;
+var MAX_TEMP_ACCOUNT_LAMPORTS = 10000000n;
+var DEFAULT_MAX_COMPUTE_UNIT_LIMIT = 14e5;
+var DEFAULT_MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS = 100000n;
+var IntentValidationError = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "IntentValidationError";
+    this.reason = reason;
+  }
+};
+function reject(reason, message) {
+  throw new IntentValidationError(reason, message);
+}
+function decodeIntentTransaction(params) {
+  const wire = Buffer.from(params.serializedTransaction, "base64");
+  const signatureCount = readShortVec(wire, 0);
+  if (signatureCount === null) {
+    reject("invalid_transaction_encoding", "Cannot parse signature count");
+  }
+  const messageOffset = signatureCount.nextOffset + signatureCount.value * 64;
+  if (messageOffset >= wire.length) {
+    reject("invalid_transaction_encoding", "Transaction has no message bytes");
+  }
+  const messageBytes = wire.subarray(messageOffset);
+  const compiled = getCompiledTransactionMessageDecoder().decode(messageBytes);
+  if (compiled.version !== 0) {
+    reject("unsupported_transaction_version", "Only v0 transactions are supported");
+  }
+  const staticAccounts = compiled.staticAccounts.map(String);
+  const loadedWritable = [];
+  const loadedReadonly = [];
+  const lookups = compiled.addressTableLookups ?? [];
+  for (const rawLookup of lookups) {
+    const lookup = rawLookup;
+    const table = params.lookupTables?.[String(lookup.lookupTableAddress)];
+    if (table === void 0) {
+      reject(
+        "lookup_table_unresolved",
+        `Transaction references unknown lookup table ${lookup.lookupTableAddress}`
+      );
+    }
+    const writableIndexes = lookup.writableIndexes ?? lookup.writableIndices ?? [];
+    const readonlyIndexes = lookup.readonlyIndexes ?? lookup.readableIndices ?? [];
+    for (const index of writableIndexes) {
+      const resolved = table[index];
+      if (resolved === void 0) {
+        reject("lookup_table_unresolved", "Lookup table index out of range");
+      }
+      loadedWritable.push(String(resolved));
+    }
+    for (const index of readonlyIndexes) {
+      const resolved = table[index];
+      if (resolved === void 0) {
+        reject("lookup_table_unresolved", "Lookup table index out of range");
+      }
+      loadedReadonly.push(String(resolved));
+    }
+  }
+  const orderedAccounts = [...staticAccounts, ...loadedWritable, ...loadedReadonly];
+  const instructions = compiled.instructions.map(
+    (instruction) => {
+      const programAddress = orderedAccounts[instruction.programAddressIndex];
+      if (programAddress === void 0) {
+        reject("invalid_transaction_encoding", "Program index out of range");
+      }
+      const accounts = (instruction.accountIndices ?? []).map((index) => {
+        const account = orderedAccounts[index];
+        if (account === void 0) {
+          reject("invalid_transaction_encoding", "Account index out of range");
+        }
+        return account;
+      });
+      return {
+        programAddress,
+        accounts,
+        data: instruction.data === void 0 ? new Uint8Array() : Uint8Array.from(instruction.data)
+      };
+    }
+  );
+  const feePayer = staticAccounts[0];
+  if (feePayer === void 0) {
+    reject("invalid_transaction_encoding", "Transaction has no fee payer");
+  }
+  return {
+    feePayer,
+    requiredSigners: staticAccounts.slice(0, compiled.header.numSignerAccounts),
+    instructions,
+    messageHash: sha256TaggedHex(Buffer.from(messageBytes))
+  };
+}
+function validatePaymentIntentTransaction(params) {
+  const { intent } = params;
+  const now = params.nowMs ?? Date.now();
+  const policy2 = resolveIntentValidationPolicy(params.policy);
+  if (new Date(intent.expiresAt).getTime() <= now) {
+    reject("expired", "Payment intent has expired");
+  }
+  if (intent.scheme !== PAYMENT_SCHEME) {
+    reject("scheme_mismatch", `scheme must be ${PAYMENT_SCHEME}`);
+  }
+  if (intent.network !== SOLANA_MAINNET_NETWORK) {
+    reject("network_mismatch", "Unsupported network");
+  }
+  if (intent.vault !== SUBLY_VAULT.address) {
+    reject("vault_mismatch", "Unsupported vault");
+  }
+  if (intent.shareMint !== SUBLY_VAULT.shareMint) {
+    reject("share_mint_mismatch", "Unsupported share mint");
+  }
+  if (intent.asset !== SUBLY_VAULT.usdcMint) {
+    reject("asset_mismatch", "Only USDC payments are supported");
+  }
+  if (intent.memo !== intent.paymentId) {
+    reject("memo_mismatch", "Memo must equal the paymentId");
+  }
+  const expectedBinding = computeRequestBindingHash({
+    sellerRequestId: intent.sellerRequestId,
+    httpMethod: intent.httpMethod,
+    canonicalResourceUrl: intent.canonicalResourceUrl,
+    requestBodyHash: intent.requestBodyHash,
+    seller: intent.seller,
+    asset: intent.asset,
+    amountRawUsdc: intent.amountRawUsdc,
+    payTo: intent.payTo,
+    sellerUsdcAta: intent.sellerUsdcAta
+  });
+  if (expectedBinding !== intent.requestBindingHash) {
+    reject(
+      "request_binding_mismatch",
+      "requestBindingHash does not match the request fields"
+    );
+  }
+  const expectedSellerAta = deriveAssociatedTokenAddress({
+    owner: intent.payTo,
+    mint: intent.asset
+  });
+  if (expectedSellerAta !== intent.sellerUsdcAta) {
+    reject(
+      "seller_ata_mismatch",
+      "sellerUsdcAta must be the associated USDC account for payTo"
+    );
+  }
+  const expectedDustAta = deriveAssociatedTokenAddress({
+    owner: intent.wallet,
+    mint: intent.asset
+  });
+  if (expectedDustAta !== intent.dustRecipientUsdcAta) {
+    reject(
+      "dust_recipient_mismatch",
+      "dustRecipientUsdcAta must be the agent wallet's USDC ATA"
+    );
+  }
+  const decoded = decodeIntentTransaction({
+    serializedTransaction: params.serializedTransaction,
+    ...params.lookupTables === void 0 ? {} : { lookupTables: params.lookupTables }
+  });
+  if (decoded.messageHash !== intent.preparedMessageHash) {
+    reject("message_hash_mismatch", "Prepared message hash mismatch");
+  }
+  if (decoded.feePayer !== intent.feePayer) {
+    reject("fee_payer_mismatch", "Transaction fee payer is not the Subly sponsor");
+  }
+  const expectedSigners = /* @__PURE__ */ new Set([
+    intent.feePayer,
+    intent.wallet,
+    intent.temporarySettlementTokenAccount
+  ]);
+  if (decoded.requiredSigners.length !== expectedSigners.size || !decoded.requiredSigners.every((signer2) => expectedSigners.has(signer2))) {
+    reject(
+      "unexpected_signers",
+      "Transaction signers must be exactly the sponsor, the agent wallet, and the temporary settlement account"
+    );
+  }
+  const ixs = [...decoded.instructions];
+  expectComputeBudgetPair(ixs, policy2);
+  expectCreateTemporaryAccount(ixs, intent, policy2);
+  expectInitializeTemporaryAccount(ixs, intent);
+  consumeFarmInstructions(ixs, intent.wallet);
+  expectKvaultWithdraw(ixs, {
+    wallet: intent.wallet,
+    vault: intent.vault,
+    shareMint: intent.shareMint,
+    asset: intent.asset,
+    userTokenAccount: intent.temporarySettlementTokenAccount,
+    maxSharesToRedeemRaw: BigInt(intent.maxSharesToRedeemRaw),
+    allowFullExit: false
+  });
+  expectTransferChecked(ixs, {
+    source: intent.temporarySettlementTokenAccount,
+    mint: intent.asset,
+    destination: intent.sellerUsdcAta,
+    authority: intent.wallet,
+    amount: BigInt(intent.amountRawUsdc),
+    label: "seller transfer"
+  });
+  if (ixs[0] !== void 0 && ixs[0].programAddress === SPL_TOKEN_PROGRAM_ID && ixs[0].data[0] === 12) {
+    expectTransferChecked(ixs, {
+      source: intent.temporarySettlementTokenAccount,
+      mint: intent.asset,
+      destination: intent.dustRecipientUsdcAta,
+      authority: intent.wallet,
+      amount: null,
+      label: "dust sweep"
+    });
+  }
+  expectCloseAccount(ixs, {
+    account: intent.temporarySettlementTokenAccount,
+    destination: intent.feePayer,
+    owner: intent.wallet
+  });
+  expectMemo(ixs, intent.memo);
+  if (ixs.length > 0) {
+    reject(
+      "unexpected_instruction",
+      `Transaction contains ${ixs.length} unexpected trailing instruction(s)`
+    );
+  }
+}
+function validateDepositIntentTransaction(params) {
+  const { intent } = params;
+  const now = params.nowMs ?? Date.now();
+  const policy2 = resolveIntentValidationPolicy(params.policy);
+  if (new Date(intent.expiresAt).getTime() <= now) {
+    reject("expired", "Deposit intent has expired");
+  }
+  assertVaultIntentTargets(intent);
+  const decoded = decodeIntentTransaction({
+    serializedTransaction: params.serializedTransaction,
+    ...params.lookupTables === void 0 ? {} : { lookupTables: params.lookupTables }
+  });
+  if (decoded.messageHash !== intent.preparedMessageHash) {
+    reject("message_hash_mismatch", "Prepared message hash mismatch");
+  }
+  if (decoded.feePayer !== intent.feePayer) {
+    reject("fee_payer_mismatch", "Transaction fee payer is not the Subly sponsor");
+  }
+  let sawDeposit = false;
+  for (const ix of decoded.instructions) {
+    switch (ix.programAddress) {
+      case COMPUTE_BUDGET_PROGRAM_ID:
+        validateComputeBudgetInstruction(ix, policy2);
+        break;
+      case ASSOCIATED_TOKEN_PROGRAM_ID2:
+        expectAtaCreateForOwner(ix, intent.wallet);
+        break;
+      case MEMO_PROGRAM_ID:
+        break;
+      case KVAULT_PROGRAM_ID: {
+        if (!bytesStartWith(ix.data, KVAULT_DEPOSIT_DISCRIMINATOR)) {
+          reject("unexpected_instruction", "Unexpected KVault instruction in deposit");
+        }
+        const maxAmount = readU64LE(ix.data, 8);
+        if (maxAmount !== BigInt(intent.amountRawUsdc)) {
+          reject("amount_mismatch", "Deposit amount does not match the intent");
+        }
+        if (ix.accounts[0] !== intent.wallet) {
+          reject("wallet_mismatch", "Deposit user is not the agent wallet");
+        }
+        if (ix.accounts[1] !== intent.vault) {
+          reject("vault_mismatch", "Deposit vault mismatch");
+        }
+        if (ix.accounts[3] !== intent.asset) {
+          reject("asset_mismatch", "Deposit token mint mismatch");
+        }
+        if (ix.accounts[5] !== intent.shareMint) {
+          reject("share_mint_mismatch", "Deposit share mint mismatch");
+        }
+        const expectedSourceAta = deriveAssociatedTokenAddress({
+          owner: intent.wallet,
+          mint: intent.asset
+        });
+        if (ix.accounts[6] !== expectedSourceAta) {
+          reject(
+            "source_ata_mismatch",
+            "Deposit source must be the agent wallet's USDC ATA"
+          );
+        }
+        sawDeposit = true;
+        break;
+      }
+      default:
+        reject(
+          "unexpected_instruction",
+          `Unexpected program ${ix.programAddress} in deposit transaction`
+        );
+    }
+  }
+  if (!sawDeposit) {
+    reject("missing_instruction", "Deposit transaction has no KVault deposit");
+  }
+}
+function validateWithdrawalIntentTransaction(params) {
+  const { intent } = params;
+  const now = params.nowMs ?? Date.now();
+  const policy2 = resolveIntentValidationPolicy(params.policy);
+  if (new Date(intent.expiresAt).getTime() <= now) {
+    reject("expired", "Withdrawal intent has expired");
+  }
+  assertVaultIntentTargets(intent);
+  const expectedDestination = deriveAssociatedTokenAddress({
+    owner: intent.wallet,
+    mint: intent.asset
+  });
+  if (expectedDestination !== intent.destinationUsdcAta) {
+    reject(
+      "destination_mismatch",
+      "Withdrawal destination must be the agent wallet's USDC ATA"
+    );
+  }
+  const decoded = decodeIntentTransaction({
+    serializedTransaction: params.serializedTransaction,
+    ...params.lookupTables === void 0 ? {} : { lookupTables: params.lookupTables }
+  });
+  if (decoded.messageHash !== intent.preparedMessageHash) {
+    reject("message_hash_mismatch", "Prepared message hash mismatch");
+  }
+  if (decoded.feePayer !== intent.feePayer) {
+    reject("fee_payer_mismatch", "Transaction fee payer is not the Subly sponsor");
+  }
+  let sawWithdraw = false;
+  for (const ix of decoded.instructions) {
+    switch (ix.programAddress) {
+      case COMPUTE_BUDGET_PROGRAM_ID:
+        validateComputeBudgetInstruction(ix, policy2);
+        break;
+      case MEMO_PROGRAM_ID:
+      case KAMINO_FARMS_PROGRAM_ID:
+        break;
+      case ASSOCIATED_TOKEN_PROGRAM_ID2:
+        expectAtaCreateForOwner(ix, intent.wallet);
+        break;
+      case SPL_TOKEN_PROGRAM_ID: {
+        if (ix.data[0] !== 9) {
+          reject(
+            "unexpected_instruction",
+            "Only CloseAccount token instructions are allowed in withdrawals"
+          );
+        }
+        if (ix.accounts[1] !== intent.wallet || ix.accounts[2] !== intent.wallet) {
+          reject(
+            "unexpected_instruction",
+            "Withdrawal CloseAccount must pay out to the agent wallet"
+          );
+        }
+        break;
+      }
+      case KVAULT_PROGRAM_ID: {
+        validateKvaultWithdrawInstruction(ix, {
+          wallet: intent.wallet,
+          vault: intent.vault,
+          shareMint: intent.shareMint,
+          asset: intent.asset,
+          userTokenAccount: intent.destinationUsdcAta,
+          maxSharesToRedeemRaw: BigInt(intent.maxSharesToRedeemRaw),
+          allowFullExit: intent.allowFullExit
+        });
+        sawWithdraw = true;
+        break;
+      }
+      default:
+        reject(
+          "unexpected_instruction",
+          `Unexpected program ${ix.programAddress} in withdrawal transaction`
+        );
+    }
+  }
+  if (!sawWithdraw) {
+    reject("missing_instruction", "Withdrawal transaction has no KVault withdraw");
+  }
+}
+function assertVaultIntentTargets(intent) {
+  if (intent.vault !== SUBLY_VAULT.address) {
+    reject("vault_mismatch", "Unsupported vault");
+  }
+  if (intent.shareMint !== SUBLY_VAULT.shareMint) {
+    reject("share_mint_mismatch", "Unsupported share mint");
+  }
+  if (intent.asset !== SUBLY_VAULT.usdcMint) {
+    reject("asset_mismatch", "Only USDC is supported");
+  }
+}
+function resolveIntentValidationPolicy(policy2) {
+  const resolved = {
+    maxComputeUnitLimit: policy2?.maxComputeUnitLimit ?? DEFAULT_MAX_COMPUTE_UNIT_LIMIT,
+    maxComputeUnitPriceMicroLamports: policy2?.maxComputeUnitPriceMicroLamports ?? DEFAULT_MAX_COMPUTE_UNIT_PRICE_MICRO_LAMPORTS,
+    maxTemporaryAccountLamports: policy2?.maxTemporaryAccountLamports ?? MAX_TEMP_ACCOUNT_LAMPORTS
+  };
+  if (!Number.isSafeInteger(resolved.maxComputeUnitLimit) || resolved.maxComputeUnitLimit <= 0) {
+    reject("invalid_policy", "maxComputeUnitLimit must be a positive safe integer");
+  }
+  if (resolved.maxComputeUnitPriceMicroLamports < 0n) {
+    reject(
+      "invalid_policy",
+      "maxComputeUnitPriceMicroLamports must be non-negative"
+    );
+  }
+  if (resolved.maxTemporaryAccountLamports <= 0n) {
+    reject("invalid_policy", "maxTemporaryAccountLamports must be positive");
+  }
+  return resolved;
+}
+function expectComputeBudgetPair(ixs, policy2) {
+  for (const discriminator of [2, 3]) {
+    const ix = ixs.shift();
+    if (ix === void 0 || ix.programAddress !== COMPUTE_BUDGET_PROGRAM_ID || ix.data[0] !== discriminator) {
+      reject(
+        "compute_budget_mismatch",
+        "Transaction must start with ComputeBudget limit and price instructions"
+      );
+    }
+    validateComputeBudgetInstruction(ix, policy2);
+  }
+}
+function validateComputeBudgetInstruction(ix, policy2) {
+  switch (ix.data[0]) {
+    case 2: {
+      const units = readU32LE(ix.data, 1);
+      if (units <= 0 || units > policy2.maxComputeUnitLimit) {
+        reject(
+          "compute_budget_mismatch",
+          `Compute unit limit ${units} exceeds policy maximum ${policy2.maxComputeUnitLimit}`
+        );
+      }
+      break;
+    }
+    case 3: {
+      const microLamports = readU64LE(ix.data, 1);
+      if (microLamports > policy2.maxComputeUnitPriceMicroLamports) {
+        reject(
+          "compute_budget_mismatch",
+          `Compute unit price ${microLamports} exceeds policy maximum ${policy2.maxComputeUnitPriceMicroLamports}`
+        );
+      }
+      break;
+    }
+    default:
+      reject("compute_budget_mismatch", "Unexpected ComputeBudget instruction");
+  }
+}
+function expectCreateTemporaryAccount(ixs, intent, policy2) {
+  const ix = ixs.shift();
+  if (ix === void 0 || ix.programAddress !== SYSTEM_PROGRAM_ID) {
+    reject("temp_account_mismatch", "Expected System createAccount instruction");
+  }
+  if (ix.data.length < 52 || readU32LE(ix.data, 0) !== 0) {
+    reject("temp_account_mismatch", "Expected createAccount discriminator");
+  }
+  const lamports = readU64LE(ix.data, 4);
+  const space = readU64LE(ix.data, 12);
+  const owner = bs583.encode(ix.data.subarray(20, 52));
+  if (space !== 165n) {
+    reject("temp_account_mismatch", "Temporary account space must be 165 bytes");
+  }
+  if (owner !== SPL_TOKEN_PROGRAM_ID) {
+    reject("temp_account_mismatch", "Temporary account owner must be the token program");
+  }
+  if (lamports > policy2.maxTemporaryAccountLamports) {
+    reject("temp_account_mismatch", "Temporary account rent exceeds the cap");
+  }
+  if (ix.accounts[0] !== intent.feePayer) {
+    reject("temp_account_mismatch", "Temporary account must be funded by the sponsor");
+  }
+  if (ix.accounts[1] !== intent.temporarySettlementTokenAccount) {
+    reject("temp_account_mismatch", "createAccount target is not the temporary account");
+  }
+}
+function expectInitializeTemporaryAccount(ixs, intent) {
+  const ix = ixs.shift();
+  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));
+  if (owner !== intent.wallet) {
+    reject(
+      "temp_account_mismatch",
+      "Temporary account token authority must be the agent wallet"
+    );
+  }
+  if (ix.accounts[0] !== intent.temporarySettlementTokenAccount) {
+    reject("temp_account_mismatch", "InitializeAccount3 target mismatch");
+  }
+  if (ix.accounts[1] !== intent.asset) {
+    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 expectKvaultWithdraw(ixs, expectation) {
+  const ix = ixs.shift();
+  if (ix === void 0 || ix.programAddress !== KVAULT_PROGRAM_ID) {
+    reject("withdraw_mismatch", "Expected KVault withdraw instruction");
+  }
+  validateKvaultWithdrawInstruction(ix, expectation);
+}
+function validateKvaultWithdrawInstruction(ix, expectation) {
+  const isWithdraw = bytesStartWith(ix.data, KVAULT_WITHDRAW_DISCRIMINATOR);
+  const isWithdrawFromAvailable = bytesStartWith(
+    ix.data,
+    KVAULT_WITHDRAW_FROM_AVAILABLE_DISCRIMINATOR
+  );
+  if (!isWithdraw && !isWithdrawFromAvailable) {
+    reject("withdraw_mismatch", "Unexpected KVault instruction");
+  }
+  const sharesAmount = readU64LE(ix.data, 8);
+  const fullExit = sharesAmount === U64_MAX;
+  if (fullExit && !expectation.allowFullExit) {
+    reject("withdraw_mismatch", "Full-exit share burn is not allowed for this intent");
+  }
+  if (!fullExit && sharesAmount > expectation.maxSharesToRedeemRaw) {
+    reject(
+      "shares_exceed_max",
+      `Withdraw burns ${sharesAmount} shares which exceeds the approved maximum ${expectation.maxSharesToRedeemRaw}`
+    );
+  }
+  if (ix.accounts[0] !== expectation.wallet) {
+    reject("withdraw_mismatch", "Withdraw user is not the agent wallet");
+  }
+  if (ix.accounts[1] !== expectation.vault) {
+    reject("withdraw_mismatch", "Withdraw vault mismatch");
+  }
+  if (ix.accounts[5] !== expectation.userTokenAccount) {
+    reject(
+      "withdraw_mismatch",
+      "Withdraw token destination is not the approved account"
+    );
+  }
+  if (ix.accounts[6] !== expectation.asset) {
+    reject("withdraw_mismatch", "Withdraw token mint mismatch");
+  }
+  const expectedSharesAta = deriveAssociatedTokenAddress({
+    owner: expectation.wallet,
+    mint: expectation.shareMint
+  });
+  if (ix.accounts[7] !== expectedSharesAta) {
+    reject("withdraw_mismatch", "Withdraw share source must be the agent share ATA");
+  }
+  if (ix.accounts[8] !== expectation.shareMint) {
+    reject("withdraw_mismatch", "Withdraw share mint mismatch");
+  }
+}
+function expectTransferChecked(ixs, expectation) {
+  const ix = ixs.shift();
+  if (ix === void 0 || ix.programAddress !== SPL_TOKEN_PROGRAM_ID || ix.data[0] !== 12) {
+    reject("transfer_mismatch", `Expected TransferChecked for ${expectation.label}`);
+  }
+  const amount = readU64LE(ix.data, 1);
+  const decimals = ix.data[9];
+  if (expectation.amount !== null && amount !== expectation.amount) {
+    reject(
+      "amount_mismatch",
+      `${expectation.label} amount ${amount} does not match ${expectation.amount}`
+    );
+  }
+  if (decimals !== USDC_DECIMALS) {
+    reject("transfer_mismatch", `${expectation.label} has unexpected decimals`);
+  }
+  if (ix.accounts[0] !== expectation.source) {
+    reject("transfer_mismatch", `${expectation.label} source mismatch`);
+  }
+  if (ix.accounts[1] !== expectation.mint) {
+    reject("transfer_mismatch", `${expectation.label} mint mismatch`);
+  }
+  if (ix.accounts[2] !== expectation.destination) {
+    reject("transfer_mismatch", `${expectation.label} destination mismatch`);
+  }
+  if (ix.accounts[3] !== expectation.authority) {
+    reject("transfer_mismatch", `${expectation.label} authority mismatch`);
+  }
+}
+function expectCloseAccount(ixs, expectation) {
+  const ix = ixs.shift();
+  if (ix === void 0 || ix.programAddress !== SPL_TOKEN_PROGRAM_ID || ix.data[0] !== 9) {
+    reject("close_mismatch", "Expected CloseAccount instruction");
+  }
+  if (ix.accounts[0] !== expectation.account) {
+    reject("close_mismatch", "CloseAccount target is not the temporary account");
+  }
+  if (ix.accounts[1] !== expectation.destination) {
+    reject("close_mismatch", "CloseAccount rent destination must be the sponsor");
+  }
+  if (ix.accounts[2] !== expectation.owner) {
+    reject("close_mismatch", "CloseAccount authority must be the agent wallet");
+  }
+}
+function expectMemo(ixs, memo) {
+  const ix = ixs.shift();
+  if (ix === void 0 || ix.programAddress !== MEMO_PROGRAM_ID) {
+    reject("memo_mismatch", "Expected Memo instruction");
+  }
+  if (Buffer.from(ix.data).toString("utf8") !== memo) {
+    reject("memo_mismatch", "Memo content does not match the paymentId");
+  }
+}
+function expectAtaCreateForOwner(ix, owner) {
+  if (ix.accounts[2] !== owner) {
+    reject(
+      "unexpected_instruction",
+      "Associated token account creation for a foreign owner"
+    );
+  }
+}
+function bytesStartWith(data, prefix) {
+  if (data.length < prefix.length) {
+    return false;
+  }
+  return prefix.every((byte, index) => data[index] === byte);
+}
+function readU64LE(data, offset) {
+  if (data.length < offset + 8) {
+    reject("invalid_transaction_encoding", "Instruction data too short for u64");
+  }
+  return Buffer.from(data.subarray(offset, offset + 8)).readBigUInt64LE(0);
+}
+function readU32LE(data, offset) {
+  if (data.length < offset + 4) {
+    reject("invalid_transaction_encoding", "Instruction data too short for u32");
+  }
+  return Buffer.from(data.subarray(offset, offset + 4)).readUInt32LE(0);
+}
+function readShortVec(bytes, startOffset) {
+  let value = 0;
+  let shift = 0;
+  let offset = startOffset;
+  while (offset < bytes.length) {
+    const byte = bytes[offset];
+    value |= (byte & 127) << shift;
+    offset += 1;
+    if ((byte & 128) === 0) {
+      return { value, nextOffset: offset };
+    }
+    shift += 7;
+    if (shift > 28) {
+      return null;
+    }
+  }
+  return null;
+}
+
+// ../../src/client/agent-wallet-signer.ts
+var LocalKeypairAgentWalletSigner = class {
+  validationMode = "structured_intent_transaction";
+  keyPairSigner;
+  validationPolicy;
+  constructor(keyPairSigner2, validationPolicy) {
+    this.keyPairSigner = keyPairSigner2;
+    this.validationPolicy = validationPolicy;
+  }
+  get walletAddress() {
+    return this.keyPairSigner.address;
+  }
+  async signPayment(params) {
+    this.assertIntentWallet(params.intent.wallet);
+    validatePaymentIntentTransaction({
+      ...params,
+      ...this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy }
+    });
+    return this.sign(params.serializedTransaction);
+  }
+  async signDeposit(params) {
+    this.assertIntentWallet(params.intent.wallet);
+    validateDepositIntentTransaction({
+      ...params,
+      ...this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy }
+    });
+    return this.sign(params.serializedTransaction);
+  }
+  async signWithdrawal(params) {
+    this.assertIntentWallet(params.intent.wallet);
+    validateWithdrawalIntentTransaction({
+      ...params,
+      ...this.validationPolicy === void 0 ? {} : { policy: this.validationPolicy }
+    });
+    return this.sign(params.serializedTransaction);
+  }
+  assertIntentWallet(wallet) {
+    if (wallet !== this.keyPairSigner.address) {
+      throw new IntentValidationError(
+        "wallet_mismatch",
+        "Intent wallet does not match this signer's wallet"
+      );
+    }
+  }
+  async signApiMessage(message) {
+    const signature = await signBytes(
+      this.keyPairSigner.keyPair.privateKey,
+      message
+    );
+    return bs584.encode(signature);
+  }
+  async sign(serializedTransaction) {
+    const { serializedBase64, transaction } = await addSignaturesToSerializedTransaction({
+      serializedBase64: serializedTransaction,
+      signers: [this.keyPairSigner.keyPair]
+    });
+    const agentSignature = signatureBase58ForSigner(
+      transaction,
+      this.keyPairSigner.address
+    );
+    if (agentSignature === null) {
+      throw new IntentValidationError(
+        "signing_failed",
+        "Agent signature was not produced"
+      );
+    }
+    return { serializedTransaction: serializedBase64, agentSignature };
+  }
+};
+
+// ../../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(rpc, serializedTransaction) {
+  const addresses = lookupTableAddressesForTransaction(serializedTransaction);
+  if (addresses.length === 0) {
+    return {};
+  }
+  const tables = await fetchAllMaybeAddressLookupTable(
+    rpc,
+    addresses.map((value) => address(value))
+  );
+  const result = {};
+  for (const table of tables) {
+    if (table.exists) {
+      result[table.address] = table.data.addresses.map(String);
+    }
+  }
+  return result;
+}
+
+// ../../src/api/wallet-auth.ts
+import { createHash as createHash3 } from "node:crypto";
+import bs585 from "bs58";
+import nacl 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";
+function sha256Hex(data) {
+  return createHash3("sha256").update(data, "utf8").digest("hex");
+}
+function walletAuthMessage(params) {
+  return new TextEncoder().encode(
+    `subly-api:${params.method.toUpperCase()}:${params.path}:${sha256Hex(
+      params.rawBody
+    )}:${params.signedAtMs}`
+  );
+}
+
+// ../../src/client/wallet-auth-headers.ts
+async function walletAuthHeaders(params) {
+  const signedAtMs = String(Date.now());
+  const message = walletAuthMessage({
+    method: params.method,
+    path: new URL(params.url).pathname,
+    rawBody: params.body ?? "",
+    signedAtMs
+  });
+  return {
+    [WALLET_AUTH_WALLET_HEADER]: params.signer.walletAddress,
+    [WALLET_AUTH_SIGNED_AT_HEADER]: signedAtMs,
+    [WALLET_AUTH_SIGNATURE_HEADER]: await params.signer.signApiMessage(message)
+  };
+}
+
+// ../../src/client/vault-flows.ts
+var VaultFlowClientError = class extends Error {
+  constructor(step, message, detail = null, code = null, errorDetails = null) {
+    super(message);
+    this.step = step;
+    this.detail = detail;
+    this.code = code;
+    this.errorDetails = errorDetails;
+    this.name = "VaultFlowClientError";
+  }
+  step;
+  detail;
+  code;
+  errorDetails;
+};
+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). Under
+   * depositPolicy "owner_approval_required" the relayer refuses to prepare
+   * without an owner approval; when the caller passes none, an already
+   * APPROVED deposit approval for this exact amount (e.g. the mandate's
+   * initialDeposit — "one Face ID covers mandate + first deposit") is looked
+   * up and used automatically before surfacing deposit_approval_required.
+   */
+  async deposit(input) {
+    let approvalId = input.approvalId;
+    let prepared;
+    try {
+      prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
+        wallet: this.signer.walletAddress,
+        amountRawUsdc: input.amountRawUsdc.toString(),
+        ...approvalId === void 0 ? {} : { approvalId }
+      });
+    } catch (error) {
+      if (!(error instanceof VaultFlowClientError) || error.code !== "deposit_approval_required" || approvalId !== void 0) {
+        throw error;
+      }
+      approvalId = await this.findApprovedDepositApproval(input.amountRawUsdc);
+      if (approvalId === void 0) {
+        throw error;
+      }
+      prepared = await this.postJson("prepare", "/v1/deposits/prepare", {
+        wallet: this.signer.walletAddress,
+        amountRawUsdc: input.amountRawUsdc.toString(),
+        approvalId
+      });
+    }
+    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 },
+        ...input.payment === void 0 ? {} : { payment: input.payment },
+        ...input.approvalId === void 0 ? {} : { approvalId: input.approvalId }
+      }
+    );
+    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"
+    };
+  }
+  /** Best-effort audit link: reports the x402 payment tx a realize funded. */
+  async reportPayment(input) {
+    await this.postJson("submit", "/v1/payments/report", {
+      wallet: this.signer.walletAddress,
+      withdrawalId: input.withdrawalId,
+      paymentTxSignature: input.paymentTxSignature
+    });
+  }
+  /** 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)}`}`
+    );
+    return body.approvals ?? [];
+  }
+  /**
+   * Creates the owner-onboarding setup link (wallet-auth pins the agreed
+   * policy + initial deposit). Paste `setupUrl` into the chat verbatim.
+   */
+  async createSetupSession(input) {
+    return await this.postJson(
+      "prepare",
+      `/v1/wallets/${this.signer.walletAddress}/setup-sessions`,
+      {
+        ...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 }
+      }
+    );
+  }
+  /** Polls a setup session (public capability URL — no auth needed). */
+  async getSetupSession(sessionId) {
+    const url = `${this.baseUrl}/v1/setup-sessions/${encodeURIComponent(sessionId)}`;
+    const response = await this.fetchImpl(url);
+    const text = await response.text();
+    if (response.status !== 200) {
+      const parsed = parseRelayerError(text);
+      throw new VaultFlowClientError(
+        "read",
+        parsed.message ?? `setup session read failed with ${response.status}`,
+        text,
+        parsed.code,
+        parsed.details
+      );
+    }
+    return JSON.parse(text);
+  }
+  /**
+   * Finds an APPROVED, unconsumed deposit approval bound to exactly this
+   * amount — the shape the mandate's initialDeposit approval has.
+   */
+  async findApprovedDepositApproval(amountRawUsdc) {
+    try {
+      const approvals = await this.listApprovals("approved");
+      const match = approvals.find((approval) => {
+        const binding = approval.binding;
+        return binding?.kind === "deposit" && binding.amountRawUsdc === amountRawUsdc.toString();
+      });
+      return match?.approvalId;
+    } catch {
+      return void 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) {
+      const parsed = parseRelayerError(text);
+      throw new VaultFlowClientError(
+        step,
+        parsed.message === null ? `${path} failed with ${response.status}: ${text}` : `${path} failed (${parsed.code ?? response.status}): ${parsed.message}`,
+        text,
+        parsed.code,
+        parsed.details
+      );
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        step,
+        `${path} returned 200 with a non-JSON body`,
+        text
+      );
+    }
+  }
+  async getJson(path) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await this.fetchImpl(url, {
+      headers: await walletAuthHeaders({
+        signer: this.signer,
+        method: "GET",
+        url
+      })
+    });
+    const text = await response.text();
+    if (response.status !== 200) {
+      const parsed = parseRelayerError(text);
+      throw new VaultFlowClientError(
+        "read",
+        parsed.message === null ? `${path} failed with ${response.status}: ${text}` : `${path} failed (${parsed.code ?? response.status}): ${parsed.message}`,
+        text,
+        parsed.code,
+        parsed.details
+      );
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new VaultFlowClientError(
+        "read",
+        `${path} returned 200 with a non-JSON body`,
+        text
+      );
+    }
+  }
+};
+function parseRelayerError(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return {
+      code: typeof parsed.error?.code === "string" ? parsed.error.code : null,
+      message: typeof parsed.error?.message === "string" ? parsed.error.message : null,
+      details: parsed.error?.details ?? null
+    };
+  } catch {
+    return { code: null, message: null, details: null };
+  }
+}
+
+// ../../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) {
+  return createSolanaRpc(url);
+}
+
+// src/setup-link.ts
+function fail(message) {
+  process.stderr.write(`${message}
+`);
+  process.exit(1);
+}
+var USAGE = "Usage: pay setup-link [--initial-deposit <rawUsdc>] [--approval-threshold <rawUsdc>] [--per-payment-cap <rawUsdc>] [--daily-api-cap <rawUsdc>] [--daily-deposit-cap <rawUsdc>] [--ttl-days <days>]";
+var FLAG_TO_POLICY_KEY = {
+  "--approval-threshold": "approvalThresholdRawUsdc",
+  "--per-payment-cap": "perPaymentCapRawUsdc",
+  "--daily-api-cap": "dailyApiSpendCapRawUsdc",
+  "--daily-deposit-cap": "dailyDepositCapRawUsdc"
+};
+var policy = {};
+var initialDepositRawUsdc;
+var mandateTtlDays;
+var args = [];
+for (const raw of process.argv.slice(2)) {
+  const eq = raw.startsWith("--") ? raw.indexOf("=") : -1;
+  if (eq > 0) {
+    args.push(raw.slice(0, eq), raw.slice(eq + 1));
+  } else {
+    args.push(raw);
+  }
+}
+for (let i = 0; i < args.length; i += 2) {
+  const flag = args[i];
+  const value = args[i + 1];
+  if (value === void 0) {
+    fail(`missing value for ${flag}
+${USAGE}`);
+  }
+  if (flag === "--initial-deposit") {
+    if (!/^[1-9]\d*$/.test(value)) {
+      fail(`--initial-deposit must be a positive raw USDC integer
+${USAGE}`);
+    }
+    initialDepositRawUsdc = value;
+  } else if (flag === "--ttl-days") {
+    const days = Number(value);
+    if (!Number.isInteger(days) || days <= 0) {
+      fail(`--ttl-days must be a positive integer
+${USAGE}`);
+    }
+    mandateTtlDays = days;
+  } else if (FLAG_TO_POLICY_KEY[flag] !== void 0) {
+    if (!/^[1-9]\d*$/.test(value)) {
+      fail(`${flag} must be a positive raw USDC integer
+${USAGE}`);
+    }
+    policy[FLAG_TO_POLICY_KEY[flag]] = value;
+  } else {
+    fail(`unrecognized flag: ${flag}
+${USAGE}`);
+  }
+}
+var relayerBaseUrl = process.env.SUBLY_RELAYER_URL ?? process.env.SUBLY_FACILITATOR_URL ?? "https://api.demo.sublyfi.com";
+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 vaultFlows = new VaultFlowClient({
+  relayerBaseUrl,
+  signer,
+  rpc: createRpc(
+    process.env.SOLANA_RPC_URL ?? "https://api.mainnet-beta.solana.com"
+  )
+});
+console.error(`[setup-link] agent ${signer.walletAddress} -> ${relayerBaseUrl}`);
+try {
+  const created = await vaultFlows.createSetupSession({
+    ...Object.keys(policy).length === 0 ? {} : { policy },
+    ...mandateTtlDays === void 0 ? {} : { mandateTtlDays },
+    ...initialDepositRawUsdc === void 0 ? {} : { initialDepositRawUsdc }
+  });
+  process.stdout.write(
+    `${JSON.stringify(
+      {
+        ...created,
+        instructions: `Paste setupUrl to the user verbatim (expires in 10 minutes, single-use). After they confirm on their device, check with: pay setup-status ${created.sessionId} \u2014 when completed, run the first deposit; its approval is picked up automatically.`
+      },
+      null,
+      2
+    )}
+`
+  );
+} catch (error) {
+  if (error instanceof VaultFlowClientError) {
+    fail(`[setup-link] failed: ${error.message}`);
+  }
+  throw error;
+}