@epicentral/sos-sdk 0.13.0-beta → 0.13.2-beta

package/generated/errors/optionProgram.ts

@@ -52,192 +52,194 @@ export const OPTION_PROGRAM_ERROR__STALE_ORACLE_PRICE = 0x1780; // 6016
 export const OPTION_PROGRAM_ERROR__LOW_ORACLE_PRICE_CONFIDENCE = 0x1781; // 6017
 /** InvalidOracleAccount: Invalid oracle account - cannot parse price feed */
 export const OPTION_PROGRAM_ERROR__INVALID_ORACLE_ACCOUNT = 0x1782; // 6018
+/** VolatilityQuoteUnavailable: Authority volatility quote unavailable or stale */
+export const OPTION_PROGRAM_ERROR__VOLATILITY_QUOTE_UNAVAILABLE = 0x1783; // 6019
 /** InvalidSwitchboardQuoteAccount: Invalid Switchboard quote account */
-export const OPTION_PROGRAM_ERROR__INVALID_SWITCHBOARD_QUOTE_ACCOUNT = 0x1783; // 6019
+export const OPTION_PROGRAM_ERROR__INVALID_SWITCHBOARD_QUOTE_ACCOUNT = 0x1784; // 6020
 /** InvalidSwitchboardUpdateProof: Switchboard quote update proof missing or invalid */
-export const OPTION_PROGRAM_ERROR__INVALID_SWITCHBOARD_UPDATE_PROOF = 0x1784; // 6020
+export const OPTION_PROGRAM_ERROR__INVALID_SWITCHBOARD_UPDATE_PROOF = 0x1785; // 6021
 /** OraclePriceUnavailable: Oracle price is unavailable */
-export const OPTION_PROGRAM_ERROR__ORACLE_PRICE_UNAVAILABLE = 0x1785; // 6021
+export const OPTION_PROGRAM_ERROR__ORACLE_PRICE_UNAVAILABLE = 0x1786; // 6022
 /** InvalidOraclePrice: Invalid oracle price - must be positive */
-export const OPTION_PROGRAM_ERROR__INVALID_ORACLE_PRICE = 0x1786; // 6022
+export const OPTION_PROGRAM_ERROR__INVALID_ORACLE_PRICE = 0x1787; // 6023
 /** InsufficientBalance: Insufficient balance for premium payment */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_BALANCE = 0x1787; // 6023
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_BALANCE = 0x1788; // 6024
 /** PositionNotFound: Position not found */
-export const OPTION_PROGRAM_ERROR__POSITION_NOT_FOUND = 0x1788; // 6024
+export const OPTION_PROGRAM_ERROR__POSITION_NOT_FOUND = 0x1789; // 6025
 /** OptionAccountMismatch: Option account mismatch */
-export const OPTION_PROGRAM_ERROR__OPTION_ACCOUNT_MISMATCH = 0x1789; // 6025
+export const OPTION_PROGRAM_ERROR__OPTION_ACCOUNT_MISMATCH = 0x178a; // 6026
 /** ArithmeticOverflow: Arithmetic overflow occurred */
-export const OPTION_PROGRAM_ERROR__ARITHMETIC_OVERFLOW = 0x178a; // 6026
+export const OPTION_PROGRAM_ERROR__ARITHMETIC_OVERFLOW = 0x178b; // 6027
 /** ArithmeticUnderflow: Arithmetic underflow occurred */
-export const OPTION_PROGRAM_ERROR__ARITHMETIC_UNDERFLOW = 0x178b; // 6027
+export const OPTION_PROGRAM_ERROR__ARITHMETIC_UNDERFLOW = 0x178c; // 6028
 /** DivisionByZero: Division by zero */
-export const OPTION_PROGRAM_ERROR__DIVISION_BY_ZERO = 0x178c; // 6028
+export const OPTION_PROGRAM_ERROR__DIVISION_BY_ZERO = 0x178d; // 6029
 /** PremiumCalculationFailed: Premium calculation failed */
-export const OPTION_PROGRAM_ERROR__PREMIUM_CALCULATION_FAILED = 0x178d; // 6029
+export const OPTION_PROGRAM_ERROR__PREMIUM_CALCULATION_FAILED = 0x178e; // 6030
 /** GreeksCalculationFailed: Greeks calculation failed */
-export const OPTION_PROGRAM_ERROR__GREEKS_CALCULATION_FAILED = 0x178e; // 6030
+export const OPTION_PROGRAM_ERROR__GREEKS_CALCULATION_FAILED = 0x178f; // 6031
 /** InvalidEscrowAuthority: Invalid escrow authority */
-export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_AUTHORITY = 0x178f; // 6031
+export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_AUTHORITY = 0x1790; // 6032
 /** EscrowAccountFrozen: Escrow account is frozen */
-export const OPTION_PROGRAM_ERROR__ESCROW_ACCOUNT_FROZEN = 0x1790; // 6032
+export const OPTION_PROGRAM_ERROR__ESCROW_ACCOUNT_FROZEN = 0x1791; // 6033
 /** MarketClosed: Market is closed */
