@tbookdev/vault-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,4359 @@
+'use strict';
+
+var anchor = require('@coral-xyz/anchor');
+var web3_js = require('@solana/web3.js');
+var crypto = require('crypto');
+var bs58 = require('bs58');
+var BN = require('bn.js');
+var splToken = require('@solana/spl-token');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58__default = /*#__PURE__*/_interopDefault(bs58);
+var BN__default = /*#__PURE__*/_interopDefault(BN);
+
+// src/client.ts
+var USDC_DECIMALS = 6;
+var SHARE_DECIMALS = 6;
+var ONE_USDC = 1e6;
+var ONE_SHARE = 1e6;
+var DEFAULT_CANCEL_FEE_BPS = 10;
+var DEFAULT_RPC_TIMEOUT_MS = 3e4;
+var DEFAULT_RPC = {
+  devnet: "https://api.devnet.solana.com",
+  "mainnet-beta": "https://api.mainnet-beta.solana.com"
+};
+function getDefaultRpcUrl(network) {
+  return DEFAULT_RPC[network];
+}
+var SHARE_PRICE_API_URL = "https://d5a6giwxrgpzqpxktgpgufpvtq0ltxgk.lambda-url.ap-southeast-1.on.aws/share-price";
+var EXPLORER_BASE = "https://explorer.solana.com";
+function explorerUrl(type, value, network) {
+  const cluster = network === "mainnet-beta" ? "" : `?cluster=${network}`;
+  return `${EXPLORER_BASE}/${type}/${value}${cluster}`;
+}
+var BUILT_IN_VAULTS = {
+  "devnet:rcUSDP": {
+    id: "rcUSDP",
+    programId: new web3_js.PublicKey("BdeE87CsE9kvxJJcxaJqxNsC2nC6hFft3UBzcgAm5X1i"),
+    // Circle devnet USDC — must match the mint the on-chain vault was initialized with
+    usdcMint: new web3_js.PublicKey("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"),
+    network: "devnet"
+  }
+  // mainnet config will be added when contract is deployed
+  // "mainnet-beta:rcUSDP": { ... },
+};
+function getVaultConfig(vaultId, network) {
+  return BUILT_IN_VAULTS[`${network}:${vaultId}`];
+}
+function listBuiltInVaults(network) {
+  return Object.values(BUILT_IN_VAULTS).filter((v) => v.network === network).map((v) => ({
+    id: v.id,
+    name: `${v.id} Vault`,
+    description: "RWA yield vault powered by TBook",
+    programId: v.programId.toBase58(),
+    network: v.network,
+    usdcMint: v.usdcMint.toBase58(),
+    shareToken: { symbol: v.id, decimals: SHARE_DECIMALS },
+    status: "active"
+  }));
+}
+var DEFAULT_VAULT_ID = "rcUSDP";
+
+// src/errors.ts
+var VaultSdkError = class extends Error {
+  /** Machine-readable error code. */
+  code;
+  /** Non-technical message suitable for displaying to end users. */
+  userFriendlyMessage;
+  constructor(code, message, userFriendlyMessage) {
+    super(message);
+    this.name = "VaultSdkError";
+    this.code = code;
+    this.userFriendlyMessage = userFriendlyMessage ?? "Something went wrong. Please try again.";
+  }
+};
+var VaultPausedError = class extends VaultSdkError {
+  constructor() {
+    super(
+      "VAULT_PAUSED",
+      "The vault is currently paused. Only claim operations are allowed.",
+      "The service is temporarily unavailable. Please try again later."
+    );
+    this.name = "VaultPausedError";
+  }
+};
+var MinDepositError = class extends VaultSdkError {
+  /** The minimum required deposit in USDC. */
+  minDeposit;
+  constructor(minDeposit) {
+    super(
+      "MIN_DEPOSIT",
+      `Minimum deposit is ${minDeposit} USDC.`,
+      `The deposit amount is too small. Minimum is ${minDeposit} USDC.`
+    );
+    this.name = "MinDepositError";
+    this.minDeposit = minDeposit;
+  }
+};
+var MaxEpochDepositError = class extends VaultSdkError {
+  maxEpochDeposit;
+  constructor(maxEpochDeposit) {
+    super(
+      "MAX_EPOCH_DEPOSIT",
+      `This deposit would exceed the epoch limit of ${maxEpochDeposit} USDC.`,
+      `The deposit amount exceeds the current limit of ${maxEpochDeposit} USDC.`
+    );
+    this.name = "MaxEpochDepositError";
+    this.maxEpochDeposit = maxEpochDeposit;
+  }
+};
+var EpochNotOpenError = class extends VaultSdkError {
+  constructor(epochType, status) {
+    super(
+      "EPOCH_NOT_OPEN",
+      `The ${epochType} epoch is currently "${status}", not "Open".`,
+      "This operation is not available right now. Please try again later."
+    );
+    this.name = "EpochNotOpenError";
+  }
+};
+var VaultNotFoundError = class extends VaultSdkError {
+  constructor() {
+    super(
+      "VAULT_NOT_FOUND",
+      "VaultMirror account not found on-chain. Is the program deployed?",
+      "The vault service is currently unreachable. Please try again later."
+    );
+    this.name = "VaultNotFoundError";
+  }
+};
+var UserAccountNotFoundError = class extends VaultSdkError {
+  constructor(pubkey) {
+    super(
+      "USER_NOT_FOUND",
+      `No vault user account found for ${pubkey}.`,
+      "No account found. Please make a deposit first to create your account."
+    );
+    this.name = "UserAccountNotFoundError";
+  }
+};
+var UnknownVaultError = class extends VaultSdkError {
+  constructor(vaultId) {
+    super(
+      "UNKNOWN_VAULT",
+      `Vault "${vaultId}" is not registered. Use listVaults() to see available vaults.`,
+      "The requested vault is not available."
+    );
+    this.name = "UnknownVaultError";
+  }
+};
+var SharePriceUnavailableError = class extends VaultSdkError {
+  constructor(reason) {
+    super(
+      "PRICE_UNAVAILABLE",
+      `Share price data is unavailable${reason ? `: ${reason}` : "."}`,
+      "Price information is temporarily unavailable. Please try again in a few minutes."
+    );
+    this.name = "SharePriceUnavailableError";
+  }
+};
+var NoPendingDepositError = class extends VaultSdkError {
+  constructor() {
+    super(
+      "NO_PENDING_DEPOSIT",
+      "No pending deposit to cancel. The user has no active deposit in the current epoch.",
+      "You don't have a pending deposit to cancel."
+    );
+    this.name = "NoPendingDepositError";
+  }
+};
+var RpcError = class extends VaultSdkError {
+  /** The underlying error from the RPC library. */
+  cause;
+  constructor(operation, cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    super(
+      "RPC_ERROR",
+      `RPC call failed during ${operation}: ${msg}`,
+      "A network error occurred. Please check your connection and try again."
+    );
+    this.name = "RpcError";
+    this.cause = cause;
+  }
+};
+var RpcTimeoutError = class extends VaultSdkError {
+  /** The timeout duration in milliseconds. */
+  timeoutMs;
+  constructor(operation, timeoutMs) {
+    super(
+      "RPC_TIMEOUT",
+      `RPC call timed out after ${timeoutMs}ms during ${operation}`,
+      "The request timed out. Please try again."
+    );
+    this.name = "RpcTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+var TransactionExpiredError = class extends VaultSdkError {
+  /** The transaction signature. */
+  signature;
+  constructor(signature) {
+    super(
+      "TX_EXPIRED",
+      `Transaction ${signature} expired (blockhash no longer valid)`,
+      "The transaction expired. Please try again."
+    );
+    this.name = "TransactionExpiredError";
+    this.signature = signature;
+  }
+};
+var TransactionFailedError = class extends VaultSdkError {
+  /** The transaction signature. */
+  signature;
+  /** The on-chain error object. */
+  txError;
+  constructor(signature, txError) {
+    super(
+      "TX_FAILED",
+      `Transaction ${signature} failed on-chain: ${JSON.stringify(txError)}`,
+      "The transaction failed. Please try again or contact support."
+    );
+    this.name = "TransactionFailedError";
+    this.signature = signature;
+    this.txError = txError;
+  }
+};
+function getVaultMirrorPda(programId) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("vault_mirror")],
+    programId
+  );
+}
+function getUsdcVaultPda(vaultMirror, programId) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("usdc_vault"), vaultMirror.toBuffer()],
+    programId
+  );
+}
+function getUserPda(vaultMirror, user, programId) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [Buffer.from("user"), vaultMirror.toBuffer(), user.toBuffer()],
+    programId
+  );
+}
+function getDepositEpochPda(vaultMirror, epoch, programId) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("deposit_epoch"),
+      vaultMirror.toBuffer(),
+      epochToLeBytes(epoch)
+    ],
+    programId
+  );
+}
+function getRedeemEpochPda(vaultMirror, epoch, programId) {
+  return web3_js.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("redeem_epoch"),
+      vaultMirror.toBuffer(),
+      epochToLeBytes(epoch)
+    ],
+    programId
+  );
+}
+function epochToLeBytes(epoch) {
+  return Buffer.from(
+    new Uint8Array(new BigUint64Array([BigInt(epoch)]).buffer)
+  );
+}
+
+// src/types.ts
+var STATUS_MAP = {
+  0: "Open",
+  1: "Frozen",
+  2: "Bridging",
+  3: "Settled",
+  4: "RolledBack"
+};
+
+// src/queries.ts
+async function fetchVaultInfo(connection, programId, program) {
+  const [vaultMirrorPda] = getVaultMirrorPda(programId);
+  if (program) {
+    try {
+      return await fetchVaultInfoAnchor(connection, programId, program, vaultMirrorPda);
+    } catch {
+    }
+  }
+  return fetchVaultInfoRaw(connection, programId, vaultMirrorPda);
+}
+async function fetchVaultInfoAnchor(connection, programId, program, vaultMirrorPda) {
+  const v = await program.account.vaultMirror.fetch(vaultMirrorPda);
+  const [usdcVaultPda] = getUsdcVaultPda(vaultMirrorPda, programId);
+  const vaultUsdcBalance = await safeTokenBalance(connection, usdcVaultPda);
+  const currentDepositEpoch = v.currentDepositEpoch.toNumber();
+  const currentRedeemEpoch = v.currentRedeemEpoch.toNumber();
+  const vault = {
+    admin: v.authority.toString(),
+    curator: v.curator.toString(),
+    operator: v.operator.toString(),
+    totalShares: v.totalShares.toNumber() / 10 ** SHARE_DECIMALS,
+    currentDepositEpoch,
+    currentRedeemEpoch,
+    maxEpochDeposit: v.maxEpochDeposit.toNumber() / 10 ** USDC_DECIMALS,
+    minDeposit: v.minDeposit.toNumber() / 10 ** USDC_DECIMALS,
+    paused: v.paused,
+    usdcMint: v.usdcMint,
+    vaultUsdcBalance,
+    tvlEstimate: vaultUsdcBalance,
+    cancelFeeBps: DEFAULT_CANCEL_FEE_BPS
+  };
+  const depositEpoch = await fetchDepositEpochAnchor(program, programId, vaultMirrorPda, currentDepositEpoch);
+  const redeemEpoch = await fetchRedeemEpochAnchor(program, programId, vaultMirrorPda, currentRedeemEpoch);
+  return { vault, depositEpoch, redeemEpoch };
+}
+async function fetchVaultInfoRaw(connection, programId, vaultMirrorPda) {
+  let accountInfo;
+  try {
+    accountInfo = await connection.getAccountInfo(vaultMirrorPda);
+  } catch (err) {
+    throw new RpcError("fetchVaultInfo", err);
+  }
+  if (!accountInfo) {
+    return { vault: null, depositEpoch: null, redeemEpoch: null };
+  }
+  const data = accountInfo.data;
+  const o = 8;
+  const admin = new web3_js.PublicKey(data.subarray(o, o + 32));
+  const curator = new web3_js.PublicKey(data.subarray(o + 32, o + 64));
+  const operator = new web3_js.PublicKey(data.subarray(o + 64, o + 96));
+  const usdcMintKey = new web3_js.PublicKey(data.subarray(o + 96, o + 128));
+  const usdcVaultKey = new web3_js.PublicKey(data.subarray(o + 128, o + 160));
+  const totalShares = Number(data.readBigUInt64LE(o + 160)) / 10 ** SHARE_DECIMALS;
+  const currentDepositEpoch = Number(data.readBigUInt64LE(o + 168));
+  const currentRedeemEpoch = Number(data.readBigUInt64LE(o + 176));
+  const maxEpochDeposit = Number(data.readBigUInt64LE(o + 184)) / 10 ** USDC_DECIMALS;
+  const minDeposit = Number(data.readBigUInt64LE(o + 192)) / 10 ** USDC_DECIMALS;
+  const paused = data[o + 200] !== 0;
+  const vaultUsdcBalance = await safeTokenBalance(connection, usdcVaultKey);
+  const vault = {
+    admin: admin.toString(),
+    curator: curator.toString(),
+    operator: operator.toString(),
+    totalShares,
+    currentDepositEpoch,
+    currentRedeemEpoch,
+    maxEpochDeposit,
+    minDeposit,
+    paused,
+    usdcMint: usdcMintKey,
+    vaultUsdcBalance,
+    tvlEstimate: vaultUsdcBalance,
+    cancelFeeBps: DEFAULT_CANCEL_FEE_BPS
+  };
+  const depositEpoch = await fetchDepositEpochRaw(connection, programId, getVaultMirrorPda(programId)[0], currentDepositEpoch);
+  const redeemEpoch = await fetchRedeemEpochRaw(connection, programId, getVaultMirrorPda(programId)[0], currentRedeemEpoch);
+  return { vault, depositEpoch, redeemEpoch };
+}
+async function fetchDepositEpochAnchor(program, programId, vaultMirrorPda, epoch) {
+  try {
+    const [pda] = getDepositEpochPda(vaultMirrorPda, epoch, programId);
+    const e = await program.account.depositEpoch.fetch(pda);
+    const statusKey = Object.keys(e.status)[0];
+    return {
+      epoch: e.epoch.toNumber(),
+      status: statusKey.charAt(0).toUpperCase() + statusKey.slice(1),
+      totalDepositUsdc: e.totalDepositUsdc.toNumber() / 10 ** USDC_DECIMALS,
+      depositUserCount: e.depositUserCount,
+      settledSharesMinted: e.settledSharesMinted.toNumber() / 10 ** SHARE_DECIMALS
+    };
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function fetchRedeemEpochAnchor(program, programId, vaultMirrorPda, epoch) {
+  try {
+    const [pda] = getRedeemEpochPda(vaultMirrorPda, epoch, programId);
+    const e = await program.account.redeemEpoch.fetch(pda);
+    const statusKey = Object.keys(e.status)[0];
+    return {
+      epoch: e.epoch.toNumber(),
+      status: statusKey.charAt(0).toUpperCase() + statusKey.slice(1),
+      totalRedeemShares: e.totalRedeemShares.toNumber() / 10 ** SHARE_DECIMALS,
+      redeemUserCount: e.redeemUserCount,
+      settledUsdcForRedeems: e.settledUsdcForRedeems.toNumber() / 10 ** USDC_DECIMALS
+    };
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function fetchDepositEpochRaw(connection, programId, vaultMirrorPda, epoch) {
+  try {
+    const [pda] = getDepositEpochPda(vaultMirrorPda, epoch, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info) return null;
+    const d = info.data;
+    const eo = 8;
+    return {
+      epoch: Number(d.readBigUInt64LE(eo)),
+      status: STATUS_MAP[d[eo + 8]] || "Open",
+      totalDepositUsdc: Number(d.readBigUInt64LE(eo + 9)) / 10 ** USDC_DECIMALS,
+      depositUserCount: d.readUInt32LE(eo + 17),
+      settledSharesMinted: Number(d.readBigUInt64LE(eo + 21)) / 10 ** SHARE_DECIMALS
+    };
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function fetchRedeemEpochRaw(connection, programId, vaultMirrorPda, epoch) {
+  try {
+    const [pda] = getRedeemEpochPda(vaultMirrorPda, epoch, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info) return null;
+    const d = info.data;
+    const eo = 8;
+    return {
+      epoch: Number(d.readBigUInt64LE(eo)),
+      status: STATUS_MAP[d[eo + 8]] || "Open",
+      totalRedeemShares: Number(d.readBigUInt64LE(eo + 9)) / 10 ** SHARE_DECIMALS,
+      redeemUserCount: d.readUInt32LE(eo + 17),
+      settledUsdcForRedeems: Number(d.readBigUInt64LE(eo + 21)) / 10 ** USDC_DECIMALS
+    };
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function fetchUserAccount(connection, programId, user, program) {
+  const [vaultMirrorPda] = getVaultMirrorPda(programId);
+  const [userPda] = getUserPda(vaultMirrorPda, user, programId);
+  if (!program) {
+    return null;
+  }
+  let userAccount;
+  try {
+    userAccount = await program.account.userAccount.fetch(userPda);
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return null;
+    }
+    throw err;
+  }
+  const shares = userAccount.shares.toNumber() / 10 ** SHARE_DECIMALS;
+  const pendingDepositUsdc = userAccount.pendingDepositUsdc.toNumber() / 10 ** USDC_DECIMALS;
+  const pendingDepositEpoch = userAccount.pendingDepositEpoch.toNumber();
+  const pendingRedeemShares = userAccount.pendingRedeemShares.toNumber() / 10 ** SHARE_DECIMALS;
+  const pendingRedeemEpoch = userAccount.pendingRedeemEpoch.toNumber();
+  const claimableUsdc = userAccount.claimableUsdc.toNumber() / 10 ** USDC_DECIMALS;
+  const effective = await computeEffectiveBalance(
+    connection,
+    programId,
+    program,
+    vaultMirrorPda,
+    {
+      shares: BigInt(userAccount.shares.toString()),
+      claimableUsdc: BigInt(userAccount.claimableUsdc.toString()),
+      pendingDepositUsdc: BigInt(userAccount.pendingDepositUsdc.toString()),
+      pendingDepositEpoch,
+      pendingRedeemShares: BigInt(userAccount.pendingRedeemShares.toString()),
+      pendingRedeemEpoch
+    }
+  );
+  return {
+    shares,
+    pendingDepositUsdc,
+    pendingDepositEpoch,
+    pendingRedeemShares,
+    pendingRedeemEpoch,
+    claimableUsdc,
+    effectiveShares: Number(effective.shares) / 10 ** SHARE_DECIMALS,
+    effectiveClaimableUsdc: Number(effective.claimableUsdc) / 10 ** USDC_DECIMALS
+  };
+}
+async function computeEffectiveBalance(connection, programId, program, vaultMirrorPda, raw) {
+  let shares = raw.shares;
+  let claimableUsdc = raw.claimableUsdc;
+  let vaultState;
+  try {
+    vaultState = await program.account.vaultMirror.fetch(vaultMirrorPda);
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return { shares, claimableUsdc };
+    }
+    throw err;
+  }
+  const currentDepositEpoch = vaultState.currentDepositEpoch.toNumber();
+  const currentRedeemEpoch = vaultState.currentRedeemEpoch.toNumber();
+  if (raw.pendingDepositUsdc > 0n && raw.pendingDepositEpoch !== currentDepositEpoch) {
+    try {
+      const [pda] = getDepositEpochPda(vaultMirrorPda, raw.pendingDepositEpoch, programId);
+      const epoch = await program.account.depositEpoch.fetch(pda);
+      const status = epoch.status;
+      if ("settled" in status) {
+        const totalDeposit = BigInt(epoch.totalDepositUsdc.toString());
+        const sharesMinted = BigInt(epoch.settledSharesMinted.toString());
+        if (totalDeposit > 0n) {
+          shares += raw.pendingDepositUsdc * sharesMinted / totalDeposit;
+        }
+      } else if ("rolledBack" in status) {
+        claimableUsdc += raw.pendingDepositUsdc;
+      }
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) ; else {
+        throw err;
+      }
+    }
+  }
+  if (raw.pendingRedeemShares > 0n && raw.pendingRedeemEpoch !== currentRedeemEpoch) {
+    try {
+      const [pda] = getRedeemEpochPda(vaultMirrorPda, raw.pendingRedeemEpoch, programId);
+      const epoch = await program.account.redeemEpoch.fetch(pda);
+      const status = epoch.status;
+      if ("settled" in status) {
+        const totalRedeem = BigInt(epoch.totalRedeemShares.toString());
+        const usdcForRedeems = BigInt(epoch.settledUsdcForRedeems.toString());
+        if (totalRedeem > 0n) {
+          claimableUsdc += raw.pendingRedeemShares * usdcForRedeems / totalRedeem;
+        }
+      } else if ("rolledBack" in status) {
+        shares += raw.pendingRedeemShares;
+      }
+    } catch (err) {
+      if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) ; else {
+        throw err;
+      }
+    }
+  }
+  return { shares, claimableUsdc };
+}
+async function getLazySettleRemainingAccounts(program, programId, vaultMirrorPda, userPda) {
+  try {
+    const userAccount = await program.account.userAccount.fetch(userPda);
+    const pendingDepositEpoch = userAccount.pendingDepositEpoch.toNumber();
+    const pendingRedeemEpoch = userAccount.pendingRedeemEpoch.toNumber();
+    const hasPendingDeposit = userAccount.pendingDepositUsdc.toNumber() > 0;
+    const hasPendingRedeem = userAccount.pendingRedeemShares.toNumber() > 0;
+    if (!hasPendingDeposit && !hasPendingRedeem) return [];
+    const accounts = [];
+    if (hasPendingDeposit) {
+      const [pda] = getDepositEpochPda(vaultMirrorPda, pendingDepositEpoch, programId);
+      accounts.push({ pubkey: pda, isWritable: false, isSigner: false });
+    }
+    if (hasPendingRedeem) {
+      const [pda] = getRedeemEpochPda(vaultMirrorPda, pendingRedeemEpoch, programId);
+      accounts.push({ pubkey: pda, isWritable: false, isSigner: false });
+    }
+    return accounts;
+  } catch (err) {
+    if (err instanceof Error && (err.message.includes("Account does not exist") || err.message.includes("could not find account"))) {
+      return [];
+    }
+    throw err;
+  }
+}
+async function safeTokenBalance(connection, tokenAccount) {
+  try {
+    const info = await connection.getTokenAccountBalance(tokenAccount);
+    return info.value.uiAmount ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/share-price-cache.ts
+var DEFAULT_MAX_STALE_MS = 6e5;
+var DEFAULT_FAILURE_THRESHOLD = 3;
+var DEFAULT_CIRCUIT_RESET_MS = 6e4;
+var SharePriceCache = class {
+  /** Maximum age (in ms) before cached data is considered stale. */
+  maxStaleMs;
+  data = null;
+  storedAt = 0;
+  // Circuit breaker state
+  failureCount = 0;
+  failureThreshold;
+  circuitOpenedAt = 0;
+  circuitResetMs;
+  constructor(opts) {
+    this.maxStaleMs = opts?.maxStaleMs ?? DEFAULT_MAX_STALE_MS;
+    this.failureThreshold = opts?.failureThreshold ?? DEFAULT_FAILURE_THRESHOLD;
+    this.circuitResetMs = opts?.circuitResetMs ?? DEFAULT_CIRCUIT_RESET_MS;
+  }
+  /**
+   * Return cached data if it is fresher than `maxAge` milliseconds.
+   * Returns `null` if the cache is empty or the data is too old.
+   *
+   * @param maxAge - Override the default freshness window (pass `Infinity` for stale-ok)
+   */
+  get(maxAge) {
+    if (!this.data) return null;
+    const age = Date.now() - this.storedAt;
+    const threshold = maxAge ?? this.maxStaleMs;
+    if (age > threshold) return null;
+    return this.data;
+  }
+  /** Store fresh share price data. */
+  set(data) {
+    this.data = data;
+    this.storedAt = Date.now();
+  }
+  /** Whether the circuit breaker is currently open (API calls should be skipped). */
+  isCircuitOpen() {
+    if (this.failureCount < this.failureThreshold) return false;
+    if (Date.now() - this.circuitOpenedAt >= this.circuitResetMs) {
+      return false;
+    }
+    return true;
+  }
+  /** Record a failed API call. Opens the circuit after the threshold is reached. */
+  recordFailure() {
+    this.failureCount += 1;
+    if (this.failureCount >= this.failureThreshold) {
+      this.circuitOpenedAt = Date.now();
+    }
+  }
+  /** Record a successful API call. Resets the circuit breaker. */
+  recordSuccess() {
+    this.failureCount = 0;
+    this.circuitOpenedAt = 0;
+  }
+};
+var sharePriceCache = new SharePriceCache();
+
+// src/share-price.ts
+var API_FETCH_TIMEOUT_MS = 5e3;
+async function fetchSharePrice(options) {
+  const opts = typeof options === "string" ? { apiUrl: options } : options ?? {};
+  const apiUrl = opts.apiUrl ?? SHARE_PRICE_API_URL;
+  const cached = sharePriceCache.get();
+  if (cached) {
+    return { ...cached, source: "cache", stale: false };
+  }
+  if (!sharePriceCache.isCircuitOpen()) {
+    try {
+      const data = await fetchFromApi(apiUrl);
+      sharePriceCache.set(data);
+      sharePriceCache.recordSuccess();
+      return { ...data, source: "api" };
+    } catch {
+      sharePriceCache.recordFailure();
+    }
+  }
+  const stale = sharePriceCache.get(Infinity);
+  if (stale) {
+    return { ...stale, source: "cache", stale: true };
+  }
+  throw new SharePriceUnavailableError("All price sources exhausted");
+}
+async function fetchFromApi(apiUrl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), API_FETCH_TIMEOUT_MS);
+  let res;
+  try {
+    res = await fetch(apiUrl, { signal: controller.signal });
+  } catch (err) {
+    throw new SharePriceUnavailableError(
+      err instanceof Error ? err.message : "Network error"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!res.ok) {
+    throw new SharePriceUnavailableError(`API returned HTTP ${res.status}`);
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new SharePriceUnavailableError("Invalid JSON response");
+  }
+  if (!data.success || !data.sharePrice) {
+    throw new SharePriceUnavailableError("Missing sharePrice in response");
+  }
+  const priceNum = parseFloat(data.sharePrice);
+  if (!Number.isFinite(priceNum) || priceNum <= 0) {
+    throw new SharePriceUnavailableError(
+      `Invalid sharePrice value: ${data.sharePrice}`
+    );
+  }
+  return {
+    price: data.sharePrice,
+    priceNum,
+    apy: data.apy || "0",
+    date: data.date || "",
+    fetchedAt: data.fetchedAt || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function anchorDiscriminator(name) {
+  return crypto.createHash("sha256").update(`global:${name}`).digest().subarray(0, 8);
+}
+var DISCRIMINATORS = {
+  deposit: {
+    disc: anchorDiscriminator("deposit"),
+    type: "deposit",
+    label: "Deposit"
+  },
+  request_redeem: {
+    disc: anchorDiscriminator("request_redeem"),
+    type: "redeem",
+    label: "Request Redeem"
+  },
+  claim: {
+    disc: anchorDiscriminator("claim"),
+    type: "claim",
+    label: "Claim"
+  },
+  cancel_deposit: {
+    disc: anchorDiscriminator("cancel_deposit"),
+    type: "cancel_deposit",
+    label: "Cancel Deposit"
+  }
+};
+var DISCRIMINATOR_ENTRIES = Object.values(DISCRIMINATORS);
+function classifyInstruction(ixData) {
+  if (ixData.length < 8) {
+    return { type: "unknown", label: "Unknown" };
+  }
+  const prefix = Buffer.from(ixData.subarray(0, 8));
+  for (const entry of DISCRIMINATOR_ENTRIES) {
+    if (prefix.equals(entry.disc)) {
+      return { type: entry.type, label: entry.label };
+    }
+  }
+  return { type: "unknown", label: "Unknown" };
+}
+async function fetchTransactionHistory(connection, userPda, programId, options) {
+  const limit = options?.limit ?? 20;
+  const signatures = await connection.getSignaturesForAddress(userPda, {
+    limit,
+    before: options?.before
+  });
+  if (signatures.length === 0) {
+    return [];
+  }
+  const sigStrings = signatures.map((s) => s.signature);
+  const parsedTxs = await connection.getParsedTransactions(sigStrings, {
+    maxSupportedTransactionVersion: 0
+  });
+  return signatures.map((sig, index) => {
+    const parsed = parsedTxs[index];
+    let type = "unknown";
+    let description = "Vault transaction";
+    if (parsed?.transaction?.message?.instructions) {
+      for (const ix of parsed.transaction.message.instructions) {
+        if ("data" in ix && ix.programId.equals(programId)) {
+          try {
+            const data = Buffer.from(bs58__default.default.decode(ix.data));
+            const classified = classifyInstruction(data);
+            type = classified.type;
+            description = classified.label;
+          } catch {
+          }
+          break;
+        }
+      }
+      if (type === "unknown" && parsed.meta?.innerInstructions) {
+        for (const inner of parsed.meta.innerInstructions) {
+          for (const ix of inner.instructions) {
+            if ("data" in ix && ix.programId.equals(programId)) {
+              try {
+                const data = Buffer.from(bs58__default.default.decode(ix.data));
+                const classified = classifyInstruction(data);
+                type = classified.type;
+                description = classified.label;
+              } catch {
+              }
+              if (type !== "unknown") break;
+            }
+          }
+          if (type !== "unknown") break;
+        }
+      }
+    }
+    if (sig.err) {
+      description = `Failed: ${description}`;
+    }
+    return {
+      signature: sig.signature,
+      type,
+      timestamp: sig.blockTime ?? 0,
+      slot: sig.slot,
+      success: sig.err === null,
+      description
+    };
+  });
+}
+
+// src/rpc-utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withTimeout(promise, ms, label) {
+  if (ms <= 0 || !Number.isFinite(ms)) return promise;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), ms);
+  try {
+    const result = await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        controller.signal.addEventListener(
+          "abort",
+          () => reject(new RpcTimeoutError(label, ms))
+        );
+      })
+    ]);
+    return result;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function confirmTransactionWithRetry(opts) {
+  const {
+    connection,
+    signature,
+    blockhash: _blockhash,
+    lastValidBlockHeight,
+    commitment = "confirmed",
+    timeoutMs = 6e4,
+    initialIntervalMs = 2e3
+  } = opts;
+  const COMMITMENT_LEVELS = ["processed", "confirmed", "finalized"];
+  const desiredLevel = COMMITMENT_LEVELS.indexOf(commitment);
+  const start = Date.now();
+  let interval = initialIntervalMs;
+  const MAX_INTERVAL = 5e3;
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const blockHeight = await connection.getBlockHeight();
+      if (blockHeight > lastValidBlockHeight) {
+        throw new TransactionExpiredError(signature);
+      }
+    } catch (err) {
+      if (err instanceof TransactionExpiredError) throw err;
+    }
+    try {
+      const { value } = await connection.getSignatureStatuses([signature]);
+      const status = value?.[0];
+      if (status?.err) {
+        throw new TransactionFailedError(signature, status.err);
+      }
+      if (status?.confirmationStatus) {
+        const actualLevel = COMMITMENT_LEVELS.indexOf(
+          status.confirmationStatus
+        );
+        if (actualLevel >= desiredLevel) {
+          return;
+        }
+      }
+    } catch (err) {
+      if (err instanceof TransactionFailedError) throw err;
+    }
+    await sleep(interval);
+    interval = Math.min(interval * 1.5, MAX_INTERVAL);
+  }
+  throw new RpcTimeoutError("confirmTransaction", timeoutMs);
+}
+
+// src/transactions.ts
+async function finalizeTx(tx, program, feePayer, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
+  const connection = program.provider.connection;
+  const { blockhash, lastValidBlockHeight } = await withTimeout(
+    connection.getLatestBlockhash(),
+    timeoutMs,
+    "getLatestBlockhash"
+  );
+  tx.recentBlockhash = blockhash;
+  tx.lastValidBlockHeight = lastValidBlockHeight;
+  tx.feePayer = feePayer;
+  return {
+    transaction: tx,
+    serialized: bs58__default.default.encode(tx.serialize({ requireAllSignatures: false })),
+    blockhash,
+    lastValidBlockHeight
+  };
+}
+function usdcToRaw(amount) {
+  const str = amount.toFixed(USDC_DECIMALS);
+  const [whole, frac = ""] = str.split(".");
+  const raw = whole + frac.padEnd(USDC_DECIMALS, "0").slice(0, USDC_DECIMALS);
+  return new BN__default.default(raw);
+}
+function sharesToRaw(amount) {
+  const str = amount.toFixed(SHARE_DECIMALS);
+  const [whole, frac = ""] = str.split(".");
+  const raw = whole + frac.padEnd(SHARE_DECIMALS, "0").slice(0, SHARE_DECIMALS);
+  return new BN__default.default(raw);
+}
+async function buildDepositTx(program, params, options) {
+  const { user, amountUsdc } = params;
+  const programId = program.programId;
+  const [vaultMirrorPda] = getVaultMirrorPda(programId);
+  const [usdcVaultPda] = getUsdcVaultPda(vaultMirrorPda, programId);
+  const [userPda] = getUserPda(vaultMirrorPda, user, programId);
+  let vaultMirrorAccount;
+  try {
+    vaultMirrorAccount = await program.account.vaultMirror.fetch(vaultMirrorPda);
+  } catch (err) {
+    throw new RpcError("buildDepositTx:fetchVaultMirror", err);
+  }
+  if (vaultMirrorAccount.paused) {
+    throw new VaultPausedError();
+  }
+  const minDeposit = vaultMirrorAccount.minDeposit.toNumber() / 10 ** USDC_DECIMALS;
+  if (amountUsdc < minDeposit) {
+    throw new MinDepositError(minDeposit);
+  }
+  const currentDepositEpoch = vaultMirrorAccount.currentDepositEpoch.toNumber();
+  vaultMirrorAccount.currentRedeemEpoch.toNumber();
+  const [depositEpochPda] = getDepositEpochPda(vaultMirrorPda, currentDepositEpoch, programId);
+  try {
+    const epochAccount = await program.account.depositEpoch.fetch(depositEpochPda);
+    if (!("open" in epochAccount.status)) {
+      const statusKey = Object.keys(epochAccount.status)[0] || "unknown";
+      throw new EpochNotOpenError("deposit", statusKey);
+    }
+  } catch (err) {
+    if (err instanceof EpochNotOpenError) throw err;
+  }
+  const usdcMint = vaultMirrorAccount.usdcMint;
+  const userUsdc = await splToken.getAssociatedTokenAddress(usdcMint, user, true);
+  const amountBn = usdcToRaw(amountUsdc);
+  const remainingAccounts = await getLazySettleRemainingAccounts(
+    program,
+    programId,
+    vaultMirrorPda,
+    userPda
+  );
+  const tx = await program.methods.deposit(amountBn).accounts({
+    user,
+    vaultMirror: vaultMirrorPda,
+    userAccount: userPda,
+    depositEpoch: depositEpochPda,
+    userUsdc,
+    usdcVault: usdcVaultPda,
+    usdcMint,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID,
+    systemProgram: web3_js.SystemProgram.programId
+  }).remainingAccounts(remainingAccounts).transaction();
+  const finalized = await finalizeTx(tx, program, user, options?.timeoutMs);
+  return {
+    ...finalized,
+    message: `Deposit ${amountUsdc} USDC into TBook Vault (Epoch #${currentDepositEpoch})`
+  };
+}
+async function buildRedeemTx(program, params, options) {
+  const { user, shares } = params;
+  const programId = program.programId;
+  const [vaultMirrorPda] = getVaultMirrorPda(programId);
+  const [userPda] = getUserPda(vaultMirrorPda, user, programId);
+  let vaultMirrorAccount;
+  try {
+    vaultMirrorAccount = await program.account.vaultMirror.fetch(vaultMirrorPda);
+  } catch (err) {
+    throw new RpcError("buildRedeemTx:fetchVaultMirror", err);
+  }
+  if (vaultMirrorAccount.paused) {
+    throw new VaultPausedError();
+  }
+  vaultMirrorAccount.currentDepositEpoch.toNumber();
+  const currentRedeemEpoch = vaultMirrorAccount.currentRedeemEpoch.toNumber();
+  const [redeemEpochPda] = getRedeemEpochPda(vaultMirrorPda, currentRedeemEpoch, programId);
+  try {
+    const epochAccount = await program.account.redeemEpoch.fetch(redeemEpochPda);
+    if (!("open" in epochAccount.status)) {
+      const statusKey = Object.keys(epochAccount.status)[0] || "unknown";
+      throw new EpochNotOpenError("redeem", statusKey);
+    }
+  } catch (err) {
+    if (err instanceof EpochNotOpenError) throw err;
+  }
+  const sharesBn = sharesToRaw(shares);
+  const remainingAccounts = await getLazySettleRemainingAccounts(
+    program,
+    programId,
+    vaultMirrorPda,
+    userPda
+  );
+  const tx = await program.methods.requestRedeem(sharesBn).accounts({
+    user,
+    vaultMirror: vaultMirrorPda,
+    userAccount: userPda,
+    redeemEpoch: redeemEpochPda,
+    systemProgram: web3_js.SystemProgram.programId
+  }).remainingAccounts(remainingAccounts).transaction();
+  const finalized = await finalizeTx(tx, program, user, options?.timeoutMs);
+  return {
+    ...finalized,
+    message: `Request redeem of ${shares} vault shares (Epoch #${currentRedeemEpoch})`
+  };
+}
+async function buildClaimTx(program, params, options) {
+  const { user } = params;
+  const programId = program.programId;
+  const [vaultMirrorPda] = getVaultMirrorPda(programId);
+  const [usdcVaultPda] = getUsdcVaultPda(vaultMirrorPda, programId);
+  const [userPda] = getUserPda(vaultMirrorPda, user, programId);
+  let vaultMirrorAccount;
+  try {
+    vaultMirrorAccount = await program.account.vaultMirror.fetch(vaultMirrorPda);
+  } catch (err) {
+    throw new RpcError("buildClaimTx:fetchVaultMirror", err);
+  }
+  const usdcMint = vaultMirrorAccount.usdcMint;
+  const userUsdc = await splToken.getAssociatedTokenAddress(usdcMint, user, true);
+  const remainingAccounts = await getLazySettleRemainingAccounts(
+    program,
+    programId,
+    vaultMirrorPda,
+    userPda
+  );
+  const tx = await program.methods.claim().accounts({
+    user,
+    vaultMirror: vaultMirrorPda,
+    userAccount: userPda,
+    userUsdc,
+    usdcVault: usdcVaultPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).remainingAccounts(remainingAccounts).transaction();
+  const finalized = await finalizeTx(tx, program, user, options?.timeoutMs);
+  return {
+    ...finalized,
+    message: "Claim USDC from TBook Vault"
+  };
+}
+async function buildCancelDepositTx(program, params, options) {
+  const { user } = params;
+  const programId = program.programId;
+  const [vaultMirrorPda] = getVaultMirrorPda(programId);
+  const [usdcVaultPda] = getUsdcVaultPda(vaultMirrorPda, programId);
+  const [userPda] = getUserPda(vaultMirrorPda, user, programId);
+  let vaultMirrorAccount;
+  try {
+    vaultMirrorAccount = await program.account.vaultMirror.fetch(vaultMirrorPda);
+  } catch (err) {
+    throw new RpcError("buildCancelDepositTx:fetchVaultMirror", err);
+  }
+  const usdcMint = vaultMirrorAccount.usdcMint;
+  const userUsdc = await splToken.getAssociatedTokenAddress(usdcMint, user, true);
+  let userAccount;
+  try {
+    userAccount = await program.account.userAccount.fetchNullable(userPda);
+  } catch (err) {
+    throw new RpcError("buildCancelDepositTx:fetchUserAccount", err);
+  }
+  if (!userAccount) {
+    throw new NoPendingDepositError();
+  }
+  if (userAccount.pendingDepositUsdc && userAccount.pendingDepositUsdc.toNumber() === 0) {
+    throw new NoPendingDepositError();
+  }
+  const depositEpochNum = userAccount.pendingDepositEpoch.toNumber();
+  const [depositEpochPda] = getDepositEpochPda(vaultMirrorPda, depositEpochNum, programId);
+  const remainingAccounts = await getLazySettleRemainingAccounts(
+    program,
+    programId,
+    vaultMirrorPda,
+    userPda
+  );
+  const tx = await program.methods.cancelDeposit().accounts({
+    user,
+    vaultMirror: vaultMirrorPda,
+    userAccount: userPda,
+    depositEpoch: depositEpochPda,
+    userUsdc,
+    usdcVault: usdcVaultPda,
+    tokenProgram: splToken.TOKEN_PROGRAM_ID
+  }).remainingAccounts(remainingAccounts).transaction();
+  const finalized = await finalizeTx(tx, program, user, options?.timeoutMs);
+  return {
+    ...finalized,
+    message: "Cancel pending deposit (0.1% fee applies)"
+  };
+}
+
+// src/idl/vault-gateway-devnet.json
+var vault_gateway_devnet_default = {
+  address: "BdeE87CsE9kvxJJcxaJqxNsC2nC6hFft3UBzcgAm5X1i",
+  metadata: {
+    name: "vault_gateway",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Solana Vault Gateway - Cross-chain entry point for TBook Vault investment"
+  },
+  instructions: [
+    {
+      name: "cancel_deposit",
+      docs: [
+        "Cancel a pending deposit in the current open deposit epoch (with fee)."
+      ],
+      discriminator: [
+        207,
+        37,
+        219,
+        229,
+        183,
+        50,
+        54,
+        245
+      ],
+      accounts: [
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "user_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  117,
+                  115,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "user"
+              }
+            ]
+          }
+        },
+        {
+          name: "deposit_epoch",
+          docs: [
+            "Current open deposit epoch"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_deposit_epoch",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "user_usdc",
+          writable: true
+        },
+        {
+          name: "usdc_vault",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "claim",
+      docs: [
+        "Claim available USDC (works even when paused)."
+      ],
+      discriminator: [
+        62,
+        198,
+        214,
+        193,
+        213,
+        159,
+        108,
+        210
+      ],
+      accounts: [
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "user_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  117,
+                  115,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "user"
+              }
+            ]
+          }
+        },
+        {
+          name: "user_usdc",
+          writable: true
+        },
+        {
+          name: "usdc_vault",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "deposit",
+      docs: [
+        "Deposit USDC into the current open deposit epoch.",
+        "Pass previous DepositEpoch/RedeemEpoch PDAs as remaining_accounts for lazy settlement."
+      ],
+      discriminator: [
+        242,
+        35,
+        198,
+        137,
+        82,
+        225,
+        242,
+        182
+      ],
+      accounts: [
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "user_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  117,
+                  115,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "user"
+              }
+            ]
+          }
+        },
+        {
+          name: "deposit_epoch",
+          docs: [
+            "Current open deposit epoch"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_deposit_epoch",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "user_usdc",
+          docs: [
+            "User's USDC token account"
+          ],
+          writable: true
+        },
+        {
+          name: "usdc_vault",
+          docs: [
+            "Vault USDC token account"
+          ],
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "deposit_to_vault",
+      docs: [
+        "Deposit USDC back into the PDA vault (curator \u2192 vault).",
+        "Used after bridging redeemed USDC back from Sui to make it claimable."
+      ],
+      discriminator: [
+        18,
+        62,
+        110,
+        8,
+        26,
+        106,
+        248,
+        151
+      ],
+      accounts: [
+        {
+          name: "curator",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "usdc_vault",
+          writable: true
+        },
+        {
+          name: "curator_usdc",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "emergency_withdraw",
+      docs: [
+        "Emergency withdraw: Authority can withdraw USDC from the vault."
+      ],
+      discriminator: [
+        239,
+        45,
+        203,
+        64,
+        150,
+        73,
+        218,
+        92
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "usdc_vault",
+          writable: true
+        },
+        {
+          name: "authority_usdc",
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "freeze_deposit_epoch",
+      docs: [
+        "Freeze the current open deposit epoch and create a new one.",
+        "Rejects if epoch has no deposits.",
+        "Serial constraint: previous deposit epoch must be Settled or RolledBack.",
+        "Routine operation \u2014 requires operator (1-of-3)."
+      ],
+      discriminator: [
+        120,
+        11,
+        158,
+        152,
+        237,
+        62,
+        188,
+        235
+      ],
+      accounts: [
+        {
+          name: "operator",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "current_deposit_epoch",
+          docs: [
+            "Current deposit epoch to freeze"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_deposit_epoch",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "previous_deposit_epoch",
+          docs: [
+            "Previous deposit epoch (optional \u2014 only needed if current > 0 for serial constraint)"
+          ],
+          optional: true
+        },
+        {
+          name: "next_deposit_epoch",
+          docs: [
+            "Next deposit epoch to create"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_deposit_epoch.checked_add(1)",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "freeze_redeem_epoch",
+      docs: [
+        "Freeze the current open redeem epoch and create a new one.",
+        "Rejects if epoch has no redeems.",
+        "Serial constraint: previous redeem epoch must be Settled or RolledBack.",
+        "Routine operation \u2014 requires operator (1-of-3)."
+      ],
+      discriminator: [
+        233,
+        155,
+        202,
+        214,
+        205,
+        1,
+        50,
+        15
+      ],
+      accounts: [
+        {
+          name: "operator",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "current_redeem_epoch",
+          docs: [
+            "Current redeem epoch to freeze"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  101,
+                  101,
+                  109,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_redeem_epoch",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "previous_redeem_epoch",
+          docs: [
+            "Previous redeem epoch (optional \u2014 only needed if current > 0 for serial constraint)"
+          ],
+          optional: true
+        },
+        {
+          name: "next_redeem_epoch",
+          docs: [
+            "Next redeem epoch to create"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  101,
+                  101,
+                  109,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_redeem_epoch.checked_add(1)",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "initialize",
+      docs: [
+        "Initialize the vault mirror, first deposit epoch (0, Open), and first redeem epoch (0, Open)"
+      ],
+      discriminator: [
+        175,
+        175,
+        109,
+        31,
+        13,
+        152,
+        155,
+        237
+      ],
+      accounts: [
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "usdc_vault",
+          docs: [
+            "USDC token account owned by VaultMirror PDA"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  117,
+                  115,
+                  100,
+                  99,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              }
+            ]
+          }
+        },
+        {
+          name: "usdc_mint"
+        },
+        {
+          name: "deposit_epoch",
+          docs: [
+            "First deposit epoch (epoch 0)"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  100,
+                  101,
+                  112,
+                  111,
+                  115,
+                  105,
+                  116,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "const",
+                value: [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "redeem_epoch",
+          docs: [
+            "First redeem epoch (epoch 0)"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  101,
+                  101,
+                  109,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "const",
+                value: [
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0,
+                  0
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "rent",
+          address: "SysvarRent111111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "curator",
+          type: "pubkey"
+        },
+        {
+          name: "operator",
+          type: "pubkey"
+        },
+        {
+          name: "max_epoch_deposit",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "mark_bridging",
+      docs: [
+        "Mark a frozen deposit epoch as bridging and extract USDC to curator's wallet for CCTP.",
+        "Sensitive operation \u2014 requires curator (2-of-3)."
+      ],
+      discriminator: [
+        161,
+        92,
+        108,
+        165,
+        34,
+        123,
+        227,
+        110
+      ],
+      accounts: [
+        {
+          name: "curator",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "deposit_epoch",
+          writable: true
+        },
+        {
+          name: "usdc_vault",
+          docs: [
+            "Vault USDC token account (PDA-owned, source of funds)"
+          ],
+          writable: true
+        },
+        {
+          name: "curator_usdc",
+          docs: [
+            "Curator's USDC token account (destination for CCTP bridge)"
+          ],
+          writable: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "nonce",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "request_redeem",
+      docs: [
+        "Request redemption of shares in the current open redeem epoch."
+      ],
+      discriminator: [
+        105,
+        49,
+        44,
+        38,
+        207,
+        241,
+        33,
+        173
+      ],
+      accounts: [
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "user_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  117,
+                  115,
+                  101,
+                  114
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "user"
+              }
+            ]
+          }
+        },
+        {
+          name: "redeem_epoch",
+          docs: [
+            "Current open redeem epoch"
+          ],
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  114,
+                  101,
+                  100,
+                  101,
+                  101,
+                  109,
+                  95,
+                  101,
+                  112,
+                  111,
+                  99,
+                  104
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault_mirror"
+              },
+              {
+                kind: "account",
+                path: "vault_mirror.current_redeem_epoch",
+                account: "VaultMirror"
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "shares",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "rollback_deposit_epoch",
+      docs: [
+        "Rollback a deposit epoch (Frozen or Bridging \u2192 RolledBack).",
+        "Users auto-rollback via lazy settlement: deposits become claimable USDC.",
+        "Sensitive operation \u2014 requires curator (2-of-3)."
+      ],
+      discriminator: [
+        119,
+        99,
+        137,
+        62,
+        80,
+        139,
+        61,
+        181
+      ],
+      accounts: [
+        {
+          name: "curator",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "deposit_epoch",
+          writable: true
+        }
+      ],
+      args: []
+    },
+    {
+      name: "rollback_redeem_epoch",
+      docs: [
+        "Rollback a redeem epoch (Frozen \u2192 RolledBack).",
+        "Users auto-rollback via lazy settlement: locked shares are restored.",
+        "Sensitive operation \u2014 requires curator (2-of-3)."
+      ],
+      discriminator: [
+        172,
+        217,
+        168,
+        112,
+        217,
+        37,
+        157,
+        218
+      ],
+      accounts: [
+        {
+          name: "curator",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "redeem_epoch",
+          writable: true
+        }
+      ],
+      args: []
+    },
+    {
+      name: "set_authority",
+      docs: [
+        "Transfer authority to a new address"
+      ],
+      discriminator: [
+        133,
+        250,
+        37,
+        21,
+        110,
+        163,
+        26,
+        121
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_authority",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_curator",
+      docs: [
+        "Change the curator address"
+      ],
+      discriminator: [
+        115,
+        127,
+        196,
+        219,
+        235,
+        198,
+        96,
+        253
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_curator",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_max_epoch_deposit",
+      docs: [
+        "Update the maximum epoch deposit cap"
+      ],
+      discriminator: [
+        205,
+        115,
+        249,
+        24,
+        108,
+        6,
+        169,
+        224
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_max",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "set_min_deposit",
+      docs: [
+        "Update the minimum deposit amount."
+      ],
+      discriminator: [
+        15,
+        182,
+        74,
+        248,
+        251,
+        148,
+        186,
+        171
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_min",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "set_operator",
+      docs: [
+        "Change the operator address"
+      ],
+      discriminator: [
+        238,
+        153,
+        101,
+        169,
+        243,
+        131,
+        36,
+        1
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "new_operator",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "set_pause",
+      docs: [
+        "Toggle pause state. When paused, deposit and redeem are blocked, but claim still works."
+      ],
+      discriminator: [
+        63,
+        32,
+        154,
+        2,
+        56,
+        103,
+        79,
+        45
+      ],
+      accounts: [
+        {
+          name: "authority",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        }
+      ],
+      args: [
+        {
+          name: "paused",
+          type: "bool"
+        }
+      ]
+    },
+    {
+      name: "settle_deposits",
+      docs: [
+        "Settle a deposit epoch: lock in shares minted and mark as Settled.",
+        "Updates vault_mirror.total_shares.",
+        "Sensitive operation \u2014 requires curator (2-of-3)."
+      ],
+      discriminator: [
+        216,
+        163,
+        126,
+        212,
+        189,
+        105,
+        226,
+        91
+      ],
+      accounts: [
+        {
+          name: "curator",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "deposit_epoch",
+          writable: true
+        }
+      ],
+      args: [
+        {
+          name: "shares_minted",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "settle_redeems",
+      docs: [
+        "Settle a redeem epoch: lock in USDC for redeemers and mark as Settled.",
+        "Updates vault_mirror.total_shares.",
+        "Curator must have called deposit_to_vault first to fund the PDA.",
+        "Sensitive operation \u2014 requires curator (2-of-3)."
+      ],
+      discriminator: [
+        41,
+        238,
+        144,
+        152,
+        241,
+        69,
+        163,
+        71
+      ],
+      accounts: [
+        {
+          name: "curator",
+          signer: true
+        },
+        {
+          name: "vault_mirror",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116,
+                  95,
+                  109,
+                  105,
+                  114,
+                  114,
+                  111,
+                  114
+                ]
+              }
+            ]
+          }
+        },
+        {
+          name: "redeem_epoch",
+          writable: true
+        }
+      ],
+      args: [
+        {
+          name: "usdc_for_redeems",
+          type: "u64"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "DepositEpoch",
+      discriminator: [
+        113,
+        170,
+        28,
+        39,
+        59,
+        253,
+        178,
+        123
+      ]
+    },
+    {
+      name: "RedeemEpoch",
+      discriminator: [
+        151,
+        138,
+        181,
+        158,
+        40,
+        74,
+        85,
+        44
+      ]
+    },
+    {
+      name: "UserAccount",
+      discriminator: [
+        211,
+        33,
+        136,
+        16,
+        186,
+        110,
+        242,
+        127
+      ]
+    },
+    {
+      name: "VaultMirror",
+      discriminator: [
+        187,
+        198,
+        62,
+        71,
+        138,
+        173,
+        117,
+        230
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "AuthorityChanged",
+      discriminator: [
+        31,
+        19,
+        174,
+        152,
+        4,
+        82,
+        215,
+        226
+      ]
+    },
+    {
+      name: "CuratorChanged",
+      discriminator: [
+        87,
+        59,
+        49,
+        50,
+        194,
+        244,
+        0,
+        178
+      ]
+    },
+    {
+      name: "DepositCancelled",
+      discriminator: [
+        233,
+        23,
+        42,
+        206,
+        203,
+        207,
+        147,
+        35
+      ]
+    },
+    {
+      name: "DepositEpochBridging",
+      discriminator: [
+        135,
+        188,
+        190,
+        180,
+        130,
+        52,
+        8,
+        188
+      ]
+    },
+    {
+      name: "DepositEpochFrozen",
+      discriminator: [
+        212,
+        27,
+        141,
+        46,
+        207,
+        146,
+        142,
+        61
+      ]
+    },
+    {
+      name: "DepositEpochRolledBack",
+      discriminator: [
+        66,
+        33,
+        209,
+        58,
+        163,
+        10,
+        48,
+        130
+      ]
+    },
+    {
+      name: "DepositLazySettled",
+      discriminator: [
+        200,
+        161,
+        186,
+        180,
+        2,
+        93,
+        11,
+        155
+      ]
+    },
+    {
+      name: "DepositsSettled",
+      discriminator: [
+        202,
+        56,
+        60,
+        238,
+        125,
+        34,
+        71,
+        245
+      ]
+    },
+    {
+      name: "EmergencyWithdrawn",
+      discriminator: [
+        116,
+        226,
+        36,
+        3,
+        37,
+        92,
+        138,
+        76
+      ]
+    },
+    {
+      name: "MaxEpochDepositChanged",
+      discriminator: [
+        111,
+        5,
+        240,
+        109,
+        254,
+        93,
+        243,
+        97
+      ]
+    },
+    {
+      name: "MinDepositChanged",
+      discriminator: [
+        110,
+        94,
+        102,
+        242,
+        183,
+        121,
+        89,
+        244
+      ]
+    },
+    {
+      name: "OperatorChanged",
+      discriminator: [
+        231,
+        79,
+        62,
+        226,
+        190,
+        139,
+        176,
+        51
+      ]
+    },
+    {
+      name: "RedeemEpochFrozen",
+      discriminator: [
+        25,
+        105,
+        245,
+        218,
+        51,
+        117,
+        30,
+        200
+      ]
+    },
+    {
+      name: "RedeemEpochRolledBack",
+      discriminator: [
+        186,
+        177,
+        42,
+        37,
+        248,
+        170,
+        149,
+        196
+      ]
+    },
+    {
+      name: "RedeemLazySettled",
+      discriminator: [
+        196,
+        65,
+        102,
+        125,
+        173,
+        10,
+        31,
+        23
+      ]
+    },
+    {
+      name: "RedeemRequested",
+      discriminator: [
+        5,
+        130,
+        67,
+        249,
+        243,
+        168,
+        11,
+        88
+      ]
+    },
+    {
+      name: "RedeemsSettled",
+      discriminator: [
+        233,
+        221,
+        150,
+        195,
+        102,
+        11,
+        229,
+        220
+      ]
+    },
+    {
+      name: "UserClaimed",
+      discriminator: [
+        222,
+        173,
+        163,
+        173,
+        82,
+        10,
+        133,
+        226
+      ]
+    },
+    {
+      name: "UserDeposited",
+      discriminator: [
+        83,
+        166,
+        194,
+        102,
+        87,
+        104,
+        88,
+        137
+      ]
+    },
+    {
+      name: "VaultFunded",
+      discriminator: [
+        192,
+        119,
+        245,
+        193,
+        55,
+        223,
+        195,
+        50
+      ]
+    },
+    {
+      name: "VaultInitialized",
+      discriminator: [
+        180,
+        43,
+        207,
+        2,
+        18,
+        71,
+        3,
+        75
+      ]
+    },
+    {
+      name: "VaultPaused",
+      discriminator: [
+        198,
+        157,
+        22,
+        151,
+        68,
+        100,
+        162,
+        35
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "VaultPaused",
+      msg: "Vault is paused"
+    },
+    {
+      code: 6001,
+      name: "DepositBelowMinimum",
+      msg: "Deposit amount below minimum"
+    },
+    {
+      code: 6002,
+      name: "EpochCapExceeded",
+      msg: "Epoch deposit cap exceeded"
+    },
+    {
+      code: 6003,
+      name: "InvalidEpochStatus",
+      msg: "Invalid epoch status for this operation"
+    },
+    {
+      code: 6004,
+      name: "EmptyDepositEpoch",
+      msg: "Deposit epoch has no deposits"
+    },
+    {
+      code: 6005,
+      name: "EmptyRedeemEpoch",
+      msg: "Redeem epoch has no redeems"
+    },
+    {
+      code: 6006,
+      name: "PreviousDepositEpochUnsettled",
+      msg: "Previous deposit epoch not yet settled or rolled back"
+    },
+    {
+      code: 6007,
+      name: "PreviousRedeemEpochUnsettled",
+      msg: "Previous redeem epoch not yet settled or rolled back"
+    },
+    {
+      code: 6008,
+      name: "NoPendingDeposit",
+      msg: "No pending deposit to cancel"
+    },
+    {
+      code: 6009,
+      name: "InsufficientShares",
+      msg: "Insufficient shares for redemption"
+    },
+    {
+      code: 6010,
+      name: "NothingToClaim",
+      msg: "No claimable USDC"
+    },
+    {
+      code: 6011,
+      name: "NotCurator",
+      msg: "Unauthorized: not curator"
+    },
+    {
+      code: 6012,
+      name: "NotOperator",
+      msg: "Unauthorized: not operator"
+    },
+    {
+      code: 6013,
+      name: "NotAuthority",
+      msg: "Unauthorized: not authority"
+    },
+    {
+      code: 6014,
+      name: "MathOverflow",
+      msg: "Math overflow"
+    },
+    {
+      code: 6015,
+      name: "InvalidDepositEpoch",
+      msg: "Invalid deposit epoch PDA passed for lazy settlement"
+    },
+    {
+      code: 6016,
+      name: "InvalidRedeemEpoch",
+      msg: "Invalid redeem epoch PDA passed for lazy settlement"
+    },
+    {
+      code: 6017,
+      name: "CannotRollbackSettled",
+      msg: "Cannot rollback a settled epoch"
+    },
+    {
+      code: 6018,
+      name: "PendingDepositUnsettled",
+      msg: "User has unsettled pending deposit from a different epoch"
+    },
+    {
+      code: 6019,
+      name: "PendingRedeemUnsettled",
+      msg: "User has unsettled pending redeem from a different epoch"
+    },
+    {
+      code: 6020,
+      name: "ZeroAmount",
+      msg: "Amount must be greater than zero"
+    },
+    {
+      code: 6021,
+      name: "MinDepositTooLow",
+      msg: "Minimum deposit must be at least 1 token (smallest unit)"
+    },
+    {
+      code: 6022,
+      name: "NoDepositActivity",
+      msg: "Deposit epoch has no activity to settle"
+    },
+    {
+      code: 6023,
+      name: "NoRedeemActivity",
+      msg: "Redeem epoch has no activity to settle"
+    }
+  ],
+  types: [
+    {
+      name: "AuthorityChanged",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "old_authority",
+            type: "pubkey"
+          },
+          {
+            name: "new_authority",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "CuratorChanged",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "old_curator",
+            type: "pubkey"
+          },
+          {
+            name: "new_curator",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositCancelled",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "amount_returned",
+            type: "u64"
+          },
+          {
+            name: "fee",
+            type: "u64"
+          },
+          {
+            name: "deposit_epoch",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositEpoch",
+      docs: [
+        "Deposit epoch \u2014 tracks a batch of user deposits (Solana \u2192 Sui path)",
+        'Seeds: [b"deposit_epoch", vault_mirror.key(), epoch.to_le_bytes()]',
+        "",
+        "Lifecycle: Open \u2192 Frozen \u2192 Bridging \u2192 Settled (or RolledBack from Frozen/Bridging)"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            docs: [
+              "Deposit epoch number"
+            ],
+            type: "u64"
+          },
+          {
+            name: "status",
+            docs: [
+              "Current status"
+            ],
+            type: {
+              defined: {
+                name: "EpochStatus"
+              }
+            }
+          },
+          {
+            name: "total_deposit_usdc",
+            docs: [
+              "Total USDC deposited by users in this epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "deposit_user_count",
+            docs: [
+              "Number of users who deposited"
+            ],
+            type: "u32"
+          },
+          {
+            name: "settled_shares_minted",
+            docs: [
+              "Total new shares minted for depositors (set by settle_deposits)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "frozen_at",
+            docs: [
+              "Timestamp when epoch was frozen"
+            ],
+            type: "i64"
+          },
+          {
+            name: "bridge_nonce",
+            docs: [
+              "CCTP bridge nonce (set by mark_bridging)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "bump",
+            docs: [
+              "Bump for this PDA"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositEpochBridging",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "nonce",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositEpochFrozen",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "total_deposit_usdc",
+            type: "u64"
+          },
+          {
+            name: "deposit_user_count",
+            type: "u32"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositEpochRolledBack",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "deposits_returned",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositLazySettled",
+      docs: [
+        "Emitted when a user's pending deposit is lazily settled"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "deposit_epoch",
+            type: "u64"
+          },
+          {
+            name: "shares_received",
+            type: "u64"
+          },
+          {
+            name: "is_rollback",
+            type: "bool"
+          }
+        ]
+      }
+    },
+    {
+      name: "DepositsSettled",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "shares_minted",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "EmergencyWithdrawn",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "EpochStatus",
+      docs: [
+        "Epoch lifecycle for deposits: Open \u2192 Frozen \u2192 Bridging \u2192 Settled (or RolledBack)",
+        "Epoch lifecycle for redeems:  Open \u2192 Frozen \u2192 Settled (or RolledBack)"
+      ],
+      type: {
+        kind: "enum",
+        variants: [
+          {
+            name: "Open"
+          },
+          {
+            name: "Frozen"
+          },
+          {
+            name: "Bridging"
+          },
+          {
+            name: "Settled"
+          },
+          {
+            name: "RolledBack"
+          }
+        ]
+      }
+    },
+    {
+      name: "MaxEpochDepositChanged",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "old_value",
+            type: "u64"
+          },
+          {
+            name: "new_value",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "MinDepositChanged",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "old_value",
+            type: "u64"
+          },
+          {
+            name: "new_value",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "OperatorChanged",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "old_operator",
+            type: "pubkey"
+          },
+          {
+            name: "new_operator",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedeemEpoch",
+      docs: [
+        "Redeem epoch \u2014 tracks a batch of user redeems (Sui \u2192 Solana path)",
+        'Seeds: [b"redeem_epoch", vault_mirror.key(), epoch.to_le_bytes()]',
+        "",
+        "Lifecycle: Open \u2192 Frozen \u2192 Settled (or RolledBack from Frozen)",
+        "No Bridging state \u2014 the Sui\u2192Solana bridge is handled off-chain by the curator."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            docs: [
+              "Redeem epoch number"
+            ],
+            type: "u64"
+          },
+          {
+            name: "status",
+            docs: [
+              "Current status"
+            ],
+            type: {
+              defined: {
+                name: "EpochStatus"
+              }
+            }
+          },
+          {
+            name: "total_redeem_shares",
+            docs: [
+              "Total shares queued for redemption in this epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "redeem_user_count",
+            docs: [
+              "Number of users who redeemed"
+            ],
+            type: "u32"
+          },
+          {
+            name: "settled_usdc_for_redeems",
+            docs: [
+              "Total USDC allocated for redeemers (set by settle_redeems)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "frozen_at",
+            docs: [
+              "Timestamp when epoch was frozen"
+            ],
+            type: "i64"
+          },
+          {
+            name: "bump",
+            docs: [
+              "Bump for this PDA"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedeemEpochFrozen",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "total_redeem_shares",
+            type: "u64"
+          },
+          {
+            name: "redeem_user_count",
+            type: "u32"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedeemEpochRolledBack",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "shares_restored",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedeemLazySettled",
+      docs: [
+        "Emitted when a user's pending redeem is lazily settled"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "redeem_epoch",
+            type: "u64"
+          },
+          {
+            name: "usdc_received",
+            type: "u64"
+          },
+          {
+            name: "is_rollback",
+            type: "bool"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedeemRequested",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "shares",
+            type: "u64"
+          },
+          {
+            name: "redeem_epoch",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "RedeemsSettled",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "usdc_for_redeems",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "UserAccount",
+      docs: [
+        "Per-user account tracking shares and pending operations",
+        'Seeds: [b"user", vault_mirror.key(), user_pubkey]',
+        "",
+        "pending_deposit_epoch refers to a DepositEpoch number.",
+        "pending_redeem_epoch refers to a RedeemEpoch number.",
+        "The two are completely independent."
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "owner",
+            docs: [
+              "User wallet pubkey"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "shares",
+            docs: [
+              "Settled (confirmed) shares"
+            ],
+            type: "u64"
+          },
+          {
+            name: "pending_deposit_usdc",
+            docs: [
+              "USDC amount pending deposit in current open deposit epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "pending_deposit_epoch",
+            docs: [
+              "DepositEpoch number of pending deposit"
+            ],
+            type: "u64"
+          },
+          {
+            name: "pending_redeem_shares",
+            docs: [
+              "Shares pending redemption in current open redeem epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "pending_redeem_epoch",
+            docs: [
+              "RedeemEpoch number of pending redeem"
+            ],
+            type: "u64"
+          },
+          {
+            name: "claimable_usdc",
+            docs: [
+              "USDC available for user to claim"
+            ],
+            type: "u64"
+          },
+          {
+            name: "bump",
+            docs: [
+              "Bump for this PDA"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "UserClaimed",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "UserDeposited",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "deposit_epoch",
+            type: "u64"
+          },
+          {
+            name: "total_pending",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultFunded",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "curator",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultInitialized",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "curator",
+            type: "pubkey"
+          },
+          {
+            name: "usdc_mint",
+            type: "pubkey"
+          },
+          {
+            name: "max_epoch_deposit",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultMirror",
+      docs: [
+        "Global vault mirror \u2014 single PDA holding all state",
+        'Seeds: [b"vault_mirror"]'
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            docs: [
+              "Admin authority (can pause, set curator/operator, change config)"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "curator",
+            docs: [
+              "Curator multisig (2-of-3) \u2014 sensitive ops: mark_bridging, settle, rollback"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "operator",
+            docs: [
+              "Operator multisig (1-of-3) \u2014 routine ops: freeze epochs"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "usdc_mint",
+            docs: [
+              "USDC SPL token mint"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "usdc_vault",
+            docs: [
+              "PDA token account holding all USDC deposits"
+            ],
+            type: "pubkey"
+          },
+          {
+            name: "total_shares",
+            docs: [
+              "Total shares across all users"
+            ],
+            type: "u64"
+          },
+          {
+            name: "current_deposit_epoch",
+            docs: [
+              "Current deposit epoch number (independent of redeem epochs)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "current_redeem_epoch",
+            docs: [
+              "Current redeem epoch number (independent of deposit epochs)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "max_epoch_deposit",
+            docs: [
+              "Global cap on deposits per epoch"
+            ],
+            type: "u64"
+          },
+          {
+            name: "min_deposit",
+            docs: [
+              "Minimum deposit amount (e.g. 1 USDC = 1_000_000)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "paused",
+            docs: [
+              "Whether deposits and redeems are paused (claim always works)"
+            ],
+            type: "bool"
+          },
+          {
+            name: "bump",
+            docs: [
+              "Bump for VaultMirror PDA"
+            ],
+            type: "u8"
+          },
+          {
+            name: "vault_bump",
+            docs: [
+              "Bump for usdc_vault token account PDA"
+            ],
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultPaused",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "paused",
+            type: "bool"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/client.ts
+var TBookVault = class _TBookVault {
+  /** Solana RPC connection. */
+  connection;
+  /** Active network. */
+  network;
+  /** Default timeout for RPC calls in milliseconds. */
+  timeoutMs;
+  apiKey;
+  /** Cache of Anchor programs, keyed by vault ID. */
+  programs = /* @__PURE__ */ new Map();
+  /** Timestamps of when each cached program was created. */
+  programCreatedAt = /* @__PURE__ */ new Map();
+  /** Maximum age for cached programs (5 minutes). */
+  static PROGRAM_CACHE_TTL_MS = 5 * 60 * 1e3;
+  constructor(options) {
+    this.network = options.network;
+    this.apiKey = options.apiKey;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_RPC_TIMEOUT_MS;
+    this.connection = new web3_js.Connection(
+      options.rpcUrl ?? getDefaultRpcUrl(options.network),
+      {
+        commitment: "confirmed",
+        confirmTransactionInitialTimeout: this.timeoutMs
+      }
+    );
+  }
+  // ── Vault Registry ──
+  /**
+   * List all available vaults on the current network.
+   *
+   * Currently returns built-in vaults only. In the future, this will
+   * also query the TBook API for dynamically registered vaults.
+   */
+  async listVaults() {
+    return listBuiltInVaults(this.network);
+  }
+  // ── Read Operations ──
+  /**
+   * Fetch global vault state and current epoch info.
+   *
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   */
+  async getVaultInfo(vaultId) {
+    const config = this.resolveVault(vaultId);
+    const program = this.getProgram(config);
+    return fetchVaultInfo(this.connection, config.programId, program);
+  }
+  /**
+   * Fetch a user's vault account with effective balances.
+   *
+   * Returns `null` if the user has never interacted with the vault.
+   *
+   * @param user - User's Solana public key (string or PublicKey)
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   */
+  async getUserAccount(user, vaultId) {
+    const config = this.resolveVault(vaultId);
+    const program = this.getProgram(config);
+    const pubkey = typeof user === "string" ? new web3_js.PublicKey(user) : user;
+    return fetchUserAccount(this.connection, config.programId, pubkey, program);
+  }
+  /**
+   * Fetch current share price from the NAV oracle.
+   *
+   * Uses a 3-layer fallback: fresh cache -> API fetch -> stale cache.
+   * The API endpoint (NAV oracle) is the authoritative price source.
+   *
+   * @param vaultId - Vault identifier. Currently all registered vaults share
+   *   one NAV source; per-vault price URLs land with the multi-asset registry
+   *   (VaultConfig.sharePriceUrl) in 0.2.0.
+   */
+  async getSharePrice(vaultId) {
+    if (vaultId) this.resolveVault(vaultId);
+    return fetchSharePrice();
+  }
+  // ── Write Operations (unsigned TX builders) ──
+  /**
+   * Build an unsigned deposit transaction.
+   *
+   * @param params - Deposit parameters (user + amount)
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   * @returns Unsigned transaction + base58 serialization + description
+   */
+  async buildDeposit(params, vaultId) {
+    const config = this.resolveVault(vaultId);
+    const program = this.getProgram(config);
+    return buildDepositTx(program, params, { timeoutMs: this.timeoutMs });
+  }
+  /**
+   * Build an unsigned redeem transaction.
+   *
+   * @param params - Redeem parameters (user + shares)
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   */
+  async buildRedeem(params, vaultId) {
+    const config = this.resolveVault(vaultId);
+    const program = this.getProgram(config);
+    return buildRedeemTx(program, params, { timeoutMs: this.timeoutMs });
+  }
+  /**
+   * Build an unsigned claim transaction.
+   * Claim always works even when the vault is paused.
+   *
+   * @param params - User parameters
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   */
+  async buildClaim(params, vaultId) {
+    const config = this.resolveVault(vaultId);
+    const program = this.getProgram(config);
+    return buildClaimTx(program, params, { timeoutMs: this.timeoutMs });
+  }
+  /**
+   * Build an unsigned cancel-deposit transaction.
+   * Returns pending USDC minus 0.1% fee.
+   *
+   * @param params - User parameters
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   */
+  async buildCancelDeposit(params, vaultId) {
+    const config = this.resolveVault(vaultId);
+    const program = this.getProgram(config);
+    return buildCancelDepositTx(program, params, { timeoutMs: this.timeoutMs });
+  }
+  // ── History ──
+  /**
+   * Fetch vault transaction history for a user.
+   *
+   * Returns classified transactions (deposit, redeem, claim, cancel_deposit)
+   * by querying the user's PDA account for signatures and parsing instruction data.
+   *
+   * @param userAddress - User's Solana wallet address (string or PublicKey)
+   * @param options - Pagination options (limit, before cursor)
+   * @param vaultId - Vault identifier (default: "rcUSDP")
+   * @returns Array of classified vault transactions, newest first
+   */
+  async getTransactionHistory(userAddress, options, vaultId) {
+    const config = this.resolveVault(vaultId);
+    const pubkey = typeof userAddress === "string" ? new web3_js.PublicKey(userAddress) : userAddress;
+    const [vaultMirror] = getVaultMirrorPda(config.programId);
+    const [userPda] = getUserPda(vaultMirror, pubkey, config.programId);
+    return fetchTransactionHistory(
+      this.connection,
+      userPda,
+      config.programId,
+      options
+    );
+  }
+  // ── Utility Methods ──
+  /**
+   * Estimate the number of shares that a USDC deposit would yield
+   * at the current share price.
+   *
+   * @param amountUsdc - USDC amount (human-readable)
+   * @returns Estimated shares as a string, or null if price unavailable
+   */
+  async estimateShares(amountUsdc) {
+    try {
+      const price = await this.getSharePrice();
+      if (price.priceNum <= 0) return null;
+      const shares = amountUsdc / price.priceNum;
+      return shares.toFixed(6);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Estimate the USDC value of a given number of shares
+   * at the current share price.
+   *
+   * @param shares - Number of shares (human-readable)
+   * @returns Estimated USDC value as a string, or null if price unavailable
+   */
+  async estimateUsdc(shares) {
+    try {
+      const price = await this.getSharePrice();
+      const usdc = shares * price.priceNum;
+      return usdc.toFixed(6);
+    } catch {
+      return null;
+    }
+  }
+  // ── Internal ──
+  /**
+   * Resolve a vault config by ID, falling back to the default vault.
+   * @throws {UnknownVaultError} If the vault ID is not registered
+   */
+  resolveVault(vaultId) {
+    const id = vaultId ?? DEFAULT_VAULT_ID;
+    const config = getVaultConfig(id, this.network);
+    if (!config) {
+      throw new UnknownVaultError(id);
+    }
+    return config;
+  }
+  /**
+   * Get or create a cached Anchor Program instance for a vault.
+   *
+   * Uses a read-only provider (no signer) since the SDK only builds
+   * transactions — it never signs or submits them.
+   */
+  getProgram(config) {
+    const key = `${config.network}:${config.id}`;
+    let program = this.programs.get(key);
+    const createdAt = this.programCreatedAt.get(key);
+    if (program && createdAt && Date.now() - createdAt > _TBookVault.PROGRAM_CACHE_TTL_MS) {
+      this.programs.delete(key);
+      this.programCreatedAt.delete(key);
+      program = void 0;
+    }
+    if (!program) {
+      const dummyWallet = {
+        publicKey: web3_js.Keypair.generate().publicKey,
+        signTransaction: async (tx) => tx,
+        signAllTransactions: async (txs) => txs
+      };
+      const provider = new anchor.AnchorProvider(this.connection, dummyWallet, {
+        commitment: "confirmed"
+      });
+      const idl = this.resolveIdl(config);
+      program = new anchor.Program(idl, provider);
+      this.programs.set(key, program);
+      this.programCreatedAt.set(key, Date.now());
+    }
+    return program;
+  }
+  /**
+   * Resolve the Anchor IDL for a given vault configuration.
+   * Currently only the built-in rcUSDP devnet IDL is supported.
+   */
+  resolveIdl(config) {
+    return vault_gateway_devnet_default;
+  }
+};
+
+// src/utils.ts
+function truncateNumber(value, decimals) {
+  const factor = Math.pow(10, decimals);
+  return Math.trunc(value * factor) / factor;
+}
+function formatTruncated(value, decimals) {
+  return truncateNumber(value, decimals).toFixed(decimals);
+}
+function formatNumber(value, decimals = 2) {
+  const truncated = truncateNumber(value, decimals);
+  return new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  }).format(truncated);
+}
+function formatCurrency(value, currency = "USD") {
+  const truncated = truncateNumber(value, 2);
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency,
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  }).format(truncated);
+}
+function formatPercentage(value, decimals = 2) {
+  return `${formatNumber(value, decimals)}%`;
+}
+function shortenAddress(address, chars = 4) {
+  if (address.length <= chars * 2 + 3) return address;
+  return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+}
+function formatUsdc(raw) {
+  return formatNumber(Number(raw) / 10 ** USDC_DECIMALS, USDC_DECIMALS);
+}
+function formatShares(raw) {
+  return formatNumber(Number(raw) / 10 ** SHARE_DECIMALS, SHARE_DECIMALS);
+}
+function rawToUi(raw, decimals) {
+  return Number(raw) / Math.pow(10, decimals);
+}
+function uiToRaw(ui, decimals) {
+  return Math.floor(ui * Math.pow(10, decimals));
+}
+function validateAmount(amount, balance, action, token, min, max) {
+  const numericAmount = Number(amount);
+  if (isNaN(numericAmount) || numericAmount <= 0) {
+    return { valid: false, error: "Please enter a valid amount greater than 0" };
+  }
+  if (numericAmount > balance) {
+    return { valid: false, error: `You only have ${balance} ${token}.` };
+  }
+  if (min !== void 0 && numericAmount < min) {
+    return { valid: false, error: `You need to ${action} at least ${min} ${token}.` };
+  }
+  if (max !== void 0 && numericAmount > max) {
+    return { valid: false, error: `You can only ${action} up to ${max} ${token}.` };
+  }
+  return { valid: true };
+}
+function isValidAmountInput(value) {
+  return value === "" || /^\d*\.?\d*$/.test(value);
+}
+
+exports.DEFAULT_CANCEL_FEE_BPS = DEFAULT_CANCEL_FEE_BPS;
+exports.DEFAULT_VAULT_ID = DEFAULT_VAULT_ID;
+exports.EpochNotOpenError = EpochNotOpenError;
+exports.MaxEpochDepositError = MaxEpochDepositError;
+exports.MinDepositError = MinDepositError;
+exports.NoPendingDepositError = NoPendingDepositError;
+exports.ONE_SHARE = ONE_SHARE;
+exports.ONE_USDC = ONE_USDC;
+exports.RpcError = RpcError;
+exports.RpcTimeoutError = RpcTimeoutError;
+exports.SHARE_DECIMALS = SHARE_DECIMALS;
+exports.STATUS_MAP = STATUS_MAP;
+exports.SharePriceCache = SharePriceCache;
+exports.SharePriceUnavailableError = SharePriceUnavailableError;
+exports.TBookVault = TBookVault;
+exports.TransactionExpiredError = TransactionExpiredError;
+exports.TransactionFailedError = TransactionFailedError;
+exports.USDC_DECIMALS = USDC_DECIMALS;
+exports.UnknownVaultError = UnknownVaultError;
+exports.UserAccountNotFoundError = UserAccountNotFoundError;
+exports.VaultNotFoundError = VaultNotFoundError;
+exports.VaultPausedError = VaultPausedError;
+exports.VaultSdkError = VaultSdkError;
+exports.buildCancelDepositTx = buildCancelDepositTx;
+exports.buildClaimTx = buildClaimTx;
+exports.buildDepositTx = buildDepositTx;
+exports.buildRedeemTx = buildRedeemTx;
+exports.confirmTransactionWithRetry = confirmTransactionWithRetry;
+exports.explorerUrl = explorerUrl;
+exports.fetchSharePrice = fetchSharePrice;
+exports.fetchTransactionHistory = fetchTransactionHistory;
+exports.fetchUserAccount = fetchUserAccount;
+exports.fetchVaultInfo = fetchVaultInfo;
+exports.formatCurrency = formatCurrency;
+exports.formatNumber = formatNumber;
+exports.formatPercentage = formatPercentage;
+exports.formatShares = formatShares;
+exports.formatTruncated = formatTruncated;
+exports.formatUsdc = formatUsdc;
+exports.getDefaultRpcUrl = getDefaultRpcUrl;
+exports.getDepositEpochPda = getDepositEpochPda;
+exports.getRedeemEpochPda = getRedeemEpochPda;
+exports.getUsdcVaultPda = getUsdcVaultPda;
+exports.getUserPda = getUserPda;
+exports.getVaultConfig = getVaultConfig;
+exports.getVaultMirrorPda = getVaultMirrorPda;
+exports.isValidAmountInput = isValidAmountInput;
+exports.listBuiltInVaults = listBuiltInVaults;
+exports.rawToUi = rawToUi;
+exports.sharePriceCache = sharePriceCache;
+exports.shortenAddress = shortenAddress;
+exports.sleep = sleep;
+exports.truncateNumber = truncateNumber;
+exports.uiToRaw = uiToRaw;
+exports.validateAmount = validateAmount;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map