@whetstone-research/doppler-sdk 1.0.1 → 1.0.2

package/dist/solana/index.js

@@ -1,11 +1,176 @@
-import { encodeInstructionData, initializeConfigArgsCodec, initializePoolArgsCodec, initializeOracleArgsCodec, setFeesArgsCodec, setSentinelArgsCodec, setRouteArgsCodec, transferAdminArgsCodec, swapExactInArgsCodec, createPositionArgsCodec, removeLiquidityArgsCodec, collectProtocolFeesArgsCodec, oracleConsultArgsCodec, quoteToNumeraireArgsCodec, decodeAmmConfig } from '../chunk-LIXSTCMM.js';
-export { MAX_FEE_AMOUNT, calculateAccruedFees, calculateTwap, calculateTwapNumber, ceilDiv, comparePoolAndOraclePrices, computePrice0Q64, computePrice1Q64, consultTwap, createCollectFeesInstruction, decodeAmmConfig, decodeOracleState, decodePool, decodePosition, fetchAllPools, fetchOracle, fetchOraclesBatch, fetchPool, fetchPoolPositions, fetchPoolsBatch, fetchPosition, fetchPositionByParams, fetchPositionsBatch, fetchUserPositions, filterActivePositions, filterPoolsByMint, getAddLiquidityQuote, getK, getOracleAddressFromPool, getOracleAge, getOracleBufferStats, getOracleDeviation, getOracleForPool, getOracleSpotPrices, getPendingFees, getPoolAddressFromMints, getPoolByMints, getPositionAddressFromParams, getPositionValue, getRemoveLiquidityQuote, getSpotPrice0, getSpotPrice1, getSwapQuote, getSwapQuoteExactOut, getTvl, isOracleStale, isqrt, maxBigInt, minBigInt, numberToQ64, poolExists, q64Div, q64Mul, q64ToNumber, ratioToNumber, sortPoolsByReserves, sortPositionsByShares } from '../chunk-LIXSTCMM.js';
-import { SYSTEM_PROGRAM_ID, ACCOUNT_ROLE_WRITABLE, ACCOUNT_ROLE_READONLY, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, ACCOUNT_ROLE_WRITABLE_SIGNER, ACCOUNT_ROLE_SIGNER, PROGRAM_ID, INSTRUCTION_DISCRIMINATORS, getConfigAddress } from '../chunk-T46KDO65.js';
-export { ACCOUNT_DISCRIMINATORS, ACCOUNT_ROLE_READONLY, ACCOUNT_ROLE_SIGNER, ACCOUNT_ROLE_WRITABLE, ACCOUNT_ROLE_WRITABLE_SIGNER, ACCOUNT_VERSION, ASSOCIATED_TOKEN_PROGRAM_ID, BPS_DENOM, INSTRUCTION_DISCRIMINATORS, MAX_ORACLE_OBSERVATIONS, MAX_SENTINEL_ALLOWLIST, PROGRAM_ID, Q64_ONE, SEED_AUTHORITY, SEED_CONFIG, SEED_ORACLE, SEED_POOL, SEED_POSITION, SEED_PROTOCOL_POSITION, SENTINEL_NO_CHANGE, SENTINEL_PROGRAM_ID, SF_AFTER_ADD_LIQ, SF_AFTER_REMOVE_LIQ, SF_AFTER_SWAP, SF_BEFORE_ADD_LIQ, SF_BEFORE_REMOVE_LIQ, SF_BEFORE_SWAP, SYSTEM_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, areMintsOrdered, getConfigAddress, getLiquidityAddresses, getOracleAddress, getPoolAddress, getPoolAuthorityAddress, getPoolInitAddresses, getPositionAddress, getProtocolPositionAddress, getSwapAddresses, sortMints } from '../chunk-T46KDO65.js';
+import { transferAdminArgsCodec, swapExactInArgsCodec, sortPositionsByShares, sortPoolsByReserves, setSentinelArgsCodec, setRouteArgsCodec, setFeesArgsCodec, removeLiquidityArgsCodec, ratioToNumber, quoteToNumeraireArgsCodec, q64ToNumber, q64Mul, q64Div, positionDataCodec, poolExists, poolDataCodec, oracleStateDataCodec, oracleConsultArgsCodec, observationCodec, numberToQ64, minBigInt, maxBigInt, isqrt, isOracleStale, initializePoolArgsCodec, initializeOracleArgsCodec, initializeConfigArgsCodec, getTvl, getSwapQuoteExactOut, getSwapQuote, getSpotPrice1, getSpotPrice0, getRemoveLiquidityQuote, getPositionValue, getPositionAddressFromParams, getPoolByMints, getPoolAddressFromMints, getPendingFees, getOracleSpotPrices, getOracleForPool, getOracleDeviation, getOracleBufferStats, getOracleAge, getOracleAddressFromPool, getK, getAddLiquidityQuote, filterPoolsByMint, filterActivePositions, fetchUserPositions, fetchPositionsBatch, fetchPositionByParams, fetchPosition, fetchPoolsBatch, fetchPoolPositions, fetchPool, fetchOraclesBatch, fetchOracle, fetchAllPools, encodeTransferAdminArgs, encodeSwapExactInArgs, encodeSetSentinelArgs, encodeSetRouteArgs, encodeSetFeesArgs, encodeRemoveLiquidityArgs, encodeQuoteToNumeraireArgs, encodeOracleConsultArgs, encodeInstructionData, encodeInitializePoolArgs, encodeInitializeOracleArgs, encodeInitializeConfigArgs, encodeCreatePositionArgs, encodeCollectProtocolFeesArgs, encodeCollectFeesArgs, encodeAddLiquidityArgs, decodePosition, decodePool, decodeOracleState, decodeAmmConfig, createPositionArgsCodec, createCollectFeesInstruction, consultTwap, computePrice1Q64, computePrice0Q64, comparePoolAndOraclePrices, collectProtocolFeesArgsCodec, collectFeesArgsCodec, ceilDiv, calculateTwapNumber, calculateTwap, calculateAccruedFees, ammConfigDataCodec, addLiquidityArgsCodec, MAX_FEE_AMOUNT } from '../chunk-BSHIMMA4.js';
+import { sortMints, getSwapAddresses, getProtocolPositionAddress, getPositionAddress, getPoolInitAddresses, getPoolAuthorityAddress, getPoolAddress, getOracleAddress, getLiquidityAddresses, getConfigAddress, CPMM_PROGRAM_ID, areMintsOrdered, TOKEN_METADATA_PROGRAM_ID, SF_BEFORE_SWAP, SF_BEFORE_REMOVE_LIQ, SF_BEFORE_ADD_LIQ, SF_AFTER_SWAP, SF_AFTER_REMOVE_LIQ, SF_AFTER_ADD_LIQ, SENTINEL_NO_CHANGE, SEED_PROTOCOL_POSITION, SEED_POSITION, SEED_POOL, SEED_ORACLE, SEED_CONFIG, SEED_AUTHORITY, Q64_ONE, MAX_SENTINEL_ALLOWLIST, MAX_ORACLE_OBSERVATIONS, INSTRUCTION_DISCRIMINATORS, BPS_DENOM, ACCOUNT_VERSION, ACCOUNT_DISCRIMINATORS, SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS } from '../chunk-J57ROY36.js';
 import { __export } from '../chunk-PZ5AY32C.js';
-import { getAddressCodec, getStructCodec, getU64Codec, getU128Codec, getBooleanCodec, getU8Codec, address, transformEncoder, getStructEncoder, fixEncoderSize, getAddressEncoder, getU8Encoder, getArrayEncoder, getBytesEncoder, getStructDecoder, fixDecoderSize, getAddressDecoder, getU8Decoder, getArrayDecoder, getBytesDecoder, combineCodec, getU64Encoder, getU16Encoder, addEncoderSizePrefix, getU32Encoder, getUtf8Encoder, getU64Decoder, getU16Decoder, addDecoderSizePrefix, getU32Decoder, getUtf8Decoder, getProgramDerivedAddress, AccountRole, getOptionEncoder, getU128Encoder, getOptionDecoder, getU128Decoder, getBooleanEncoder, getBooleanDecoder, mergeBytes } from '@solana/kit';
-import '@solana/program-client-core';
+import { getAddressCodec, getProgramDerivedAddress, AccountRole, getStructCodec, getU64Codec, getU128Codec, getBooleanCodec, getU8Codec, address, transformEncoder, getStructEncoder, fixEncoderSize, getAddressEncoder, getU8Encoder, getArrayEncoder, getBytesEncoder, getStructDecoder, fixDecoderSize, getAddressDecoder, getU8Decoder, getArrayDecoder, getBytesDecoder, combineCodec, getU64Encoder, getU16Encoder, addEncoderSizePrefix, getU32Encoder, getUtf8Encoder, getU64Decoder, getU16Decoder, addDecoderSizePrefix, getU32Decoder, getUtf8Decoder, getOptionEncoder, getU128Encoder, getOptionDecoder, getU128Decoder, getBooleanEncoder, getBooleanDecoder, mergeBytes, isProgramError, decodeAccount, assertAccountExists, fetchEncodedAccount, assertAccountsExist, fetchEncodedAccounts, SolanaError, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, containsBytes, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, assertIsInstructionWithAccounts } from '@solana/kit';
+import { getAccountMetaFactory, addSelfPlanAndSendFunctions, addSelfFetchFunctions, getAddressFromResolvedInstructionAccount } from '@solana/program-client-core';
+import { keccak_256 } from '@noble/hashes/sha3.js';
 
+// src/solana/cpmm/index.ts
+var cpmm_exports = {};
+__export(cpmm_exports, {
+  ACCOUNT_DISCRIMINATORS: () => ACCOUNT_DISCRIMINATORS,
+  ACCOUNT_VERSION: () => ACCOUNT_VERSION,
+  BPS_DENOM: () => BPS_DENOM,
+  CPMM_ERROR_MESSAGES: () => CPMM_ERROR_MESSAGES,
+  CPMM_PROGRAM_ID: () => CPMM_PROGRAM_ID,
+  CpmmError: () => CpmmError,
+  CpmmErrorCode: () => CpmmErrorCode,
+  INSTRUCTION_DISCRIMINATORS: () => INSTRUCTION_DISCRIMINATORS,
+  MAX_FEE_AMOUNT: () => MAX_FEE_AMOUNT,
+  MAX_ORACLE_OBSERVATIONS: () => MAX_ORACLE_OBSERVATIONS,
+  MAX_SENTINEL_ALLOWLIST: () => MAX_SENTINEL_ALLOWLIST,
+  Q64_ONE: () => Q64_ONE,
+  SEED_AUTHORITY: () => SEED_AUTHORITY,
+  SEED_CONFIG: () => SEED_CONFIG,
+  SEED_ORACLE: () => SEED_ORACLE,
+  SEED_POOL: () => SEED_POOL,
+  SEED_POSITION: () => SEED_POSITION,
+  SEED_PROTOCOL_POSITION: () => SEED_PROTOCOL_POSITION,
+  SENTINEL_NO_CHANGE: () => SENTINEL_NO_CHANGE,
+  SF_AFTER_ADD_LIQ: () => SF_AFTER_ADD_LIQ,
+  SF_AFTER_REMOVE_LIQ: () => SF_AFTER_REMOVE_LIQ,
+  SF_AFTER_SWAP: () => SF_AFTER_SWAP,
+  SF_BEFORE_ADD_LIQ: () => SF_BEFORE_ADD_LIQ,
+  SF_BEFORE_REMOVE_LIQ: () => SF_BEFORE_REMOVE_LIQ,
+  SF_BEFORE_SWAP: () => SF_BEFORE_SWAP,
+  TOKEN_METADATA_PROGRAM_ID: () => TOKEN_METADATA_PROGRAM_ID,
+  addLiquidityArgsCodec: () => addLiquidityArgsCodec,
+  ammConfigDataCodec: () => ammConfigDataCodec,
+  areMintsOrdered: () => areMintsOrdered,
+  calculateAccruedFees: () => calculateAccruedFees,
+  calculateTwap: () => calculateTwap,
+  calculateTwapNumber: () => calculateTwapNumber,
+  ceilDiv: () => ceilDiv,
+  collectFeesArgsCodec: () => collectFeesArgsCodec,
+  collectProtocolFeesArgsCodec: () => collectProtocolFeesArgsCodec,
+  comparePoolAndOraclePrices: () => comparePoolAndOraclePrices,
+  computePrice0Q64: () => computePrice0Q64,
+  computePrice1Q64: () => computePrice1Q64,
+  consultTwap: () => consultTwap,
+  createAddLiquidityInstruction: () => createAddLiquidityInstruction,
+  createClosePositionInstruction: () => createClosePositionInstruction,
+  createCollectFeesInstruction: () => createCollectFeesInstruction,
+  createCollectProtocolFeesInstruction: () => createCollectProtocolFeesInstruction,
+  createCreatePositionInstruction: () => createCreatePositionInstruction,
+  createInitializeConfigInstruction: () => createInitializeConfigInstruction,
+  createInitializeOracleInstruction: () => createInitializeOracleInstruction,
+  createInitializePoolInstruction: () => createInitializePoolInstruction,
+  createOracleConsultInstruction: () => createOracleConsultInstruction,
+  createOracleUpdateInstruction: () => createOracleUpdateInstruction,
+  createPauseInstruction: () => createPauseInstruction,
+  createPositionArgsCodec: () => createPositionArgsCodec,
+  createQuoteToNumeraireInstruction: () => createQuoteToNumeraireInstruction,
+  createRemoveLiquidityInstruction: () => createRemoveLiquidityInstruction,
+  createSetFeesInstruction: () => createSetFeesInstruction,
+  createSetRouteInstruction: () => createSetRouteInstruction,
+  createSetSentinelInstruction: () => createSetSentinelInstruction,
+  createSkimInstruction: () => createSkimInstruction,
+  createSwapExactInInstruction: () => createSwapExactInInstruction,
+  createSwapInstruction: () => createSwapInstruction,
+  createTransferAdminInstruction: () => createTransferAdminInstruction,
+  createUnpauseInstruction: () => createUnpauseInstruction,
+  curveParamsToMarketCap: () => curveParamsToMarketCap,
+  decodeAmmConfig: () => decodeAmmConfig,
+  decodeOracleConsultResult: () => decodeOracleConsultResult,
+  decodeOracleState: () => decodeOracleState,
+  decodePool: () => decodePool,
+  decodePosition: () => decodePosition,
+  decodeQuoteToNumeraireResult: () => decodeQuoteToNumeraireResult,
+  encodeAddLiquidityArgs: () => encodeAddLiquidityArgs,
+  encodeCollectFeesArgs: () => encodeCollectFeesArgs,
+  encodeCollectProtocolFeesArgs: () => encodeCollectProtocolFeesArgs,
+  encodeCreatePositionArgs: () => encodeCreatePositionArgs,
+  encodeInitializeConfigArgs: () => encodeInitializeConfigArgs,
+  encodeInitializeOracleArgs: () => encodeInitializeOracleArgs,
+  encodeInitializePoolArgs: () => encodeInitializePoolArgs,
+  encodeInstructionData: () => encodeInstructionData,
+  encodeOracleConsultArgs: () => encodeOracleConsultArgs,
+  encodeQuoteToNumeraireArgs: () => encodeQuoteToNumeraireArgs,
+  encodeRemoveLiquidityArgs: () => encodeRemoveLiquidityArgs,
+  encodeSetFeesArgs: () => encodeSetFeesArgs,
+  encodeSetRouteArgs: () => encodeSetRouteArgs,
+  encodeSetSentinelArgs: () => encodeSetSentinelArgs,
+  encodeSwapExactInArgs: () => encodeSwapExactInArgs,
+  encodeTransferAdminArgs: () => encodeTransferAdminArgs,
+  fetchAllPools: () => fetchAllPools,
+  fetchConfig: () => fetchConfig,
+  fetchConfigWithAddress: () => fetchConfigWithAddress,
+  fetchOracle: () => fetchOracle,
+  fetchOraclesBatch: () => fetchOraclesBatch,
+  fetchPool: () => fetchPool,
+  fetchPoolPositions: () => fetchPoolPositions,
+  fetchPoolsBatch: () => fetchPoolsBatch,
+  fetchPosition: () => fetchPosition,
+  fetchPositionByParams: () => fetchPositionByParams,
+  fetchPositionsBatch: () => fetchPositionsBatch,
+  fetchUserPositions: () => fetchUserPositions,
+  filterActivePositions: () => filterActivePositions,
+  filterPoolsByMint: () => filterPoolsByMint,
+  getAddLiquidityQuote: () => getAddLiquidityQuote,
+  getConfigAddress: () => getConfigAddress,
+  getErrorMessage: () => getErrorMessage,
+  getK: () => getK,
+  getLiquidityAddresses: () => getLiquidityAddresses,
+  getMetadataAddress: () => getMetadataAddress,
+  getOracleAddress: () => getOracleAddress,
+  getOracleAddressFromPool: () => getOracleAddressFromPool,
+  getOracleAge: () => getOracleAge,
+  getOracleBufferStats: () => getOracleBufferStats,
+  getOracleDeviation: () => getOracleDeviation,
+  getOracleForPool: () => getOracleForPool,
+  getOracleSpotPrices: () => getOracleSpotPrices,
+  getPendingFees: () => getPendingFees,
+  getPoolAddress: () => getPoolAddress,
+  getPoolAddressFromMints: () => getPoolAddressFromMints,
+  getPoolAuthorityAddress: () => getPoolAuthorityAddress,
+  getPoolByMints: () => getPoolByMints,
+  getPoolInitAddresses: () => getPoolInitAddresses,
+  getPositionAddress: () => getPositionAddress,
+  getPositionAddressFromParams: () => getPositionAddressFromParams,
+  getPositionValue: () => getPositionValue,
+  getProtocolPositionAddress: () => getProtocolPositionAddress,
+  getRemoveLiquidityQuote: () => getRemoveLiquidityQuote,
+  getSpotPrice0: () => getSpotPrice0,
+  getSpotPrice1: () => getSpotPrice1,
+  getSwapAddresses: () => getSwapAddresses,
+  getSwapQuote: () => getSwapQuote,
+  getSwapQuoteExactOut: () => getSwapQuoteExactOut,
+  getTvl: () => getTvl,
+  initializeConfigArgsCodec: () => initializeConfigArgsCodec,
+  initializeOracleArgsCodec: () => initializeOracleArgsCodec,
+  initializePoolArgsCodec: () => initializePoolArgsCodec,
+  isCpmmError: () => isCpmmError,
+  isOracleStale: () => isOracleStale,
+  isqrt: () => isqrt,
+  marketCapToCurveParams: () => marketCapToCurveParams,
+  marketCapToSingleCurveParams: () => marketCapToSingleCurveParams,
+  marketCapToTokenPrice: () => marketCapToTokenPrice,
+  maxBigInt: () => maxBigInt,
+  minBigInt: () => minBigInt,
+  numberToQ64: () => numberToQ64,
+  observationCodec: () => observationCodec,
+  oracleConsultArgsCodec: () => oracleConsultArgsCodec,
+  oracleStateDataCodec: () => oracleStateDataCodec,
+  parseErrorFromLogs: () => parseErrorFromLogs,
+  poolDataCodec: () => poolDataCodec,
+  poolExists: () => poolExists,
+  positionDataCodec: () => positionDataCodec,
+  q64Div: () => q64Div,
+  q64Mul: () => q64Mul,
+  q64ToNumber: () => q64ToNumber,
+  quoteToNumeraireArgsCodec: () => quoteToNumeraireArgsCodec,
+  ratioToNumber: () => ratioToNumber,
+  removeLiquidityArgsCodec: () => removeLiquidityArgsCodec,
+  setFeesArgsCodec: () => setFeesArgsCodec,
+  setRouteArgsCodec: () => setRouteArgsCodec,
+  setSentinelArgsCodec: () => setSentinelArgsCodec,
+  sortMints: () => sortMints,
+  sortPoolsByReserves: () => sortPoolsByReserves,
+  sortPositionsByShares: () => sortPositionsByShares,
+  swapExactInArgsCodec: () => swapExactInArgsCodec,
+  transferAdminArgsCodec: () => transferAdminArgsCodec,
+  validateMarketCapParameters: () => validateMarketCapParameters
+});
 var addressCodec = getAddressCodec();
 var textEncoder = new TextEncoder();
 async function getMetadataAddress(mint) {
@@ -301,14 +466,12 @@ function getErrorMessage(code) {
   }
   return `Unknown error code: ${code}`;
 }