-export const OPTION_PROGRAM_ERROR__MARKET_CLOSED = 0x1791; // 6033
+export const OPTION_PROGRAM_ERROR__MARKET_CLOSED = 0x1792; // 6034
 /** MaxPositionsReached: Maximum positions limit reached */
-export const OPTION_PROGRAM_ERROR__MAX_POSITIONS_REACHED = 0x1792; // 6034
+export const OPTION_PROGRAM_ERROR__MAX_POSITIONS_REACHED = 0x1793; // 6035
 /** MinimumPositionSizeNotMet: Minimum position size not met */
-export const OPTION_PROGRAM_ERROR__MINIMUM_POSITION_SIZE_NOT_MET = 0x1793; // 6035
+export const OPTION_PROGRAM_ERROR__MINIMUM_POSITION_SIZE_NOT_MET = 0x1794; // 6036
 /** MaximumPositionSizeExceeded: Maximum position size exceeded */
-export const OPTION_PROGRAM_ERROR__MAXIMUM_POSITION_SIZE_EXCEEDED = 0x1794; // 6036
+export const OPTION_PROGRAM_ERROR__MAXIMUM_POSITION_SIZE_EXCEEDED = 0x1795; // 6037
 /** InvalidMakerAuthority: Invalid maker authority */
-export const OPTION_PROGRAM_ERROR__INVALID_MAKER_AUTHORITY = 0x1795; // 6037
+export const OPTION_PROGRAM_ERROR__INVALID_MAKER_AUTHORITY = 0x1796; // 6038
 /** InvalidBuyerAuthority: Invalid buyer authority */
-export const OPTION_PROGRAM_ERROR__INVALID_BUYER_AUTHORITY = 0x1796; // 6038
+export const OPTION_PROGRAM_ERROR__INVALID_BUYER_AUTHORITY = 0x1797; // 6039
 /** OptionChainFull: Option chain is full */
-export const OPTION_PROGRAM_ERROR__OPTION_CHAIN_FULL = 0x1797; // 6039
+export const OPTION_PROGRAM_ERROR__OPTION_CHAIN_FULL = 0x1798; // 6040
 /** DuplicateOption: Duplicate option exists */
-export const OPTION_PROGRAM_ERROR__DUPLICATE_OPTION = 0x1798; // 6040
+export const OPTION_PROGRAM_ERROR__DUPLICATE_OPTION = 0x1799; // 6041
 /** PriceImpactTooHigh: Price impact too high */
-export const OPTION_PROGRAM_ERROR__PRICE_IMPACT_TOO_HIGH = 0x1799; // 6041
+export const OPTION_PROGRAM_ERROR__PRICE_IMPACT_TOO_HIGH = 0x179a; // 6042
 /** SlippageToleranceExceeded: Slippage tolerance exceeded */
-export const OPTION_PROGRAM_ERROR__SLIPPAGE_TOLERANCE_EXCEEDED = 0x179a; // 6042
+export const OPTION_PROGRAM_ERROR__SLIPPAGE_TOLERANCE_EXCEEDED = 0x179b; // 6043
 /** InsufficientPoolLiquidity: Insufficient pool liquidity available */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_POOL_LIQUIDITY = 0x179b; // 6043
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_POOL_LIQUIDITY = 0x179c; // 6044
 /** InsufficientPoolAggregateLiquidity: Insufficient aggregate pool liquidity for requested quantity */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_POOL_AGGREGATE_LIQUIDITY = 0x179c; // 6044
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_POOL_AGGREGATE_LIQUIDITY = 0x179d; // 6045
 /** InsufficientWriterPositionLiquidity: Insufficient active writer liquidity to fill requested quantity */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_WRITER_POSITION_LIQUIDITY = 0x179d; // 6045
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_WRITER_POSITION_LIQUIDITY = 0x179e; // 6046
 /** InsufficientUserBalance: Insufficient user balance for withdrawal */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_USER_BALANCE = 0x179e; // 6046
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_USER_BALANCE = 0x179f; // 6047
 /** UnhealthyPosition: Health ratio below liquidation threshold */
-export const OPTION_PROGRAM_ERROR__UNHEALTHY_POSITION = 0x179f; // 6047
+export const OPTION_PROGRAM_ERROR__UNHEALTHY_POSITION = 0x17a0; // 6048
 /** UnauthorizedOmlp: Unauthorized to perform this OMLP action */
-export const OPTION_PROGRAM_ERROR__UNAUTHORIZED_OMLP = 0x17a0; // 6048
+export const OPTION_PROGRAM_ERROR__UNAUTHORIZED_OMLP = 0x17a1; // 6049
 /** InvalidTenor: Invalid loan tenor */
-export const OPTION_PROGRAM_ERROR__INVALID_TENOR = 0x17a1; // 6049
+export const OPTION_PROGRAM_ERROR__INVALID_TENOR = 0x17a2; // 6050
 /** InvalidRate: Invalid interest rate */
