@optionsfi/sdk 0.2.0

package/dist/index.js

@@ -0,0 +1,3529 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_PRICING_PARAMS: () => DEFAULT_PRICING_PARAMS,
+  DEVNET_CONFIG: () => DEVNET_CONFIG,
+  DEVNET_USDC_MINT: () => DEVNET_USDC_MINT,
+  MAINNET_CONFIG: () => MAINNET_CONFIG,
+  MAINNET_USDC_MINT: () => MAINNET_USDC_MINT,
+  OptionPricing: () => OptionPricing,
+  PYTH_HERMES_URL: () => PYTH_HERMES_URL,
+  PYTH_PRICE_FEEDS: () => PYTH_PRICE_FEEDS,
+  RFQClient: () => RFQClient,
+  RFQ_DEFAULTS: () => RFQ_DEFAULTS,
+  TOKEN_DECIMALS: () => TOKEN_DECIMALS,
+  VAULT_IDL: () => vault_default,
+  VAULT_PROGRAM_ID: () => VAULT_PROGRAM_ID,
+  ValidationError: () => ValidationError,
+  VaultInstructions: () => VaultInstructions,
+  bpsToPercent: () => bpsToPercent,
+  deriveShareEscrowPda: () => deriveShareEscrowPda,
+  deriveVaultPda: () => deriveVaultPda,
+  deriveWhitelistPda: () => deriveWhitelistPda,
+  deriveWithdrawalPda: () => deriveWithdrawalPda,
+  formatBps: () => formatBps,
+  formatDate: () => formatDate,
+  formatPercent: () => formatPercent,
+  formatPrice: () => formatPrice,
+  formatRFQId: () => formatRFQId,
+  formatTimeToExpiry: () => formatTimeToExpiry,
+  formatTimestamp: () => formatTimestamp,
+  formatTokenAmount: () => formatTokenAmount,
+  formatUSDC: () => formatUSDC,
+  parseTokenAmount: () => parseTokenAmount,
+  parseUSDC: () => parseUSDC,
+  percentToBps: () => percentToBps,
+  shortenAddress: () => shortenAddress,
+  validateBlackScholesParams: () => validateBlackScholesParams,
+  validatePublicKey: () => validatePublicKey,
+  validateRFQParams: () => validateRFQParams,
+  validateTimestamp: () => validateTimestamp,
+  validateTokenAmount: () => validateTokenAmount
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/RFQClient.ts
+var import_ws = __toESM(require("ws"));
+var import_web3 = require("@solana/web3.js");
+
+// src/constants/config.ts
+var DEVNET_CONFIG = {
+  rpcUrl: "https://api.devnet.solana.com",
+  rfqRouterUrl: "wss://rfq.optionsfi.xyz",
+  programId: "A4jgqct3bwTwRmHECHdPpbH3a8ksaVb7rny9pMUGFo94",
+  network: "devnet",
+  rfqTimeoutMs: 3e4
+};
+var MAINNET_CONFIG = {
+  rpcUrl: "https://api.mainnet-beta.solana.com",
+  rfqRouterUrl: "wss://rfq.optionsfi.xyz",
+  programId: "A4jgqct3bwTwRmHECHdPpbH3a8ksaVb7rny9pMUGFo94",
+  network: "mainnet-beta",
+  rfqTimeoutMs: 3e4
+};
+var DEFAULT_PRICING_PARAMS = {
+  /** Default risk-free rate (5%) */
+  riskFreeRate: 0.05,
+  /** Default volatility lookback period in days */
+  volatilityLookbackDays: 30,
+  /** Maximum acceptable deviation from fair value (5%) */
+  maxQuoteDeviationBps: 500,
+  /** Trading days per year for volatility annualization */
+  tradingDaysPerYear: 252
+};
+var RFQ_DEFAULTS = {
+  /** Default RFQ timeout in milliseconds */
+  timeoutMs: 3e4,
+  /** Minimum quote collection time */
+  minQuoteTimeMs: 5e3,
+  /** Quote expiry buffer (how long before expiry to stop accepting) */
+  quoteExpiryBufferMs: 2e3
+};
+var TOKEN_DECIMALS = {
+  USDC: 6,
+  SOL: 9,
+  NVDAX: 6
+  // Example: tokenized NVIDIA stock
+};
+
+// src/client/RFQClient.ts
+var RFQClient = class {
+  connection;
+  wsConnection = null;
+  config;
+  quoteCallbacks = /* @__PURE__ */ new Map();
+  eventCallbacks = /* @__PURE__ */ new Set();
+  activeRFQs = /* @__PURE__ */ new Map();
+  isConnected = false;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 5;
+  /**
+   * Create a new RFQ Client
+   * 
+   * @param config - Configuration for connecting to OptionsFi
+   */
+  constructor(config) {
+    this.config = {
+      ...config,
+      rfqTimeoutMs: config.rfqTimeoutMs ?? RFQ_DEFAULTS.timeoutMs
+    };
+    this.connection = new import_web3.Connection(config.rpcUrl, "confirmed");
+  }
+  /**
+   * Connect to the RFQ router WebSocket
+   * 
+   * @returns Promise that resolves when connected
+   * @throws Error if connection fails
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.wsConnection = new import_ws.default(this.config.rfqRouterUrl);
+        this.wsConnection.on("open", () => {
+          console.log("Connected to OptionsFi RFQ Router");
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          resolve();
+        });
+        this.wsConnection.on("message", (data) => {
+          try {
+            const message = JSON.parse(data.toString());
+            this.handleMessage(message);
+          } catch (error) {
+            console.error("Failed to parse WebSocket message:", error);
+          }
+        });
+        this.wsConnection.on("error", (error) => {
+          console.error("WebSocket error:", error);
+          this.emitEvent({
+            type: "connection_error",
+            rfqId: "",
+            data: error,
+            timestamp: Date.now()
+          });
+          if (!this.isConnected) {
+            reject(error);
+          }
+        });
+        this.wsConnection.on("close", () => {
+          console.log("WebSocket connection closed");
+          this.isConnected = false;
+          this.attemptReconnect();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the RFQ router
+   */
+  disconnect() {
+    if (this.wsConnection) {
+      this.wsConnection.close();
+      this.wsConnection = null;
+      this.isConnected = false;
+    }
+  }
+  /**
+   * Check if the client is connected
+   */
+  get connected() {
+    return this.isConnected;
+  }
+  /**
+   * Create a new RFQ and broadcast to market makers
+   * 
+   * @param params - RFQ parameters
+   * @returns RFQ ID
+   * @throws Error if not connected or params invalid
+   */
+  async createRFQ(params) {
+    if (!this.wsConnection || !this.isConnected) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    this.validateRFQParams(params);
+    const rfqId = this.generateRFQId();
+    const rfq = {
+      id: rfqId,
+      params,
+      quotes: [],
+      status: "open",
+      createdAt: Date.now()
+    };
+    this.activeRFQs.set(rfqId, rfq);
+    const message = {
+      type: "create_rfq",
+      rfqId,
+      underlying: params.asset,
+      optionType: params.optionType,
+      strike: params.strike,
+      expiry: params.expiry,
+      size: params.quantity.toString(),
+      premiumFloor: params.premiumFloor?.toString() ?? "0",
+      timestamp: Date.now()
+    };
+    this.wsConnection.send(JSON.stringify(message));
+    return rfqId;
+  }
+  /**
+   * Subscribe to quotes for a specific RFQ
+   * 
+   * @param rfqId - RFQ to subscribe to
+   * @param callback - Called when a quote is received
+   */
+  subscribeToQuotes(rfqId, callback) {
+    this.quoteCallbacks.set(rfqId, callback);
+    if (this.wsConnection && this.isConnected) {
+      this.wsConnection.send(JSON.stringify({
+        type: "subscribe_quotes",
+        rfqId
+      }));
+    }
+  }
+  /**
+   * Unsubscribe from quotes for an RFQ
+   * 
+   * @param rfqId - RFQ to unsubscribe from
+   */
+  unsubscribeFromQuotes(rfqId) {
+    this.quoteCallbacks.delete(rfqId);
+  }
+  /**
+   * Accept a quote and execute the option trade
+   * 
+   * @param rfqId - RFQ ID
+   * @param quoteId - Quote to accept
+   * @param wallet - Solana wallet for signing
+   * @returns Transaction signature
+   */
+  async executeOption(rfqId, quoteId, wallet) {
+    const rfq = this.activeRFQs.get(rfqId);
+    if (!rfq) {
+      throw new Error(`RFQ ${rfqId} not found`);
+    }
+    const quote = rfq.quotes.find((q) => q.id === quoteId);
+    if (!quote) {
+      throw new Error(`Quote ${quoteId} not found in RFQ ${rfqId}`);
+    }
+    if (this.wsConnection && this.isConnected) {
+      this.wsConnection.send(JSON.stringify({
+        type: "accept_quote",
+        rfqId,
+        quoteId
+      }));
+    }
+    const tx = await this.buildExecutionTransaction(rfq, quote);
+    const signedTx = await wallet.signTransaction(tx);
+    const signature = await this.connection.sendRawTransaction(
+      signedTx.serialize()
+    );
+    await this.connection.confirmTransaction(signature, "confirmed");
+    rfq.status = "filled";
+    rfq.fill = {
+      quoteId,
+      marketMaker: quote.marketMaker,
+      premium: quote.premium,
+      filledAt: Date.now(),
+      transactionSignature: signature
+    };
+    return signature;
+  }
+  /**
+   * Cancel an open RFQ
+   * 
+   * @param rfqId - RFQ to cancel
+   */
+  async cancelRFQ(rfqId) {
+    const rfq = this.activeRFQs.get(rfqId);
+    if (!rfq) {
+      throw new Error(`RFQ ${rfqId} not found`);
+    }
+    if (rfq.status !== "open") {
+      throw new Error(`Cannot cancel RFQ with status: ${rfq.status}`);
+    }
+    if (this.wsConnection && this.isConnected) {
+      this.wsConnection.send(JSON.stringify({
+        type: "cancel_rfq",
+        rfqId
+      }));
+    }
+    rfq.status = "cancelled";
+    this.quoteCallbacks.delete(rfqId);
+  }
+  /**
+   * Get an active RFQ by ID
+   * 
+   * @param rfqId - RFQ ID
+   * @returns RFQ or undefined
+   */
+  getRFQ(rfqId) {
+    return this.activeRFQs.get(rfqId);
+  }
+  /**
+   * Get all active RFQs
+   */
+  getAllRFQs() {
+    return Array.from(this.activeRFQs.values());
+  }
+  /**
+   * Subscribe to all RFQ events
+   * 
+   * @param callback - Called for each event
+   * @returns Unsubscribe function
+   */
+  onEvent(callback) {
+    this.eventCallbacks.add(callback);
+    return () => this.eventCallbacks.delete(callback);
+  }
+  // ============================================================================
+  // Private Methods
+  // ============================================================================
+  handleMessage(message) {
+    if (message.type === "quote" && message.rfqId) {
+      const quote = {
+        id: message.quoteId || `quote_${Date.now()}`,
+        rfqId: message.rfqId,
+        marketMaker: message.maker,
+        premium: BigInt(message.premium),
+        timestamp: Date.now(),
+        expiresAt: message.expiresAt || Date.now() + 6e4
+      };
+      const rfq = this.activeRFQs.get(message.rfqId);
+      if (rfq && rfq.status === "open") {
+        rfq.quotes.push(quote);
+      }
+      const callback = this.quoteCallbacks.get(message.rfqId);
+      if (callback) {
+        callback(quote);
+      }
+      this.emitEvent({
+        type: "quote_received",
+        rfqId: message.rfqId,
+        data: quote,
+        timestamp: Date.now()
+      });
+    } else if (message.type === "fill" && message.rfqId) {
+      const rfq = this.activeRFQs.get(message.rfqId);
+      if (rfq) {
+        rfq.status = "filled";
+        this.emitEvent({
+          type: "rfq_filled",
+          rfqId: message.rfqId,
+          data: rfq,
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  emitEvent(event) {
+    for (const callback of this.eventCallbacks) {
+      try {
+        callback(event);
+      } catch (error) {
+        console.error("Event callback error:", error);
+      }
+    }
+  }
+  validateRFQParams(params) {
+    if (!params.asset || params.asset.length === 0) {
+      throw new Error("Asset is required");
+    }
+    if (params.quantity <= 0) {
+      throw new Error("Quantity must be positive");
+    }
+    if (params.strike <= 0) {
+      throw new Error("Strike must be positive");
+    }
+    if (params.expiry <= Math.floor(Date.now() / 1e3)) {
+      throw new Error("Expiry must be in the future");
+    }
+    if (!["call", "put"].includes(params.optionType)) {
+      throw new Error('Option type must be "call" or "put"');
+    }
+    if (!["buy", "sell"].includes(params.side)) {
+      throw new Error('Side must be "buy" or "sell"');
+    }
+  }
+  generateRFQId() {
+    return `rfq_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+  }
+  async buildExecutionTransaction(rfq, quote) {
+    throw new Error(
+      "Transaction building not yet implemented. Use VaultInstructions class to build transactions manually."
+    );
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnection attempts reached");
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    console.log(`Attempting reconnection in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => {
+      this.connect().catch((error) => {
+        console.error("Reconnection failed:", error);
+      });
+    }, delay);
+  }
+};
+
+// src/client/VaultInstructions.ts
+var anchor = __toESM(require("@coral-xyz/anchor"));
+var import_web33 = require("@solana/web3.js");
+
+// src/constants/addresses.ts
+var import_web32 = require("@solana/web3.js");
+var VAULT_PROGRAM_ID = new import_web32.PublicKey(
+  "A4jgqct3bwTwRmHECHdPpbH3a8ksaVb7rny9pMUGFo94"
+);
+var DEVNET_USDC_MINT = new import_web32.PublicKey(
+  "Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr"
+);
+var MAINNET_USDC_MINT = new import_web32.PublicKey(
+  "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+);
+var PYTH_PRICE_FEEDS = {
+  /** NVDA/USD price feed */
+  NVDA: "0x4244d07890e4610f46bbde67de8f43a4bf8b569eebe904f136b469f148503b7f",
+  /** SOL/USD price feed */
+  SOL: "0xef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d",
+  /** BTC/USD price feed */
+  BTC: "0xe62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43",
+  /** ETH/USD price feed */
+  ETH: "0xff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace"
+};
+var PYTH_HERMES_URL = "https://hermes.pyth.network";
+function deriveVaultPda(assetId) {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [Buffer.from("vault"), Buffer.from(assetId)],
+    VAULT_PROGRAM_ID
+  );
+}
+function deriveWithdrawalPda(vault, user, epoch) {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [
+      Buffer.from("withdrawal"),
+      vault.toBuffer(),
+      user.toBuffer(),
+      Buffer.from(epoch.toString())
+    ],
+    VAULT_PROGRAM_ID
+  );
+}
+function deriveShareEscrowPda(vault) {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [Buffer.from("share_escrow"), vault.toBuffer()],
+    VAULT_PROGRAM_ID
+  );
+}
+function deriveWhitelistPda(vault) {
+  return import_web32.PublicKey.findProgramAddressSync(
+    [Buffer.from("whitelist"), vault.toBuffer()],
+    VAULT_PROGRAM_ID
+  );
+}
+
+// src/idl/vault.json
+var vault_default = {
+  address: "A4jgqct3bwTwRmHECHdPpbH3a8ksaVb7rny9pMUGFo94",
+  metadata: {
+    name: "vault",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "OptionsFi V2 - Covered Call Vault"
+  },
+  instructions: [
+    {
+      name: "add_market_maker",
+      docs: [
+        "Add a market maker to the whitelist"
+      ],
+      discriminator: [
+        24,
+        255,
+        135,
+        32,
+        193,
+        2,
+        112,
+        44
+      ],
+      accounts: [
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          },
+          relations: [
+            "whitelist"
+          ]
+        },
+        {
+          name: "whitelist",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  104,
+                  105,
+                  116,
+                  101,
+                  108,
+                  105,
+                  115,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault",
+            "whitelist"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "market_maker",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "advance_epoch",
+      docs: [
+        "Advance epoch (called by keeper after settlement)",
+        "Premium earned is credited to total_assets, increasing share value"
+      ],
+      discriminator: [
+        93,
+        138,
+        234,
+        218,
+        241,
+        230,
+        132,
+        38
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "premium_earned",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "cancel_param_change",
+      docs: [
+        "Cancel a queued parameter change"
+      ],
+      discriminator: [
+        150,
+        147,
+        92,
+        108,
+        72,
+        160,
+        224,
+        55
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: []
+    },
+    {
+      name: "close_orphaned_token_account",
+      docs: [
+        "Close an orphaned token account that was owned by a vault PDA",
+        "This is used to clean up old share escrows, vault token accounts, etc.",
+        "after a vault has been force-closed, enabling reuse of asset IDs.",
+        "",
+        "The caller must provide the correct asset_id that was used to derive the vault PDA.",
+        "The vault PDA must NOT exist anymore (force-closed)."
+      ],
+      discriminator: [
+        232,
+        127,
+        173,
+        13,
+        92,
+        144,
+        116,
+        98
+      ],
+      accounts: [
+        {
+          name: "vault_pda",
+          docs: [
+            "We verify this matches the derived PDA in the instruction"
+          ],
+          writable: true
+        },
+        {
+          name: "token_account",
+          docs: [
+            "The token account to close (share escrow, vault token account, etc.)"
+          ],
+          writable: true
+        },
+        {
+          name: "authority",
+          docs: [
+            "Authority receiving the lamports"
+          ],
+          writable: true,
+          signer: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "asset_id",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "close_vault",
+      docs: [
+        "Close a vault and recover rent (authority only)",
+        "Vault must be empty (no assets, shares, or pending withdrawals)"
+      ],
+      discriminator: [
+        141,
+        103,
+        17,
+        126,
+        72,
+        75,
+        29,
+        29
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: []
+    },
+    {
+      name: "collect_premium",
+      docs: [
+        "Collect premium from market maker (called during epoch roll)",
+        "Transfers USDC from payer to vault's premium account",
+        "SECURITY FIX M-1: Now requires authority signature to prevent front-running"
+      ],
+      discriminator: [
+        166,
+        199,
+        123,
+        128,
+        71,
+        141,
+        223,
+        204
+      ],
+      accounts: [
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_premium_account",
+          writable: true
+        },
+        {
+          name: "payer_token_account",
+          writable: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "authority",
+          docs: [
+            "SECURITY FIX M-1: Authority must sign to prevent front-running premium collection"
+          ],
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "create_share_metadata",
+      docs: [
+        "Create metadata for the share token (vNVDAx, etc.)",
+        "Only callable by vault authority since vault PDA is the mint authority"
+      ],
+      discriminator: [
+        176,
+        243,
+        233,
+        202,
+        218,
+        168,
+        53,
+        158
+      ],
+      accounts: [
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "share_mint",
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "metadata",
+          writable: true
+        },
+        {
+          name: "payer",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "rent",
+          address: "SysvarRent111111111111111111111111111111111"
+        },
+        {
+          name: "token_metadata_program",
+          address: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+        }
+      ],
+      args: [
+        {
+          name: "name",
+          type: "string"
+        },
+        {
+          name: "symbol",
+          type: "string"
+        },
+        {
+          name: "uri",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "deposit",
+      docs: [
+        "Deposit underlying tokens and receive vault shares"
+      ],
+      discriminator: [
+        242,
+        35,
+        198,
+        137,
+        82,
+        225,
+        242,
+        182
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "share_mint",
+          writable: true
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "user_token_account",
+          writable: true
+        },
+        {
+          name: "user_share_account",
+          writable: true
+        },
+        {
+          name: "share_escrow",
+          writable: true
+        },
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "execute_param_change",
+      docs: [
+        "SECURITY FIX M-3: Execute queued parameter changes after timelock"
+      ],
+      discriminator: [
+        162,
+        166,
+        56,
+        243,
+        168,
+        135,
+        66,
+        175
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: []
+    },
+    {
+      name: "force_close_vault",
+      docs: [
+        "Force close a vault account (bypasses deserialization)",
+        "USE WITH CAUTION: Only for recovering from incompatible account structures",
+        "SECURITY FIX C-2: Now verifies caller is the stored vault authority"
+      ],
+      discriminator: [
+        229,
+        45,
+        206,
+        4,
+        96,
+        129,
+        140,
+        24
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        }
+      ],
+      args: [
+        {
+          name: "asset_id",
+          type: "string"
+        }
+      ]
+    },
+    {
+      name: "initialize_vault",
+      docs: [
+        "Initialize a new vault for a specific xStock asset"
+      ],
+      discriminator: [
+        48,
+        191,
+        163,
+        44,
+        71,
+        129,
+        63,
+        164
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "arg",
+                path: "asset_id"
+              }
+            ]
+          }
+        },
+        {
+          name: "underlying_mint"
+        },
+        {
+          name: "premium_mint"
+        },
+        {
+          name: "share_mint",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "vault_token_account",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "premium_token_account",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "share_escrow",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  115,
+                  104,
+                  97,
+                  114,
+                  101,
+                  95,
+                  101,
+                  115,
+                  99,
+                  114,
+                  111,
+                  119
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "rent",
+          address: "SysvarRent111111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "asset_id",
+          type: "string"
+        },
+        {
+          name: "utilization_cap_bps",
+          type: "u16"
+        },
+        {
+          name: "min_epoch_duration",
+          type: "i64"
+        }
+      ]
+    },
+    {
+      name: "initialize_whitelist",
+      docs: [
+        "Initialize the market maker whitelist"
+      ],
+      discriminator: [
+        223,
+        228,
+        11,
+        219,
+        112,
+        174,
+        108,
+        18
+      ],
+      accounts: [
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "whitelist",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  104,
+                  105,
+                  116,
+                  101,
+                  108,
+                  105,
+                  115,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: []
+    },
+    {
+      name: "pay_settlement",
+      docs: [
+        "Pay out to market maker for ITM settlement",
+        "Only callable by vault authority",
+        "SECURITY: Settlement capped at epoch premium earned"
+      ],
+      discriminator: [
+        65,
+        54,
+        44,
+        166,
+        205,
+        55,
+        164,
+        205
+      ],
+      accounts: [
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          },
+          relations: [
+            "whitelist"
+          ]
+        },
+        {
+          name: "whitelist",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  104,
+                  105,
+                  116,
+                  101,
+                  108,
+                  105,
+                  115,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "vault_premium_account",
+          writable: true
+        },
+        {
+          name: "recipient_token_account",
+          writable: true
+        },
+        {
+          name: "recipient"
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "process_withdrawal",
+      docs: [
+        "Process withdrawal after epoch settles",
+        "SECURITY FIX H-3: Added min_expected_amount for slippage protection"
+      ],
+      discriminator: [
+        51,
+        97,
+        236,
+        17,
+        37,
+        33,
+        196,
+        64
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          },
+          relations: [
+            "withdrawal_request"
+          ]
+        },
+        {
+          name: "withdrawal_request",
+          writable: true
+        },
+        {
+          name: "share_mint",
+          writable: true
+        },
+        {
+          name: "vault_token_account",
+          writable: true
+        },
+        {
+          name: "user_token_account",
+          writable: true
+        },
+        {
+          name: "share_escrow",
+          writable: true
+        },
+        {
+          name: "vault_premium_account",
+          writable: true
+        },
+        {
+          name: "user_premium_account",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "const",
+                value: [
+                  6,
+                  221,
+                  246,
+                  225,
+                  215,
+                  101,
+                  161,
+                  147,
+                  217,
+                  203,
+                  225,
+                  70,
+                  206,
+                  235,
+                  121,
+                  172,
+                  28,
+                  180,
+                  133,
+                  237,
+                  95,
+                  91,
+                  55,
+                  145,
+                  58,
+                  140,
+                  245,
+                  133,
+                  126,
+                  255,
+                  0,
+                  169
+                ]
+              },
+              {
+                kind: "account",
+                path: "premium_mint"
+              }
+            ],
+            program: {
+              kind: "const",
+              value: [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          name: "premium_mint"
+        },
+        {
+          name: "user",
+          writable: true,
+          signer: true,
+          relations: [
+            "withdrawal_request"
+          ]
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        },
+        {
+          name: "associated_token_program",
+          address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        }
+      ],
+      args: [
+        {
+          name: "min_expected_amount",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "queue_param_change",
+      docs: [
+        "SECURITY FIX M-3: Queue a parameter change with timelock",
+        "Changes take effect after TIMELOCK_DURATION (24 hours)"
+      ],
+      discriminator: [
+        140,
+        242,
+        124,
+        63,
+        143,
+        237,
+        195,
+        231
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "new_min_epoch_duration",
+          type: {
+            option: "i64"
+          }
+        },
+        {
+          name: "new_utilization_cap_bps",
+          type: {
+            option: "u16"
+          }
+        }
+      ]
+    },
+    {
+      name: "record_notional_exposure",
+      docs: [
+        "Record notional exposure when an RFQ is filled (fractional options)",
+        "Premium is in premium_mint tokens (USDC)"
+      ],
+      discriminator: [
+        26,
+        180,
+        108,
+        160,
+        15,
+        34,
+        179,
+        128
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "notional_tokens",
+          type: "u64"
+        },
+        {
+          name: "premium",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "remove_market_maker",
+      docs: [
+        "SECURITY FIX M-4: Remove a market maker from the whitelist"
+      ],
+      discriminator: [
+        101,
+        241,
+        39,
+        132,
+        210,
+        208,
+        183,
+        254
+      ],
+      accounts: [
+        {
+          name: "vault",
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          },
+          relations: [
+            "whitelist"
+          ]
+        },
+        {
+          name: "whitelist",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  104,
+                  105,
+                  116,
+                  101,
+                  108,
+                  105,
+                  115,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          writable: true,
+          signer: true,
+          relations: [
+            "vault",
+            "whitelist"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "market_maker",
+          type: "pubkey"
+        }
+      ]
+    },
+    {
+      name: "request_withdrawal",
+      docs: [
+        "Request withdrawal (queued until epoch end)"
+      ],
+      discriminator: [
+        251,
+        85,
+        121,
+        205,
+        56,
+        201,
+        12,
+        177
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "withdrawal_request",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  119,
+                  105,
+                  116,
+                  104,
+                  100,
+                  114,
+                  97,
+                  119,
+                  97,
+                  108
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault"
+              },
+              {
+                kind: "account",
+                path: "user"
+              },
+              {
+                kind: "account",
+                path: "vault.epoch",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "share_escrow",
+          writable: true
+        },
+        {
+          name: "user_share_account",
+          writable: true
+        },
+        {
+          name: "user",
+          writable: true,
+          signer: true
+        },
+        {
+          name: "system_program",
+          address: "11111111111111111111111111111111"
+        },
+        {
+          name: "token_program",
+          address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+        }
+      ],
+      args: [
+        {
+          name: "shares",
+          type: "u64"
+        }
+      ]
+    },
+    {
+      name: "set_min_epoch_duration",
+      docs: [
+        "DEPRECATED: Direct parameter changes now require timelock",
+        "Kept for backwards compatibility but will fail"
+      ],
+      discriminator: [
+        172,
+        45,
+        116,
+        18,
+        195,
+        137,
+        80,
+        225
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "_duration",
+          type: "i64"
+        }
+      ]
+    },
+    {
+      name: "set_pause",
+      docs: [
+        "SECURITY: Pause or unpause the vault (emergency control)",
+        "When paused, deposits and withdrawal requests are blocked"
+      ],
+      discriminator: [
+        63,
+        32,
+        154,
+        2,
+        56,
+        103,
+        79,
+        45
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "paused",
+          type: "bool"
+        }
+      ]
+    },
+    {
+      name: "set_utilization_cap",
+      docs: [
+        "DEPRECATED: Direct parameter changes now require timelock",
+        "Kept for backwards compatibility but will fail"
+      ],
+      discriminator: [
+        54,
+        143,
+        110,
+        156,
+        48,
+        172,
+        7,
+        64
+      ],
+      accounts: [
+        {
+          name: "vault",
+          writable: true,
+          pda: {
+            seeds: [
+              {
+                kind: "const",
+                value: [
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                kind: "account",
+                path: "vault.asset_id",
+                account: "Vault"
+              }
+            ]
+          }
+        },
+        {
+          name: "authority",
+          signer: true,
+          relations: [
+            "vault"
+          ]
+        }
+      ],
+      args: [
+        {
+          name: "_cap_bps",
+          type: "u16"
+        }
+      ]
+    }
+  ],
+  accounts: [
+    {
+      name: "Vault",
+      discriminator: [
+        211,
+        8,
+        232,
+        43,
+        2,
+        152,
+        117,
+        119
+      ]
+    },
+    {
+      name: "VaultWhitelist",
+      discriminator: [
+        82,
+        19,
+        233,
+        96,
+        174,
+        0,
+        57,
+        17
+      ]
+    },
+    {
+      name: "WithdrawalRequest",
+      discriminator: [
+        242,
+        88,
+        147,
+        173,
+        182,
+        62,
+        229,
+        193
+      ]
+    }
+  ],
+  events: [
+    {
+      name: "DepositEvent",
+      discriminator: [
+        120,
+        248,
+        61,
+        83,
+        31,
+        142,
+        107,
+        144
+      ]
+    },
+    {
+      name: "EpochAdvancedEvent",
+      discriminator: [
+        26,
+        197,
+        195,
+        116,
+        126,
+        48,
+        210,
+        42
+      ]
+    },
+    {
+      name: "MarketMakerRemovedEvent",
+      discriminator: [
+        238,
+        48,
+        105,
+        84,
+        228,
+        245,
+        204,
+        75
+      ]
+    },
+    {
+      name: "NotionalExposureEvent",
+      discriminator: [
+        220,
+        74,
+        165,
+        136,
+        237,
+        183,
+        23,
+        38
+      ]
+    },
+    {
+      name: "ParamChangeExecutedEvent",
+      discriminator: [
+        208,
+        23,
+        211,
+        151,
+        8,
+        56,
+        124,
+        26
+      ]
+    },
+    {
+      name: "ParamChangeQueuedEvent",
+      discriminator: [
+        44,
+        143,
+        34,
+        222,
+        153,
+        125,
+        73,
+        23
+      ]
+    },
+    {
+      name: "PremiumCollectedEvent",
+      discriminator: [
+        76,
+        52,
+        166,
+        111,
+        182,
+        211,
+        215,
+        144
+      ]
+    },
+    {
+      name: "SettlementPaidEvent",
+      discriminator: [
+        97,
+        3,
+        234,
+        177,
+        141,
+        83,
+        59,
+        26
+      ]
+    },
+    {
+      name: "VaultPausedEvent",
+      discriminator: [
+        75,
+        189,
+        120,
+        167,
+        117,
+        229,
+        155,
+        60
+      ]
+    },
+    {
+      name: "WithdrawalProcessedEvent",
+      discriminator: [
+        23,
+        252,
+        30,
+        4,
+        24,
+        110,
+        166,
+        133
+      ]
+    },
+    {
+      name: "WithdrawalRequestedEvent",
+      discriminator: [
+        82,
+        227,
+        155,
+        140,
+        223,
+        124,
+        77,
+        243
+      ]
+    }
+  ],
+  errors: [
+    {
+      code: 6e3,
+      name: "ZeroAmount",
+      msg: "Amount must be greater than zero"
+    },
+    {
+      code: 6001,
+      name: "ZeroShares",
+      msg: "Calculated shares must be greater than zero"
+    },
+    {
+      code: 6002,
+      name: "InsufficientShares",
+      msg: "Insufficient shares"
+    },
+    {
+      code: 6003,
+      name: "AlreadyProcessed",
+      msg: "Withdrawal already processed"
+    },
+    {
+      code: 6004,
+      name: "EpochNotSettled",
+      msg: "Epoch has not settled yet"
+    },
+    {
+      code: 6005,
+      name: "Overflow",
+      msg: "Arithmetic overflow"
+    },
+    {
+      code: 6006,
+      name: "ExceedsUtilizationCap",
+      msg: "Exceeds utilization cap"
+    },
+    {
+      code: 6007,
+      name: "NotWhitelisted",
+      msg: "Recipient is not whitelisted"
+    },
+    {
+      code: 6008,
+      name: "WhitelistFull",
+      msg: "Whitelist is full"
+    },
+    {
+      code: 6009,
+      name: "AlreadyWhitelisted",
+      msg: "Market maker already whitelisted"
+    },
+    {
+      code: 6010,
+      name: "InsufficientLiquidity",
+      msg: "Insufficient liquidity for first deposit"
+    },
+    {
+      code: 6011,
+      name: "EpochTooShort",
+      msg: "Epoch duration too short"
+    },
+    {
+      code: 6012,
+      name: "ExcessivePremium",
+      msg: "Premium exceeds safety limits"
+    },
+    {
+      code: 6013,
+      name: "ExcessiveYield",
+      msg: "Implied yield too high"
+    },
+    {
+      code: 6014,
+      name: "ExcessiveSettlement",
+      msg: "Settlement exceeds epoch premium earned"
+    },
+    {
+      code: 6015,
+      name: "InsufficientVaultBalance",
+      msg: "Insufficient vault balance for withdrawal"
+    },
+    {
+      code: 6016,
+      name: "VaultPaused",
+      msg: "Vault is paused"
+    },
+    {
+      code: 6017,
+      name: "VaultNotEmpty",
+      msg: "Vault must be empty to close"
+    },
+    {
+      code: 6018,
+      name: "InvalidVaultPda",
+      msg: "Invalid vault PDA"
+    },
+    {
+      code: 6019,
+      name: "SlippageExceeded",
+      msg: "Withdrawal amount below minimum expected (slippage protection)"
+    },
+    {
+      code: 6020,
+      name: "DivisionByZero",
+      msg: "Division by zero"
+    },
+    {
+      code: 6021,
+      name: "TimelockNotExpired",
+      msg: "Timelock has not expired yet"
+    },
+    {
+      code: 6022,
+      name: "UseTimelockForParamChange",
+      msg: "Direct param changes deprecated - use queue_param_change"
+    },
+    {
+      code: 6023,
+      name: "InvalidParameter",
+      msg: "Invalid parameter value"
+    },
+    {
+      code: 6024,
+      name: "UnauthorizedForceClose",
+      msg: "Caller is not the vault authority"
+    },
+    {
+      code: 6025,
+      name: "VaultStillExists",
+      msg: "Vault still exists - close it first before cleaning up token accounts"
+    }
+  ],
+  types: [
+    {
+      name: "DepositEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "shares_minted",
+            type: "u64"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "EpochAdvancedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "new_epoch",
+            type: "u64"
+          },
+          {
+            name: "premium_earned",
+            type: "u64"
+          },
+          {
+            name: "notional_exposed",
+            type: "u64"
+          },
+          {
+            name: "avg_premium_bps",
+            type: "u32"
+          },
+          {
+            name: "total_assets",
+            type: "u64"
+          },
+          {
+            name: "total_shares",
+            type: "u64"
+          },
+          {
+            name: "premium_balance_usdc",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "MarketMakerRemovedEvent",
+      docs: [
+        "SECURITY FIX M-4: Event emitted when a market maker is removed"
+      ],
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "market_maker",
+            type: "pubkey"
+          }
+        ]
+      }
+    },
+    {
+      name: "NotionalExposureEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "notional_tokens",
+            type: "u64"
+          },
+          {
+            name: "premium",
+            type: "u64"
+          },
+          {
+            name: "total_notional_this_epoch",
+            type: "u64"
+          },
+          {
+            name: "total_premium_this_epoch",
+            type: "u64"
+          },
+          {
+            name: "avg_premium_bps",
+            type: "u32"
+          }
+        ]
+      }
+    },
+    {
+      name: "ParamChangeExecutedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "new_min_epoch_duration",
+            type: "i64"
+          },
+          {
+            name: "new_utilization_cap_bps",
+            type: "u16"
+          }
+        ]
+      }
+    },
+    {
+      name: "ParamChangeQueuedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "new_min_epoch_duration",
+            type: {
+              option: "i64"
+            }
+          },
+          {
+            name: "new_utilization_cap_bps",
+            type: {
+              option: "u16"
+            }
+          },
+          {
+            name: "unlock_time",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "PremiumCollectedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "payer",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "SettlementPaidEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "recipient",
+            type: "pubkey"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "Vault",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "asset_id",
+            type: "string"
+          },
+          {
+            name: "underlying_mint",
+            type: "pubkey"
+          },
+          {
+            name: "share_mint",
+            type: "pubkey"
+          },
+          {
+            name: "vault_token_account",
+            type: "pubkey"
+          },
+          {
+            name: "premium_mint",
+            type: "pubkey"
+          },
+          {
+            name: "premium_token_account",
+            type: "pubkey"
+          },
+          {
+            name: "share_escrow",
+            type: "pubkey"
+          },
+          {
+            name: "total_assets",
+            type: "u64"
+          },
+          {
+            name: "total_shares",
+            type: "u64"
+          },
+          {
+            name: "virtual_offset",
+            docs: [
+              "Virtual offset for share calculations (prevents first-depositor attacks)",
+              "effective_shares = total_shares + virtual_offset"
+            ],
+            type: "u64"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          },
+          {
+            name: "utilization_cap_bps",
+            type: "u16"
+          },
+          {
+            name: "min_epoch_duration",
+            type: "i64"
+          },
+          {
+            name: "last_roll_timestamp",
+            type: "i64"
+          },
+          {
+            name: "pending_withdrawals",
+            type: "u64"
+          },
+          {
+            name: "epoch_notional_exposed",
+            type: "u64"
+          },
+          {
+            name: "epoch_premium_earned",
+            type: "u64"
+          },
+          {
+            name: "epoch_premium_per_token_bps",
+            type: "u32"
+          },
+          {
+            name: "premium_balance_usdc",
+            docs: [
+              "Accumulated USDC premium balance (separate from underlying TVL)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "is_paused",
+            docs: [
+              "SECURITY: Emergency pause flag"
+            ],
+            type: "bool"
+          },
+          {
+            name: "pending_min_epoch_duration",
+            docs: [
+              "SECURITY FIX M-3: Timelock for parameter changes"
+            ],
+            type: "i64"
+          },
+          {
+            name: "pending_utilization_cap",
+            type: "u16"
+          },
+          {
+            name: "param_change_unlock_time",
+            type: "i64"
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultPausedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "paused",
+            type: "bool"
+          },
+          {
+            name: "timestamp",
+            type: "i64"
+          }
+        ]
+      }
+    },
+    {
+      name: "VaultWhitelist",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "authority",
+            type: "pubkey"
+          },
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "market_makers",
+            type: {
+              vec: "pubkey"
+            }
+          },
+          {
+            name: "bump",
+            type: "u8"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalProcessedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "shares",
+            type: "u64"
+          },
+          {
+            name: "amount",
+            type: "u64"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalRequest",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "shares",
+            type: "u64"
+          },
+          {
+            name: "request_epoch",
+            type: "u64"
+          },
+          {
+            name: "processed",
+            type: "bool"
+          }
+        ]
+      }
+    },
+    {
+      name: "WithdrawalRequestedEvent",
+      type: {
+        kind: "struct",
+        fields: [
+          {
+            name: "vault",
+            type: "pubkey"
+          },
+          {
+            name: "user",
+            type: "pubkey"
+          },
+          {
+            name: "shares",
+            type: "u64"
+          },
+          {
+            name: "epoch",
+            type: "u64"
+          }
+        ]
+      }
+    }
+  ]
+};
+
+// src/client/VaultInstructions.ts
+var TOKEN_PROGRAM_ID = new import_web33.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var VaultInstructions = class {
+  connection;
+  program = null;
+  idl;
+  /**
+   * Create a new VaultInstructions client
+   * 
+   * @param connection - Solana connection
+   * @param idl - Optional IDL (uses bundled vault IDL by default)
+   */
+  constructor(connection, idl) {
+    this.connection = connection;
+    this.idl = idl || vault_default;
+  }
+  /**
+   * Initialize the Anchor program interface
+   * 
+   * @param wallet - Optional wallet for signing (not required for instruction building)
+   */
+  async initialize(wallet) {
+    const provider = new anchor.AnchorProvider(
+      this.connection,
+      wallet || {},
+      { commitment: "confirmed" }
+    );
+    this.program = new anchor.Program(this.idl, VAULT_PROGRAM_ID, provider);
+  }
+  /**
+   * Set the program IDL
+   * 
+   * @param idl - Vault program IDL
+   */
+  setIDL(idl) {
+    this.idl = idl;
+  }
+  /**
+   * Check if the client is initialized
+   */
+  get isInitialized() {
+    return this.program !== null;
+  }
+  /**
+   * Fetch vault account data
+   * 
+   * @param assetId - Asset identifier (e.g., "NVDAX")
+   * @returns Vault data or null if not found
+   */
+  async fetchVault(assetId) {
+    if (!this.program) {
+      throw new Error("Client not initialized. Call initialize() first.");
+    }
+    try {
+      const [vaultPda] = deriveVaultPda(assetId);
+      const vault = await this.program.account.vault.fetch(vaultPda);
+      return {
+        authority: vault.authority,
+        assetId: vault.assetId,
+        underlyingMint: vault.underlyingMint,
+        shareMint: vault.shareMint,
+        vaultTokenAccount: vault.vaultTokenAccount,
+        premiumMint: vault.premiumMint,
+        premiumTokenAccount: vault.premiumTokenAccount,
+        shareEscrow: vault.shareEscrow,
+        totalAssets: BigInt(vault.totalAssets.toString()),
+        totalShares: BigInt(vault.totalShares.toString()),
+        virtualOffset: BigInt(vault.virtualOffset.toString()),
+        epoch: BigInt(vault.epoch.toString()),
+        utilizationCapBps: vault.utilizationCapBps,
+        minEpochDuration: BigInt(vault.minEpochDuration.toString()),
+        lastRollTimestamp: BigInt(vault.lastRollTimestamp.toString()),
+        pendingWithdrawals: BigInt(vault.pendingWithdrawals.toString()),
+        epochNotionalExposed: BigInt(vault.epochNotionalExposed.toString()),
+        epochPremiumEarned: BigInt(vault.epochPremiumEarned.toString()),
+        epochPremiumPerTokenBps: vault.epochPremiumPerTokenBps,
+        isPaused: vault.isPaused,
+        bump: vault.bump
+      };
+    } catch (error) {
+      if (error.message?.includes("Account does not exist")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Build instruction to record notional exposure after RFQ execution
+   * 
+   * @param params - Exposure parameters
+   * @returns TransactionInstruction
+   */
+  async recordNotionalExposure(params) {
+    if (!this.program) {
+      throw new Error("Client not initialized. Call initialize() first.");
+    }
+    return await this.program.methods.recordNotionalExposure(
+      new anchor.BN(params.notionalTokens.toString()),
+      new anchor.BN(params.premium.toString())
+    ).accounts({
+      vault: params.vault,
+      authority: params.authority
+    }).instruction();
+  }
+  /**
+   * Build instruction to collect premium from market maker
+   * 
+   * @param params - Collection parameters
+   * @returns TransactionInstruction
+   */
+  async collectPremium(params) {
+    if (!this.program) {
+      throw new Error("Client not initialized. Call initialize() first.");
+    }
+    const vault = await this.program.account.vault.fetch(params.vault);
+    return await this.program.methods.collectPremium(new anchor.BN(params.amount.toString())).accounts({
+      vault: params.vault,
+      vaultPremiumAccount: vault.premiumTokenAccount,
+      payerTokenAccount: params.payerTokenAccount,
+      payer: params.authority,
+      // Payer is typically the authority
+      authority: params.authority,
+      tokenProgram: TOKEN_PROGRAM_ID
+    }).instruction();
+  }
+  /**
+   * Build instruction to pay settlement to market maker
+   * 
+   * @param params - Settlement parameters
+   * @returns TransactionInstruction
+   */
+  async paySettlement(params) {
+    if (!this.program) {
+      throw new Error("Client not initialized. Call initialize() first.");
+    }
+    const vault = await this.program.account.vault.fetch(params.vault);
+    return await this.program.methods.paySettlement(new anchor.BN(params.amount.toString())).accounts({
+      vault: params.vault,
+      vaultPremiumAccount: vault.premiumTokenAccount,
+      recipientTokenAccount: params.recipientTokenAccount,
+      recipient: params.recipient,
+      authority: params.authority,
+      tokenProgram: TOKEN_PROGRAM_ID
+    }).instruction();
+  }
+  /**
+   * Build instruction to advance epoch
+   * 
+   * @param params - Advance epoch parameters
+   * @returns TransactionInstruction
+   */
+  async advanceEpoch(params) {
+    if (!this.program) {
+      throw new Error("Client not initialized. Call initialize() first.");
+    }
+    return await this.program.methods.advanceEpoch(new anchor.BN(params.premiumEarned.toString())).accounts({
+      vault: params.vault,
+      authority: params.authority
+    }).instruction();
+  }
+  /**
+   * Calculate share price from vault data
+   * 
+   * @param vault - Vault data
+   * @param decimals - Token decimals (default: 6)
+   * @returns Share price as a number
+   */
+  static calculateSharePrice(vault, decimals = 6) {
+    if (vault.totalShares === 0n) {
+      return 1;
+    }
+    const totalAssets = Number(vault.totalAssets) / 10 ** decimals;
+    const totalShares = Number(vault.totalShares) / 10 ** decimals;
+    const virtualOffset = Number(vault.virtualOffset) / 10 ** decimals;
+    return (totalAssets + virtualOffset) / totalShares;
+  }
+  /**
+   * Calculate utilization percentage from vault data
+   * 
+   * @param vault - Vault data
+   * @returns Utilization as decimal (0-1)
+   */
+  static calculateUtilization(vault) {
+    if (vault.totalAssets === 0n) {
+      return 0;
+    }
+    return Number(vault.epochNotionalExposed) / Number(vault.totalAssets);
+  }
+  /**
+   * Check if vault can accept more exposure
+   * 
+   * @param vault - Vault data
+   * @param additionalNotional - Additional notional to expose
+   * @returns Whether the vault can accept the exposure
+   */
+  static canAcceptExposure(vault, additionalNotional) {
+    const maxExposure = vault.totalAssets * BigInt(vault.utilizationCapBps) / 10000n;
+    const newExposure = vault.epochNotionalExposed + additionalNotional;
+    return newExposure <= maxExposure;
+  }
+  /**
+   * Calculate remaining capacity for option writing
+   * 
+   * @param vault - Vault data
+   * @returns Remaining notional capacity
+   */
+  static getRemainingCapacity(vault) {
+    const maxExposure = vault.totalAssets * BigInt(vault.utilizationCapBps) / 10000n;
+    const remaining = maxExposure - vault.epochNotionalExposed;
+    return remaining > 0n ? remaining : 0n;
+  }
+};
+
+// src/utils/pricing.ts
+var OptionPricing = class {
+  /**
+   * Calculate option prices using Black-Scholes formula
+   * 
+   * @param params - Pricing parameters
+   * @returns Call and put prices with deltas
+   */
+  static blackScholes(params) {
+    const { spot, strike, timeToExpiry, riskFreeRate, volatility } = params;
+    if (timeToExpiry <= 0) {
+      const intrinsicCall = Math.max(0, spot - strike);
+      const intrinsicPut = Math.max(0, strike - spot);
+      return {
+        call: intrinsicCall,
+        put: intrinsicPut,
+        delta: {
+          call: intrinsicCall > 0 ? 1 : 0,
+          put: intrinsicPut > 0 ? -1 : 0
+        }
+      };
+    }
+    if (volatility <= 0) {
+      throw new Error("Volatility must be positive");
+    }
+    const sqrtT = Math.sqrt(timeToExpiry);
+    const d1 = (Math.log(spot / strike) + (riskFreeRate + 0.5 * volatility * volatility) * timeToExpiry) / (volatility * sqrtT);
+    const d2 = d1 - volatility * sqrtT;
+    const callPrice = spot * this.normalCDF(d1) - strike * Math.exp(-riskFreeRate * timeToExpiry) * this.normalCDF(d2);
+    const putPrice = strike * Math.exp(-riskFreeRate * timeToExpiry) * this.normalCDF(-d2) - spot * this.normalCDF(-d1);
+    const callDelta = this.normalCDF(d1);
+    const putDelta = callDelta - 1;
+    return {
+      call: Math.max(0, callPrice),
+      put: Math.max(0, putPrice),
+      delta: { call: callDelta, put: putDelta }
+    };
+  }
+  /**
+   * Calculate covered call premium
+   * 
+   * @param params - Premium calculation parameters
+   * @returns Premium in same units as spot price
+   */
+  static calculateCoveredCallPremium(params) {
+    const {
+      spot,
+      strikePercent,
+      daysToExpiry,
+      volatility,
+      riskFreeRate = DEFAULT_PRICING_PARAMS.riskFreeRate
+    } = params;
+    const strike = spot * strikePercent;
+    const timeToExpiry = daysToExpiry / 365;
+    const prices = this.blackScholes({
+      spot,
+      strike,
+      timeToExpiry,
+      riskFreeRate,
+      volatility
+    });
+    return prices.call;
+  }
+  /**
+   * Calculate premium as basis points of notional
+   * 
+   * @param premium - Premium amount
+   * @param spot - Spot price
+   * @returns Premium in basis points
+   */
+  static premiumToBps(premium, spot) {
+    return Math.round(premium / spot * 1e4);
+  }
+  /**
+   * Convert basis points to premium
+   * 
+   * @param bps - Basis points
+   * @param spot - Spot price
+   * @returns Premium amount
+   */
+  static bpsToPremium(bps, spot) {
+    return bps / 1e4 * spot;
+  }
+  /**
+   * Calculate time to expiry in years
+   * 
+   * @param expiryTimestamp - Expiry Unix timestamp (seconds)
+   * @returns Time in years
+   */
+  static timeToExpiry(expiryTimestamp) {
+    const now = Date.now() / 1e3;
+    const secondsToExpiry = expiryTimestamp - now;
+    return secondsToExpiry / (365.25 * 24 * 60 * 60);
+  }
+  /**
+   * Suggest a strike price based on delta target
+   * 
+   * @param spotPrice - Current spot price
+   * @param deltaBps - Delta in basis points (e.g., 1000 = 10% OTM)
+   * @param optionType - 'call' or 'put'
+   * @returns Suggested strike price
+   */
+  static suggestStrike(spotPrice, deltaBps, optionType = "call") {
+    const multiplier = optionType === "call" ? 1 : -1;
+    return spotPrice * (1 + multiplier * deltaBps / 1e4);
+  }
+  /**
+   * Validate a quote against fair value
+   * 
+   * @param quotePremium - Premium from quote
+   * @param fairValue - Calculated fair value
+   * @param maxDeviationBps - Maximum acceptable deviation in bps (default: 500)
+   * @returns Validation result
+   */
+  static validateQuote(quotePremium, fairValue, maxDeviationBps = DEFAULT_PRICING_PARAMS.maxQuoteDeviationBps) {
+    if (fairValue <= 0) {
+      return {
+        isValid: false,
+        reason: "Fair value must be positive",
+        fairValue
+      };
+    }
+    const deviation = Math.abs(quotePremium - fairValue) / fairValue;
+    const deviationBps = Math.round(deviation * 1e4);
+    const maxDeviation = maxDeviationBps / 1e4;
+    if (deviation > maxDeviation) {
+      return {
+        isValid: false,
+        reason: `Quote deviates ${deviationBps} bps from fair value (max: ${maxDeviationBps} bps)`,
+        fairValue,
+        deviationBps
+      };
+    }
+    return {
+      isValid: true,
+      fairValue,
+      deviationBps
+    };
+  }
+  /**
+   * Calculate historical volatility from price data
+   * 
+   * @param prices - Array of closing prices (oldest first)
+   * @param tradingDaysPerYear - Trading days for annualization (default: 252)
+   * @returns Annualized volatility
+   */
+  static calculateHistoricalVolatility(prices, tradingDaysPerYear = DEFAULT_PRICING_PARAMS.tradingDaysPerYear) {
+    if (prices.length < 2) {
+      throw new Error("Need at least 2 prices to calculate volatility");
+    }
+    const logReturns = [];
+    for (let i = 1; i < prices.length; i++) {
+      const logReturn = Math.log(prices[i] / prices[i - 1]);
+      logReturns.push(logReturn);
+    }
+    const mean = logReturns.reduce((sum, r) => sum + r, 0) / logReturns.length;
+    const variance = logReturns.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / (logReturns.length - 1);
+    const dailyStdDev = Math.sqrt(variance);
+    return dailyStdDev * Math.sqrt(tradingDaysPerYear);
+  }
+  /**
+   * Calculate implied volatility from option price using Newton-Raphson
+   * 
+   * @param optionPrice - Market price of option
+   * @param spot - Spot price
+   * @param strike - Strike price
+   * @param timeToExpiry - Time to expiry in years
+   * @param riskFreeRate - Risk-free rate
+   * @param optionType - 'call' or 'put'
+   * @param maxIterations - Maximum iterations (default: 100)
+   * @returns Implied volatility
+   */
+  static calculateImpliedVolatility(optionPrice, spot, strike, timeToExpiry, riskFreeRate, optionType, maxIterations = 100) {
+    let sigma = Math.sqrt(2 * Math.PI / timeToExpiry) * (optionPrice / spot);
+    const tolerance = 1e-6;
+    for (let i = 0; i < maxIterations; i++) {
+      const prices = this.blackScholes({
+        spot,
+        strike,
+        timeToExpiry,
+        riskFreeRate,
+        volatility: sigma
+      });
+      const price = optionType === "call" ? prices.call : prices.put;
+      const diff = price - optionPrice;
+      if (Math.abs(diff) < tolerance) {
+        return sigma;
+      }
+      const sqrtT = Math.sqrt(timeToExpiry);
+      const d1 = (Math.log(spot / strike) + (riskFreeRate + 0.5 * sigma * sigma) * timeToExpiry) / (sigma * sqrtT);
+      const vega = spot * sqrtT * this.normalPDF(d1);
+      if (vega < 1e-10) {
+        throw new Error("Implied volatility calculation failed: vega too small");
+      }
+      sigma = sigma - diff / vega;
+      sigma = Math.max(0.01, Math.min(5, sigma));
+    }
+    throw new Error("Implied volatility calculation did not converge");
+  }
+  // ============================================================================
+  // Private Helper Functions
+  // ============================================================================
+  /**
+   * Standard normal CDF using Abramowitz & Stegun approximation
+   */
+  static normalCDF(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign = x < 0 ? -1 : 1;
+    x = Math.abs(x) / Math.sqrt(2);
+    const t = 1 / (1 + p * x);
+    const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-x * x);
+    return 0.5 * (1 + sign * y);
+  }
+  /**
+   * Standard normal PDF
+   */
+  static normalPDF(x) {
+    return Math.exp(-0.5 * x * x) / Math.sqrt(2 * Math.PI);
+  }
+};
+
+// src/utils/validation.ts
+var ValidationError = class extends Error {
+  field;
+  constructor(field, message) {
+    super(`Validation error on '${field}': ${message}`);
+    this.name = "ValidationError";
+    this.field = field;
+  }
+};
+function validateRFQParams(params) {
+  if (!params.asset || params.asset.trim().length === 0) {
+    throw new ValidationError("asset", "Asset identifier is required");
+  }
+  if (!["buy", "sell"].includes(params.side)) {
+    throw new ValidationError("side", 'Side must be "buy" or "sell"');
+  }
+  if (!["call", "put"].includes(params.optionType)) {
+    throw new ValidationError("optionType", 'Option type must be "call" or "put"');
+  }
+  if (params.strike <= 0) {
+    throw new ValidationError("strike", "Strike must be a positive number");
+  }
+  if (params.expiry <= Math.floor(Date.now() / 1e3)) {
+    throw new ValidationError("expiry", "Expiry must be in the future");
+  }
+  if (params.quantity <= 0n) {
+    throw new ValidationError("quantity", "Quantity must be positive");
+  }
+  if (!params.vaultAddress || params.vaultAddress.length < 32) {
+    throw new ValidationError("vaultAddress", "Valid vault address is required");
+  }
+  if (params.premiumFloor !== void 0 && params.premiumFloor < 0n) {
+    throw new ValidationError("premiumFloor", "Premium floor cannot be negative");
+  }
+}
+function validateBlackScholesParams(params) {
+  if (params.spot <= 0) {
+    throw new ValidationError("spot", "Spot price must be positive");
+  }
+  if (params.strike <= 0) {
+    throw new ValidationError("strike", "Strike price must be positive");
+  }
+  if (params.timeToExpiry <= 0) {
+    throw new ValidationError("timeToExpiry", "Time to expiry must be positive");
+  }
+  if (params.volatility <= 0) {
+    throw new ValidationError("volatility", "Volatility must be positive");
+  }
+  if (params.volatility > 5) {
+    throw new ValidationError("volatility", "Volatility seems too high (>500%)");
+  }
+  if (params.riskFreeRate < -0.1 || params.riskFreeRate > 1) {
+    throw new ValidationError("riskFreeRate", "Risk-free rate seems unreasonable");
+  }
+}
+function validatePublicKey(address, fieldName = "address") {
+  const base58Regex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+  if (!base58Regex.test(address)) {
+    throw new ValidationError(fieldName, "Invalid Solana public key format");
+  }
+}
+function validateTokenAmount(amount, fieldName = "amount", decimals = 6) {
+  if (amount < 0n) {
+    throw new ValidationError(fieldName, "Amount cannot be negative");
+  }
+  const maxReasonable = BigInt(1e15) * BigInt(10 ** decimals);
+  if (amount > maxReasonable) {
+    throw new ValidationError(fieldName, "Amount seems unreasonably large");
+  }
+}
+function validateTimestamp(timestamp, fieldName = "timestamp", options = {}) {
+  if (!Number.isInteger(timestamp) || timestamp < 0) {
+    throw new ValidationError(fieldName, "Invalid timestamp");
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  if (options.mustBeFuture && timestamp <= now) {
+    throw new ValidationError(fieldName, "Timestamp must be in the future");
+  }
+  if (options.maxFutureDays) {
+    const maxTimestamp = now + options.maxFutureDays * 24 * 60 * 60;
+    if (timestamp > maxTimestamp) {
+      throw new ValidationError(
+        fieldName,
+        `Timestamp cannot be more than ${options.maxFutureDays} days in the future`
+      );
+    }
+  }
+}
+
+// src/utils/formatting.ts
+function formatTokenAmount(amount, decimals, maxDecimals = 2) {
+  const divisor = BigInt(10 ** decimals);
+  const intPart = amount / divisor;
+  const fracPart = amount % divisor;
+  const fracStr = fracPart.toString().padStart(decimals, "0");
+  const truncatedFrac = fracStr.slice(0, maxDecimals);
+  if (maxDecimals === 0 || parseInt(truncatedFrac) === 0) {
+    return intPart.toString();
+  }
+  const trimmedFrac = truncatedFrac.replace(/0+$/, "");
+  return trimmedFrac ? `${intPart}.${trimmedFrac}` : intPart.toString();
+}
+function parseTokenAmount(amount, decimals) {
+  const parts = amount.split(".");
+  const intPart = parts[0] || "0";
+  let fracPart = parts[1] || "";
+  fracPart = fracPart.slice(0, decimals).padEnd(decimals, "0");
+  return BigInt(intPart) * BigInt(10 ** decimals) + BigInt(fracPart);
+}
+function formatUSDC(amount, maxDecimals = 2) {
+  return formatTokenAmount(amount, TOKEN_DECIMALS.USDC, maxDecimals);
+}
+function parseUSDC(amount) {
+  return parseTokenAmount(amount, TOKEN_DECIMALS.USDC);
+}
+function formatPrice(price, decimals = 2) {
+  return price.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function formatPercent(value, decimals = 2) {
+  return `${(value * 100).toFixed(decimals)}%`;
+}
+function formatBps(bps) {
+  return `${bps.toLocaleString()} bps`;
+}
+function bpsToPercent(bps) {
+  return bps / 100;
+}
+function percentToBps(percent) {
+  return Math.round(percent * 100);
+}
+function formatTimestamp(timestamp) {
+  return new Date(timestamp * 1e3).toISOString();
+}
+function formatDate(timestamp, options = {
+  year: "numeric",
+  month: "short",
+  day: "numeric",
+  hour: "2-digit",
+  minute: "2-digit"
+}) {
+  return new Date(timestamp * 1e3).toLocaleString("en-US", options);
+}
+function formatTimeToExpiry(expiryTimestamp) {
+  const now = Math.floor(Date.now() / 1e3);
+  const secondsRemaining = expiryTimestamp - now;
+  if (secondsRemaining <= 0) {
+    return "Expired";
+  }
+  const days = Math.floor(secondsRemaining / 86400);
+  const hours = Math.floor(secondsRemaining % 86400 / 3600);
+  const minutes = Math.floor(secondsRemaining % 3600 / 60);
+  if (days > 0) {
+    return `${days}d ${hours}h`;
+  }
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  return `${minutes}m`;
+}
+function shortenAddress(address, chars = 4) {
+  if (address.length <= chars * 2 + 3) {
+    return address;
+  }
+  return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+}
+function formatRFQId(rfqId) {
+  const parts = rfqId.split("_");
+  if (parts.length >= 3) {
+    return `RFQ-${parts[2].toUpperCase()}`;
+  }
+  return rfqId.slice(0, 12);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_PRICING_PARAMS,
+  DEVNET_CONFIG,
+  DEVNET_USDC_MINT,
+  MAINNET_CONFIG,
+  MAINNET_USDC_MINT,
+  OptionPricing,
+  PYTH_HERMES_URL,
+  PYTH_PRICE_FEEDS,
+  RFQClient,
+  RFQ_DEFAULTS,
+  TOKEN_DECIMALS,
+  VAULT_IDL,
+  VAULT_PROGRAM_ID,
+  ValidationError,
+  VaultInstructions,
+  bpsToPercent,
+  deriveShareEscrowPda,
+  deriveVaultPda,
+  deriveWhitelistPda,
+  deriveWithdrawalPda,
+  formatBps,
+  formatDate,
+  formatPercent,
+  formatPrice,
+  formatRFQId,
+  formatTimeToExpiry,
+  formatTimestamp,
+  formatTokenAmount,
+  formatUSDC,
+  parseTokenAmount,
+  parseUSDC,
+  percentToBps,
+  shortenAddress,
+  validateBlackScholesParams,
+  validatePublicKey,
+  validateRFQParams,
+  validateTimestamp,
+  validateTokenAmount
+});