-
-// src/solana/instructions/initializeConfig.ts
-function createInitializeConfigInstruction(accounts, args, programId = PROGRAM_ID) {
-  const { config, payer, systemProgram = SYSTEM_PROGRAM_ID } = accounts;
+function createInitializeConfigInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
+  const { config, payer, systemProgram = SYSTEM_PROGRAM_ADDRESS } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_WRITABLE },
-    { address: payer, role: ACCOUNT_ROLE_WRITABLE_SIGNER },
-    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.WRITABLE },
+    { address: payer, role: AccountRole.WRITABLE_SIGNER },
+    { address: systemProgram, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.initializeConfig,
@@ -321,8 +484,6 @@ function createInitializeConfigInstruction(accounts, args, programId = PROGRAM_I
     data
   };
 }
-
-// src/solana/instructions/initializePool.ts
 function isTransactionSigner(value) {
   return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
 }
@@ -336,7 +497,7 @@ function createSignerAccountMeta(value, role) {
   }
   return { address: value, role };
 }
-function createInitializePoolInstruction(accounts, args, programId = PROGRAM_ID) {
+function createInitializePoolInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
@@ -347,23 +508,23 @@ function createInitializePoolInstruction(accounts, args, programId = PROGRAM_ID)
     token0Mint,
     token1Mint,
     payer,
-    tokenProgram = TOKEN_PROGRAM_ID,
-    systemProgram = SYSTEM_PROGRAM_ID,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS,
+    systemProgram = SYSTEM_PROGRAM_ADDRESS,
     rent
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
-    { address: authority, role: ACCOUNT_ROLE_READONLY },
-    createSignerAccountMeta(vault0, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    createSignerAccountMeta(vault1, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
-    createSignerAccountMeta(payer, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY },
-    { address: systemProgram, role: ACCOUNT_ROLE_READONLY },
-    { address: rent, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: protocolPosition, role: AccountRole.WRITABLE },
+    { address: authority, role: AccountRole.READONLY },
+    createSignerAccountMeta(vault0, AccountRole.WRITABLE_SIGNER),
+    createSignerAccountMeta(vault1, AccountRole.WRITABLE_SIGNER),
+    { address: token0Mint, role: AccountRole.READONLY },
+    { address: token1Mint, role: AccountRole.READONLY },
+    createSignerAccountMeta(payer, AccountRole.WRITABLE_SIGNER),
+    { address: tokenProgram, role: AccountRole.READONLY },
+    { address: systemProgram, role: AccountRole.READONLY },
+    { address: rent, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.initializePool,
@@ -376,24 +537,22 @@ function createInitializePoolInstruction(accounts, args, programId = PROGRAM_ID)
     data
   };
 }
-
-// src/solana/instructions/initializeOracle.ts
-function createInitializeOracleInstruction(accounts, args, programId = PROGRAM_ID) {
+function createInitializeOracleInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
     oracle,
     admin,
     payer,
-    systemProgram = SYSTEM_PROGRAM_ID
+    systemProgram = SYSTEM_PROGRAM_ADDRESS
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_READONLY },
-    { address: oracle, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER },
-    { address: payer, role: ACCOUNT_ROLE_WRITABLE_SIGNER },
-    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.READONLY },
+    { address: oracle, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER },
+    { address: payer, role: AccountRole.WRITABLE_SIGNER },
+    { address: systemProgram, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.initializeOracle,
@@ -406,14 +565,12 @@ function createInitializeOracleInstruction(accounts, args, programId = PROGRAM_I
     data
   };
 }
-
-// src/solana/instructions/setFees.ts
-function createSetFeesInstruction(accounts, args, programId = PROGRAM_ID) {
+function createSetFeesInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const { config, pool, admin } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.setFees,
@@ -426,14 +583,12 @@ function createSetFeesInstruction(accounts, args, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/setSentinel.ts
-function createSetSentinelInstruction(accounts, args, programId = PROGRAM_ID) {
+function createSetSentinelInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const { config, pool, admin } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.setSentinel,
@@ -446,18 +601,16 @@ function createSetSentinelInstruction(accounts, args, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/setRoute.ts
-function createSetRouteInstruction(accounts, args, programId = PROGRAM_ID) {
+function createSetRouteInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const { config, pool, nextPool, admin } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE }
   ];
   if (nextPool) {
-    keys.push({ address: nextPool, role: ACCOUNT_ROLE_READONLY });
+    keys.push({ address: nextPool, role: AccountRole.READONLY });
   }
-  keys.push({ address: admin, role: ACCOUNT_ROLE_SIGNER });
+  keys.push({ address: admin, role: AccountRole.READONLY_SIGNER });
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.setRoute,
     setRouteArgsCodec,
@@ -469,13 +622,11 @@ function createSetRouteInstruction(accounts, args, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/pause.ts
-function createPauseInstruction(accounts, programId = PROGRAM_ID) {
+function createPauseInstruction(accounts, programId = CPMM_PROGRAM_ID) {
   const { config, admin } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+    { address: config, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER }
   ];
   const data = INSTRUCTION_DISCRIMINATORS.pause;
   return {
@@ -484,13 +635,11 @@ function createPauseInstruction(accounts, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/unpause.ts
-function createUnpauseInstruction(accounts, programId = PROGRAM_ID) {
+function createUnpauseInstruction(accounts, programId = CPMM_PROGRAM_ID) {
   const { config, admin } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+    { address: config, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER }
   ];
   const data = INSTRUCTION_DISCRIMINATORS.unpause;
   return {
@@ -499,13 +648,11 @@ function createUnpauseInstruction(accounts, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/transferAdmin.ts
-function createTransferAdminInstruction(accounts, args, programId = PROGRAM_ID) {
+function createTransferAdminInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const { config, admin } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+    { address: config, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.transferAdmin,
@@ -518,9 +665,7 @@ function createTransferAdminInstruction(accounts, args, programId = PROGRAM_ID)
     data
   };
 }
-
-// src/solana/instructions/skim.ts
-function createSkimInstruction(accounts, programId = PROGRAM_ID) {
+function createSkimInstruction(accounts, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
@@ -532,20 +677,20 @@ function createSkimInstruction(accounts, programId = PROGRAM_ID) {
     token1Mint,
     adminAta0,
     adminAta1,
-    tokenProgram = TOKEN_PROGRAM_ID
+    tokenProgram = TOKEN_PROGRAM_ADDRESS
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_READONLY },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER },
-    { address: authority, role: ACCOUNT_ROLE_READONLY },
-    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: adminAta0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: adminAta1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.READONLY },
+    { address: admin, role: AccountRole.READONLY_SIGNER },
+    { address: authority, role: AccountRole.READONLY },
+    { address: vault0, role: AccountRole.WRITABLE },
+    { address: vault1, role: AccountRole.WRITABLE },
+    { address: token0Mint, role: AccountRole.READONLY },
+    { address: token1Mint, role: AccountRole.READONLY },
+    { address: adminAta0, role: AccountRole.WRITABLE },
+    { address: adminAta1, role: AccountRole.WRITABLE },
+    { address: tokenProgram, role: AccountRole.READONLY }
   ];
   const data = INSTRUCTION_DISCRIMINATORS.skim;
   return {
@@ -554,9 +699,7 @@ function createSkimInstruction(accounts, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/swapExactIn.ts
-function createSwapExactInInstruction(accounts, args, programId = PROGRAM_ID) {
+function createSwapExactInInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
@@ -568,28 +711,28 @@ function createSwapExactInInstruction(accounts, args, programId = PROGRAM_ID) {
     userIn,
     userOut,
     user,
-    tokenProgram = TOKEN_PROGRAM_ID,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS,
     oracle,
     remainingAccounts = []
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: authority, role: ACCOUNT_ROLE_READONLY },
-    { address: vaultIn, role: ACCOUNT_ROLE_WRITABLE },
-    { address: vaultOut, role: ACCOUNT_ROLE_WRITABLE },
-    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: userIn, role: ACCOUNT_ROLE_WRITABLE },
-    { address: userOut, role: ACCOUNT_ROLE_WRITABLE },
-    { address: user, role: ACCOUNT_ROLE_SIGNER },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: authority, role: AccountRole.READONLY },
+    { address: vaultIn, role: AccountRole.WRITABLE },
+    { address: vaultOut, role: AccountRole.WRITABLE },
+    { address: token0Mint, role: AccountRole.READONLY },
+    { address: token1Mint, role: AccountRole.READONLY },
+    { address: userIn, role: AccountRole.WRITABLE },
+    { address: userOut, role: AccountRole.WRITABLE },
+    { address: user, role: AccountRole.READONLY_SIGNER },
+    { address: tokenProgram, role: AccountRole.READONLY }
   ];
   if (oracle) {
-    keys.push({ address: oracle, role: ACCOUNT_ROLE_WRITABLE });
+    keys.push({ address: oracle, role: AccountRole.WRITABLE });
   }
   for (const account of remainingAccounts) {
-    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+    keys.push({ address: account, role: AccountRole.READONLY });
   }
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.swapExactIn,
@@ -620,7 +763,7 @@ function createSwapInstruction(params) {
     oracle,
     remainingAccounts,
     updateOracle = false,
-    programId = PROGRAM_ID
+    programId = CPMM_PROGRAM_ID
   } = params;
   const [vaultIn, vaultOut] = direction === 0 ? [vault0, vault1] : [vault1, vault0];
   const [userIn, userOut] = direction === 0 ? [userToken0, userToken1] : [userToken1, userToken0];
@@ -648,22 +791,20 @@ function createSwapInstruction(params) {
     programId
   );
 }
-
-// src/solana/instructions/createPosition.ts
-function createCreatePositionInstruction(accounts, args, programId = PROGRAM_ID) {
+function createCreatePositionInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     pool,
     position,
     owner,
     payer,
-    systemProgram = SYSTEM_PROGRAM_ID
+    systemProgram = SYSTEM_PROGRAM_ADDRESS
   } = accounts;
   const keys = [
-    { address: pool, role: ACCOUNT_ROLE_READONLY },
-    { address: position, role: ACCOUNT_ROLE_WRITABLE },
-    { address: owner, role: ACCOUNT_ROLE_SIGNER },
-    { address: payer, role: ACCOUNT_ROLE_WRITABLE_SIGNER },
-    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: pool, role: AccountRole.READONLY },
+    { address: position, role: AccountRole.WRITABLE },
+    { address: owner, role: AccountRole.READONLY_SIGNER },
+    { address: payer, role: AccountRole.WRITABLE_SIGNER },
+    { address: systemProgram, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.createPosition,
@@ -676,15 +817,13 @@ function createCreatePositionInstruction(accounts, args, programId = PROGRAM_ID)
     data
   };
 }
-
-// src/solana/instructions/closePosition.ts
-function createClosePositionInstruction(accounts, programId = PROGRAM_ID) {
+function createClosePositionInstruction(accounts, programId = CPMM_PROGRAM_ID) {
   const { pool, position, owner, rentRecipient } = accounts;
   const keys = [
-    { address: pool, role: ACCOUNT_ROLE_READONLY },
-    { address: position, role: ACCOUNT_ROLE_WRITABLE },
-    { address: owner, role: ACCOUNT_ROLE_SIGNER },
-    { address: rentRecipient, role: ACCOUNT_ROLE_WRITABLE }
+    { address: pool, role: AccountRole.READONLY },
+    { address: position, role: AccountRole.WRITABLE },
+    { address: owner, role: AccountRole.READONLY_SIGNER },
+    { address: rentRecipient, role: AccountRole.WRITABLE }
   ];
   const data = INSTRUCTION_DISCRIMINATORS.closePosition;
   return {
@@ -699,7 +838,7 @@ var addLiquidityArgsWithOracleCodec = getStructCodec([
   ["minSharesOut", getU128Codec()],
   ["updateOracle", getBooleanCodec()]
 ]);
-function createAddLiquidityInstruction(accounts, args, programId = PROGRAM_ID) {
+function createAddLiquidityInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
@@ -713,30 +852,30 @@ function createAddLiquidityInstruction(accounts, args, programId = PROGRAM_ID) {
     token1Mint,
     user0,
     user1,
-    tokenProgram = TOKEN_PROGRAM_ID,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS,
     oracle,
     remainingAccounts = []
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: position, role: ACCOUNT_ROLE_WRITABLE },
-    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
-    { address: owner, role: ACCOUNT_ROLE_SIGNER },
-    { address: authority, role: ACCOUNT_ROLE_READONLY },
-    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: user0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: user1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: position, role: AccountRole.WRITABLE },
+    { address: protocolPosition, role: AccountRole.WRITABLE },
+    { address: owner, role: AccountRole.READONLY_SIGNER },
+    { address: authority, role: AccountRole.READONLY },
+    { address: vault0, role: AccountRole.WRITABLE },
+    { address: vault1, role: AccountRole.WRITABLE },
+    { address: token0Mint, role: AccountRole.READONLY },
+    { address: token1Mint, role: AccountRole.READONLY },
+    { address: user0, role: AccountRole.WRITABLE },
+    { address: user1, role: AccountRole.WRITABLE },
+    { address: tokenProgram, role: AccountRole.READONLY }
   ];
   if (oracle) {
-    keys.push({ address: oracle, role: ACCOUNT_ROLE_WRITABLE });
+    keys.push({ address: oracle, role: AccountRole.WRITABLE });
   }
   for (const account of remainingAccounts) {
-    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+    keys.push({ address: account, role: AccountRole.READONLY });
   }
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.addLiquidity,
@@ -749,9 +888,7 @@ function createAddLiquidityInstruction(accounts, args, programId = PROGRAM_ID) {
     data
   };
 }
-
-// src/solana/instructions/removeLiquidity.ts
-function createRemoveLiquidityInstruction(accounts, args, programId = PROGRAM_ID) {
+function createRemoveLiquidityInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
@@ -765,30 +902,30 @@ function createRemoveLiquidityInstruction(accounts, args, programId = PROGRAM_ID
     token1Mint,
     user0,
     user1,
-    tokenProgram = TOKEN_PROGRAM_ID,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS,
     oracle,
     remainingAccounts = []
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: position, role: ACCOUNT_ROLE_WRITABLE },
-    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
-    { address: owner, role: ACCOUNT_ROLE_SIGNER },
-    { address: authority, role: ACCOUNT_ROLE_READONLY },
-    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: user0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: user1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: position, role: AccountRole.WRITABLE },
+    { address: protocolPosition, role: AccountRole.WRITABLE },
+    { address: owner, role: AccountRole.READONLY_SIGNER },
+    { address: authority, role: AccountRole.READONLY },
+    { address: vault0, role: AccountRole.WRITABLE },
+    { address: vault1, role: AccountRole.WRITABLE },
+    { address: token0Mint, role: AccountRole.READONLY },
+    { address: token1Mint, role: AccountRole.READONLY },
+    { address: user0, role: AccountRole.WRITABLE },
+    { address: user1, role: AccountRole.WRITABLE },
+    { address: tokenProgram, role: AccountRole.READONLY }
   ];
   if (oracle) {
-    keys.push({ address: oracle, role: ACCOUNT_ROLE_WRITABLE });
+    keys.push({ address: oracle, role: AccountRole.WRITABLE });
   }
   for (const account of remainingAccounts) {
-    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+    keys.push({ address: account, role: AccountRole.READONLY });
   }
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.removeLiquidity,
@@ -801,9 +938,7 @@ function createRemoveLiquidityInstruction(accounts, args, programId = PROGRAM_ID
     data
   };
 }
-
-// src/solana/instructions/collectProtocolFees.ts
-function createCollectProtocolFeesInstruction(accounts, args, programId = PROGRAM_ID) {
+function createCollectProtocolFeesInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const {
     config,
     pool,
@@ -816,21 +951,21 @@ function createCollectProtocolFeesInstruction(accounts, args, programId = PROGRA
     token1Mint,
     recipient0,
     recipient1,
-    tokenProgram = TOKEN_PROGRAM_ID
+    tokenProgram = TOKEN_PROGRAM_ADDRESS
   } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
-    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
-    { address: admin, role: ACCOUNT_ROLE_SIGNER },
-    { address: authority, role: ACCOUNT_ROLE_READONLY },
-    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
-    { address: recipient0, role: ACCOUNT_ROLE_WRITABLE },
-    { address: recipient1, role: ACCOUNT_ROLE_WRITABLE },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: pool, role: AccountRole.WRITABLE },
+    { address: protocolPosition, role: AccountRole.WRITABLE },
+    { address: admin, role: AccountRole.READONLY_SIGNER },
+    { address: authority, role: AccountRole.READONLY },
+    { address: vault0, role: AccountRole.WRITABLE },
+    { address: vault1, role: AccountRole.WRITABLE },
+    { address: token0Mint, role: AccountRole.READONLY },
+    { address: token1Mint, role: AccountRole.READONLY },
+    { address: recipient0, role: AccountRole.WRITABLE },
+    { address: recipient1, role: AccountRole.WRITABLE },
+    { address: tokenProgram, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.collectProtocolFees,
@@ -843,13 +978,11 @@ function createCollectProtocolFeesInstruction(accounts, args, programId = PROGRA
     data
   };
 }
-
-// src/solana/instructions/oracleUpdate.ts
-function createOracleUpdateInstruction(accounts, programId = PROGRAM_ID) {
+function createOracleUpdateInstruction(accounts, programId = CPMM_PROGRAM_ID) {
   const { pool, oracle } = accounts;
   const keys = [
-    { address: pool, role: ACCOUNT_ROLE_READONLY },
-    { address: oracle, role: ACCOUNT_ROLE_WRITABLE }
+    { address: pool, role: AccountRole.READONLY },
+    { address: oracle, role: AccountRole.WRITABLE }
   ];
   const data = INSTRUCTION_DISCRIMINATORS.oracleUpdate;
   return {
@@ -865,11 +998,11 @@ var oracleConsultResultCodec = getStructCodec([
 function decodeOracleConsultResult(data) {
   return oracleConsultResultCodec.decode(data);
 }
-function createOracleConsultInstruction(accounts, args, programId = PROGRAM_ID) {
+function createOracleConsultInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const { pool, oracle } = accounts;
   const keys = [
-    { address: pool, role: ACCOUNT_ROLE_READONLY },
-    { address: oracle, role: ACCOUNT_ROLE_READONLY }
+    { address: pool, role: AccountRole.READONLY },
+    { address: oracle, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.oracleConsult,
@@ -890,14 +1023,14 @@ var quoteToNumeraireResultCodec = getStructCodec([
 function decodeQuoteToNumeraireResult(data) {
   return quoteToNumeraireResultCodec.decode(data);
 }
-function createQuoteToNumeraireInstruction(accounts, args, programId = PROGRAM_ID) {
+function createQuoteToNumeraireInstruction(accounts, args, programId = CPMM_PROGRAM_ID) {
   const { config, startPool, remainingAccounts = [] } = accounts;
   const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: startPool, role: ACCOUNT_ROLE_READONLY }
+    { address: config, role: AccountRole.READONLY },
+    { address: startPool, role: AccountRole.READONLY }
   ];
   for (const account of remainingAccounts) {
-    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+    keys.push({ address: account, role: AccountRole.READONLY });
   }
   const data = encodeInstructionData(
     INSTRUCTION_DISCRIMINATORS.quoteToNumeraire,
@@ -920,7 +1053,7 @@ function base64ToBytes(base64) {
   }
   return bytes;
 }
-async function fetchConfig(rpc, programId = PROGRAM_ID, commitment) {
+async function fetchConfig(rpc, programId = CPMM_PROGRAM_ID, commitment) {
   const [configAddress] = await getConfigAddress(programId);
   const response = await rpc.getAccountInfo(configAddress, {
     encoding: "base64",
@@ -931,7 +1064,7 @@ async function fetchConfig(rpc, programId = PROGRAM_ID, commitment) {
   }
   return decodeAmmConfig(base64ToBytes(response.value.data[0]));
 }
-async function fetchConfigWithAddress(rpc, programId = PROGRAM_ID, commitment) {
+async function fetchConfigWithAddress(rpc, programId = CPMM_PROGRAM_ID, commitment) {
   const [configAddress] = await getConfigAddress(programId);
   const account = await fetchConfig(rpc, programId, commitment);
   if (!account) {
@@ -944,6 +1077,7 @@ async function fetchConfigWithAddress(rpc, programId = PROGRAM_ID, commitment) {
 var initializer_exports = {};
 __export(initializer_exports, {
   BPF_LOADER_UPGRADEABLE_PROGRAM_ID: () => BPF_LOADER_UPGRADEABLE_PROGRAM_ID,
+  CPMM_SENTINEL_PROGRAM_ID: () => CPMM_SENTINEL_PROGRAM_ID,
   CURVE_KIND_XYK: () => CURVE_KIND_XYK,
   CURVE_PARAMS_FORMAT_XYK_V0: () => CURVE_PARAMS_FORMAT_XYK_V0,
   DIRECTION_BUY: () => DIRECTION_BUY,
@@ -959,12 +1093,14 @@ __export(initializer_exports, {
   PHASE_ABORTED: () => PHASE_ABORTED,
   PHASE_MIGRATED: () => PHASE_MIGRATED,
   PHASE_TRADING: () => PHASE_TRADING,
+  PREDICTION_SENTINEL_PROGRAM_ID: () => PREDICTION_SENTINEL_PROGRAM_ID,
   SEED_CONFIG: () => SEED_CONFIG2,
   SEED_LAUNCH: () => SEED_LAUNCH,
   SEED_LAUNCH_AUTHORITY: () => SEED_LAUNCH_AUTHORITY,
   SENTINEL_NO_CHANGE: () => SENTINEL_NO_CHANGE2,
   SF_AFTER_SWAP: () => SF_AFTER_SWAP2,
   SF_BEFORE_SWAP: () => SF_BEFORE_SWAP2,
+  computeRemainingAccountsHash: () => computeRemainingAccountsHash,
   createAbortLaunchInstruction: () => createAbortLaunchInstruction,
   createCurveSwapExactInInstruction: () => createCurveSwapExactInInstruction,
   createInitializeConfigInstruction: () => createInitializeConfigInstruction2,
@@ -978,7 +1114,7 @@ __export(initializer_exports, {
   decodePreviewSwapExactInResult: () => decodePreviewSwapExactInResult,
   encodeU64LE: () => encodeU64LE,
   fetchAllLaunches: () => fetchAllLaunches,
-  fetchLaunch: () => fetchLaunch,
+  fetchLaunch: () => fetchLaunch2,
   fetchLaunchesByAuthority: () => fetchLaunchesByAuthority,
   getConfigAddress: () => getConfigAddress2,
   getInitConfigCodec: () => getInitConfigCodec,
@@ -998,7 +1134,8 @@ __export(initializer_exports, {
   getProgramDataAddress: () => getProgramDataAddress,
   getTokenMetadataAddress: () => getTokenMetadataAddress,
   launchExists: () => launchExists,
-  launchIdFromU64: () => launchIdFromU64
+  launchIdFromU64: () => launchIdFromU64,
+  phaseLabel: () => phaseLabel
 });
 var INITIALIZER_PROGRAM_ID = address(
   "4h3Dqyo5qmteJoMxXt3tdtfXELDB6pdRTPU9mWruiKp1"
@@ -1006,42 +1143,48 @@ var INITIALIZER_PROGRAM_ID = address(
 var BPF_LOADER_UPGRADEABLE_PROGRAM_ID = address(
   "BPFLoaderUpgradeab1e11111111111111111111111"
 );
+var CPMM_SENTINEL_PROGRAM_ID = address(
+  "2vJ1c62knEwZbxp3XdHB4RSmCfz55pA6tRkCho63gW7u"
+);
+var PREDICTION_SENTINEL_PROGRAM_ID = address(
+  "7QcQDANJVC17Jgc6KjjeagSkm2zAphgHVPK5agJzyihB"
+);
 var SEED_CONFIG2 = "config_v3";
 var SEED_LAUNCH = "launch_v3";
 var SEED_LAUNCH_AUTHORITY = "launch_authority_v3";
 var EMPTY_REMAINING_ACCOUNTS_HASH = new Uint8Array([
-  223,
-  63,
-  97,
-  152,
-  4,
-  169,
-  47,
-  219,
+  232,
+  231,
+  118,
+  38,
+  88,
+  111,
+  115,
+  185,
+  85,
+  54,
+  76,
+  123,
+  75,
+  191,
+  11,
+  183,
+  247,
+  104,
+  94,
+  189,
   64,
-  87,
-  25,
-  45,
-  196,
-  61,
-  215,
-  72,
-  234,
-  119,
-  138,
-  220,
-  82,
-  188,
-  73,
-  140,
   232,
-  5,
+  82,
+  177,
+  100,
+  99,
+  58,
+  74,
+  203,
+  211,
   36,
-  192,
-  20,
-  184,
-  17,
-  25
+  76
 ]);
 var DOPPLER_DEVNET_ALT = address(
   "7r5rdLkGMzTq5Q2kBhkePw4ZTeZEooHgTXktYoamNmVq"
@@ -1617,8 +1760,6 @@ function launchIdFromU64(launchId) {
   out.set(encodeU64LE(launchId), 0);
   return out;
 }
-
-// src/solana/initializer/instructions/initializeConfig.ts
 function isTransactionSigner2(value) {
   return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
 }
@@ -1633,21 +1774,19 @@ function createInitializeConfigInstruction2(accounts, args, programId = INITIALI
     admin,
     config,
     programData,
-    systemProgram = SYSTEM_PROGRAM_ID
+    systemProgram = SYSTEM_PROGRAM_ADDRESS
   } = accounts;
   const keys = [
-    createSignerAccountMeta2(admin, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    { address: config, role: ACCOUNT_ROLE_WRITABLE },
-    { address: programData, role: ACCOUNT_ROLE_READONLY },
-    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+    createSignerAccountMeta2(admin, AccountRole.WRITABLE_SIGNER),
+    { address: config, role: AccountRole.WRITABLE },
+    { address: programData, role: AccountRole.READONLY },
+    { address: systemProgram, role: AccountRole.READONLY }
   ];
   const data = new Uint8Array(
     getInitializeConfigInstructionDataEncoder().encode(args)
   );
   return { programAddress: programId, accounts: keys, data };
 }
-
-// src/solana/initializer/instructions/setMigratorAllowlist.ts
 function isTransactionSigner3(value) {
   return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
 }
@@ -1660,16 +1799,14 @@ function createSignerAccountMeta3(value, role) {
 function createSetMigratorAllowlistInstruction(accounts, allowlist, programId = INITIALIZER_PROGRAM_ID) {
   const { admin, config } = accounts;
   const keys = [
-    createSignerAccountMeta3(admin, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    { address: config, role: ACCOUNT_ROLE_WRITABLE }
+    createSignerAccountMeta3(admin, AccountRole.WRITABLE_SIGNER),
+    { address: config, role: AccountRole.WRITABLE }
   ];
   const data = new Uint8Array(
     getSetMigratorAllowlistInstructionDataEncoder().encode({ allowlist })
   );
   return { programAddress: programId, accounts: keys, data };
 }
-
-// src/solana/initializer/instructions/setSentinelAllowlist.ts
 function isTransactionSigner4(value) {
   return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
 }
@@ -1682,8 +1819,8 @@ function createSignerAccountMeta4(value, role) {
 function createSetSentinelAllowlistInstruction(accounts, allowlist, programId = INITIALIZER_PROGRAM_ID) {
   const { admin, config } = accounts;
   const keys = [
-    createSignerAccountMeta4(admin, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    { address: config, role: ACCOUNT_ROLE_WRITABLE }
+    createSignerAccountMeta4(admin, AccountRole.WRITABLE_SIGNER),
+    { address: config, role: AccountRole.WRITABLE }
   ];
   const data = new Uint8Array(
     getSetSentinelAllowlistInstructionDataEncoder().encode({ allowlist })
@@ -1723,251 +1860,2105 @@ var CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS = {
     176
   ])
 };
-
-// src/solana/generated/predictionMigrator/programs/predictionMigrator.ts
-var PREDICTION_MIGRATOR_PROGRAM_ADDRESS = "HYHdyy7QZg8Ucky9Z97xNtSCvrZxVNkeoney8xEPXjiZ";
-
-// src/solana/initializer/instructions/initializeLaunch.ts
-function isTransactionSigner5(value) {
-  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
-}
-function createAccountMeta(value, role) {
-  if (isTransactionSigner5(value)) {
-    return { address: value.address, role, signer: value };
-  }
-  return { address: value, role };
-}
-async function getTokenMetadataAddress(mint) {
-  const encoder = getAddressEncoder();
-  const [metadataAddress] = await getProgramDerivedAddress({
-    programAddress: TOKEN_METADATA_PROGRAM_ID,
-    seeds: [
-      new TextEncoder().encode("metadata"),
-      encoder.encode(TOKEN_METADATA_PROGRAM_ID),
-      encoder.encode(mint)
-    ]
+var addressCodec3 = getAddressCodec();
+var textEncoder3 = new TextEncoder();
+async function getCpmmMigratorStateAddress(launch, programId = CPMM_MIGRATOR_PROGRAM_ID) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder3.encode(SEED_STATE), addressCodec3.encode(launch)]
   });
-  return metadataAddress;
-}
-var ALT_INDEX = {
-  [TOKEN_PROGRAM_ID]: 0,
-  [SYSTEM_PROGRAM_ID]: 1,
-  SysvarRent111111111111111111111111111111111: 2,
-  [INITIALIZER_PROGRAM_ID]: 3,
-  [TOKEN_METADATA_PROGRAM_ID]: 4,
-  [CPMM_MIGRATOR_PROGRAM_ID]: 5,
-  So11111111111111111111111111111111111111112: 6,
-  // index 7 = config PDA — resolved at call time from accounts.config
-  [PREDICTION_MIGRATOR_PROGRAM_ADDRESS]: 8
-};
-function validateInitializeLaunchCurveParams(args) {
-  if (args.curveKind !== CURVE_KIND_XYK) {
-    throw new Error(
-      `unsupported curve kind: ${args.curveKind}; only CURVE_KIND_XYK is currently enabled`
-    );
-  }
-  if (args.curveParams.length !== 1 || args.curveParams[0] !== CURVE_PARAMS_FORMAT_XYK_V0) {
-    throw new Error("xyk curve params must be [CURVE_PARAMS_FORMAT_XYK_V0]");
-  }
 }
-function createInitializeLaunchInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
-  validateInitializeLaunchCurveParams(args);
-  const {
-    config,
-    launch,
-    launchAuthority,
-    baseMint,
-    quoteMint,
-    baseVault,
-    quoteVault,
-    payer,
-    authority,
-    migratorProgram,
-    tokenProgram = TOKEN_PROGRAM_ID,
-    systemProgram = SYSTEM_PROGRAM_ID,
-    rent,
-    metadataAccount,
-    addressLookupTable: alt
-  } = accounts;
-  const withMetadata = Boolean(
-    args.metadataName && args.metadataName.length > 0
+var CLAIM_RECEIPT_DISCRIMINATOR = new Uint8Array([
+  223,
+  233,
+  11,
+  229,
+  124,
+  165,
+  207,
+  28
+]);
+function getClaimReceiptDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    CLAIM_RECEIPT_DISCRIMINATOR
   );
-  if (withMetadata && !metadataAccount) {
-    throw new Error(
-      "metadataName is set but metadataAccount was not provided. Derive it with await initializer.getTokenMetadataAddress(baseMintAddress)."
-    );
-  }
-  const altIndexMap = alt ? { ...ALT_INDEX, [config]: 7 } : {};
-  function staticOrLookup(addr, role) {
-    if (alt && altIndexMap[addr] !== void 0) {
-      return {
-        address: addr,
-        role,
-        lookupTableAddress: alt,
-        addressIndex: altIndexMap[addr]
-      };
-    }
-    return { address: addr, role };
-  }
-  const keys = [
-    staticOrLookup(config, AccountRole.READONLY),
-    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
-    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
-    createAccountMeta(baseMint, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    staticOrLookup(quoteMint, AccountRole.READONLY),
-    createAccountMeta(baseVault, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    createAccountMeta(quoteVault, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    createAccountMeta(payer, ACCOUNT_ROLE_WRITABLE_SIGNER)
-  ];
-  if (authority) {
-    keys.push(createAccountMeta(authority, ACCOUNT_ROLE_SIGNER));
-  }
-  if (migratorProgram) {
-    keys.push(staticOrLookup(migratorProgram, AccountRole.READONLY));
-  }
-  keys.push(staticOrLookup(tokenProgram, AccountRole.READONLY));
-  keys.push(staticOrLookup(systemProgram, AccountRole.READONLY));
-  keys.push(staticOrLookup(rent, AccountRole.READONLY));
-  if (withMetadata) {
-    keys.push({ address: metadataAccount, role: ACCOUNT_ROLE_WRITABLE });
-    keys.push(staticOrLookup(TOKEN_METADATA_PROGRAM_ID, AccountRole.READONLY));
-  }
-  const data = new Uint8Array(
-    getInitializeLaunchInstructionDataEncoder().encode(args)
+}
+function getClaimReceiptEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["market", getAddressEncoder()],
+      ["claimer", getAddressEncoder()],
+      ["burnedAmount", getU64Encoder()],
+      ["rewardDebt", getU128Encoder()],
+      ["bump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 7)]
+    ]),
+    (value) => ({ ...value, discriminator: CLAIM_RECEIPT_DISCRIMINATOR })
   );
-  return { programAddress: programId, accounts: keys, data };
 }
-
-// src/solana/initializer/instructions/curveSwapExactIn.ts
-function isTransactionSigner6(value) {
-  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+function getClaimReceiptDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["market", getAddressDecoder()],
+    ["claimer", getAddressDecoder()],
+    ["burnedAmount", getU64Decoder()],
+    ["rewardDebt", getU128Decoder()],
+    ["bump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 7)]
+  ]);
 }
-function createAccountMeta2(value, role) {
-  if (isTransactionSigner6(value)) {
-    return { address: value.address, role, signer: value };
-  }
-  return { address: value, role };
+function getClaimReceiptCodec() {
+  return combineCodec(getClaimReceiptEncoder(), getClaimReceiptDecoder());
 }
-function createCurveSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
-  const {
-    config,
-    launch,
-    launchAuthority,
-    baseVault,
-    quoteVault,
-    userBaseAccount,
-    userQuoteAccount,
-    baseMint,
-    quoteMint,
-    user,
-    sentinelProgram = SYSTEM_PROGRAM_ID,
-    tokenProgram = TOKEN_PROGRAM_ID
-  } = accounts;
-  const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
-    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
-    { address: baseVault, role: ACCOUNT_ROLE_WRITABLE },
-    { address: quoteVault, role: ACCOUNT_ROLE_WRITABLE },
-    { address: userBaseAccount, role: ACCOUNT_ROLE_WRITABLE },
-    { address: userQuoteAccount, role: ACCOUNT_ROLE_WRITABLE },
-    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
-    { address: quoteMint, role: ACCOUNT_ROLE_READONLY },
-    createAccountMeta2(user, ACCOUNT_ROLE_SIGNER),
-    // sentinel_program is Optional in the on-chain struct but still occupies a fixed
-    // slot (token_program follows it).  Always emit it — use SYSTEM_PROGRAM_ID as the
-    // no-op placeholder when no real sentinel is configured.
-    { address: sentinelProgram, role: ACCOUNT_ROLE_READONLY },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
-  ];
-  const data = new Uint8Array(
-    getCurveSwapExactInInstructionDataEncoder().encode(args)
+function decodeClaimReceipt(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getClaimReceiptDecoder()
   );
-  return { programAddress: programId, accounts: keys, data };
 }
-
-// src/solana/initializer/instructions/migrateLaunch.ts
-function isTransactionSigner7(value) {
-  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+async function fetchClaimReceipt(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeClaimReceipt(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
 }
-function createSignerAccountMeta5(value, role) {
-  if (isTransactionSigner7(value)) {
-    return { address: value.address, role, signer: value };
-  }
-  return { address: value, role };
+async function fetchMaybeClaimReceipt(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeClaimReceipt(maybeAccount);
 }
-function createMigrateLaunchInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
-  const {
-    config,
-    launch,
-    launchAuthority,
-    baseMint,
-    quoteMint,
-    baseVault,
-    quoteVault,
-    migratorProgram,
-    payer,
-    tokenProgram = TOKEN_PROGRAM_ID,
-    systemProgram = SYSTEM_PROGRAM_ID,
-    rent
-  } = accounts;
-  const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
-    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
-    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
-    { address: quoteMint, role: ACCOUNT_ROLE_READONLY },
-    { address: baseVault, role: ACCOUNT_ROLE_WRITABLE },
-    { address: quoteVault, role: ACCOUNT_ROLE_WRITABLE },
-    { address: migratorProgram, role: ACCOUNT_ROLE_READONLY },
-    createSignerAccountMeta5(payer, ACCOUNT_ROLE_WRITABLE_SIGNER),
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY },
-    { address: systemProgram, role: ACCOUNT_ROLE_READONLY },
-    { address: rent, role: ACCOUNT_ROLE_READONLY }
-  ];
-  const data = encodeInstructionData(
-    INITIALIZER_INSTRUCTION_DISCRIMINATORS.migrateLaunch
-  );
-  return { programAddress: programId, accounts: keys, data };
+async function fetchAllClaimReceipt(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeClaimReceipt(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
 }
-
-// src/solana/initializer/instructions/abortLaunch.ts
-function isTransactionSigner8(value) {
-  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+async function fetchAllMaybeClaimReceipt(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeClaimReceipt(maybeAccount));
 }
-function createAccountMeta3(value, role) {
-  if (isTransactionSigner8(value)) {
-    return { address: value.address, role, signer: value };
-  }
-  return { address: value, role };
+function getClaimReceiptSize() {
+  return 104;
 }
-function createAbortLaunchInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
-  const {
-    config,
-    launch,
-    launchAuthority,
-    baseVault,
-    quoteVault,
-    authority,
-    authorityBaseAccount,
-    baseMint,
-    tokenProgram = TOKEN_PROGRAM_ID
-  } = accounts;
-  const keys = [
-    { address: config, role: ACCOUNT_ROLE_READONLY },
-    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
-    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
-    { address: baseVault, role: ACCOUNT_ROLE_WRITABLE },
-    { address: quoteVault, role: ACCOUNT_ROLE_READONLY },
-    createAccountMeta3(authority, ACCOUNT_ROLE_SIGNER),
-    { address: authorityBaseAccount, role: ACCOUNT_ROLE_WRITABLE },
-    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
-    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
-  ];
-  const data = encodeInstructionData(
-    INITIALIZER_INSTRUCTION_DISCRIMINATORS.abortLaunch
+var ENTRY_DISCRIMINATOR = new Uint8Array([
+  63,
+  18,
+  152,
+  113,
+  215,
+  246,
+  221,
+  250
+]);
+function getEntryDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(ENTRY_DISCRIMINATOR);
+}
+function getEntryEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["oracle", getAddressEncoder()],
+      ["entryId", fixEncoderSize(getBytesEncoder(), 32)],
+      ["baseMint", getAddressEncoder()],
+      ["contribution", getU64Encoder()],
+      ["isMigrated", getBooleanEncoder()],
+      ["bump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 14)]
+    ]),
+    (value) => ({ ...value, discriminator: ENTRY_DISCRIMINATOR })
   );
-  return { programAddress: programId, accounts: keys, data };
+}
+function getEntryDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["oracle", getAddressDecoder()],
+    ["entryId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["baseMint", getAddressDecoder()],
+    ["contribution", getU64Decoder()],
+    ["isMigrated", getBooleanDecoder()],
+    ["bump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 14)]
+  ]);
+}
+function getEntryCodec() {
+  return combineCodec(getEntryEncoder(), getEntryDecoder());
+}
+function decodeEntry(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getEntryDecoder()
+  );
+}
+async function fetchEntry(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeEntry(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeEntry(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeEntry(maybeAccount);
+}
+async function fetchAllEntry(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeEntry(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeEntry(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeEntry(maybeAccount));
+}
+function getEntrySize() {
+  return 128;
+}
+var ENTRY_BY_MINT_DISCRIMINATOR = new Uint8Array([
+  188,
+  191,
+  157,
+  194,
+  68,
+  82,
+  181,
+  126
+]);
+function getEntryByMintDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    ENTRY_BY_MINT_DISCRIMINATOR
+  );
+}
+function getEntryByMintEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["oracle", getAddressEncoder()],
+      ["baseMint", getAddressEncoder()],
+      ["entryId", fixEncoderSize(getBytesEncoder(), 32)],
+      ["bump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 7)]
+    ]),
+    (value) => ({ ...value, discriminator: ENTRY_BY_MINT_DISCRIMINATOR })
+  );
+}
+function getEntryByMintDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["oracle", getAddressDecoder()],
+    ["baseMint", getAddressDecoder()],
+    ["entryId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["bump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 7)]
+  ]);
+}
+function getEntryByMintCodec() {
+  return combineCodec(getEntryByMintEncoder(), getEntryByMintDecoder());
+}
+function decodeEntryByMint(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getEntryByMintDecoder()
+  );
+}
+async function fetchEntryByMint(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeEntryByMint(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeEntryByMint(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeEntryByMint(maybeAccount);
+}
+async function fetchAllEntryByMint(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeEntryByMint(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeEntryByMint(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeEntryByMint(maybeAccount));
+}
+function getEntryByMintSize() {
+  return 112;
+}
+function getAccumulatorUpdatedEncoder() {
+  return getStructEncoder([
+    ["market", getAddressEncoder()],
+    ["newTotalPot", getU64Encoder()],
+    ["newAccQuotePerToken", getU128Encoder()]
+  ]);
+}
+function getAccumulatorUpdatedDecoder() {
+  return getStructDecoder([
+    ["market", getAddressDecoder()],
+    ["newTotalPot", getU64Decoder()],
+    ["newAccQuotePerToken", getU128Decoder()]
+  ]);
+}
+function getAccumulatorUpdatedCodec() {
+  return combineCodec(
+    getAccumulatorUpdatedEncoder(),
+    getAccumulatorUpdatedDecoder()
+  );
+}
+function getCalldataBufEncoder2() {
+  return getStructEncoder([
+    ["len", getU16Encoder()],
+    ["bytes", fixEncoderSize(getBytesEncoder(), 256)]
+  ]);
+}
+function getCalldataBufDecoder2() {
+  return getStructDecoder([
+    ["len", getU16Decoder()],
+    ["bytes", fixDecoderSize(getBytesDecoder(), 256)]
+  ]);
+}
+function getCalldataBufCodec() {
+  return combineCodec(getCalldataBufEncoder2(), getCalldataBufDecoder2());
+}
+function getEntryMigratedEncoder() {
+  return getStructEncoder([
+    ["market", getAddressEncoder()],
+    ["oracle", getAddressEncoder()],
+    ["entryId", fixEncoderSize(getBytesEncoder(), 32)],
+    ["baseMint", getAddressEncoder()],
+    ["contribution", getU64Encoder()],
+    ["isWinner", getBooleanEncoder()]
+  ]);
+}
+function getEntryMigratedDecoder() {
+  return getStructDecoder([
+    ["market", getAddressDecoder()],
+    ["oracle", getAddressDecoder()],
+    ["entryId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["baseMint", getAddressDecoder()],
+    ["contribution", getU64Decoder()],
+    ["isWinner", getBooleanDecoder()]
+  ]);
+}
+function getEntryMigratedCodec() {
+  return combineCodec(getEntryMigratedEncoder(), getEntryMigratedDecoder());
+}
+function getEntryRegisteredEncoder() {
+  return getStructEncoder([
+    ["market", getAddressEncoder()],
+    ["oracle", getAddressEncoder()],
+    ["entryId", fixEncoderSize(getBytesEncoder(), 32)],
+    ["baseMint", getAddressEncoder()]
+  ]);
+}
+function getEntryRegisteredDecoder() {
+  return getStructDecoder([
+    ["market", getAddressDecoder()],
+    ["oracle", getAddressDecoder()],
+    ["entryId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["baseMint", getAddressDecoder()]
+  ]);
+}
+function getEntryRegisteredCodec() {
+  return combineCodec(getEntryRegisteredEncoder(), getEntryRegisteredDecoder());
+}
+function getMarketCreatedEncoder() {
+  return getStructEncoder([
+    ["market", getAddressEncoder()],
+    ["oracle", getAddressEncoder()],
+    ["quoteMint", getAddressEncoder()]
+  ]);
+}
+function getMarketCreatedDecoder() {
+  return getStructDecoder([
+    ["market", getAddressDecoder()],
+    ["oracle", getAddressDecoder()],
+    ["quoteMint", getAddressDecoder()]
+  ]);
+}
+function getMarketCreatedCodec() {
+  return combineCodec(getMarketCreatedEncoder(), getMarketCreatedDecoder());
+}
+function getMarketResolvedEncoder() {
+  return getStructEncoder([
+    ["market", getAddressEncoder()],
+    ["oracle", getAddressEncoder()],
+    ["winnerMint", getAddressEncoder()],
+    ["claimableSupply", getU64Encoder()],
+    ["totalPot", getU64Encoder()]
+  ]);
+}
+function getMarketResolvedDecoder() {
+  return getStructDecoder([
+    ["market", getAddressDecoder()],
+    ["oracle", getAddressDecoder()],
+    ["winnerMint", getAddressDecoder()],
+    ["claimableSupply", getU64Decoder()],
+    ["totalPot", getU64Decoder()]
+  ]);
+}
+function getMarketResolvedCodec() {
+  return combineCodec(getMarketResolvedEncoder(), getMarketResolvedDecoder());
+}
+function getMigrateEntryArgsEncoder() {
+  return getStructEncoder([["entryId", fixEncoderSize(getBytesEncoder(), 32)]]);
+}
+function getMigrateEntryArgsDecoder() {
+  return getStructDecoder([["entryId", fixDecoderSize(getBytesDecoder(), 32)]]);
+}
+function getMigrateEntryArgsCodec() {
+  return combineCodec(
+    getMigrateEntryArgsEncoder(),
+    getMigrateEntryArgsDecoder()
+  );
+}
+function getPreviewPayoutIfWinnerArgsEncoder() {
+  return getStructEncoder([
+    ["candidateWinnerMint", getAddressEncoder()],
+    ["tokenAmount", getU64Encoder()]
+  ]);
+}
+function getPreviewPayoutIfWinnerArgsDecoder() {
+  return getStructDecoder([
+    ["candidateWinnerMint", getAddressDecoder()],
+    ["tokenAmount", getU64Decoder()]
+  ]);
+}
+function getPreviewPayoutIfWinnerArgsCodec() {
+  return combineCodec(
+    getPreviewPayoutIfWinnerArgsEncoder(),
+    getPreviewPayoutIfWinnerArgsDecoder()
+  );
+}
+function getRegisterEntryArgsEncoder() {
+  return getStructEncoder([["entryId", fixEncoderSize(getBytesEncoder(), 32)]]);
+}
+function getRegisterEntryArgsDecoder() {
+  return getStructDecoder([["entryId", fixDecoderSize(getBytesDecoder(), 32)]]);
+}
+function getRegisterEntryArgsCodec() {
+  return combineCodec(
+    getRegisterEntryArgsEncoder(),
+    getRegisterEntryArgsDecoder()
+  );
+}
+function getRewardsClaimedEncoder() {
+  return getStructEncoder([
+    ["market", getAddressEncoder()],
+    ["claimer", getAddressEncoder()],
+    ["burnedAmount", getU64Encoder()],
+    ["rewardAmount", getU64Encoder()],
+    ["totalBurned", getU64Encoder()]
+  ]);
+}
+function getRewardsClaimedDecoder() {
+  return getStructDecoder([
+    ["market", getAddressDecoder()],
+    ["claimer", getAddressDecoder()],
+    ["burnedAmount", getU64Decoder()],
+    ["rewardAmount", getU64Decoder()],
+    ["totalBurned", getU64Decoder()]
+  ]);
+}
+function getRewardsClaimedCodec() {
+  return combineCodec(getRewardsClaimedEncoder(), getRewardsClaimedDecoder());
+}
+
+// src/solana/generated/predictionMigrator/accounts/launch.ts
+var LAUNCH_DISCRIMINATOR2 = new Uint8Array([
+  144,
+  51,
+  51,
+  163,
+  206,
+  85,
+  213,
+  38
+]);
+function getLaunchDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(LAUNCH_DISCRIMINATOR2);
+}
+function getLaunchEncoder2() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["authority", getAddressEncoder()],
+      ["namespace", getAddressEncoder()],
+      ["launchId", fixEncoderSize(getBytesEncoder(), 32)],
+      ["phase", getU8Encoder()],
+      ["bump", getU8Encoder()],
+      ["launchAuthorityBump", getU8Encoder()],
+      ["pad0", fixEncoderSize(getBytesEncoder(), 5)],
+      ["baseMint", getAddressEncoder()],
+      ["quoteMint", getAddressEncoder()],
+      ["baseVault", getAddressEncoder()],
+      ["quoteVault", getAddressEncoder()],
+      ["baseTotalSupply", getU64Encoder()],
+      ["baseForDistribution", getU64Encoder()],
+      ["baseForLiquidity", getU64Encoder()],
+      ["baseForCurve", getU64Encoder()],
+      ["curveVirtualBase", getU64Encoder()],
+      ["curveVirtualQuote", getU64Encoder()],
+      ["curveFeeBps", getU16Encoder()],
+      ["pad1", fixEncoderSize(getBytesEncoder(), 6)],
+      ["allowBuy", getU8Encoder()],
+      ["allowSell", getU8Encoder()],
+      ["pad2", fixEncoderSize(getBytesEncoder(), 6)],
+      ["sentinelProgram", getAddressEncoder()],
+      ["sentinelFlags", getU32Encoder()],
+      ["pad3", fixEncoderSize(getBytesEncoder(), 4)],
+      ["sentinelCalldata", getCalldataBufEncoder2()],
+      ["migratorProgram", getAddressEncoder()],
+      ["migratorInitCalldata", getCalldataBufEncoder2()],
+      ["migratorMigrateCalldata", getCalldataBufEncoder2()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 64)]
+    ]),
+    (value) => ({ ...value, discriminator: LAUNCH_DISCRIMINATOR2 })
+  );
+}
+function getLaunchDecoder2() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["authority", getAddressDecoder()],
+    ["namespace", getAddressDecoder()],
+    ["launchId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["phase", getU8Decoder()],
+    ["bump", getU8Decoder()],
+    ["launchAuthorityBump", getU8Decoder()],
+    ["pad0", fixDecoderSize(getBytesDecoder(), 5)],
+    ["baseMint", getAddressDecoder()],
+    ["quoteMint", getAddressDecoder()],
+    ["baseVault", getAddressDecoder()],
+    ["quoteVault", getAddressDecoder()],
+    ["baseTotalSupply", getU64Decoder()],
+    ["baseForDistribution", getU64Decoder()],
+    ["baseForLiquidity", getU64Decoder()],
+    ["baseForCurve", getU64Decoder()],
+    ["curveVirtualBase", getU64Decoder()],
+    ["curveVirtualQuote", getU64Decoder()],
+    ["curveFeeBps", getU16Decoder()],
+    ["pad1", fixDecoderSize(getBytesDecoder(), 6)],
+    ["allowBuy", getU8Decoder()],
+    ["allowSell", getU8Decoder()],
+    ["pad2", fixDecoderSize(getBytesDecoder(), 6)],
+    ["sentinelProgram", getAddressDecoder()],
+    ["sentinelFlags", getU32Decoder()],
+    ["pad3", fixDecoderSize(getBytesDecoder(), 4)],
+    ["sentinelCalldata", getCalldataBufDecoder2()],
+    ["migratorProgram", getAddressDecoder()],
+    ["migratorInitCalldata", getCalldataBufDecoder2()],
+    ["migratorMigrateCalldata", getCalldataBufDecoder2()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 64)]
+  ]);
+}
+function getLaunchCodec2() {
+  return combineCodec(getLaunchEncoder2(), getLaunchDecoder2());
+}
+function decodeLaunch(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getLaunchDecoder2()
+  );
+}
+async function fetchLaunch(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeLaunch(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeLaunch(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeLaunch(maybeAccount);
+}
+async function fetchAllLaunch(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeLaunch(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeLaunch(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeLaunch(maybeAccount));
+}
+function getLaunchSize() {
+  return 1214;
+}
+var MARKET_DISCRIMINATOR = new Uint8Array([
+  219,
+  190,
+  213,
+  55,
+  0,
+  227,
+  198,
+  154
+]);
+function getMarketDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(MARKET_DISCRIMINATOR);
+}
+function getMarketEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["oracle", getAddressEncoder()],
+      ["quoteMint", getAddressEncoder()],
+      ["potVault", getAddressEncoder()],
+      ["totalPot", getU64Encoder()],
+      ["totalClaimed", getU64Encoder()],
+      ["winnerMint", getAddressEncoder()],
+      ["claimableSupply", getU64Encoder()],
+      ["accQuotePerToken", getU128Encoder()],
+      ["isResolved", getBooleanEncoder()],
+      ["bump", getU8Encoder()],
+      ["marketAuthorityBump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 29)]
+    ]),
+    (value) => ({ ...value, discriminator: MARKET_DISCRIMINATOR })
+  );
+}
+function getMarketDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["oracle", getAddressDecoder()],
+    ["quoteMint", getAddressDecoder()],
+    ["potVault", getAddressDecoder()],
+    ["totalPot", getU64Decoder()],
+    ["totalClaimed", getU64Decoder()],
+    ["winnerMint", getAddressDecoder()],
+    ["claimableSupply", getU64Decoder()],
+    ["accQuotePerToken", getU128Decoder()],
+    ["isResolved", getBooleanDecoder()],
+    ["bump", getU8Decoder()],
+    ["marketAuthorityBump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 29)]
+  ]);
+}
+function getMarketCodec() {
+  return combineCodec(getMarketEncoder(), getMarketDecoder());
+}
+function decodeMarket(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getMarketDecoder()
+  );
+}
+async function fetchMarket(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeMarket(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeMarket(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeMarket(maybeAccount);
+}
+async function fetchAllMarket(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeMarket(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeMarket(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeMarket(maybeAccount));
+}
+function getMarketSize() {
+  return 208;
+}
+var ORACLE_STATE_DISCRIMINATOR = new Uint8Array([
+  97,
+  156,
+  157,
+  189,
+  194,
+  73,
+  8,
+  15
+]);
+function getOracleStateDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    ORACLE_STATE_DISCRIMINATOR
+  );
+}
+function getOracleStateEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["oracleAuthority", getAddressEncoder()],
+      ["quoteMint", getAddressEncoder()],
+      ["isFinalized", getBooleanEncoder()],
+      ["winningMint", getAddressEncoder()],
+      ["nonce", getU64Encoder()],
+      ["bump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 31)]
+    ]),
+    (value) => ({ ...value, discriminator: ORACLE_STATE_DISCRIMINATOR })
+  );
+}
+function getOracleStateDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["oracleAuthority", getAddressDecoder()],
+    ["quoteMint", getAddressDecoder()],
+    ["isFinalized", getBooleanDecoder()],
+    ["winningMint", getAddressDecoder()],
+    ["nonce", getU64Decoder()],
+    ["bump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 31)]
+  ]);
+}
+function getOracleStateCodec() {
+  return combineCodec(getOracleStateEncoder(), getOracleStateDecoder());
+}
+function decodeOracleState2(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getOracleStateDecoder()
+  );
+}
+async function fetchOracleState(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeOracleState(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeOracleState(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeOracleState2(maybeAccount);
+}
+async function fetchAllOracleState(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeOracleState(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeOracleState(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeOracleState2(maybeAccount));
+}
+function getOracleStateSize() {
+  return 145;
+}
+var CLAIM_DISCRIMINATOR = new Uint8Array([
+  62,
+  198,
+  214,
+  193,
+  213,
+  159,
+  108,
+  210
+]);
+function getClaimDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(CLAIM_DISCRIMINATOR);
+}
+function getClaimInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["burnAmount", getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CLAIM_DISCRIMINATOR })
+  );
+}
+function getClaimInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["burnAmount", getU64Decoder()]
+  ]);
+}
+function getClaimInstructionDataCodec() {
+  return combineCodec(
+    getClaimInstructionDataEncoder(),
+    getClaimInstructionDataDecoder()
+  );
+}
+async function getClaimInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    market: { value: input.market ?? null, isWritable: true },
+    marketAuthority: {
+      value: input.marketAuthority ?? null,
+      isWritable: false
+    },
+    potVault: { value: input.potVault ?? null, isWritable: true },
+    winnerMint: { value: input.winnerMint ?? null, isWritable: true },
+    entryByMint: { value: input.entryByMint ?? null, isWritable: false },
+    claimerWinnerAta: {
+      value: input.claimerWinnerAta ?? null,
+      isWritable: true
+    },
+    claimerQuoteAta: { value: input.claimerQuoteAta ?? null, isWritable: true },
+    claimer: { value: input.claimer ?? null, isWritable: false },
+    receipt: { value: input.receipt ?? null, isWritable: true },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.marketAuthority.value) {
+    accounts.marketAuthority.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([
+            109,
+            97,
+            114,
+            107,
+            101,
+            116,
+            95,
+            97,
+            117,
+            116,
+            104,
+            111,
+            114,
+            105,
+            116,
+            121
+          ])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.receipt.value) {
+    accounts.receipt.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([114, 101, 99, 101, 105, 112, 116])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "claimer",
+            accounts.claimer.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("marketAuthority", accounts.marketAuthority),
+      getAccountMeta("potVault", accounts.potVault),
+      getAccountMeta("winnerMint", accounts.winnerMint),
+      getAccountMeta("entryByMint", accounts.entryByMint),
+      getAccountMeta("claimerWinnerAta", accounts.claimerWinnerAta),
+      getAccountMeta("claimerQuoteAta", accounts.claimerQuoteAta),
+      getAccountMeta("claimer", accounts.claimer),
+      getAccountMeta("receipt", accounts.receipt),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getClaimInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getClaimInstruction(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    market: { value: input.market ?? null, isWritable: true },
+    marketAuthority: {
+      value: input.marketAuthority ?? null,
+      isWritable: false
+    },
+    potVault: { value: input.potVault ?? null, isWritable: true },
+    winnerMint: { value: input.winnerMint ?? null, isWritable: true },
+    entryByMint: { value: input.entryByMint ?? null, isWritable: false },
+    claimerWinnerAta: {
+      value: input.claimerWinnerAta ?? null,
+      isWritable: true
+    },
+    claimerQuoteAta: { value: input.claimerQuoteAta ?? null, isWritable: true },
+    claimer: { value: input.claimer ?? null, isWritable: false },
+    receipt: { value: input.receipt ?? null, isWritable: true },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("marketAuthority", accounts.marketAuthority),
+      getAccountMeta("potVault", accounts.potVault),
+      getAccountMeta("winnerMint", accounts.winnerMint),
+      getAccountMeta("entryByMint", accounts.entryByMint),
+      getAccountMeta("claimerWinnerAta", accounts.claimerWinnerAta),
+      getAccountMeta("claimerQuoteAta", accounts.claimerQuoteAta),
+      getAccountMeta("claimer", accounts.claimer),
+      getAccountMeta("receipt", accounts.receipt),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getClaimInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseClaimInstruction(instruction) {
+  if (instruction.accounts.length < 12) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 12
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      market: getNextAccount(),
+      marketAuthority: getNextAccount(),
+      potVault: getNextAccount(),
+      winnerMint: getNextAccount(),
+      entryByMint: getNextAccount(),
+      claimerWinnerAta: getNextAccount(),
+      claimerQuoteAta: getNextAccount(),
+      claimer: getNextAccount(),
+      receipt: getNextAccount(),
+      payer: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getClaimInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var MIGRATE_ENTRY_DISCRIMINATOR = new Uint8Array([
+  239,
+  154,
+  55,
+  173,
+  110,
+  36,
+  188,
+  214
+]);
+function getMigrateEntryDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    MIGRATE_ENTRY_DISCRIMINATOR
+  );
+}
+function getMigrateEntryInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["entryId", fixEncoderSize(getBytesEncoder(), 32)]
+    ]),
+    (value) => ({ ...value, discriminator: MIGRATE_ENTRY_DISCRIMINATOR })
+  );
+}
+function getMigrateEntryInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["entryId", fixDecoderSize(getBytesDecoder(), 32)]
+  ]);
+}
+function getMigrateEntryInstructionDataCodec() {
+  return combineCodec(
+    getMigrateEntryInstructionDataEncoder(),
+    getMigrateEntryInstructionDataDecoder()
+  );
+}
+async function getMigrateEntryInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    initializerConfig: {
+      value: input.initializerConfig ?? null,
+      isWritable: false
+    },
+    launch: { value: input.launch ?? null, isWritable: false },
+    launchAuthority: {
+      value: input.launchAuthority ?? null,
+      isWritable: false
+    },
+    baseMint: { value: input.baseMint ?? null, isWritable: true },
+    quoteMint: { value: input.quoteMint ?? null, isWritable: false },
+    baseVault: { value: input.baseVault ?? null, isWritable: true },
+    quoteVault: { value: input.quoteVault ?? null, isWritable: true },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rent: { value: input.rent ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: true },
+    potVault: { value: input.potVault ?? null, isWritable: true },
+    marketAuthority: {
+      value: input.marketAuthority ?? null,
+      isWritable: false
+    },
+    entry: { value: input.entry ?? null, isWritable: true },
+    entryByMint: { value: input.entryByMint ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rent.value) {
+    accounts.rent.value = "SysvarRent111111111111111111111111111111111";
+  }
+  if (!accounts.market.value) {
+    accounts.market.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(new Uint8Array([109, 97, 114, 107, 101, 116])),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.marketAuthority.value) {
+    accounts.marketAuthority.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([
+            109,
+            97,
+            114,
+            107,
+            101,
+            116,
+            95,
+            97,
+            117,
+            116,
+            104,
+            111,
+            114,
+            105,
+            116,
+            121
+          ])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.entryByMint.value) {
+    accounts.entryByMint.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([
+            101,
+            110,
+            116,
+            114,
+            121,
+            95,
+            98,
+            121,
+            95,
+            109,
+            105,
+            110,
+            116
+          ])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "baseMint",
+            accounts.baseMint.value
+          )
+        )
+      ]
+    });
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("initializerConfig", accounts.initializerConfig),
+      getAccountMeta("launch", accounts.launch),
+      getAccountMeta("launchAuthority", accounts.launchAuthority),
+      getAccountMeta("baseMint", accounts.baseMint),
+      getAccountMeta("quoteMint", accounts.quoteMint),
+      getAccountMeta("baseVault", accounts.baseVault),
+      getAccountMeta("quoteVault", accounts.quoteVault),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("rent", accounts.rent),
+      getAccountMeta("oracle", accounts.oracle),
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("potVault", accounts.potVault),
+      getAccountMeta("marketAuthority", accounts.marketAuthority),
+      getAccountMeta("entry", accounts.entry),
+      getAccountMeta("entryByMint", accounts.entryByMint)
+    ],
+    data: getMigrateEntryInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getMigrateEntryInstruction(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    initializerConfig: {
+      value: input.initializerConfig ?? null,
+      isWritable: false
+    },
+    launch: { value: input.launch ?? null, isWritable: false },
+    launchAuthority: {
+      value: input.launchAuthority ?? null,
+      isWritable: false
+    },
+    baseMint: { value: input.baseMint ?? null, isWritable: true },
+    quoteMint: { value: input.quoteMint ?? null, isWritable: false },
+    baseVault: { value: input.baseVault ?? null, isWritable: true },
+    quoteVault: { value: input.quoteVault ?? null, isWritable: true },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rent: { value: input.rent ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: true },
+    potVault: { value: input.potVault ?? null, isWritable: true },
+    marketAuthority: {
+      value: input.marketAuthority ?? null,
+      isWritable: false
+    },
+    entry: { value: input.entry ?? null, isWritable: true },
+    entryByMint: { value: input.entryByMint ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rent.value) {
+    accounts.rent.value = "SysvarRent111111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("initializerConfig", accounts.initializerConfig),
+      getAccountMeta("launch", accounts.launch),
+      getAccountMeta("launchAuthority", accounts.launchAuthority),
+      getAccountMeta("baseMint", accounts.baseMint),
+      getAccountMeta("quoteMint", accounts.quoteMint),
+      getAccountMeta("baseVault", accounts.baseVault),
+      getAccountMeta("quoteVault", accounts.quoteVault),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("rent", accounts.rent),
+      getAccountMeta("oracle", accounts.oracle),
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("potVault", accounts.potVault),
+      getAccountMeta("marketAuthority", accounts.marketAuthority),
+      getAccountMeta("entry", accounts.entry),
+      getAccountMeta("entryByMint", accounts.entryByMint)
+    ],
+    data: getMigrateEntryInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseMigrateEntryInstruction(instruction) {
+  if (instruction.accounts.length < 17) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 17
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      initializerConfig: getNextAccount(),
+      launch: getNextAccount(),
+      launchAuthority: getNextAccount(),
+      baseMint: getNextAccount(),
+      quoteMint: getNextAccount(),
+      baseVault: getNextAccount(),
+      quoteVault: getNextAccount(),
+      payer: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount(),
+      rent: getNextAccount(),
+      oracle: getNextAccount(),
+      market: getNextAccount(),
+      potVault: getNextAccount(),
+      marketAuthority: getNextAccount(),
+      entry: getNextAccount(),
+      entryByMint: getNextAccount()
+    },
+    data: getMigrateEntryInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR = new Uint8Array([
+  228,
+  144,
+  72,
+  185,
+  234,
+  186,
+  183,
+  143
+]);
+function getPreviewPayoutIfWinnerDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR
+  );
+}
+function getPreviewPayoutIfWinnerInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["candidateWinnerMint", getAddressEncoder()],
+      ["tokenAmount", getU64Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR
+    })
+  );
+}
+function getPreviewPayoutIfWinnerInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["candidateWinnerMint", getAddressDecoder()],
+    ["tokenAmount", getU64Decoder()]
+  ]);
+}
+function getPreviewPayoutIfWinnerInstructionDataCodec() {
+  return combineCodec(
+    getPreviewPayoutIfWinnerInstructionDataEncoder(),
+    getPreviewPayoutIfWinnerInstructionDataDecoder()
+  );
+}
+function getPreviewPayoutIfWinnerInstruction(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    market: { value: input.market ?? null, isWritable: false },
+    candidateMint: { value: input.candidateMint ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("candidateMint", accounts.candidateMint)
+    ],
+    data: getPreviewPayoutIfWinnerInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parsePreviewPayoutIfWinnerInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: { market: getNextAccount(), candidateMint: getNextAccount() },
+    data: getPreviewPayoutIfWinnerInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+var REGISTER_ENTRY_DISCRIMINATOR = new Uint8Array([
+  198,
+  25,
+  1,
+  183,
+  73,
+  219,
+  215,
+  14
+]);
+function getRegisterEntryDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    REGISTER_ENTRY_DISCRIMINATOR
+  );
+}
+function getRegisterEntryInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["entryId", fixEncoderSize(getBytesEncoder(), 32)]
+    ]),
+    (value) => ({ ...value, discriminator: REGISTER_ENTRY_DISCRIMINATOR })
+  );
+}
+function getRegisterEntryInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["entryId", fixDecoderSize(getBytesDecoder(), 32)]
+  ]);
+}
+function getRegisterEntryInstructionDataCodec() {
+  return combineCodec(
+    getRegisterEntryInstructionDataEncoder(),
+    getRegisterEntryInstructionDataDecoder()
+  );
+}
+async function getRegisterEntryInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    initializerConfig: {
+      value: input.initializerConfig ?? null,
+      isWritable: false
+    },
+    launch: { value: input.launch ?? null, isWritable: false },
+    launchAuthority: {
+      value: input.launchAuthority ?? null,
+      isWritable: false
+    },
+    baseMint: { value: input.baseMint ?? null, isWritable: false },
+    quoteMint: { value: input.quoteMint ?? null, isWritable: false },
+    baseVault: { value: input.baseVault ?? null, isWritable: false },
+    quoteVault: { value: input.quoteVault ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rent: { value: input.rent ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: true },
+    potVault: { value: input.potVault ?? null, isWritable: true },
+    marketAuthority: {
+      value: input.marketAuthority ?? null,
+      isWritable: false
+    },
+    entry: { value: input.entry ?? null, isWritable: true },
+    entryByMint: { value: input.entryByMint ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rent.value) {
+    accounts.rent.value = "SysvarRent111111111111111111111111111111111";
+  }
+  if (!accounts.market.value) {
+    accounts.market.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(new Uint8Array([109, 97, 114, 107, 101, 116])),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.potVault.value) {
+    accounts.potVault.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([112, 111, 116, 95, 118, 97, 117, 108, 116])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.marketAuthority.value) {
+    accounts.marketAuthority.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([
+            109,
+            97,
+            114,
+            107,
+            101,
+            116,
+            95,
+            97,
+            117,
+            116,
+            104,
+            111,
+            114,
+            105,
+            116,
+            121
+          ])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.entryByMint.value) {
+    accounts.entryByMint.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder().encode(
+          new Uint8Array([
+            101,
+            110,
+            116,
+            114,
+            121,
+            95,
+            98,
+            121,
+            95,
+            109,
+            105,
+            110,
+            116
+          ])
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        ),
+        getAddressEncoder().encode(
+          getAddressFromResolvedInstructionAccount(
+            "baseMint",
+            accounts.baseMint.value
+          )
+        )
+      ]
+    });
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("initializerConfig", accounts.initializerConfig),
+      getAccountMeta("launch", accounts.launch),
+      getAccountMeta("launchAuthority", accounts.launchAuthority),
+      getAccountMeta("baseMint", accounts.baseMint),
+      getAccountMeta("quoteMint", accounts.quoteMint),
+      getAccountMeta("baseVault", accounts.baseVault),
+      getAccountMeta("quoteVault", accounts.quoteVault),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("rent", accounts.rent),
+      getAccountMeta("oracle", accounts.oracle),
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("potVault", accounts.potVault),
+      getAccountMeta("marketAuthority", accounts.marketAuthority),
+      getAccountMeta("entry", accounts.entry),
+      getAccountMeta("entryByMint", accounts.entryByMint)
+    ],
+    data: getRegisterEntryInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getRegisterEntryInstruction(input, config) {
+  const programAddress = config?.programAddress ?? PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    initializerConfig: {
+      value: input.initializerConfig ?? null,
+      isWritable: false
+    },
+    launch: { value: input.launch ?? null, isWritable: false },
+    launchAuthority: {
+      value: input.launchAuthority ?? null,
+      isWritable: false
+    },
+    baseMint: { value: input.baseMint ?? null, isWritable: false },
+    quoteMint: { value: input.quoteMint ?? null, isWritable: false },
+    baseVault: { value: input.baseVault ?? null, isWritable: false },
+    quoteVault: { value: input.quoteVault ?? null, isWritable: false },
+    payer: { value: input.payer ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    rent: { value: input.rent ?? null, isWritable: false },
+    oracle: { value: input.oracle ?? null, isWritable: false },
+    market: { value: input.market ?? null, isWritable: true },
+    potVault: { value: input.potVault ?? null, isWritable: true },
+    marketAuthority: {
+      value: input.marketAuthority ?? null,
+      isWritable: false
+    },
+    entry: { value: input.entry ?? null, isWritable: true },
+    entryByMint: { value: input.entryByMint ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.rent.value) {
+    accounts.rent.value = "SysvarRent111111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("initializerConfig", accounts.initializerConfig),
+      getAccountMeta("launch", accounts.launch),
+      getAccountMeta("launchAuthority", accounts.launchAuthority),
+      getAccountMeta("baseMint", accounts.baseMint),
+      getAccountMeta("quoteMint", accounts.quoteMint),
+      getAccountMeta("baseVault", accounts.baseVault),
+      getAccountMeta("quoteVault", accounts.quoteVault),
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+      getAccountMeta("systemProgram", accounts.systemProgram),
+      getAccountMeta("rent", accounts.rent),
+      getAccountMeta("oracle", accounts.oracle),
+      getAccountMeta("market", accounts.market),
+      getAccountMeta("potVault", accounts.potVault),
+      getAccountMeta("marketAuthority", accounts.marketAuthority),
+      getAccountMeta("entry", accounts.entry),
+      getAccountMeta("entryByMint", accounts.entryByMint)
+    ],
+    data: getRegisterEntryInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseRegisterEntryInstruction(instruction) {
+  if (instruction.accounts.length < 17) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 17
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      initializerConfig: getNextAccount(),
+      launch: getNextAccount(),
+      launchAuthority: getNextAccount(),
+      baseMint: getNextAccount(),
+      quoteMint: getNextAccount(),
+      baseVault: getNextAccount(),
+      quoteVault: getNextAccount(),
+      payer: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount(),
+      rent: getNextAccount(),
+      oracle: getNextAccount(),
+      market: getNextAccount(),
+      potVault: getNextAccount(),
+      marketAuthority: getNextAccount(),
+      entry: getNextAccount(),
+      entryByMint: getNextAccount()
+    },
+    data: getRegisterEntryInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/solana/generated/predictionMigrator/programs/predictionMigrator.ts
+var PREDICTION_MIGRATOR_PROGRAM_ADDRESS = "HYHdyy7QZg8Ucky9Z97xNtSCvrZxVNkeoney8xEPXjiZ";
+var PredictionMigratorAccount = /* @__PURE__ */ ((PredictionMigratorAccount2) => {
+  PredictionMigratorAccount2[PredictionMigratorAccount2["ClaimReceipt"] = 0] = "ClaimReceipt";
+  PredictionMigratorAccount2[PredictionMigratorAccount2["Entry"] = 1] = "Entry";
+  PredictionMigratorAccount2[PredictionMigratorAccount2["EntryByMint"] = 2] = "EntryByMint";
+  PredictionMigratorAccount2[PredictionMigratorAccount2["Launch"] = 3] = "Launch";
+  PredictionMigratorAccount2[PredictionMigratorAccount2["Market"] = 4] = "Market";
+  PredictionMigratorAccount2[PredictionMigratorAccount2["OracleState"] = 5] = "OracleState";
+  return PredictionMigratorAccount2;
+})(PredictionMigratorAccount || {});
+function identifyPredictionMigratorAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([223, 233, 11, 229, 124, 165, 207, 28])
+    ),
+    0
+  )) {
+    return 0 /* ClaimReceipt */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([63, 18, 152, 113, 215, 246, 221, 250])
+    ),
+    0
+  )) {
+    return 1 /* Entry */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([188, 191, 157, 194, 68, 82, 181, 126])
+    ),
+    0
+  )) {
+    return 2 /* EntryByMint */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([144, 51, 51, 163, 206, 85, 213, 38])
+    ),
+    0
+  )) {
+    return 3 /* Launch */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([219, 190, 213, 55, 0, 227, 198, 154])
+    ),
+    0
+  )) {
+    return 4 /* Market */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([97, 156, 157, 189, 194, 73, 8, 15])
+    ),
+    0
+  )) {
+    return 5 /* OracleState */;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
+    { accountData: data, programName: "predictionMigrator" }
+  );
+}
+var PredictionMigratorInstruction = /* @__PURE__ */ ((PredictionMigratorInstruction2) => {
+  PredictionMigratorInstruction2[PredictionMigratorInstruction2["Claim"] = 0] = "Claim";
+  PredictionMigratorInstruction2[PredictionMigratorInstruction2["MigrateEntry"] = 1] = "MigrateEntry";
+  PredictionMigratorInstruction2[PredictionMigratorInstruction2["PreviewPayoutIfWinner"] = 2] = "PreviewPayoutIfWinner";
+  PredictionMigratorInstruction2[PredictionMigratorInstruction2["RegisterEntry"] = 3] = "RegisterEntry";
+  return PredictionMigratorInstruction2;
+})(PredictionMigratorInstruction || {});
+function identifyPredictionMigratorInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([62, 198, 214, 193, 213, 159, 108, 210])
+    ),
+    0
+  )) {
+    return 0 /* Claim */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([239, 154, 55, 173, 110, 36, 188, 214])
+    ),
+    0
+  )) {
+    return 1 /* MigrateEntry */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([228, 144, 72, 185, 234, 186, 183, 143])
+    ),
+    0
+  )) {
+    return 2 /* PreviewPayoutIfWinner */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([198, 25, 1, 183, 73, 219, 215, 14])
+    ),
+    0
+  )) {
+    return 3 /* RegisterEntry */;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "predictionMigrator" }
+  );
+}
+function parsePredictionMigratorInstruction(instruction) {
+  const instructionType = identifyPredictionMigratorInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* Claim */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 0 /* Claim */,
+        ...parseClaimInstruction(instruction)
+      };
+    }
+    case 1 /* MigrateEntry */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 1 /* MigrateEntry */,
+        ...parseMigrateEntryInstruction(instruction)
+      };
+    }
+    case 2 /* PreviewPayoutIfWinner */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 2 /* PreviewPayoutIfWinner */,
+        ...parsePreviewPayoutIfWinnerInstruction(instruction)
+      };
+    }
+    case 3 /* RegisterEntry */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 3 /* RegisterEntry */,
+        ...parseRegisterEntryInstruction(instruction)
+      };
+    }
+    default:
+      throw new SolanaError(
+        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType,
+          programName: "predictionMigrator"
+        }
+      );
+  }
+}
+function predictionMigratorProgram() {
+  return (client) => {
+    return {
+      ...client,
+      predictionMigrator: {
+        accounts: {
+          claimReceipt: addSelfFetchFunctions(client, getClaimReceiptCodec()),
+          entry: addSelfFetchFunctions(client, getEntryCodec()),
+          entryByMint: addSelfFetchFunctions(client, getEntryByMintCodec()),
+          launch: addSelfFetchFunctions(client, getLaunchCodec2()),
+          market: addSelfFetchFunctions(client, getMarketCodec()),
+          oracleState: addSelfFetchFunctions(client, getOracleStateCodec())
+        },
+        instructions: {
+          claim: (input) => addSelfPlanAndSendFunctions(
+            client,
+            getClaimInstructionAsync({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          ),
+          migrateEntry: (input) => addSelfPlanAndSendFunctions(
+            client,
+            getMigrateEntryInstructionAsync({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          ),
+          previewPayoutIfWinner: (input) => addSelfPlanAndSendFunctions(
+            client,
+            getPreviewPayoutIfWinnerInstruction(input)
+          ),
+          registerEntry: (input) => addSelfPlanAndSendFunctions(
+            client,
+            getRegisterEntryInstructionAsync({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          )
+        }
+      }
+    };
+  };
+}
+var addressCodec4 = getAddressCodec();
+var textEncoder4 = new TextEncoder();
+async function getPredictionMarketAddress(oracleState, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder4.encode("market"), addressCodec4.encode(oracleState)]
+  });
+}
+async function getPredictionMarketAuthorityAddress(market, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder4.encode("market_authority"),
+      addressCodec4.encode(market)
+    ]
+  });
+}
+async function getPredictionPotVaultAddress(market, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder4.encode("pot_vault"), addressCodec4.encode(market)]
+  });
+}
+async function getPredictionEntryAddress(oracleState, entryId, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder4.encode("entry"),
+      addressCodec4.encode(oracleState),
+      entryId
+    ]
+  });
+}
+async function getPredictionEntryByMintAddress(oracleState, mint, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder4.encode("entry_by_mint"),
+      addressCodec4.encode(oracleState),
+      addressCodec4.encode(mint)
+    ]
+  });
+}
+
+// src/solana/initializer/instructions/initializeLaunch.ts
+function isTransactionSigner5(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createAccountMeta(value, role) {
+  if (isTransactionSigner5(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+async function getTokenMetadataAddress(mint) {
+  const encoder = getAddressEncoder();
+  const [metadataAddress] = await getProgramDerivedAddress({
+    programAddress: TOKEN_METADATA_PROGRAM_ID,
+    seeds: [
+      new TextEncoder().encode("metadata"),
+      encoder.encode(TOKEN_METADATA_PROGRAM_ID),
+      encoder.encode(mint)
+    ]
+  });
+  return metadataAddress;
+}
+var ALT_INDEX = {
+  [TOKEN_PROGRAM_ADDRESS]: 0,
+  [SYSTEM_PROGRAM_ADDRESS]: 1,
+  SysvarRent111111111111111111111111111111111: 2,
+  [INITIALIZER_PROGRAM_ID]: 3,
+  [TOKEN_METADATA_PROGRAM_ID]: 4,
+  [CPMM_MIGRATOR_PROGRAM_ID]: 5,
+  So11111111111111111111111111111111111111112: 6,
+  // index 7 = config PDA — resolved at call time from accounts.config
+  [PREDICTION_MIGRATOR_PROGRAM_ADDRESS]: 8
+};
+function validateInitializeLaunchCurveParams(args) {
+  if (args.curveKind !== CURVE_KIND_XYK) {
+    throw new Error(
+      `unsupported curve kind: ${args.curveKind}; only CURVE_KIND_XYK is currently enabled`
+    );
+  }
+  if (args.curveParams.length !== 1 || args.curveParams[0] !== CURVE_PARAMS_FORMAT_XYK_V0) {
+    throw new Error("xyk curve params must be [CURVE_PARAMS_FORMAT_XYK_V0]");
+  }
+}
+async function createInitializeLaunchInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
+  validateInitializeLaunchCurveParams(args);
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseMint,
+    quoteMint,
+    baseVault,
+    quoteVault,
+    payer,
+    authority,
+    migratorProgram,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS,
+    systemProgram = SYSTEM_PROGRAM_ADDRESS,
+    rent,
+    metadataAccount,
+    addressLookupTable: alt
+  } = accounts;
+  const withMetadata = Boolean(
+    args.metadataName && args.metadataName.length > 0
+  );
+  if (withMetadata && !metadataAccount) {
+    throw new Error(
+      "metadataName is set but metadataAccount was not provided. Derive it with await initializer.getTokenMetadataAddress(baseMintAddress)."
+    );
+  }
+  const altIndexMap = alt ? { ...ALT_INDEX, [config]: 7 } : {};
+  function staticOrLookup(addr, role) {
+    if (alt && altIndexMap[addr] !== void 0) {
+      return {
+        address: addr,
+        role,
+        lookupTableAddress: alt,
+        addressIndex: altIndexMap[addr]
+      };
+    }
+    return { address: addr, role };
+  }
+  const keys = [
+    staticOrLookup(config, AccountRole.READONLY),
+    { address: launch, role: AccountRole.WRITABLE },
+    { address: launchAuthority, role: AccountRole.READONLY },
+    createAccountMeta(baseMint, AccountRole.WRITABLE_SIGNER),
+    staticOrLookup(quoteMint, AccountRole.READONLY),
+    createAccountMeta(baseVault, AccountRole.WRITABLE_SIGNER),
+    createAccountMeta(quoteVault, AccountRole.WRITABLE_SIGNER),
+    createAccountMeta(payer, AccountRole.WRITABLE_SIGNER)
+  ];
+  if (authority) {
+    keys.push(createAccountMeta(authority, AccountRole.READONLY_SIGNER));
+  }
+  if (migratorProgram) {
+    keys.push(staticOrLookup(migratorProgram, AccountRole.READONLY));
+  }
+  keys.push(staticOrLookup(tokenProgram, AccountRole.READONLY));
+  keys.push(staticOrLookup(systemProgram, AccountRole.READONLY));
+  keys.push(staticOrLookup(rent, AccountRole.READONLY));
+  if (withMetadata) {
+    keys.push({ address: metadataAccount, role: AccountRole.WRITABLE });
+    keys.push(staticOrLookup(TOKEN_METADATA_PROGRAM_ID, AccountRole.READONLY));
+  }
+  const encoderArgs = {
+    ...args,
+    allowBuy: args.allowBuy ? 1 : 0,
+    allowSell: args.allowSell ? 1 : 0,
+    migratorProgram: migratorProgram ?? SYSTEM_PROGRAM_ADDRESS
+  };
+  const data = new Uint8Array(
+    getInitializeLaunchInstructionDataEncoder().encode(encoderArgs)
+  );
+  if (migratorProgram === CPMM_MIGRATOR_PROGRAM_ID) {
+    const [cpmmMigratorState] = await getCpmmMigratorStateAddress(launch);
+    keys.push({ address: cpmmMigratorState, role: AccountRole.WRITABLE });
+  }
+  if (migratorProgram === PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+    const oracleState = args.namespace;
+    const entryId = args.launchId;
+    const baseMintAddress = isTransactionSigner5(baseMint) ? baseMint.address : baseMint;
+    const [market] = await getPredictionMarketAddress(oracleState);
+    const [potVault] = await getPredictionPotVaultAddress(market);
+    const [marketAuthority] = await getPredictionMarketAuthorityAddress(market);
+    const [entry] = await getPredictionEntryAddress(oracleState, entryId);
+    const [entryByMint] = await getPredictionEntryByMintAddress(
+      oracleState,
+      baseMintAddress
+    );
+    keys.push({ address: oracleState, role: AccountRole.READONLY });
+    keys.push({ address: market, role: AccountRole.WRITABLE });
+    keys.push({ address: potVault, role: AccountRole.WRITABLE });
+    keys.push({ address: marketAuthority, role: AccountRole.READONLY });
+    keys.push({ address: entry, role: AccountRole.WRITABLE });
+    keys.push({ address: entryByMint, role: AccountRole.WRITABLE });
+  }
+  return { programAddress: programId, accounts: keys, data };
+}
+function isTransactionSigner6(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createAccountMeta2(value, role) {
+  if (isTransactionSigner6(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createCurveSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseVault,
+    quoteVault,
+    userBaseAccount,
+    userQuoteAccount,
+    baseMint,
+    quoteMint,
+    user,
+    sentinelProgram = SYSTEM_PROGRAM_ADDRESS,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: AccountRole.READONLY },
+    { address: launch, role: AccountRole.WRITABLE },
+    { address: launchAuthority, role: AccountRole.READONLY },
+    { address: baseVault, role: AccountRole.WRITABLE },
+    { address: quoteVault, role: AccountRole.WRITABLE },
+    { address: userBaseAccount, role: AccountRole.WRITABLE },
+    { address: userQuoteAccount, role: AccountRole.WRITABLE },
+    { address: baseMint, role: AccountRole.READONLY },
+    { address: quoteMint, role: AccountRole.READONLY },
+    createAccountMeta2(user, AccountRole.READONLY_SIGNER),
+    // sentinel_program is Optional in the on-chain struct but still occupies a fixed
+    // slot (token_program follows it).  Always emit it — use SYSTEM_PROGRAM_ADDRESS as the
+    // no-op placeholder when no real sentinel is configured.
+    { address: sentinelProgram, role: AccountRole.READONLY },
+    { address: tokenProgram, role: AccountRole.READONLY }
+  ];
+  const data = new Uint8Array(
+    getCurveSwapExactInInstructionDataEncoder().encode(args)
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+function isTransactionSigner7(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createSignerAccountMeta5(value, role) {
+  if (isTransactionSigner7(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createMigrateLaunchInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseMint,
+    quoteMint,
+    baseVault,
+    quoteVault,
+    migratorProgram,
+    payer,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS,
+    systemProgram = SYSTEM_PROGRAM_ADDRESS,
+    rent
+  } = accounts;
+  const keys = [
+    { address: config, role: AccountRole.READONLY },
+    { address: launch, role: AccountRole.WRITABLE },
+    { address: launchAuthority, role: AccountRole.READONLY },
+    { address: baseMint, role: AccountRole.READONLY },
+    { address: quoteMint, role: AccountRole.READONLY },
+    { address: baseVault, role: AccountRole.WRITABLE },
+    { address: quoteVault, role: AccountRole.WRITABLE },
+    { address: migratorProgram, role: AccountRole.READONLY },
+    createSignerAccountMeta5(payer, AccountRole.WRITABLE_SIGNER),
+    { address: tokenProgram, role: AccountRole.READONLY },
+    { address: systemProgram, role: AccountRole.READONLY },
+    { address: rent, role: AccountRole.READONLY }
+  ];
+  const data = encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.migrateLaunch
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+function isTransactionSigner8(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createAccountMeta3(value, role) {
+  if (isTransactionSigner8(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createAbortLaunchInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseVault,
+    quoteVault,
+    authority,
+    authorityBaseAccount,
+    baseMint,
+    tokenProgram = TOKEN_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: AccountRole.READONLY },
+    { address: launch, role: AccountRole.WRITABLE },
+    { address: launchAuthority, role: AccountRole.READONLY },
+    { address: baseVault, role: AccountRole.WRITABLE },
+    { address: quoteVault, role: AccountRole.READONLY },
+    createAccountMeta3(authority, AccountRole.READONLY_SIGNER),
+    { address: authorityBaseAccount, role: AccountRole.WRITABLE },
+    { address: baseMint, role: AccountRole.READONLY },
+    { address: tokenProgram, role: AccountRole.READONLY }
+  ];
+  const data = encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.abortLaunch
+  );
+  return { programAddress: programId, accounts: keys, data };
 }
 var previewSwapExactInResultCodec = getStructCodec([
   ["amountOut", getU64Codec()],
@@ -1976,11 +3967,11 @@ var previewSwapExactInResultCodec = getStructCodec([
 function createPreviewSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
   const { launch, baseVault, quoteVault, sentinelProgram } = accounts;
   const keys = [
-    { address: launch, role: ACCOUNT_ROLE_READONLY },
-    { address: baseVault, role: ACCOUNT_ROLE_READONLY },
-    { address: quoteVault, role: ACCOUNT_ROLE_READONLY }
+    { address: launch, role: AccountRole.READONLY },
+    { address: baseVault, role: AccountRole.READONLY },
+    { address: quoteVault, role: AccountRole.READONLY }
   ];
-  const accountsList = sentinelProgram ? [...keys, { address: sentinelProgram, role: ACCOUNT_ROLE_READONLY }] : keys;
+  const accountsList = sentinelProgram ? [...keys, { address: sentinelProgram, role: AccountRole.READONLY }] : keys;
   const data = new Uint8Array(
     getPreviewSwapExactInInstructionDataEncoder().encode(args)
   );
@@ -1997,10 +3988,10 @@ var previewMigrationResultCodec = getStructCodec([
 function createPreviewMigrationInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
   const { launch, baseMint, baseVault, quoteVault } = accounts;
   const keys = [
-    { address: launch, role: ACCOUNT_ROLE_READONLY },
-    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
-    { address: baseVault, role: ACCOUNT_ROLE_READONLY },
-    { address: quoteVault, role: ACCOUNT_ROLE_READONLY }
+    { address: launch, role: AccountRole.READONLY },
+    { address: baseMint, role: AccountRole.READONLY },
+    { address: baseVault, role: AccountRole.READONLY },
+    { address: quoteVault, role: AccountRole.READONLY }
   ];
   const data = encodeInstructionData(
     INITIALIZER_INSTRUCTION_DISCRIMINATORS.previewMigration
@@ -2010,7 +4001,28 @@ function createPreviewMigrationInstruction(accounts, programId = INITIALIZER_PRO
 function decodePreviewMigrationResult(data) {
   return previewMigrationResultCodec.decode(data);
 }
-var addressCodec3 = getAddressCodec();
+function computeRemainingAccountsHash(addresses) {
+  const addressEncoder = getAddressEncoder();
+  const buf = new Uint8Array(4 + addresses.length * 32);
+  new DataView(buf.buffer).setUint32(0, addresses.length, true);
+  for (let i = 0; i < addresses.length; i++) {
+    buf.set(addressEncoder.encode(addresses[i]), 4 + i * 32);
+  }
+  return keccak_256(buf);
+}
+function phaseLabel(phase) {
+  switch (phase) {
+    case PHASE_TRADING:
+      return "TRADING";
+    case PHASE_MIGRATED:
+      return "MIGRATED";
+    case PHASE_ABORTED:
+      return "ABORTED";
+    default:
+      return String(phase);
+  }
+}
+var addressCodec5 = getAddressCodec();
 function bytesToBase64(bytes) {
   let binary = "";
   for (let i = 0; i < bytes.length; i++) {
@@ -2026,7 +4038,7 @@ function base64ToBytes2(base64) {
   }
   return bytes;
 }
-async function fetchLaunch(rpc, address3, config) {
+async function fetchLaunch2(rpc, address3, config) {
   const response = await rpc.getAccountInfo(address3, {
     encoding: "base64",
     commitment: config?.commitment
@@ -2080,7 +4092,7 @@ async function fetchLaunchesByAuthority(rpc, authority, config) {
     memcmp: {
       offset: 8n,
       bytes: bytesToBase64(
-        addressCodec3.encode(authority)
+        addressCodec5.encode(authority)
       ),
       encoding: "base64"
     }
@@ -2110,7 +4122,7 @@ async function launchExists(rpc, namespace, launchId, config) {
     launchId,
     programId
   );
-  const launch = await fetchLaunch(rpc, launchAddress, config);
+  const launch = await fetchLaunch2(rpc, launchAddress, config);
   return launch !== null;
 }
 
@@ -2251,14 +4263,6 @@ function getCpmmMigratorStateCodec() {
   );
 }
 if (process.env.NODE_ENV !== "production") ;
-var addressCodec4 = getAddressCodec();
-var textEncoder3 = new TextEncoder();
-async function getCpmmMigratorStateAddress(launch, programId = CPMM_MIGRATOR_PROGRAM_ID) {
-  return getProgramDerivedAddress({
-    programAddress: programId,
-    seeds: [textEncoder3.encode(SEED_STATE), addressCodec4.encode(launch)]
-  });
-}
 
 // src/solana/migrators/cpmmMigrator/client.ts
 function base64ToBytes3(base64) {
@@ -2293,6 +4297,679 @@ function encodeMigrateCalldata(args) {
   ]);
 }
 
-export { CPMM_ERROR_MESSAGES, CpmmError, CpmmErrorCode, cpmmMigrator_exports as cpmmMigrator, createAddLiquidityInstruction, createClosePositionInstruction, createCollectProtocolFeesInstruction, createCreatePositionInstruction, createInitializeConfigInstruction, createInitializeOracleInstruction, createInitializePoolInstruction, createOracleConsultInstruction, createOracleUpdateInstruction, createPauseInstruction, createQuoteToNumeraireInstruction, createRemoveLiquidityInstruction, createSetFeesInstruction, createSetRouteInstruction, createSetSentinelInstruction, createSkimInstruction, createSwapExactInInstruction, createSwapInstruction, createTransferAdminInstruction, createUnpauseInstruction, curveParamsToMarketCap, decodeOracleConsultResult, decodeQuoteToNumeraireResult, fetchConfig, fetchConfigWithAddress, getErrorMessage, getMetadataAddress, initializer_exports as initializer, isCpmmError, marketCapToCurveParams, marketCapToSingleCurveParams, marketCapToTokenPrice, parseErrorFromLogs, validateMarketCapParameters };
+// src/solana/migrators/predictionMigrator/index.ts
+var predictionMigrator_exports = {};
+__export(predictionMigrator_exports, {
+  CLAIM_DISCRIMINATOR: () => CLAIM_DISCRIMINATOR,
+  CLAIM_RECEIPT_DISCRIMINATOR: () => CLAIM_RECEIPT_DISCRIMINATOR,
+  ENTRY_BY_MINT_DISCRIMINATOR: () => ENTRY_BY_MINT_DISCRIMINATOR,
+  ENTRY_DISCRIMINATOR: () => ENTRY_DISCRIMINATOR,
+  LAUNCH_DISCRIMINATOR: () => LAUNCH_DISCRIMINATOR2,
+  MARKET_DISCRIMINATOR: () => MARKET_DISCRIMINATOR,
+  MIGRATE_ENTRY_DISCRIMINATOR: () => MIGRATE_ENTRY_DISCRIMINATOR,
+  ORACLE_STATE_DISCRIMINATOR: () => ORACLE_STATE_DISCRIMINATOR,
+  PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED: () => PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED,
+  PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED: () => PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED,
+  PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED: () => PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED,
+  PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED: () => PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED,
+  PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE: () => PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE,
+  PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID: () => PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID,
+  PREDICTION_MIGRATOR_ERROR__INVALID_INPUT: () => PREDICTION_MIGRATOR_ERROR__INVALID_INPUT,
+  PREDICTION_MIGRATOR_ERROR__INVALID_MARKET: () => PREDICTION_MIGRATOR_ERROR__INVALID_MARKET,
+  PREDICTION_MIGRATOR_ERROR__INVALID_MINT: () => PREDICTION_MIGRATOR_ERROR__INVALID_MINT,
+  PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE: () => PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE,
+  PREDICTION_MIGRATOR_ERROR__INVALID_VAULT: () => PREDICTION_MIGRATOR_ERROR__INVALID_VAULT,
+  PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT: () => PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT,
+  PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED: () => PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED,
+  PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW: () => PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW,
+  PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS: () => PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS,
+  PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED: () => PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED,
+  PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH: () => PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH,
+  PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED: () => PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED,
+  PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED: () => PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED,
+  PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY: () => PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY,
+  PREDICTION_MIGRATOR_PROGRAM_ADDRESS: () => PREDICTION_MIGRATOR_PROGRAM_ADDRESS,
+  PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR: () => PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR,
+  PredictionMigratorAccount: () => PredictionMigratorAccount,
+  PredictionMigratorInstruction: () => PredictionMigratorInstruction,
+  REGISTER_ENTRY_DISCRIMINATOR: () => REGISTER_ENTRY_DISCRIMINATOR,
+  decodeClaimReceipt: () => decodeClaimReceipt,
+  decodeEntry: () => decodeEntry,
+  decodeEntryByMint: () => decodeEntryByMint,
+  decodeLaunch: () => decodeLaunch,
+  decodeMarket: () => decodeMarket,
+  decodeOracleState: () => decodeOracleState2,
+  fetchAllClaimReceipt: () => fetchAllClaimReceipt,
+  fetchAllEntry: () => fetchAllEntry,
+  fetchAllEntryByMint: () => fetchAllEntryByMint,
+  fetchAllLaunch: () => fetchAllLaunch,
+  fetchAllMarket: () => fetchAllMarket,
+  fetchAllMaybeClaimReceipt: () => fetchAllMaybeClaimReceipt,
+  fetchAllMaybeEntry: () => fetchAllMaybeEntry,
+  fetchAllMaybeEntryByMint: () => fetchAllMaybeEntryByMint,
+  fetchAllMaybeLaunch: () => fetchAllMaybeLaunch,
+  fetchAllMaybeMarket: () => fetchAllMaybeMarket,
+  fetchAllMaybeOracleState: () => fetchAllMaybeOracleState,
+  fetchAllOracleState: () => fetchAllOracleState,
+  fetchClaimReceipt: () => fetchClaimReceipt,
+  fetchEntry: () => fetchEntry,
+  fetchEntryByMint: () => fetchEntryByMint,
+  fetchLaunch: () => fetchLaunch,
+  fetchMarket: () => fetchMarket,
+  fetchMaybeClaimReceipt: () => fetchMaybeClaimReceipt,
+  fetchMaybeEntry: () => fetchMaybeEntry,
+  fetchMaybeEntryByMint: () => fetchMaybeEntryByMint,
+  fetchMaybeLaunch: () => fetchMaybeLaunch,
+  fetchMaybeMarket: () => fetchMaybeMarket,
+  fetchMaybeOracleState: () => fetchMaybeOracleState,
+  fetchOracleState: () => fetchOracleState,
+  getAccumulatorUpdatedCodec: () => getAccumulatorUpdatedCodec,
+  getAccumulatorUpdatedDecoder: () => getAccumulatorUpdatedDecoder,
+  getAccumulatorUpdatedEncoder: () => getAccumulatorUpdatedEncoder,
+  getCalldataBufCodec: () => getCalldataBufCodec,
+  getCalldataBufDecoder: () => getCalldataBufDecoder2,
+  getCalldataBufEncoder: () => getCalldataBufEncoder2,
+  getClaimDiscriminatorBytes: () => getClaimDiscriminatorBytes,
+  getClaimInstruction: () => getClaimInstruction,
+  getClaimInstructionAsync: () => getClaimInstructionAsync,
+  getClaimInstructionDataCodec: () => getClaimInstructionDataCodec,
+  getClaimInstructionDataDecoder: () => getClaimInstructionDataDecoder,
+  getClaimInstructionDataEncoder: () => getClaimInstructionDataEncoder,
+  getClaimReceiptCodec: () => getClaimReceiptCodec,
+  getClaimReceiptDecoder: () => getClaimReceiptDecoder,
+  getClaimReceiptDiscriminatorBytes: () => getClaimReceiptDiscriminatorBytes,
+  getClaimReceiptEncoder: () => getClaimReceiptEncoder,
+  getClaimReceiptSize: () => getClaimReceiptSize,
+  getEntryByMintCodec: () => getEntryByMintCodec,
+  getEntryByMintDecoder: () => getEntryByMintDecoder,
+  getEntryByMintDiscriminatorBytes: () => getEntryByMintDiscriminatorBytes,
+  getEntryByMintEncoder: () => getEntryByMintEncoder,
+  getEntryByMintSize: () => getEntryByMintSize,
+  getEntryCodec: () => getEntryCodec,
+  getEntryDecoder: () => getEntryDecoder,
+  getEntryDiscriminatorBytes: () => getEntryDiscriminatorBytes,
+  getEntryEncoder: () => getEntryEncoder,
+  getEntryMigratedCodec: () => getEntryMigratedCodec,
+  getEntryMigratedDecoder: () => getEntryMigratedDecoder,
+  getEntryMigratedEncoder: () => getEntryMigratedEncoder,
+  getEntryRegisteredCodec: () => getEntryRegisteredCodec,
+  getEntryRegisteredDecoder: () => getEntryRegisteredDecoder,
+  getEntryRegisteredEncoder: () => getEntryRegisteredEncoder,
+  getEntrySize: () => getEntrySize,
+  getLaunchCodec: () => getLaunchCodec2,
+  getLaunchDecoder: () => getLaunchDecoder2,
+  getLaunchDiscriminatorBytes: () => getLaunchDiscriminatorBytes,
+  getLaunchEncoder: () => getLaunchEncoder2,
+  getLaunchSize: () => getLaunchSize,
+  getMarketCodec: () => getMarketCodec,
+  getMarketCreatedCodec: () => getMarketCreatedCodec,
+  getMarketCreatedDecoder: () => getMarketCreatedDecoder,
+  getMarketCreatedEncoder: () => getMarketCreatedEncoder,
+  getMarketDecoder: () => getMarketDecoder,
+  getMarketDiscriminatorBytes: () => getMarketDiscriminatorBytes,
+  getMarketEncoder: () => getMarketEncoder,
+  getMarketResolvedCodec: () => getMarketResolvedCodec,
+  getMarketResolvedDecoder: () => getMarketResolvedDecoder,
+  getMarketResolvedEncoder: () => getMarketResolvedEncoder,
+  getMarketSize: () => getMarketSize,
+  getMigrateEntryArgsCodec: () => getMigrateEntryArgsCodec,
+  getMigrateEntryArgsDecoder: () => getMigrateEntryArgsDecoder,
+  getMigrateEntryArgsEncoder: () => getMigrateEntryArgsEncoder,
+  getMigrateEntryDiscriminatorBytes: () => getMigrateEntryDiscriminatorBytes,
+  getMigrateEntryInstruction: () => getMigrateEntryInstruction,
+  getMigrateEntryInstructionAsync: () => getMigrateEntryInstructionAsync,
+  getMigrateEntryInstructionDataCodec: () => getMigrateEntryInstructionDataCodec,
+  getMigrateEntryInstructionDataDecoder: () => getMigrateEntryInstructionDataDecoder,
+  getMigrateEntryInstructionDataEncoder: () => getMigrateEntryInstructionDataEncoder,
+  getOracleStateCodec: () => getOracleStateCodec,
+  getOracleStateDecoder: () => getOracleStateDecoder,
+  getOracleStateDiscriminatorBytes: () => getOracleStateDiscriminatorBytes,
+  getOracleStateEncoder: () => getOracleStateEncoder,
+  getOracleStateSize: () => getOracleStateSize,
+  getPredictionEntryAddress: () => getPredictionEntryAddress,
+  getPredictionEntryByMintAddress: () => getPredictionEntryByMintAddress,
+  getPredictionMarketAddress: () => getPredictionMarketAddress,
+  getPredictionMarketAuthorityAddress: () => getPredictionMarketAuthorityAddress,
+  getPredictionMigratorErrorMessage: () => getPredictionMigratorErrorMessage,
+  getPredictionPotVaultAddress: () => getPredictionPotVaultAddress,
+  getPreviewPayoutIfWinnerArgsCodec: () => getPreviewPayoutIfWinnerArgsCodec,
+  getPreviewPayoutIfWinnerArgsDecoder: () => getPreviewPayoutIfWinnerArgsDecoder,
+  getPreviewPayoutIfWinnerArgsEncoder: () => getPreviewPayoutIfWinnerArgsEncoder,
+  getPreviewPayoutIfWinnerDiscriminatorBytes: () => getPreviewPayoutIfWinnerDiscriminatorBytes,
+  getPreviewPayoutIfWinnerInstruction: () => getPreviewPayoutIfWinnerInstruction,
+  getPreviewPayoutIfWinnerInstructionDataCodec: () => getPreviewPayoutIfWinnerInstructionDataCodec,
+  getPreviewPayoutIfWinnerInstructionDataDecoder: () => getPreviewPayoutIfWinnerInstructionDataDecoder,
+  getPreviewPayoutIfWinnerInstructionDataEncoder: () => getPreviewPayoutIfWinnerInstructionDataEncoder,
+  getRegisterEntryArgsCodec: () => getRegisterEntryArgsCodec,
+  getRegisterEntryArgsDecoder: () => getRegisterEntryArgsDecoder,
+  getRegisterEntryArgsEncoder: () => getRegisterEntryArgsEncoder,
+  getRegisterEntryDiscriminatorBytes: () => getRegisterEntryDiscriminatorBytes,
+  getRegisterEntryInstruction: () => getRegisterEntryInstruction,
+  getRegisterEntryInstructionAsync: () => getRegisterEntryInstructionAsync,
+  getRegisterEntryInstructionDataCodec: () => getRegisterEntryInstructionDataCodec,
+  getRegisterEntryInstructionDataDecoder: () => getRegisterEntryInstructionDataDecoder,
+  getRegisterEntryInstructionDataEncoder: () => getRegisterEntryInstructionDataEncoder,
+  getRewardsClaimedCodec: () => getRewardsClaimedCodec,
+  getRewardsClaimedDecoder: () => getRewardsClaimedDecoder,
+  getRewardsClaimedEncoder: () => getRewardsClaimedEncoder,
+  identifyPredictionMigratorAccount: () => identifyPredictionMigratorAccount,
+  identifyPredictionMigratorInstruction: () => identifyPredictionMigratorInstruction,
+  isPredictionMigratorError: () => isPredictionMigratorError,
+  parseClaimInstruction: () => parseClaimInstruction,
+  parseMigrateEntryInstruction: () => parseMigrateEntryInstruction,
+  parsePredictionMigratorInstruction: () => parsePredictionMigratorInstruction,
+  parsePreviewPayoutIfWinnerInstruction: () => parsePreviewPayoutIfWinnerInstruction,
+  parseRegisterEntryInstruction: () => parseRegisterEntryInstruction,
+  predictionMigratorProgram: () => predictionMigratorProgram
+});
+var PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED = 6e3;
+var PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH = 6001;
+var PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED = 6002;
+var PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED = 6003;
+var PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED = 6004;
+var PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED = 6005;
+var PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED = 6006;
+var PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED = 6007;
+var PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT = 6008;
+var PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE = 6009;
+var PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW = 6010;
+var PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID = 6011;
+var PREDICTION_MIGRATOR_ERROR__INVALID_MARKET = 6012;
+var PREDICTION_MIGRATOR_ERROR__INVALID_VAULT = 6013;
+var PREDICTION_MIGRATOR_ERROR__INVALID_MINT = 6014;
+var PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED = 6015;
+var PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS = 6016;
+var PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE = 6017;
+var PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY = 6018;
+var PREDICTION_MIGRATOR_ERROR__INVALID_INPUT = 6019;
+var predictionMigratorErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  predictionMigratorErrorMessages = {
+    [PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED]: `Entry already migrated`,
+    [PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED]: `Entry already registered`,
+    [PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED]: `Entry not migrated`,
+    [PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED]: `Entry not registered`,
+    [PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE]: `Insufficient balance`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID]: `Invalid entry ID`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_INPUT]: `Invalid input`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_MARKET]: `Invalid market`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_MINT]: `Invalid mint`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE]: `Invalid oracle`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_VAULT]: `Invalid vault`,
+    [PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT]: `Invalid winner mint`,
+    [PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED]: `Market not resolved`,
+    [PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW]: `Math overflow`,
+    [PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS]: `No pending rewards`,
+    [PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED]: `Oracle not finalized`,
+    [PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH]: `Quote mint mismatch`,
+    [PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED]: `Unauthorized`,
+    [PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED]: `Winning entry not migrated`,
+    [PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY]: `Zero claimable supply`
+  };
+}
+function getPredictionMigratorErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return predictionMigratorErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isPredictionMigratorError(error, transactionMessage, code) {
+  return isProgramError(
+    error,
+    transactionMessage,
+    PREDICTION_MIGRATOR_PROGRAM_ADDRESS,
+    code
+  );
+}
+
+// src/solana/trustedOracle/index.ts
+var trustedOracle_exports = {};
+__export(trustedOracle_exports, {
+  FINALIZE_DISCRIMINATOR: () => FINALIZE_DISCRIMINATOR,
+  INITIALIZE_ORACLE_DISCRIMINATOR: () => INITIALIZE_ORACLE_DISCRIMINATOR,
+  ORACLE_STATE_DISCRIMINATOR: () => ORACLE_STATE_DISCRIMINATOR2,
+  TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED: () => TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED,
+  TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT: () => TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT,
+  TRUSTED_ORACLE_ERROR__NOT_FINALIZED: () => TRUSTED_ORACLE_ERROR__NOT_FINALIZED,
+  TRUSTED_ORACLE_ERROR__UNAUTHORIZED: () => TRUSTED_ORACLE_ERROR__UNAUTHORIZED,
+  TRUSTED_ORACLE_PROGRAM_ADDRESS: () => TRUSTED_ORACLE_PROGRAM_ADDRESS,
+  TrustedOracleAccount: () => TrustedOracleAccount,
+  TrustedOracleInstruction: () => TrustedOracleInstruction,
+  decodeOracleState: () => decodeOracleState3,
+  fetchAllMaybeOracleState: () => fetchAllMaybeOracleState2,
+  fetchAllOracleState: () => fetchAllOracleState2,
+  fetchMaybeOracleState: () => fetchMaybeOracleState2,
+  fetchOracleState: () => fetchOracleState2,
+  getFinalizeDiscriminatorBytes: () => getFinalizeDiscriminatorBytes,
+  getFinalizeInstruction: () => getFinalizeInstruction,
+  getFinalizeInstructionDataCodec: () => getFinalizeInstructionDataCodec,
+  getFinalizeInstructionDataDecoder: () => getFinalizeInstructionDataDecoder,
+  getFinalizeInstructionDataEncoder: () => getFinalizeInstructionDataEncoder,
+  getInitializeOracleArgsCodec: () => getInitializeOracleArgsCodec,
+  getInitializeOracleArgsDecoder: () => getInitializeOracleArgsDecoder,
+  getInitializeOracleArgsEncoder: () => getInitializeOracleArgsEncoder,
+  getInitializeOracleDiscriminatorBytes: () => getInitializeOracleDiscriminatorBytes,
+  getInitializeOracleInstruction: () => getInitializeOracleInstruction,
+  getInitializeOracleInstructionDataCodec: () => getInitializeOracleInstructionDataCodec,
+  getInitializeOracleInstructionDataDecoder: () => getInitializeOracleInstructionDataDecoder,
+  getInitializeOracleInstructionDataEncoder: () => getInitializeOracleInstructionDataEncoder,
+  getOracleStateAddress: () => getOracleStateAddress,
+  getOracleStateCodec: () => getOracleStateCodec2,
+  getOracleStateDecoder: () => getOracleStateDecoder2,
+  getOracleStateDiscriminatorBytes: () => getOracleStateDiscriminatorBytes2,
+  getOracleStateEncoder: () => getOracleStateEncoder2,
+  getOracleStateSize: () => getOracleStateSize2,
+  getTrustedOracleErrorMessage: () => getTrustedOracleErrorMessage,
+  identifyTrustedOracleAccount: () => identifyTrustedOracleAccount,
+  identifyTrustedOracleInstruction: () => identifyTrustedOracleInstruction,
+  isTrustedOracleError: () => isTrustedOracleError,
+  parseFinalizeInstruction: () => parseFinalizeInstruction,
+  parseInitializeOracleInstruction: () => parseInitializeOracleInstruction,
+  parseTrustedOracleInstruction: () => parseTrustedOracleInstruction,
+  trustedOracleProgram: () => trustedOracleProgram
+});
+var ORACLE_STATE_DISCRIMINATOR2 = new Uint8Array([
+  97,
+  156,
+  157,
+  189,
+  194,
+  73,
+  8,
+  15
+]);
+function getOracleStateDiscriminatorBytes2() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    ORACLE_STATE_DISCRIMINATOR2
+  );
+}
+function getOracleStateEncoder2() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["oracleAuthority", getAddressEncoder()],
+      ["quoteMint", getAddressEncoder()],
+      ["isFinalized", getBooleanEncoder()],
+      ["winningMint", getAddressEncoder()],
+      ["nonce", getU64Encoder()],
+      ["bump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 31)]
+    ]),
+    (value) => ({ ...value, discriminator: ORACLE_STATE_DISCRIMINATOR2 })
+  );
+}
+function getOracleStateDecoder2() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["oracleAuthority", getAddressDecoder()],
+    ["quoteMint", getAddressDecoder()],
+    ["isFinalized", getBooleanDecoder()],
+    ["winningMint", getAddressDecoder()],
+    ["nonce", getU64Decoder()],
+    ["bump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 31)]
+  ]);
+}
+function getOracleStateCodec2() {
+  return combineCodec(getOracleStateEncoder2(), getOracleStateDecoder2());
+}
+function decodeOracleState3(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getOracleStateDecoder2()
+  );
+}
+async function fetchOracleState2(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeOracleState2(rpc, address3, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeOracleState2(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
+  return decodeOracleState3(maybeAccount);
+}
+async function fetchAllOracleState2(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeOracleState2(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeOracleState2(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeOracleState3(maybeAccount));
+}
+function getOracleStateSize2() {
+  return 145;
+}
+var FINALIZE_DISCRIMINATOR = new Uint8Array([
+  171,
+  61,
+  218,
+  56,
+  127,
+  115,
+  12,
+  217
+]);
+function getFinalizeDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(FINALIZE_DISCRIMINATOR);
+}
+function getFinalizeInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["winningMint", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: FINALIZE_DISCRIMINATOR })
+  );
+}
+function getFinalizeInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["winningMint", getAddressDecoder()]
+  ]);
+}
+function getFinalizeInstructionDataCodec() {
+  return combineCodec(
+    getFinalizeInstructionDataEncoder(),
+    getFinalizeInstructionDataDecoder()
+  );
+}
+function getFinalizeInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TRUSTED_ORACLE_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    oracleAuthority: {
+      value: input.oracleAuthority ?? null,
+      isWritable: false
+    },
+    oracleState: { value: input.oracleState ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("oracleAuthority", accounts.oracleAuthority),
+      getAccountMeta("oracleState", accounts.oracleState)
+    ],
+    data: getFinalizeInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseFinalizeInstruction(instruction) {
+  if (instruction.accounts.length < 2) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 2
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      oracleAuthority: getNextAccount(),
+      oracleState: getNextAccount()
+    },
+    data: getFinalizeInstructionDataDecoder().decode(instruction.data)
+  };
+}
+var INITIALIZE_ORACLE_DISCRIMINATOR = new Uint8Array([
+  144,
+  223,
+  131,
+  120,
+  196,
+  253,
+  181,
+  99
+]);
+function getInitializeOracleDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    INITIALIZE_ORACLE_DISCRIMINATOR
+  );
+}
+function getInitializeOracleInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["nonce", getU64Encoder()],
+      ["quoteMint", getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_ORACLE_DISCRIMINATOR })
+  );
+}
+function getInitializeOracleInstructionDataDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["nonce", getU64Decoder()],
+    ["quoteMint", getAddressDecoder()]
+  ]);
+}
+function getInitializeOracleInstructionDataCodec() {
+  return combineCodec(
+    getInitializeOracleInstructionDataEncoder(),
+    getInitializeOracleInstructionDataDecoder()
+  );
+}
+function getInitializeOracleInstruction(input, config) {
+  const programAddress = config?.programAddress ?? TRUSTED_ORACLE_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    oracleAuthority: { value: input.oracleAuthority ?? null, isWritable: true },
+    oracleState: { value: input.oracleState ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("oracleAuthority", accounts.oracleAuthority),
+      getAccountMeta("oracleState", accounts.oracleState),
+      getAccountMeta("systemProgram", accounts.systemProgram)
+    ],
+    data: getInitializeOracleInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializeOracleInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 3
+      }
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      oracleAuthority: getNextAccount(),
+      oracleState: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeOracleInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/solana/generated/trustedOracle/programs/trustedOracle.ts
+var TRUSTED_ORACLE_PROGRAM_ADDRESS = "HhUzN7VvonNUevATyugZUepzxpeEZMXQbV92X2xvsp5m";
+var TrustedOracleAccount = /* @__PURE__ */ ((TrustedOracleAccount2) => {
+  TrustedOracleAccount2[TrustedOracleAccount2["OracleState"] = 0] = "OracleState";
+  return TrustedOracleAccount2;
+})(TrustedOracleAccount || {});
+function identifyTrustedOracleAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([97, 156, 157, 189, 194, 73, 8, 15])
+    ),
+    0
+  )) {
+    return 0 /* OracleState */;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
+    { accountData: data, programName: "trustedOracle" }
+  );
+}
+var TrustedOracleInstruction = /* @__PURE__ */ ((TrustedOracleInstruction2) => {
+  TrustedOracleInstruction2[TrustedOracleInstruction2["Finalize"] = 0] = "Finalize";
+  TrustedOracleInstruction2[TrustedOracleInstruction2["InitializeOracle"] = 1] = "InitializeOracle";
+  return TrustedOracleInstruction2;
+})(TrustedOracleInstruction || {});
+function identifyTrustedOracleInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([171, 61, 218, 56, 127, 115, 12, 217])
+    ),
+    0
+  )) {
+    return 0 /* Finalize */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize(getBytesEncoder(), 8).encode(
+      new Uint8Array([144, 223, 131, 120, 196, 253, 181, 99])
+    ),
+    0
+  )) {
+    return 1 /* InitializeOracle */;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "trustedOracle" }
+  );
+}
+function parseTrustedOracleInstruction(instruction) {
+  const instructionType = identifyTrustedOracleInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* Finalize */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 0 /* Finalize */,
+        ...parseFinalizeInstruction(instruction)
+      };
+    }
+    case 1 /* InitializeOracle */: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 1 /* InitializeOracle */,
+        ...parseInitializeOracleInstruction(instruction)
+      };
+    }
+    default:
+      throw new SolanaError(
+        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType,
+          programName: "trustedOracle"
+        }
+      );
+  }
+}
+function trustedOracleProgram() {
+  return (client) => {
+    return {
+      ...client,
+      trustedOracle: {
+        accounts: {
+          oracleState: addSelfFetchFunctions(client, getOracleStateCodec2())
+        },
+        instructions: {
+          finalize: (input) => addSelfPlanAndSendFunctions(client, getFinalizeInstruction(input)),
+          initializeOracle: (input) => addSelfPlanAndSendFunctions(
+            client,
+            getInitializeOracleInstruction(input)
+          )
+        }
+      }
+    };
+  };
+}
+
+// src/solana/generated/trustedOracle/errors/trustedOracle.ts
+var TRUSTED_ORACLE_ERROR__UNAUTHORIZED = 6e3;
+var TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED = 6001;
+var TRUSTED_ORACLE_ERROR__NOT_FINALIZED = 6002;
+var TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT = 6003;
+var trustedOracleErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  trustedOracleErrorMessages = {
+    [TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED]: `Oracle already finalized`,
+    [TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT]: `Invalid winning mint`,
+    [TRUSTED_ORACLE_ERROR__NOT_FINALIZED]: `Oracle not finalized`,
+    [TRUSTED_ORACLE_ERROR__UNAUTHORIZED]: `Unauthorized: only oracle authority can perform this action`
+  };
+}
+function getTrustedOracleErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return trustedOracleErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isTrustedOracleError(error, transactionMessage, code) {
+  return isProgramError(
+    error,
+    transactionMessage,
+    TRUSTED_ORACLE_PROGRAM_ADDRESS,
+    code
+  );
+}
+function getInitializeOracleArgsEncoder() {
+  return getStructEncoder([
+    ["nonce", getU64Encoder()],
+    ["quoteMint", getAddressEncoder()]
+  ]);
+}
+function getInitializeOracleArgsDecoder() {
+  return getStructDecoder([
+    ["nonce", getU64Decoder()],
+    ["quoteMint", getAddressDecoder()]
+  ]);
+}
+function getInitializeOracleArgsCodec() {
+  return combineCodec(
+    getInitializeOracleArgsEncoder(),
+    getInitializeOracleArgsDecoder()
+  );
+}
+async function getOracleStateAddress(oracleAuthority, nonce) {
+  const nonceBytes = new Uint8Array(8);
+  new DataView(nonceBytes.buffer).setBigUint64(0, nonce, true);
+  return getProgramDerivedAddress({
+    programAddress: TRUSTED_ORACLE_PROGRAM_ADDRESS,
+    seeds: [
+      new TextEncoder().encode("oracle"),
+      getAddressEncoder().encode(oracleAuthority),
+      nonceBytes
+    ]
+  });
+}
+
+export { cpmm_exports as cpmm, cpmmMigrator_exports as cpmmMigrator, initializer_exports as initializer, predictionMigrator_exports as predictionMigrator, trustedOracle_exports as trustedOracle };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map