-export const OPTION_PROGRAM_ERROR__INVALID_RATE = 0x17a2; // 6050
+export const OPTION_PROGRAM_ERROR__INVALID_RATE = 0x17a3; // 6051
 /** NotForeclosable: Loan is not eligible for foreclosure */
-export const OPTION_PROGRAM_ERROR__NOT_FORECLOSABLE = 0x17a3; // 6051
+export const OPTION_PROGRAM_ERROR__NOT_FORECLOSABLE = 0x17a4; // 6052
 /** InsufficientVaultLiquidity: Vault has insufficient liquidity */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_VAULT_LIQUIDITY = 0x17a4; // 6052
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_VAULT_LIQUIDITY = 0x17a5; // 6053
 /** InsufficientLoanCollateral: Collateral insufficient for loan */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_LOAN_COLLATERAL = 0x17a5; // 6053
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_LOAN_COLLATERAL = 0x17a6; // 6054
 /** OracleTooStale: Oracle price is stale - cannot validate */
-export const OPTION_PROGRAM_ERROR__ORACLE_TOO_STALE = 0x17a6; // 6054
+export const OPTION_PROGRAM_ERROR__ORACLE_TOO_STALE = 0x17a7; // 6055
 /** ValidationRequired: Must call option_validate before borrow/settlement */
-export const OPTION_PROGRAM_ERROR__VALIDATION_REQUIRED = 0x17a7; // 6055
+export const OPTION_PROGRAM_ERROR__VALIDATION_REQUIRED = 0x17a8; // 6056
 /** HealthCalculationFailed: Health ratio calculation failed */
-export const OPTION_PROGRAM_ERROR__HEALTH_CALCULATION_FAILED = 0x17a8; // 6056
+export const OPTION_PROGRAM_ERROR__HEALTH_CALCULATION_FAILED = 0x17a9; // 6057
 /** ContractAlreadySettled: Contract already settled */
-export const OPTION_PROGRAM_ERROR__CONTRACT_ALREADY_SETTLED = 0x17a9; // 6057
+export const OPTION_PROGRAM_ERROR__CONTRACT_ALREADY_SETTLED = 0x17aa; // 6058
 /** NoYieldAvailable: No yield available to claim */
-export const OPTION_PROGRAM_ERROR__NO_YIELD_AVAILABLE = 0x17aa; // 6058
+export const OPTION_PROGRAM_ERROR__NO_YIELD_AVAILABLE = 0x17ab; // 6059
 /** UnauthorizedAccess: Unauthorized access - you don't own this resource */
-export const OPTION_PROGRAM_ERROR__UNAUTHORIZED_ACCESS = 0x17ab; // 6059
+export const OPTION_PROGRAM_ERROR__UNAUTHORIZED_ACCESS = 0x17ac; // 6060
 /** InsufficientQuantity: Insufficient quantity available in ask position */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_QUANTITY = 0x17ac; // 6060
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_QUANTITY = 0x17ad; // 6061
 /** NothingToClaim: Nothing to claim - no unclaimed premium */
-export const OPTION_PROGRAM_ERROR__NOTHING_TO_CLAIM = 0x17ad; // 6061
+export const OPTION_PROGRAM_ERROR__NOTHING_TO_CLAIM = 0x17ae; // 6062
 /** PoolNotActive: Pool is not active */
-export const OPTION_PROGRAM_ERROR__POOL_NOT_ACTIVE = 0x17ae; // 6062
+export const OPTION_PROGRAM_ERROR__POOL_NOT_ACTIVE = 0x17af; // 6063
 /** PoolAlreadyExists: Pool already exists for this option */
-export const OPTION_PROGRAM_ERROR__POOL_ALREADY_EXISTS = 0x17af; // 6063
+export const OPTION_PROGRAM_ERROR__POOL_ALREADY_EXISTS = 0x17b0; // 6064
 /** PoolNotExercised: Pool has not been exercised yet */
-export const OPTION_PROGRAM_ERROR__POOL_NOT_EXERCISED = 0x17b0; // 6064
+export const OPTION_PROGRAM_ERROR__POOL_NOT_EXERCISED = 0x17b1; // 6065
 /** AlreadySettled: Maker's collateral share has already been settled */
-export const OPTION_PROGRAM_ERROR__ALREADY_SETTLED = 0x17b1; // 6065
+export const OPTION_PROGRAM_ERROR__ALREADY_SETTLED = 0x17b2; // 6066
 /** InsufficientPoolCollateral: Insufficient collateral in pool for exercise */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_POOL_COLLATERAL = 0x17b2; // 6066
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_POOL_COLLATERAL = 0x17b3; // 6067
 /** CollateralPoolNotFound: Collateral pool does not exist */
-export const OPTION_PROGRAM_ERROR__COLLATERAL_POOL_NOT_FOUND = 0x17b3; // 6067
+export const OPTION_PROGRAM_ERROR__COLLATERAL_POOL_NOT_FOUND = 0x17b4; // 6068
 /** NoCollateralToWithdraw: No collateral to withdraw */
-export const OPTION_PROGRAM_ERROR__NO_COLLATERAL_TO_WITHDRAW = 0x17b4; // 6068
+export const OPTION_PROGRAM_ERROR__NO_COLLATERAL_TO_WITHDRAW = 0x17b5; // 6069
 /** OptionNotExpired: Option has not expired yet - cannot settle */
-export const OPTION_PROGRAM_ERROR__OPTION_NOT_EXPIRED = 0x17b5; // 6069
+export const OPTION_PROGRAM_ERROR__OPTION_NOT_EXPIRED = 0x17b6; // 6070
 /** LenderRepaymentNotComplete: Lender repayment phase is not complete */
-export const OPTION_PROGRAM_ERROR__LENDER_REPAYMENT_NOT_COMPLETE = 0x17b6; // 6070
+export const OPTION_PROGRAM_ERROR__LENDER_REPAYMENT_NOT_COMPLETE = 0x17b7; // 6071
 /** BuyerPayoutNotComplete: Buyer payout phase is not complete */
-export const OPTION_PROGRAM_ERROR__BUYER_PAYOUT_NOT_COMPLETE = 0x17b7; // 6071
+export const OPTION_PROGRAM_ERROR__BUYER_PAYOUT_NOT_COMPLETE = 0x17b8; // 6072
 /** SettlementClaimAlreadyPrepared: Settlement claim has already been prepared */
-export const OPTION_PROGRAM_ERROR__SETTLEMENT_CLAIM_ALREADY_PREPARED = 0x17b8; // 6072
+export const OPTION_PROGRAM_ERROR__SETTLEMENT_CLAIM_ALREADY_PREPARED = 0x17b9; // 6073
 /** SettlementClaimNotPrepared: Settlement claim has not been prepared */
-export const OPTION_PROGRAM_ERROR__SETTLEMENT_CLAIM_NOT_PREPARED = 0x17b9; // 6073
+export const OPTION_PROGRAM_ERROR__SETTLEMENT_CLAIM_NOT_PREPARED = 0x17ba; // 6074
 /** SettlementClaimAlreadyClaimed: Settlement claim has already been claimed */
-export const OPTION_PROGRAM_ERROR__SETTLEMENT_CLAIM_ALREADY_CLAIMED = 0x17ba; // 6074
+export const OPTION_PROGRAM_ERROR__SETTLEMENT_CLAIM_ALREADY_CLAIMED = 0x17bb; // 6075
 /** MakerLiquidated: Maker was liquidated and is excluded from expiry settlement */
-export const OPTION_PROGRAM_ERROR__MAKER_LIQUIDATED = 0x17bb; // 6075
+export const OPTION_PROGRAM_ERROR__MAKER_LIQUIDATED = 0x17bc; // 6076
 /** SupplyLimitExceeded: Deposit would exceed vault supply limit */
-export const OPTION_PROGRAM_ERROR__SUPPLY_LIMIT_EXCEEDED = 0x17bc; // 6076
+export const OPTION_PROGRAM_ERROR__SUPPLY_LIMIT_EXCEEDED = 0x17bd; // 6077
 /** InvalidFeeWallet: Invalid fee wallet - must match protocol constant */
-export const OPTION_PROGRAM_ERROR__INVALID_FEE_WALLET = 0x17bd; // 6077
+export const OPTION_PROGRAM_ERROR__INVALID_FEE_WALLET = 0x17be; // 6078
 /** InvalidProtocolFee: Invalid protocol fee rate */
-export const OPTION_PROGRAM_ERROR__INVALID_PROTOCOL_FEE = 0x17be; // 6078
+export const OPTION_PROGRAM_ERROR__INVALID_PROTOCOL_FEE = 0x17bf; // 6079
 /** UnderlyingAssetMismatch: Underlying asset mismatch - market data or mint does not match option */
-export const OPTION_PROGRAM_ERROR__UNDERLYING_ASSET_MISMATCH = 0x17bf; // 6079
+export const OPTION_PROGRAM_ERROR__UNDERLYING_ASSET_MISMATCH = 0x17c0; // 6080
 /** InvalidMint: Invalid token mint - does not match expected underlying asset */
-export const OPTION_PROGRAM_ERROR__INVALID_MINT = 0x17c0; // 6080
+export const OPTION_PROGRAM_ERROR__INVALID_MINT = 0x17c1; // 6081
 /** BatchSizeExceeded: Batch size exceeds maximum allowed (10 positions) */
-export const OPTION_PROGRAM_ERROR__BATCH_SIZE_EXCEEDED = 0x17c1; // 6081
+export const OPTION_PROGRAM_ERROR__BATCH_SIZE_EXCEEDED = 0x17c2; // 6082
 /** NoPositionsProvided: No positions provided in batch */
-export const OPTION_PROGRAM_ERROR__NO_POSITIONS_PROVIDED = 0x17c2; // 6082
+export const OPTION_PROGRAM_ERROR__NO_POSITIONS_PROVIDED = 0x17c3; // 6083
 /** PositionOptionMismatch: Position account does not belong to this option */
-export const OPTION_PROGRAM_ERROR__POSITION_OPTION_MISMATCH = 0x17c3; // 6083
+export const OPTION_PROGRAM_ERROR__POSITION_OPTION_MISMATCH = 0x17c4; // 6084
 /** OptionPoolMismatch: Option account does not match the option pool's option account */
-export const OPTION_PROGRAM_ERROR__OPTION_POOL_MISMATCH = 0x17c4; // 6084
+export const OPTION_PROGRAM_ERROR__OPTION_POOL_MISMATCH = 0x17c5; // 6085
 /** InvalidSeed: Invalid seed - must be exactly 32 bytes */
-export const OPTION_PROGRAM_ERROR__INVALID_SEED = 0x17c5; // 6085
+export const OPTION_PROGRAM_ERROR__INVALID_SEED = 0x17c6; // 6086
 /** InvalidAuthority: Invalid authority - does not match escrow authority */
-export const OPTION_PROGRAM_ERROR__INVALID_AUTHORITY = 0x17c6; // 6086
+export const OPTION_PROGRAM_ERROR__INVALID_AUTHORITY = 0x17c7; // 6087
 /** EscrowAccountRequired: Escrow accounts required when borrowed_amount > 0 */
-export const OPTION_PROGRAM_ERROR__ESCROW_ACCOUNT_REQUIRED = 0x17c7; // 6087
+export const OPTION_PROGRAM_ERROR__ESCROW_ACCOUNT_REQUIRED = 0x17c8; // 6088
 /** InvalidEscrowMaker: Escrow state maker does not match instruction maker */
-export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_MAKER = 0x17c8; // 6088
+export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_MAKER = 0x17c9; // 6089
 /** EscrowMintMismatch: Escrow collateral mint does not match collateral pool mint */
-export const OPTION_PROGRAM_ERROR__ESCROW_MINT_MISMATCH = 0x17c9; // 6089
+export const OPTION_PROGRAM_ERROR__ESCROW_MINT_MISMATCH = 0x17ca; // 6090
 /** InsufficientEscrowBalance: Insufficient balance in escrow token account */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_ESCROW_BALANCE = 0x17ca; // 6090
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_ESCROW_BALANCE = 0x17cb; // 6091
 /** InvalidEscrowOwner: Escrow token account owner mismatch */
-export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_OWNER = 0x17cb; // 6091
+export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_OWNER = 0x17cc; // 6092
 /** InvalidEscrowMint: Escrow token account mint mismatch */
-export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_MINT = 0x17cc; // 6092
+export const OPTION_PROGRAM_ERROR__INVALID_ESCROW_MINT = 0x17cd; // 6093
 /** AccountFrozen: Token account is frozen and cannot be burned */
-export const OPTION_PROGRAM_ERROR__ACCOUNT_FROZEN = 0x17cd; // 6093
+export const OPTION_PROGRAM_ERROR__ACCOUNT_FROZEN = 0x17ce; // 6094
 /** InvalidAccount: Invalid account - does not match expected account */
-export const OPTION_PROGRAM_ERROR__INVALID_ACCOUNT = 0x17ce; // 6094
+export const OPTION_PROGRAM_ERROR__INVALID_ACCOUNT = 0x17cf; // 6095
 /** UnwindRepayAccountsMissing: Unwind repayment accounts are required when active pool loans exist */
-export const OPTION_PROGRAM_ERROR__UNWIND_REPAY_ACCOUNTS_MISSING = 0x17cf; // 6095
+export const OPTION_PROGRAM_ERROR__UNWIND_REPAY_ACCOUNTS_MISSING = 0x17d0; // 6096
 /** InsufficientCollateralVault: Collateral vault has insufficient funds for unwind collateral return */
-export const OPTION_PROGRAM_ERROR__INSUFFICIENT_COLLATERAL_VAULT = 0x17d0; // 6096
+export const OPTION_PROGRAM_ERROR__INSUFFICIENT_COLLATERAL_VAULT = 0x17d1; // 6097
 /** InvalidVaultMint: Invalid vault mint - does not match expected collateral mint */
-export const OPTION_PROGRAM_ERROR__INVALID_VAULT_MINT = 0x17d1; // 6097
+export const OPTION_PROGRAM_ERROR__INVALID_VAULT_MINT = 0x17d2; // 6098
 /** InvalidCollateralMint: Invalid collateral mint - not supported or no vault exists */
-export const OPTION_PROGRAM_ERROR__INVALID_COLLATERAL_MINT = 0x17d2; // 6098
+export const OPTION_PROGRAM_ERROR__INVALID_COLLATERAL_MINT = 0x17d3; // 6099
 /** CollateralMismatch: Collateral mint mismatch - position uses different collateral type */
-export const OPTION_PROGRAM_ERROR__COLLATERAL_MISMATCH = 0x17d3; // 6099
+export const OPTION_PROGRAM_ERROR__COLLATERAL_MISMATCH = 0x17d4; // 6100
 /** BuyRemainingAccountsUnsorted: buy_from_pool remaining_accounts are not sorted by (created_at asc, pubkey asc) */
-export const OPTION_PROGRAM_ERROR__BUY_REMAINING_ACCOUNTS_UNSORTED = 0x17d4; // 6100
+export const OPTION_PROGRAM_ERROR__BUY_REMAINING_ACCOUNTS_UNSORTED = 0x17d5; // 6101
 /** CloseLongWritersIncomplete: close_long_to_pool requires a complete set of active WriterPositions: sum(sold_qty) must equal pool.total_sold_qty */
-export const OPTION_PROGRAM_ERROR__CLOSE_LONG_WRITERS_INCOMPLETE = 0x17d5; // 6101
+export const OPTION_PROGRAM_ERROR__CLOSE_LONG_WRITERS_INCOMPLETE = 0x17d6; // 6102
 /** CloseLongNoSoldInventory: close_long_to_pool cannot run because no writer has sold inventory for this pool */
-export const OPTION_PROGRAM_ERROR__CLOSE_LONG_NO_SOLD_INVENTORY = 0x17d6; // 6102
+export const OPTION_PROGRAM_ERROR__CLOSE_LONG_NO_SOLD_INVENTORY = 0x17d7; // 6103
 /** CloseLongDuplicateWriter: close_long_to_pool remaining_accounts contain duplicate WriterPosition entries */
-export const OPTION_PROGRAM_ERROR__CLOSE_LONG_DUPLICATE_WRITER = 0x17d7; // 6103
+export const OPTION_PROGRAM_ERROR__CLOSE_LONG_DUPLICATE_WRITER = 0x17d8; // 6104
 /** MaintenanceBufferBreached: Writer position breaches maintenance buffer: free_collateral + claimable_theta < accrued_interest + fees + buffer */
-export const OPTION_PROGRAM_ERROR__MAINTENANCE_BUFFER_BREACHED = 0x17d8; // 6104
+export const OPTION_PROGRAM_ERROR__MAINTENANCE_BUFFER_BREACHED = 0x17d9; // 6105
 /** LiquidationInsufficientCollateralForDebt: Liquidation cannot cover full debt (principal + interest + fees) from writer's collateral + theta; call rescue path instead */
-export const OPTION_PROGRAM_ERROR__LIQUIDATION_INSUFFICIENT_COLLATERAL_FOR_DEBT = 0x17d9; // 6105
+export const OPTION_PROGRAM_ERROR__LIQUIDATION_INSUFFICIENT_COLLATERAL_FOR_DEBT = 0x17da; // 6106
 /** ThetaClaimDisabled: claim_theta instruction has been removed; theta is now auto-realized on unwind or forfeited on liquidation */
-export const OPTION_PROGRAM_ERROR__THETA_CLAIM_DISABLED = 0x17da; // 6106
+export const OPTION_PROGRAM_ERROR__THETA_CLAIM_DISABLED = 0x17db; // 6107
 /** PoolLoanWriterMismatch: PoolLoan.writer_position does not match the WriterPosition in this instruction */
-export const OPTION_PROGRAM_ERROR__POOL_LOAN_WRITER_MISMATCH = 0x17db; // 6107
+export const OPTION_PROGRAM_ERROR__POOL_LOAN_WRITER_MISMATCH = 0x17dc; // 6108
 /** MaintenanceLoansIncomplete: Maintenance debt sync remaining_accounts must contain every active PoolLoan for this writer */
-export const OPTION_PROGRAM_ERROR__MAINTENANCE_LOANS_INCOMPLETE = 0x17dc; // 6108
+export const OPTION_PROGRAM_ERROR__MAINTENANCE_LOANS_INCOMPLETE = 0x17dd; // 6109
 /** RescueUnauthorized: Rescue liquidation is gated to the vault keeper */
-export const OPTION_PROGRAM_ERROR__RESCUE_UNAUTHORIZED = 0x17dd; // 6109
+export const OPTION_PROGRAM_ERROR__RESCUE_UNAUTHORIZED = 0x17de; // 6110
 /** InvalidLoanRepayment: Loan repayment amount exceeds synced balances (principal/interest/fees) */
-export const OPTION_PROGRAM_ERROR__INVALID_LOAN_REPAYMENT = 0x17de; // 6110
+export const OPTION_PROGRAM_ERROR__INVALID_LOAN_REPAYMENT = 0x17df; // 6111
 /** RescuePreconditionsNotMet: Rescue preconditions not met: collateral_vault must be short of the remaining debt after theta forfeiture */
-export const OPTION_PROGRAM_ERROR__RESCUE_PRECONDITIONS_NOT_MET = 0x17df; // 6111
+export const OPTION_PROGRAM_ERROR__RESCUE_PRECONDITIONS_NOT_MET = 0x17e0; // 6112
 
 export type OptionProgramError =
   | typeof OPTION_PROGRAM_ERROR__ACCOUNT_FROZEN
@@ -351,7 +353,8 @@ export type OptionProgramError =
   | typeof OPTION_PROGRAM_ERROR__UNDERLYING_ASSET_MISMATCH
   | typeof OPTION_PROGRAM_ERROR__UNHEALTHY_POSITION
   | typeof OPTION_PROGRAM_ERROR__UNWIND_REPAY_ACCOUNTS_MISSING
-  | typeof OPTION_PROGRAM_ERROR__VALIDATION_REQUIRED;
+  | typeof OPTION_PROGRAM_ERROR__VALIDATION_REQUIRED
+  | typeof OPTION_PROGRAM_ERROR__VOLATILITY_QUOTE_UNAVAILABLE;
 
 let optionProgramErrorMessages: Record<OptionProgramError, string> | undefined;
 if (process.env.NODE_ENV !== "production") {
@@ -468,6 +471,7 @@ if (process.env.NODE_ENV !== "production") {
     [OPTION_PROGRAM_ERROR__UNHEALTHY_POSITION]: `Health ratio below liquidation threshold`,
     [OPTION_PROGRAM_ERROR__UNWIND_REPAY_ACCOUNTS_MISSING]: `Unwind repayment accounts are required when active pool loans exist`,
     [OPTION_PROGRAM_ERROR__VALIDATION_REQUIRED]: `Must call option_validate before borrow/settlement`,
+    [OPTION_PROGRAM_ERROR__VOLATILITY_QUOTE_UNAVAILABLE]: `Authority volatility quote unavailable or stale`,
   };
 }
 

package/generated/programs/optionProgram.ts

@@ -7,13 +7,62 @@
  */
 
 import {
+  assertIsInstructionWithAccounts,
   containsBytes,
   fixEncoderSize,
   getBytesEncoder,
   type Address,
+  type Instruction,
+  type InstructionWithData,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 import {
+  parseAcceptAdminInstruction,
+  parseAutoExerciseAllExpiredInstruction,
+  parseAutoExerciseExpiredInstruction,
+  parseBorrowFromPoolInstruction,
+  parseBuyFromPoolInstruction,
+  parseClaimBuyerSettlementInstruction,
+  parseClaimMakerRemainingInstruction,
+  parseClaimMakerSettlementInstruction,
+  parseCloseLongToPoolInstruction,
+  parseCloseOptionInstruction,
+  parseCreateEscrowV2Instruction,
+  parseDepositCollateralInstruction,
+  parseDepositToPositionInstruction,
+  parseInitCollateralPoolInstruction,
+  parseInitConfigInstruction,
+  parseInitializeMarketDataInstruction,
+  parseInitOptionPoolInstruction,
+  parseLiquidateWriterPositionInstruction,
+  parseLiquidateWriterPositionRescueInstruction,
+  parseMigrateCollateralPoolV1ToV2Instruction,
+  parseMigrateMarketDataVolOracleInstruction,
+  parseOmlpCreateVaultInstruction,
+  parseOmlpUpdateFeeWalletInstruction,
+  parseOmlpUpdateInterestModelInstruction,
+  parseOmlpUpdateLiquidationThresholdInstruction,
+  parseOmlpUpdateMaintenanceBufferInstruction,
+  parseOmlpUpdateMaxBorrowCapInstruction,
+  parseOmlpUpdateMaxLeverageInstruction,
+  parseOmlpUpdateProtocolFeeInstruction,
+  parseOmlpUpdateSupplyLimitInstruction,
+  parseOptionExerciseInstruction,
+  parseOptionMintInstruction,
+  parseOptionValidateInstruction,
+  parsePrepareBuyerSettlementInstruction,
+  parsePrepareMakerSettlementInstruction,
+  parseRepayPoolLoanFromCollateralInstruction,
+  parseRepayPoolLoanFromWalletInstruction,
+  parseRepayPoolLoanInstruction,
+  parseSettleMakerCollateralInstruction,
+  parseSyncWriterPositionInstruction,
+  parseTransferAdminInstruction,
+  parseUnwindWriterUnsoldInstruction,
+  parseUpdateImpliedVolatilityInstruction,
+  parseUpdateMarketDataInstruction,
+  parseWithdrawFromPositionInstruction,
+  parseWriteToPoolInstruction,
   type ParsedAcceptAdminInstruction,
   type ParsedAutoExerciseAllExpiredInstruction,
   type ParsedAutoExerciseExpiredInstruction,
@@ -950,3 +999,338 @@ export type ParsedOptionProgramInstruction<
   | ({
       instructionType: OptionProgramInstruction.WriteToPool;
     } & ParsedWriteToPoolInstruction<TProgram>);
+
+export function parseOptionProgramInstruction<TProgram extends string>(
+  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedOptionProgramInstruction<TProgram> {
+  const instructionType = identifyOptionProgramInstruction(instruction);
+  switch (instructionType) {
+    case OptionProgramInstruction.AcceptAdmin: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.AcceptAdmin,
+        ...parseAcceptAdminInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.AutoExerciseAllExpired: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.AutoExerciseAllExpired,
+        ...parseAutoExerciseAllExpiredInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.AutoExerciseExpired: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.AutoExerciseExpired,
+        ...parseAutoExerciseExpiredInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.BorrowFromPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.BorrowFromPool,
+        ...parseBorrowFromPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.BuyFromPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.BuyFromPool,
+        ...parseBuyFromPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.ClaimBuyerSettlement: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.ClaimBuyerSettlement,
+        ...parseClaimBuyerSettlementInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.ClaimMakerRemaining: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.ClaimMakerRemaining,
+        ...parseClaimMakerRemainingInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.ClaimMakerSettlement: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.ClaimMakerSettlement,
+        ...parseClaimMakerSettlementInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CloseLongToPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CloseLongToPool,
+        ...parseCloseLongToPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CloseOption: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CloseOption,
+        ...parseCloseOptionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.CreateEscrowV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.CreateEscrowV2,
+        ...parseCreateEscrowV2Instruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.DepositCollateral: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.DepositCollateral,
+        ...parseDepositCollateralInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.DepositToPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.DepositToPosition,
+        ...parseDepositToPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitCollateralPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitCollateralPool,
+        ...parseInitCollateralPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitConfig: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitConfig,
+        ...parseInitConfigInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitOptionPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitOptionPool,
+        ...parseInitOptionPoolInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.InitializeMarketData: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.InitializeMarketData,
+        ...parseInitializeMarketDataInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.LiquidateWriterPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.LiquidateWriterPosition,
+        ...parseLiquidateWriterPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.LiquidateWriterPositionRescue: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.LiquidateWriterPositionRescue,
+        ...parseLiquidateWriterPositionRescueInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.MigrateCollateralPoolV1ToV2: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.MigrateCollateralPoolV1ToV2,
+        ...parseMigrateCollateralPoolV1ToV2Instruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.MigrateMarketDataVolOracle: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.MigrateMarketDataVolOracle,
+        ...parseMigrateMarketDataVolOracleInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpCreateVault: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpCreateVault,
+        ...parseOmlpCreateVaultInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateFeeWallet: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateFeeWallet,
+        ...parseOmlpUpdateFeeWalletInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateInterestModel: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateInterestModel,
+        ...parseOmlpUpdateInterestModelInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateLiquidationThreshold: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType:
+          OptionProgramInstruction.OmlpUpdateLiquidationThreshold,
+        ...parseOmlpUpdateLiquidationThresholdInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateMaintenanceBuffer: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateMaintenanceBuffer,
+        ...parseOmlpUpdateMaintenanceBufferInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateMaxBorrowCap: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateMaxBorrowCap,
+        ...parseOmlpUpdateMaxBorrowCapInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateMaxLeverage: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateMaxLeverage,
+        ...parseOmlpUpdateMaxLeverageInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateProtocolFee: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateProtocolFee,
+        ...parseOmlpUpdateProtocolFeeInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OmlpUpdateSupplyLimit: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OmlpUpdateSupplyLimit,
+        ...parseOmlpUpdateSupplyLimitInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OptionExercise: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OptionExercise,
+        ...parseOptionExerciseInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OptionMint: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OptionMint,
+        ...parseOptionMintInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.OptionValidate: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.OptionValidate,
+        ...parseOptionValidateInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.PrepareBuyerSettlement: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.PrepareBuyerSettlement,
+        ...parsePrepareBuyerSettlementInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.PrepareMakerSettlement: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.PrepareMakerSettlement,
+        ...parsePrepareMakerSettlementInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.RepayPoolLoan: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.RepayPoolLoan,
+        ...parseRepayPoolLoanInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.RepayPoolLoanFromCollateral: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.RepayPoolLoanFromCollateral,
+        ...parseRepayPoolLoanFromCollateralInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.RepayPoolLoanFromWallet: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.RepayPoolLoanFromWallet,
+        ...parseRepayPoolLoanFromWalletInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.SettleMakerCollateral: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.SettleMakerCollateral,
+        ...parseSettleMakerCollateralInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.SyncWriterPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.SyncWriterPosition,
+        ...parseSyncWriterPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.TransferAdmin: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.TransferAdmin,
+        ...parseTransferAdminInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.UnwindWriterUnsold: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.UnwindWriterUnsold,
+        ...parseUnwindWriterUnsoldInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.UpdateImpliedVolatility: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.UpdateImpliedVolatility,
+        ...parseUpdateImpliedVolatilityInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.UpdateMarketData: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.UpdateMarketData,
+        ...parseUpdateMarketDataInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.WithdrawFromPosition: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.WithdrawFromPosition,
+        ...parseWithdrawFromPositionInstruction(instruction),
+      };
+    }
+    case OptionProgramInstruction.WriteToPool: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: OptionProgramInstruction.WriteToPool,
+        ...parseWriteToPoolInstruction(instruction),
+      };
+    }
+    default:
+      throw new Error(
+        `Unrecognized instruction type: ${instructionType as string}`,
+      );
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epicentral/sos-sdk",
-  "version": "0.13.0-beta",
+  "version": "0.13.2-beta",
   "private": false,
   "description": "Solana Option Standard SDK. The frontend-first SDK for Native Options Trading on Solana. Created by Epicentral Labs.",
   "type": "module",