@whetstone-research/doppler-sdk 1.0.2 → 1.0.5

package/dist/solana/index.cjs

@@ -0,0 +1,4981 @@
+'use strict';
+
+var chunkBXATWUGJ_cjs = require('../chunk-BXATWUGJ.cjs');
+var chunkDPKVNI6Q_cjs = require('../chunk-DPKVNI6Q.cjs');
+var chunkQ7SFCCGT_cjs = require('../chunk-Q7SFCCGT.cjs');
+var kit = require('@solana/kit');
+var programClientCore = require('@solana/program-client-core');
+var sha3_js = require('@noble/hashes/sha3.js');
+
+// src/solana/cpmm/index.ts
+var cpmm_exports = {};
+chunkQ7SFCCGT_cjs.__export(cpmm_exports, {
+  ACCOUNT_DISCRIMINATORS: () => chunkDPKVNI6Q_cjs.ACCOUNT_DISCRIMINATORS,
+  ACCOUNT_VERSION: () => chunkDPKVNI6Q_cjs.ACCOUNT_VERSION,
+  BPS_DENOM: () => chunkDPKVNI6Q_cjs.BPS_DENOM,
+  CPMM_ERROR_MESSAGES: () => CPMM_ERROR_MESSAGES,
+  CPMM_PROGRAM_ID: () => chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID,
+  CpmmError: () => CpmmError,
+  CpmmErrorCode: () => CpmmErrorCode,
+  INSTRUCTION_DISCRIMINATORS: () => chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS,
+  MAX_FEE_AMOUNT: () => chunkBXATWUGJ_cjs.MAX_FEE_AMOUNT,
+  MAX_ORACLE_OBSERVATIONS: () => chunkDPKVNI6Q_cjs.MAX_ORACLE_OBSERVATIONS,
+  MAX_SENTINEL_ALLOWLIST: () => chunkDPKVNI6Q_cjs.MAX_SENTINEL_ALLOWLIST,
+  Q64_ONE: () => chunkDPKVNI6Q_cjs.Q64_ONE,
+  SEED_AUTHORITY: () => chunkDPKVNI6Q_cjs.SEED_AUTHORITY,
+  SEED_CONFIG: () => chunkDPKVNI6Q_cjs.SEED_CONFIG,
+  SEED_ORACLE: () => chunkDPKVNI6Q_cjs.SEED_ORACLE,
+  SEED_POOL: () => chunkDPKVNI6Q_cjs.SEED_POOL,
+  SEED_POSITION: () => chunkDPKVNI6Q_cjs.SEED_POSITION,
+  SEED_PROTOCOL_POSITION: () => chunkDPKVNI6Q_cjs.SEED_PROTOCOL_POSITION,
+  SENTINEL_NO_CHANGE: () => chunkDPKVNI6Q_cjs.SENTINEL_NO_CHANGE,
+  SF_AFTER_ADD_LIQ: () => chunkDPKVNI6Q_cjs.SF_AFTER_ADD_LIQ,
+  SF_AFTER_REMOVE_LIQ: () => chunkDPKVNI6Q_cjs.SF_AFTER_REMOVE_LIQ,
+  SF_AFTER_SWAP: () => chunkDPKVNI6Q_cjs.SF_AFTER_SWAP,
+  SF_BEFORE_ADD_LIQ: () => chunkDPKVNI6Q_cjs.SF_BEFORE_ADD_LIQ,
+  SF_BEFORE_REMOVE_LIQ: () => chunkDPKVNI6Q_cjs.SF_BEFORE_REMOVE_LIQ,
+  SF_BEFORE_SWAP: () => chunkDPKVNI6Q_cjs.SF_BEFORE_SWAP,
+  TOKEN_METADATA_PROGRAM_ID: () => chunkDPKVNI6Q_cjs.TOKEN_METADATA_PROGRAM_ID,
+  addLiquidityArgsCodec: () => chunkBXATWUGJ_cjs.addLiquidityArgsCodec,
+  ammConfigDataCodec: () => chunkBXATWUGJ_cjs.ammConfigDataCodec,
+  areMintsOrdered: () => chunkDPKVNI6Q_cjs.areMintsOrdered,
+  calculateAccruedFees: () => chunkBXATWUGJ_cjs.calculateAccruedFees,
+  calculateTwap: () => chunkBXATWUGJ_cjs.calculateTwap,
+  calculateTwapNumber: () => chunkBXATWUGJ_cjs.calculateTwapNumber,
+  ceilDiv: () => chunkBXATWUGJ_cjs.ceilDiv,
+  collectFeesArgsCodec: () => chunkBXATWUGJ_cjs.collectFeesArgsCodec,
+  collectProtocolFeesArgsCodec: () => chunkBXATWUGJ_cjs.collectProtocolFeesArgsCodec,
+  comparePoolAndOraclePrices: () => chunkBXATWUGJ_cjs.comparePoolAndOraclePrices,
+  computePrice0Q64: () => chunkBXATWUGJ_cjs.computePrice0Q64,
+  computePrice1Q64: () => chunkBXATWUGJ_cjs.computePrice1Q64,
+  consultTwap: () => chunkBXATWUGJ_cjs.consultTwap,
+  createAddLiquidityInstruction: () => createAddLiquidityInstruction,
+  createClosePositionInstruction: () => createClosePositionInstruction,
+  createCollectFeesInstruction: () => chunkBXATWUGJ_cjs.createCollectFeesInstruction,
+  createCollectProtocolFeesInstruction: () => createCollectProtocolFeesInstruction,
+  createCreatePositionInstruction: () => createCreatePositionInstruction,
+  createInitializeConfigInstruction: () => createInitializeConfigInstruction,
+  createInitializeOracleInstruction: () => createInitializeOracleInstruction,
+  createInitializePoolInstruction: () => createInitializePoolInstruction,
+  createOracleConsultInstruction: () => createOracleConsultInstruction,
+  createOracleUpdateInstruction: () => createOracleUpdateInstruction,
+  createPauseInstruction: () => createPauseInstruction,
+  createPositionArgsCodec: () => chunkBXATWUGJ_cjs.createPositionArgsCodec,
+  createQuoteToNumeraireInstruction: () => createQuoteToNumeraireInstruction,
+  createRemoveLiquidityInstruction: () => createRemoveLiquidityInstruction,
+  createSetFeesInstruction: () => createSetFeesInstruction,
+  createSetRouteInstruction: () => createSetRouteInstruction,
+  createSetSentinelInstruction: () => createSetSentinelInstruction,
+  createSkimInstruction: () => createSkimInstruction,
+  createSwapExactInInstruction: () => createSwapExactInInstruction,
+  createSwapInstruction: () => createSwapInstruction,
+  createTransferAdminInstruction: () => createTransferAdminInstruction,
+  createUnpauseInstruction: () => createUnpauseInstruction,
+  curveParamsToMarketCap: () => curveParamsToMarketCap,
+  decodeAmmConfig: () => chunkBXATWUGJ_cjs.decodeAmmConfig,
+  decodeOracleConsultResult: () => decodeOracleConsultResult,
+  decodeOracleState: () => chunkBXATWUGJ_cjs.decodeOracleState,
+  decodePool: () => chunkBXATWUGJ_cjs.decodePool,
+  decodePosition: () => chunkBXATWUGJ_cjs.decodePosition,
+  decodeQuoteToNumeraireResult: () => decodeQuoteToNumeraireResult,
+  encodeAddLiquidityArgs: () => chunkBXATWUGJ_cjs.encodeAddLiquidityArgs,
+  encodeCollectFeesArgs: () => chunkBXATWUGJ_cjs.encodeCollectFeesArgs,
+  encodeCollectProtocolFeesArgs: () => chunkBXATWUGJ_cjs.encodeCollectProtocolFeesArgs,
+  encodeCreatePositionArgs: () => chunkBXATWUGJ_cjs.encodeCreatePositionArgs,
+  encodeInitializeConfigArgs: () => chunkBXATWUGJ_cjs.encodeInitializeConfigArgs,
+  encodeInitializeOracleArgs: () => chunkBXATWUGJ_cjs.encodeInitializeOracleArgs,
+  encodeInitializePoolArgs: () => chunkBXATWUGJ_cjs.encodeInitializePoolArgs,
+  encodeInstructionData: () => chunkBXATWUGJ_cjs.encodeInstructionData,
+  encodeOracleConsultArgs: () => chunkBXATWUGJ_cjs.encodeOracleConsultArgs,
+  encodeQuoteToNumeraireArgs: () => chunkBXATWUGJ_cjs.encodeQuoteToNumeraireArgs,
+  encodeRemoveLiquidityArgs: () => chunkBXATWUGJ_cjs.encodeRemoveLiquidityArgs,
+  encodeSetFeesArgs: () => chunkBXATWUGJ_cjs.encodeSetFeesArgs,
+  encodeSetRouteArgs: () => chunkBXATWUGJ_cjs.encodeSetRouteArgs,
+  encodeSetSentinelArgs: () => chunkBXATWUGJ_cjs.encodeSetSentinelArgs,
+  encodeSwapExactInArgs: () => chunkBXATWUGJ_cjs.encodeSwapExactInArgs,
+  encodeTransferAdminArgs: () => chunkBXATWUGJ_cjs.encodeTransferAdminArgs,
+  fetchAllPools: () => chunkBXATWUGJ_cjs.fetchAllPools,
+  fetchConfig: () => fetchConfig,
+  fetchConfigWithAddress: () => fetchConfigWithAddress,
+  fetchOracle: () => chunkBXATWUGJ_cjs.fetchOracle,
+  fetchOraclesBatch: () => chunkBXATWUGJ_cjs.fetchOraclesBatch,
+  fetchPool: () => chunkBXATWUGJ_cjs.fetchPool,
+  fetchPoolPositions: () => chunkBXATWUGJ_cjs.fetchPoolPositions,
+  fetchPoolsBatch: () => chunkBXATWUGJ_cjs.fetchPoolsBatch,
+  fetchPosition: () => chunkBXATWUGJ_cjs.fetchPosition,
+  fetchPositionByParams: () => chunkBXATWUGJ_cjs.fetchPositionByParams,
+  fetchPositionsBatch: () => chunkBXATWUGJ_cjs.fetchPositionsBatch,
+  fetchUserPositions: () => chunkBXATWUGJ_cjs.fetchUserPositions,
+  filterActivePositions: () => chunkBXATWUGJ_cjs.filterActivePositions,
+  filterPoolsByMint: () => chunkBXATWUGJ_cjs.filterPoolsByMint,
+  getAddLiquidityQuote: () => chunkBXATWUGJ_cjs.getAddLiquidityQuote,
+  getConfigAddress: () => chunkDPKVNI6Q_cjs.getConfigAddress,
+  getErrorMessage: () => getErrorMessage,
+  getK: () => chunkBXATWUGJ_cjs.getK,
+  getLiquidityAddresses: () => chunkDPKVNI6Q_cjs.getLiquidityAddresses,
+  getMetadataAddress: () => getMetadataAddress,
+  getOracleAddress: () => chunkDPKVNI6Q_cjs.getOracleAddress,
+  getOracleAddressFromPool: () => chunkBXATWUGJ_cjs.getOracleAddressFromPool,
+  getOracleAge: () => chunkBXATWUGJ_cjs.getOracleAge,
+  getOracleBufferStats: () => chunkBXATWUGJ_cjs.getOracleBufferStats,
+  getOracleDeviation: () => chunkBXATWUGJ_cjs.getOracleDeviation,
+  getOracleForPool: () => chunkBXATWUGJ_cjs.getOracleForPool,
+  getOracleSpotPrices: () => chunkBXATWUGJ_cjs.getOracleSpotPrices,
+  getPendingFees: () => chunkBXATWUGJ_cjs.getPendingFees,
+  getPoolAddress: () => chunkDPKVNI6Q_cjs.getPoolAddress,
+  getPoolAddressFromMints: () => chunkBXATWUGJ_cjs.getPoolAddressFromMints,
+  getPoolAuthorityAddress: () => chunkDPKVNI6Q_cjs.getPoolAuthorityAddress,
+  getPoolByMints: () => chunkBXATWUGJ_cjs.getPoolByMints,
+  getPoolInitAddresses: () => chunkDPKVNI6Q_cjs.getPoolInitAddresses,
+  getPositionAddress: () => chunkDPKVNI6Q_cjs.getPositionAddress,
+  getPositionAddressFromParams: () => chunkBXATWUGJ_cjs.getPositionAddressFromParams,
+  getPositionValue: () => chunkBXATWUGJ_cjs.getPositionValue,
+  getProtocolPositionAddress: () => chunkDPKVNI6Q_cjs.getProtocolPositionAddress,
+  getRemoveLiquidityQuote: () => chunkBXATWUGJ_cjs.getRemoveLiquidityQuote,
+  getSpotPrice0: () => chunkBXATWUGJ_cjs.getSpotPrice0,
+  getSpotPrice1: () => chunkBXATWUGJ_cjs.getSpotPrice1,
+  getSwapAddresses: () => chunkDPKVNI6Q_cjs.getSwapAddresses,
+  getSwapQuote: () => chunkBXATWUGJ_cjs.getSwapQuote,
+  getSwapQuoteExactOut: () => chunkBXATWUGJ_cjs.getSwapQuoteExactOut,
+  getTvl: () => chunkBXATWUGJ_cjs.getTvl,
+  initializeConfigArgsCodec: () => chunkBXATWUGJ_cjs.initializeConfigArgsCodec,
+  initializeOracleArgsCodec: () => chunkBXATWUGJ_cjs.initializeOracleArgsCodec,
+  initializePoolArgsCodec: () => chunkBXATWUGJ_cjs.initializePoolArgsCodec,
+  isCpmmError: () => isCpmmError,
+  isOracleStale: () => chunkBXATWUGJ_cjs.isOracleStale,
+  isqrt: () => chunkBXATWUGJ_cjs.isqrt,
+  marketCapToCurveParams: () => marketCapToCurveParams,
+  marketCapToSingleCurveParams: () => marketCapToSingleCurveParams,
+  marketCapToTokenPrice: () => marketCapToTokenPrice,
+  maxBigInt: () => chunkBXATWUGJ_cjs.maxBigInt,
+  minBigInt: () => chunkBXATWUGJ_cjs.minBigInt,
+  numberToQ64: () => chunkBXATWUGJ_cjs.numberToQ64,
+  observationCodec: () => chunkBXATWUGJ_cjs.observationCodec,
+  oracleConsultArgsCodec: () => chunkBXATWUGJ_cjs.oracleConsultArgsCodec,
+  oracleStateDataCodec: () => chunkBXATWUGJ_cjs.oracleStateDataCodec,
+  parseErrorFromLogs: () => parseErrorFromLogs,
+  poolDataCodec: () => chunkBXATWUGJ_cjs.poolDataCodec,
+  poolExists: () => chunkBXATWUGJ_cjs.poolExists,
+  positionDataCodec: () => chunkBXATWUGJ_cjs.positionDataCodec,
+  q64Div: () => chunkBXATWUGJ_cjs.q64Div,
+  q64Mul: () => chunkBXATWUGJ_cjs.q64Mul,
+  q64ToNumber: () => chunkBXATWUGJ_cjs.q64ToNumber,
+  quoteToNumeraireArgsCodec: () => chunkBXATWUGJ_cjs.quoteToNumeraireArgsCodec,
+  ratioToNumber: () => chunkBXATWUGJ_cjs.ratioToNumber,
+  removeLiquidityArgsCodec: () => chunkBXATWUGJ_cjs.removeLiquidityArgsCodec,
+  setFeesArgsCodec: () => chunkBXATWUGJ_cjs.setFeesArgsCodec,
+  setRouteArgsCodec: () => chunkBXATWUGJ_cjs.setRouteArgsCodec,
+  setSentinelArgsCodec: () => chunkBXATWUGJ_cjs.setSentinelArgsCodec,
+  sortMints: () => chunkDPKVNI6Q_cjs.sortMints,
+  sortPoolsByReserves: () => chunkBXATWUGJ_cjs.sortPoolsByReserves,
+  sortPositionsByShares: () => chunkBXATWUGJ_cjs.sortPositionsByShares,
+  swapExactInArgsCodec: () => chunkBXATWUGJ_cjs.swapExactInArgsCodec,
+  transferAdminArgsCodec: () => chunkBXATWUGJ_cjs.transferAdminArgsCodec,
+  validateMarketCapParameters: () => validateMarketCapParameters
+});
+var addressCodec = kit.getAddressCodec();
+var textEncoder = new TextEncoder();
+async function getMetadataAddress(mint) {
+  return kit.getProgramDerivedAddress({
+    programAddress: chunkDPKVNI6Q_cjs.TOKEN_METADATA_PROGRAM_ID,
+    seeds: [
+      textEncoder.encode("metadata"),
+      addressCodec.encode(chunkDPKVNI6Q_cjs.TOKEN_METADATA_PROGRAM_ID),
+      addressCodec.encode(mint)
+    ]
+  });
+}
+
+// src/solana/core/marketCapHelpers.ts
+function marketCapToTokenPrice(marketCapUSD, baseTotalSupply, baseDecimals) {
+  if (marketCapUSD <= 0) {
+    throw new Error("Market cap must be positive");
+  }
+  if (baseTotalSupply <= 0n) {
+    throw new Error("Token supply must be positive");
+  }
+  const supplyNum = Number(baseTotalSupply) / 10 ** baseDecimals;
+  return marketCapUSD / supplyNum;
+}
+function validateMarketCapParameters(marketCapUSD, baseTotalSupply, baseDecimals) {
+  const warnings = [];
+  if (marketCapUSD < 1e3) {
+    warnings.push(
+      `Market cap $${marketCapUSD.toLocaleString()} is very small. Verify this is intentional.`
+    );
+  }
+  if (marketCapUSD > 1e12) {
+    warnings.push(
+      `Market cap $${marketCapUSD.toLocaleString()} exceeds $1T. Verify this is correct.`
+    );
+  }
+  const tokenPriceUSD = marketCapToTokenPrice(
+    marketCapUSD,
+    baseTotalSupply,
+    baseDecimals
+  );
+  if (tokenPriceUSD < 1e-6) {
+    warnings.push(
+      `Implied token price $${tokenPriceUSD.toExponential(2)} is very small. This may cause precision issues.`
+    );
+  }
+  if (tokenPriceUSD > 1e6) {
+    warnings.push(
+      `Implied token price $${tokenPriceUSD.toLocaleString()} is very large. Verify token supply and market cap.`
+    );
+  }
+  return { valid: warnings.length === 0, warnings };
+}
+function marketCapToCurveParams(input) {
+  const {
+    startMarketCapUSD,
+    endMarketCapUSD,
+    baseTotalSupply,
+    baseForCurve,
+    baseDecimals,
+    quoteDecimals,
+    numerairePriceUSD,
+    virtualBase
+  } = input;
+  if (startMarketCapUSD <= 0)
+    throw new Error("startMarketCapUSD must be positive");
+  if (endMarketCapUSD <= 0) throw new Error("endMarketCapUSD must be positive");
+  if (startMarketCapUSD >= endMarketCapUSD) {
+    throw new Error("startMarketCapUSD must be less than endMarketCapUSD");
+  }
+  if (baseForCurve <= 0n) throw new Error("baseForCurve must be positive");
+  if (baseForCurve > baseTotalSupply)
+    throw new Error("baseForCurve cannot exceed baseTotalSupply");
+  if (numerairePriceUSD <= 0)
+    throw new Error("numerairePriceUSD must be positive");
+  const canonicalVirtualBase = virtualBase !== void 0 && virtualBase > 0n ? virtualBase : baseForCurve;
+  return {
+    start: _marketCapToCurveParams(
+      startMarketCapUSD,
+      baseTotalSupply,
+      baseForCurve,
+      baseDecimals,
+      quoteDecimals,
+      numerairePriceUSD,
+      canonicalVirtualBase
+    ),
+    end: _marketCapToCurveParams(
+      endMarketCapUSD,
+      baseTotalSupply,
+      baseForCurve,
+      baseDecimals,
+      quoteDecimals,
+      numerairePriceUSD,
+      canonicalVirtualBase
+    )
+  };
+}
+function marketCapToSingleCurveParams(marketCapUSD, baseTotalSupply, baseForCurve, baseDecimals, quoteDecimals, numerairePriceUSD, virtualBase) {
+  if (marketCapUSD <= 0) throw new Error("marketCapUSD must be positive");
+  if (baseForCurve <= 0n) throw new Error("baseForCurve must be positive");
+  if (baseForCurve > baseTotalSupply)
+    throw new Error("baseForCurve cannot exceed baseTotalSupply");
+  if (numerairePriceUSD <= 0)
+    throw new Error("numerairePriceUSD must be positive");
+  const canonicalVirtualBase = virtualBase !== void 0 && virtualBase > 0n ? virtualBase : baseForCurve;
+  return _marketCapToCurveParams(
+    marketCapUSD,
+    baseTotalSupply,
+    baseForCurve,
+    baseDecimals,
+    quoteDecimals,
+    numerairePriceUSD,
+    canonicalVirtualBase
+  );
+}
+function curveParamsToMarketCap(input) {
+  const {
+    curveVirtualBase,
+    curveVirtualQuote,
+    baseReserve,
+    quoteReserve,
+    baseTotalSupply,
+    baseDecimals,
+    quoteDecimals,
+    numerairePriceUSD
+  } = input;
+  if (curveVirtualBase <= 0n)
+    throw new Error("curveVirtualBase must be positive");
+  if (curveVirtualQuote <= 0n)
+    throw new Error("curveVirtualQuote must be positive");
+  if (baseReserve < 0n) throw new Error("baseReserve must be non-negative");
+  if (quoteReserve < 0n) throw new Error("quoteReserve must be non-negative");
+  const spotPriceUSD = _spotPriceUSD(
+    curveVirtualBase,
+    curveVirtualQuote,
+    baseReserve,
+    quoteReserve,
+    baseDecimals,
+    quoteDecimals,
+    numerairePriceUSD
+  );
+  const supplyHuman = Number(baseTotalSupply) / 10 ** baseDecimals;
+  return spotPriceUSD * supplyHuman;
+}
+function _marketCapToCurveParams(marketCapUSD, baseTotalSupply, baseForCurve, baseDecimals, quoteDecimals, numerairePriceUSD, curveVirtualBase) {
+  const tokenPriceUSD = marketCapToTokenPrice(
+    marketCapUSD,
+    baseTotalSupply,
+    baseDecimals
+  );
+  const priceInNumeraire = tokenPriceUSD / numerairePriceUSD;
+  const decimalScale = 10 ** (quoteDecimals - baseDecimals);
+  const rawPriceQuotePerBase = priceInNumeraire * decimalScale;
+  const effectiveDenominator = baseForCurve + curveVirtualBase;
+  const PRECISION = 1000000000n;
+  const rawPriceScaled = BigInt(
+    Math.round(rawPriceQuotePerBase * Number(PRECISION))
+  );
+  const curveVirtualQuote = effectiveDenominator * rawPriceScaled / PRECISION;
+  if (curveVirtualQuote <= 0n) {
+    throw new Error(
+      `Computed curveVirtualQuote is zero or negative for marketCap=$${marketCapUSD.toLocaleString()}. Try a higher market cap or larger virtualBase.`
+    );
+  }
+  return { curveVirtualBase, curveVirtualQuote };
+}
+function _spotPriceUSD(curveVirtualBase, curveVirtualQuote, baseReserve, quoteReserve, baseDecimals, quoteDecimals, numerairePriceUSD) {
+  const effBase = Number(baseReserve + curveVirtualBase);
+  const effQuote = Number(quoteReserve + curveVirtualQuote);
+  const rawRatio = effQuote / effBase;
+  const decimalScale = 10 ** (baseDecimals - quoteDecimals);
+  return rawRatio * decimalScale * numerairePriceUSD;
+}
+
+// src/solana/core/errors.ts
+var CpmmErrorCode = /* @__PURE__ */ ((CpmmErrorCode2) => {
+  CpmmErrorCode2[CpmmErrorCode2["Unauthorized"] = 6e3] = "Unauthorized";
+  CpmmErrorCode2[CpmmErrorCode2["PoolLocked"] = 6001] = "PoolLocked";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidFee"] = 6002] = "InvalidFee";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidFeeSplit"] = 6003] = "InvalidFeeSplit";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidDirection"] = 6004] = "InvalidDirection";
+  CpmmErrorCode2[CpmmErrorCode2["InsufficientLiquidity"] = 6005] = "InsufficientLiquidity";
+  CpmmErrorCode2[CpmmErrorCode2["SlippageExceeded"] = 6006] = "SlippageExceeded";
+  CpmmErrorCode2[CpmmErrorCode2["MathOverflow"] = 6007] = "MathOverflow";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidMintOrder"] = 6008] = "InvalidMintOrder";
+  CpmmErrorCode2[CpmmErrorCode2["SameMintPair"] = 6009] = "SameMintPair";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidVault"] = 6010] = "InvalidVault";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidPosition"] = 6011] = "InvalidPosition";
+  CpmmErrorCode2[CpmmErrorCode2["PositionNotEmpty"] = 6012] = "PositionNotEmpty";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidRoute"] = 6013] = "InvalidRoute";
+  CpmmErrorCode2[CpmmErrorCode2["NotSupportedInV0_1"] = 6014] = "NotSupportedInV0_1";
+  CpmmErrorCode2[CpmmErrorCode2["OracleNotInitialized"] = 6015] = "OracleNotInitialized";
+  CpmmErrorCode2[CpmmErrorCode2["ZeroSharesOut"] = 6016] = "ZeroSharesOut";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelRejected"] = 6017] = "SentinelRejected";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelCpiFailed"] = 6018] = "SentinelCpiFailed";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelProgramNotProvided"] = 6019] = "SentinelProgramNotProvided";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelProgramNotExecutable"] = 6020] = "SentinelProgramNotExecutable";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelReturnDataMissing"] = 6021] = "SentinelReturnDataMissing";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelReturnDataInvalid"] = 6022] = "SentinelReturnDataInvalid";
+  CpmmErrorCode2[CpmmErrorCode2["SentinelNotAllowlisted"] = 6023] = "SentinelNotAllowlisted";
+  CpmmErrorCode2[CpmmErrorCode2["TotalSharesZero"] = 6024] = "TotalSharesZero";
+  CpmmErrorCode2[CpmmErrorCode2["AmountZero"] = 6025] = "AmountZero";
+  CpmmErrorCode2[CpmmErrorCode2["Paused"] = 6026] = "Paused";
+  CpmmErrorCode2[CpmmErrorCode2["InvariantViolation"] = 6027] = "InvariantViolation";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidMint"] = 6028] = "InvalidMint";
+  CpmmErrorCode2[CpmmErrorCode2["InvalidInput"] = 6029] = "InvalidInput";
+  CpmmErrorCode2[CpmmErrorCode2["Reentrancy"] = 6030] = "Reentrancy";
+  return CpmmErrorCode2;
+})(CpmmErrorCode || {});
+var CPMM_ERROR_MESSAGES = {
+  [6e3 /* Unauthorized */]: "Unauthorized: Caller lacks required authority",
+  [6001 /* PoolLocked */]: "Pool is currently locked (reentrancy protection)",
+  [6002 /* InvalidFee */]: "Invalid fee value (exceeds max or invalid range)",
+  [6003 /* InvalidFeeSplit */]: "Invalid fee split value (exceeds max or invalid range)",
+  [6004 /* InvalidDirection */]: "Invalid swap direction (must be 0 or 1)",
+  [6005 /* InsufficientLiquidity */]: "Insufficient liquidity for this operation",
+  [6006 /* SlippageExceeded */]: "Slippage exceeded: Output amount less than minimum",
+  [6007 /* MathOverflow */]: "Math operation overflowed",
+  [6008 /* InvalidMintOrder */]: "Token mints not in canonical order",
+  [6009 /* SameMintPair */]: "Cannot create pool with identical tokens",
+  [6010 /* InvalidVault */]: "Vault account is invalid or does not match",
+  [6011 /* InvalidPosition */]: "Position account is invalid or does not match",
+  [6012 /* PositionNotEmpty */]: "Cannot close position with non-zero shares or fees",
+  [6013 /* InvalidRoute */]: "Invalid route configuration",
+  [6014 /* NotSupportedInV0_1 */]: "Not supported in v0.1",
+  [6015 /* OracleNotInitialized */]: "Oracle not initialized for this pool",
+  [6016 /* ZeroSharesOut */]: "Zero shares out",
+  [6017 /* SentinelRejected */]: "Sentinel program rejected the operation",
+  [6018 /* SentinelCpiFailed */]: "Sentinel CPI call failed",
+  [6019 /* SentinelProgramNotProvided */]: "Sentinel program account not provided",
+  [6020 /* SentinelProgramNotExecutable */]: "Sentinel program account is not executable",
+  [6021 /* SentinelReturnDataMissing */]: "Sentinel return data missing or wrong program id",
+  [6022 /* SentinelReturnDataInvalid */]: "Sentinel return data invalid length or could not deserialize",
+  [6023 /* SentinelNotAllowlisted */]: "Sentinel program not in allowlist",
+  [6024 /* TotalSharesZero */]: "Pool has zero shares (no liquidity)",
+  [6025 /* AmountZero */]: "Amount cannot be zero",
+  [6026 /* Paused */]: "Pool is paused by admin",
+  [6027 /* InvariantViolation */]: "Internal invariant violation",
+  [6028 /* InvalidMint */]: "Invalid mint address",
+  [6029 /* InvalidInput */]: "Invalid input parameter",
+  [6030 /* Reentrancy */]: "Reentrancy detected"
+};
+var CpmmError = class extends Error {
+  constructor(code, logs) {
+    super(CPMM_ERROR_MESSAGES[code] || `Unknown CPMM error: ${code}`);
+    this.code = code;
+    this.logs = logs;
+    this.name = "CpmmError";
+  }
+  /**
+   * Get the error code name
+   */
+  get codeName() {
+    return CpmmErrorCode[this.code] || "Unknown";
+  }
+};
+function parseErrorFromLogs(logs) {
+  for (const log of logs) {
+    const anchorMatch = log.match(
+      /AnchorError.*Error Code:\s*(\w+)\.\s*Error Number:\s*(\d+)/
+    );
+    if (anchorMatch) {
+      const errorNumber = parseInt(anchorMatch[2], 10);
+      if (errorNumber >= 6e3 && errorNumber <= 6030) {
+        return new CpmmError(errorNumber, logs);
+      }
+    }
+    const hexMatch = log.match(/Error Number:\s*0x([0-9a-fA-F]+)/);
+    if (hexMatch) {
+      const errorNumber = parseInt(hexMatch[1], 16);
+      if (errorNumber >= 6e3 && errorNumber <= 6030) {
+        return new CpmmError(errorNumber, logs);
+      }
+    }
+    const customMatch = log.match(/Error Message:\s*(.+)/);
+    if (customMatch) {
+      const message = customMatch[1].toLowerCase();
+      for (const [code, msg] of Object.entries(CPMM_ERROR_MESSAGES)) {
+        if (msg.toLowerCase().includes(message) || message.includes(msg.toLowerCase())) {
+          return new CpmmError(parseInt(code), logs);
+        }
+      }
+    }
+  }
+  return null;
+}
+function isCpmmError(code) {
+  return code >= 6e3 && code <= 6030;
+}
+function getErrorMessage(code) {
+  if (isCpmmError(code)) {
+    return CPMM_ERROR_MESSAGES[code];
+  }
+  return `Unknown error code: ${code}`;
+}
+function createInitializeConfigInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, payer, systemProgram = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.WRITABLE },
+    { address: payer, role: kit.AccountRole.WRITABLE_SIGNER },
+    { address: systemProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.initializeConfig,
+    chunkBXATWUGJ_cjs.initializeConfigArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function isTransactionSigner(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createSignerAccountMeta(value, role) {
+  if (isTransactionSigner(value)) {
+    return {
+      address: value.address,
+      role,
+      signer: value
+    };
+  }
+  return { address: value, role };
+}
+function createInitializePoolInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    protocolPosition,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    payer,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS,
+    systemProgram = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS,
+    rent
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: protocolPosition, role: kit.AccountRole.WRITABLE },
+    { address: authority, role: kit.AccountRole.READONLY },
+    createSignerAccountMeta(vault0, kit.AccountRole.WRITABLE_SIGNER),
+    createSignerAccountMeta(vault1, kit.AccountRole.WRITABLE_SIGNER),
+    { address: token0Mint, role: kit.AccountRole.READONLY },
+    { address: token1Mint, role: kit.AccountRole.READONLY },
+    createSignerAccountMeta(payer, kit.AccountRole.WRITABLE_SIGNER),
+    { address: tokenProgram, role: kit.AccountRole.READONLY },
+    { address: systemProgram, role: kit.AccountRole.READONLY },
+    { address: rent, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.initializePool,
+    chunkBXATWUGJ_cjs.initializePoolArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createInitializeOracleInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    oracle,
+    admin,
+    payer,
+    systemProgram = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.READONLY },
+    { address: oracle, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER },
+    { address: payer, role: kit.AccountRole.WRITABLE_SIGNER },
+    { address: systemProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.initializeOracle,
+    chunkBXATWUGJ_cjs.initializeOracleArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createSetFeesInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, pool, admin } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.setFees,
+    chunkBXATWUGJ_cjs.setFeesArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createSetSentinelInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, pool, admin } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.setSentinel,
+    chunkBXATWUGJ_cjs.setSentinelArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createSetRouteInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, pool, nextPool, admin } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE }
+  ];
+  if (nextPool) {
+    keys.push({ address: nextPool, role: kit.AccountRole.READONLY });
+  }
+  keys.push({ address: admin, role: kit.AccountRole.READONLY_SIGNER });
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.setRoute,
+    chunkBXATWUGJ_cjs.setRouteArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createPauseInstruction(accounts, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, admin } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER }
+  ];
+  const data = chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.pause;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createUnpauseInstruction(accounts, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, admin } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER }
+  ];
+  const data = chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.unpause;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createTransferAdminInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, admin } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.transferAdmin,
+    chunkBXATWUGJ_cjs.transferAdminArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createSkimInstruction(accounts, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    admin,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    adminAta0,
+    adminAta1,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.READONLY },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER },
+    { address: authority, role: kit.AccountRole.READONLY },
+    { address: vault0, role: kit.AccountRole.WRITABLE },
+    { address: vault1, role: kit.AccountRole.WRITABLE },
+    { address: token0Mint, role: kit.AccountRole.READONLY },
+    { address: token1Mint, role: kit.AccountRole.READONLY },
+    { address: adminAta0, role: kit.AccountRole.WRITABLE },
+    { address: adminAta1, role: kit.AccountRole.WRITABLE },
+    { address: tokenProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.skim;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createSwapExactInInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    authority,
+    vaultIn,
+    vaultOut,
+    token0Mint,
+    token1Mint,
+    userIn,
+    userOut,
+    user,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS,
+    oracle,
+    remainingAccounts = []
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: authority, role: kit.AccountRole.READONLY },
+    { address: vaultIn, role: kit.AccountRole.WRITABLE },
+    { address: vaultOut, role: kit.AccountRole.WRITABLE },
+    { address: token0Mint, role: kit.AccountRole.READONLY },
+    { address: token1Mint, role: kit.AccountRole.READONLY },
+    { address: userIn, role: kit.AccountRole.WRITABLE },
+    { address: userOut, role: kit.AccountRole.WRITABLE },
+    { address: user, role: kit.AccountRole.READONLY_SIGNER },
+    { address: tokenProgram, role: kit.AccountRole.READONLY }
+  ];
+  if (oracle) {
+    keys.push({ address: oracle, role: kit.AccountRole.WRITABLE });
+  }
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: kit.AccountRole.READONLY });
+  }
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.swapExactIn,
+    chunkBXATWUGJ_cjs.swapExactInArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createSwapInstruction(params) {
+  const {
+    config,
+    pool,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    userToken0,
+    userToken1,
+    user,
+    amountIn,
+    minAmountOut,
+    direction,
+    oracle,
+    remainingAccounts,
+    updateOracle = false,
+    programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID
+  } = params;
+  const [vaultIn, vaultOut] = direction === 0 ? [vault0, vault1] : [vault1, vault0];
+  const [userIn, userOut] = direction === 0 ? [userToken0, userToken1] : [userToken1, userToken0];
+  return createSwapExactInInstruction(
+    {
+      config,
+      pool,
+      authority,
+      vaultIn,
+      vaultOut,
+      token0Mint,
+      token1Mint,
+      userIn,
+      userOut,
+      user,
+      oracle,
+      remainingAccounts
+    },
+    {
+      amountIn,
+      minAmountOut,
+      direction,
+      updateOracle
+    },
+    programId
+  );
+}
+function createCreatePositionInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    pool,
+    position,
+    owner,
+    payer,
+    systemProgram = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: pool, role: kit.AccountRole.READONLY },
+    { address: position, role: kit.AccountRole.WRITABLE },
+    { address: owner, role: kit.AccountRole.READONLY_SIGNER },
+    { address: payer, role: kit.AccountRole.WRITABLE_SIGNER },
+    { address: systemProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.createPosition,
+    chunkBXATWUGJ_cjs.createPositionArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createClosePositionInstruction(accounts, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { pool, position, owner, rentRecipient } = accounts;
+  const keys = [
+    { address: pool, role: kit.AccountRole.READONLY },
+    { address: position, role: kit.AccountRole.WRITABLE },
+    { address: owner, role: kit.AccountRole.READONLY_SIGNER },
+    { address: rentRecipient, role: kit.AccountRole.WRITABLE }
+  ];
+  const data = chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.closePosition;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var addLiquidityArgsWithOracleCodec = kit.getStructCodec([
+  ["amount0Max", kit.getU64Codec()],
+  ["amount1Max", kit.getU64Codec()],
+  ["minSharesOut", kit.getU128Codec()],
+  ["updateOracle", kit.getBooleanCodec()]
+]);
+function createAddLiquidityInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    position,
+    protocolPosition,
+    owner,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    user0,
+    user1,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS,
+    oracle,
+    remainingAccounts = []
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: position, role: kit.AccountRole.WRITABLE },
+    { address: protocolPosition, role: kit.AccountRole.WRITABLE },
+    { address: owner, role: kit.AccountRole.READONLY_SIGNER },
+    { address: authority, role: kit.AccountRole.READONLY },
+    { address: vault0, role: kit.AccountRole.WRITABLE },
+    { address: vault1, role: kit.AccountRole.WRITABLE },
+    { address: token0Mint, role: kit.AccountRole.READONLY },
+    { address: token1Mint, role: kit.AccountRole.READONLY },
+    { address: user0, role: kit.AccountRole.WRITABLE },
+    { address: user1, role: kit.AccountRole.WRITABLE },
+    { address: tokenProgram, role: kit.AccountRole.READONLY }
+  ];
+  if (oracle) {
+    keys.push({ address: oracle, role: kit.AccountRole.WRITABLE });
+  }
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: kit.AccountRole.READONLY });
+  }
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.addLiquidity,
+    addLiquidityArgsWithOracleCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createRemoveLiquidityInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    position,
+    protocolPosition,
+    owner,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    user0,
+    user1,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS,
+    oracle,
+    remainingAccounts = []
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: position, role: kit.AccountRole.WRITABLE },
+    { address: protocolPosition, role: kit.AccountRole.WRITABLE },
+    { address: owner, role: kit.AccountRole.READONLY_SIGNER },
+    { address: authority, role: kit.AccountRole.READONLY },
+    { address: vault0, role: kit.AccountRole.WRITABLE },
+    { address: vault1, role: kit.AccountRole.WRITABLE },
+    { address: token0Mint, role: kit.AccountRole.READONLY },
+    { address: token1Mint, role: kit.AccountRole.READONLY },
+    { address: user0, role: kit.AccountRole.WRITABLE },
+    { address: user1, role: kit.AccountRole.WRITABLE },
+    { address: tokenProgram, role: kit.AccountRole.READONLY }
+  ];
+  if (oracle) {
+    keys.push({ address: oracle, role: kit.AccountRole.WRITABLE });
+  }
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: kit.AccountRole.READONLY });
+  }
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.removeLiquidity,
+    chunkBXATWUGJ_cjs.removeLiquidityArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createCollectProtocolFeesInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    protocolPosition,
+    admin,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    recipient0,
+    recipient1,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: pool, role: kit.AccountRole.WRITABLE },
+    { address: protocolPosition, role: kit.AccountRole.WRITABLE },
+    { address: admin, role: kit.AccountRole.READONLY_SIGNER },
+    { address: authority, role: kit.AccountRole.READONLY },
+    { address: vault0, role: kit.AccountRole.WRITABLE },
+    { address: vault1, role: kit.AccountRole.WRITABLE },
+    { address: token0Mint, role: kit.AccountRole.READONLY },
+    { address: token1Mint, role: kit.AccountRole.READONLY },
+    { address: recipient0, role: kit.AccountRole.WRITABLE },
+    { address: recipient1, role: kit.AccountRole.WRITABLE },
+    { address: tokenProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.collectProtocolFees,
+    chunkBXATWUGJ_cjs.collectProtocolFeesArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+function createOracleUpdateInstruction(accounts, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { pool, oracle } = accounts;
+  const keys = [
+    { address: pool, role: kit.AccountRole.READONLY },
+    { address: oracle, role: kit.AccountRole.WRITABLE }
+  ];
+  const data = chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.oracleUpdate;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var oracleConsultResultCodec = kit.getStructCodec([
+  ["price0Q64", kit.getU128Codec()],
+  ["price1Q64", kit.getU128Codec()]
+]);
+function decodeOracleConsultResult(data) {
+  return oracleConsultResultCodec.decode(data);
+}
+function createOracleConsultInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { pool, oracle } = accounts;
+  const keys = [
+    { address: pool, role: kit.AccountRole.READONLY },
+    { address: oracle, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.oracleConsult,
+    chunkBXATWUGJ_cjs.oracleConsultArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var quoteToNumeraireResultCodec = kit.getStructCodec([
+  ["amountInNumeraire", kit.getU128Codec()],
+  ["endMint", kit.getAddressCodec()],
+  ["hopsUsed", kit.getU8Codec()]
+]);
+function decodeQuoteToNumeraireResult(data) {
+  return quoteToNumeraireResultCodec.decode(data);
+}
+function createQuoteToNumeraireInstruction(accounts, args, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID) {
+  const { config, startPool, remainingAccounts = [] } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: startPool, role: kit.AccountRole.READONLY }
+  ];
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: kit.AccountRole.READONLY });
+  }
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    chunkDPKVNI6Q_cjs.INSTRUCTION_DISCRIMINATORS.quoteToNumeraire,
+    chunkBXATWUGJ_cjs.quoteToNumeraireArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/client/config.ts
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function fetchConfig(rpc, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID, commitment) {
+  const [configAddress] = await chunkDPKVNI6Q_cjs.getConfigAddress(programId);
+  const response = await rpc.getAccountInfo(configAddress, {
+    encoding: "base64",
+    commitment
+  }).send();
+  if (!response.value) {
+    return null;
+  }
+  return chunkBXATWUGJ_cjs.decodeAmmConfig(base64ToBytes(response.value.data[0]));
+}
+async function fetchConfigWithAddress(rpc, programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID, commitment) {
+  const [configAddress] = await chunkDPKVNI6Q_cjs.getConfigAddress(programId);
+  const account = await fetchConfig(rpc, programId, commitment);
+  if (!account) {
+    return null;
+  }
+  return { address: configAddress, account };
+}
+
+// src/solana/initializer/index.ts
+var initializer_exports = {};
+chunkQ7SFCCGT_cjs.__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,
+  DIRECTION_SELL: () => DIRECTION_SELL,
+  DOPPLER_DEVNET_ALT: () => DOPPLER_DEVNET_ALT,
+  EMPTY_REMAINING_ACCOUNTS_HASH: () => EMPTY_REMAINING_ACCOUNTS_HASH,
+  INITIALIZER_ACCOUNT_DISCRIMINATORS: () => INITIALIZER_ACCOUNT_DISCRIMINATORS,
+  INITIALIZER_INSTRUCTION_DISCRIMINATORS: () => INITIALIZER_INSTRUCTION_DISCRIMINATORS,
+  INITIALIZER_PROGRAM_ID: () => INITIALIZER_PROGRAM_ID,
+  MAX_CALLDATA: () => MAX_CALLDATA,
+  MAX_MIGRATOR_ALLOWLIST: () => MAX_MIGRATOR_ALLOWLIST,
+  MAX_SENTINEL_ALLOWLIST: () => MAX_SENTINEL_ALLOWLIST2,
+  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,
+  createInitializeLaunchInstruction: () => createInitializeLaunchInstruction,
+  createMigrateLaunchInstruction: () => createMigrateLaunchInstruction,
+  createPreviewMigrationInstruction: () => createPreviewMigrationInstruction,
+  createPreviewSwapExactInInstruction: () => createPreviewSwapExactInInstruction,
+  createSetMigratorAllowlistInstruction: () => createSetMigratorAllowlistInstruction,
+  createSetSentinelAllowlistInstruction: () => createSetSentinelAllowlistInstruction,
+  decodePreviewMigrationResult: () => decodePreviewMigrationResult,
+  decodePreviewSwapExactInResult: () => decodePreviewSwapExactInResult,
+  encodeU64LE: () => encodeU64LE,
+  fetchAllLaunches: () => fetchAllLaunches,
+  fetchLaunch: () => fetchLaunch2,
+  fetchLaunchesByAuthority: () => fetchLaunchesByAuthority,
+  getConfigAddress: () => getConfigAddress2,
+  getInitConfigCodec: () => getInitConfigCodec,
+  getInitConfigDecoder: () => getInitConfigDecoder,
+  getInitConfigEncoder: () => getInitConfigEncoder,
+  getInitializeConfigArgsCodec: () => getInitializeConfigArgsCodec,
+  getInitializeConfigArgsDecoder: () => getInitializeConfigArgsDecoder,
+  getInitializeConfigArgsEncoder: () => getInitializeConfigArgsEncoder,
+  getInitializeLaunchArgsCodec: () => getInitializeLaunchArgsCodec,
+  getInitializeLaunchArgsDecoder: () => getInitializeLaunchArgsDecoder,
+  getInitializeLaunchArgsEncoder: () => getInitializeLaunchArgsEncoder,
+  getLaunchAddress: () => getLaunchAddress,
+  getLaunchAuthorityAddress: () => getLaunchAuthorityAddress,
+  getLaunchCodec: () => getLaunchCodec,
+  getLaunchDecoder: () => getLaunchDecoder,
+  getLaunchEncoder: () => getLaunchEncoder,
+  getProgramDataAddress: () => getProgramDataAddress,
+  getTokenMetadataAddress: () => getTokenMetadataAddress,
+  launchExists: () => launchExists,
+  launchIdFromU64: () => launchIdFromU64,
+  phaseLabel: () => phaseLabel
+});
+var INITIALIZER_PROGRAM_ID = kit.address(
+  "4h3Dqyo5qmteJoMxXt3tdtfXELDB6pdRTPU9mWruiKp1"
+);
+var BPF_LOADER_UPGRADEABLE_PROGRAM_ID = kit.address(
+  "BPFLoaderUpgradeab1e11111111111111111111111"
+);
+var CPMM_SENTINEL_PROGRAM_ID = kit.address(
+  "2vJ1c62knEwZbxp3XdHB4RSmCfz55pA6tRkCho63gW7u"
+);
+var PREDICTION_SENTINEL_PROGRAM_ID = kit.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([
+  232,
+  231,
+  118,
+  38,
+  88,
+  111,
+  115,
+  185,
+  85,
+  54,
+  76,
+  123,
+  75,
+  191,
+  11,
+  183,
+  247,
+  104,
+  94,
+  189,
+  64,
+  232,
+  82,
+  177,
+  100,
+  99,
+  58,
+  74,
+  203,
+  211,
+  36,
+  76
+]);
+var DOPPLER_DEVNET_ALT = kit.address(
+  "7r5rdLkGMzTq5Q2kBhkePw4ZTeZEooHgTXktYoamNmVq"
+);
+var MAX_MIGRATOR_ALLOWLIST = 32;
+var MAX_SENTINEL_ALLOWLIST2 = 32;
+var MAX_CALLDATA = 256;
+var PHASE_TRADING = 0;
+var PHASE_MIGRATED = 1;
+var PHASE_ABORTED = 2;
+var DIRECTION_BUY = 0;
+var DIRECTION_SELL = 1;
+var CURVE_KIND_XYK = 0;
+var CURVE_PARAMS_FORMAT_XYK_V0 = 0;
+var SF_BEFORE_SWAP2 = 1 << 0;
+var SF_AFTER_SWAP2 = 1 << 1;
+var SENTINEL_NO_CHANGE2 = 65535;
+var INITIALIZER_INSTRUCTION_DISCRIMINATORS = {
+  // SHA256("global:initialize_config")[0:8]
+  initializeConfig: new Uint8Array([
+    208,
+    127,
+    21,
+    1,
+    194,
+    190,
+    196,
+    70
+  ]),
+  // SHA256("global:set_migrator_allowlist")[0:8]
+  setMigratorAllowlist: new Uint8Array([
+    209,
+    90,
+    181,
+    104,
+    99,
+    108,
+    233,
+    168
+  ]),
+  // SHA256("global:set_sentinel_allowlist")[0:8]
+  setSentinelAllowlist: new Uint8Array([
+    233,
+    72,
+    180,
+    246,
+    171,
+    117,
+    21,
+    50
+  ]),
+  // SHA256("global:initialize_launch")[0:8]
+  initializeLaunch: new Uint8Array([
+    90,
+    201,
+    220,
+    142,
+    112,
+    253,
+    100,
+    13
+  ]),
+  // SHA256("global:curve_swap_exact_in")[0:8]
+  curveSwapExactIn: new Uint8Array([
+    196,
+    247,
+    195,
+    126,
+    227,
+    27,
+    166,
+    93
+  ]),
+  // SHA256("global:migrate_launch")[0:8]
+  migrateLaunch: new Uint8Array([
+    19,
+    199,
+    119,
+    103,
+    13,
+    30,
+    12,
+    205
+  ]),
+  // SHA256("global:abort_launch")[0:8]
+  abortLaunch: new Uint8Array([44, 112, 192, 235, 227, 61, 179, 7]),
+  // SHA256("global:preview_swap_exact_in")[0:8]
+  previewSwapExactIn: new Uint8Array([
+    50,
+    130,
+    31,
+    69,
+    147,
+    58,
+    222,
+    178
+  ]),
+  // SHA256("global:preview_migration")[0:8]
+  previewMigration: new Uint8Array([
+    216,
+    180,
+    209,
+    112,
+    62,
+    16,
+    15,
+    63
+  ])
+};
+var INITIALIZER_ACCOUNT_DISCRIMINATORS = {
+  // SHA256("account:InitConfig")[0:8]
+  InitConfig: new Uint8Array([97, 166, 35, 7, 20, 2, 164, 126]),
+  // SHA256("account:Launch")[0:8]
+  Launch: new Uint8Array([144, 51, 51, 163, 206, 85, 213, 38])
+};
+var INIT_CONFIG_DISCRIMINATOR = new Uint8Array([
+  97,
+  166,
+  35,
+  7,
+  20,
+  2,
+  164,
+  126
+]);
+function getInitConfigEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["admin", kit.getAddressEncoder()],
+      ["migratorAllowlistLen", kit.getU8Encoder()],
+      ["migratorAllowlist", kit.getArrayEncoder(kit.getAddressEncoder(), { size: 32 })],
+      ["sentinelAllowlistLen", kit.getU8Encoder()],
+      ["sentinelAllowlist", kit.getArrayEncoder(kit.getAddressEncoder(), { size: 32 })],
+      ["bump", kit.getU8Encoder()],
+      ["version", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 31)]
+    ]),
+    (value) => ({ ...value, discriminator: INIT_CONFIG_DISCRIMINATOR })
+  );
+}
+function getInitConfigDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["admin", kit.getAddressDecoder()],
+    ["migratorAllowlistLen", kit.getU8Decoder()],
+    ["migratorAllowlist", kit.getArrayDecoder(kit.getAddressDecoder(), { size: 32 })],
+    ["sentinelAllowlistLen", kit.getU8Decoder()],
+    ["sentinelAllowlist", kit.getArrayDecoder(kit.getAddressDecoder(), { size: 32 })],
+    ["bump", kit.getU8Decoder()],
+    ["version", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 31)]
+  ]);
+}
+function getInitConfigCodec() {
+  return kit.combineCodec(getInitConfigEncoder(), getInitConfigDecoder());
+}
+function getCalldataBufEncoder() {
+  return kit.getStructEncoder([
+    ["len", kit.getU16Encoder()],
+    ["bytes", kit.fixEncoderSize(kit.getBytesEncoder(), 256)]
+  ]);
+}
+function getCalldataBufDecoder() {
+  return kit.getStructDecoder([
+    ["len", kit.getU16Decoder()],
+    ["bytes", kit.fixDecoderSize(kit.getBytesDecoder(), 256)]
+  ]);
+}
+function getInitializeConfigArgsEncoder() {
+  return kit.getStructEncoder([
+    ["migratorAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())],
+    ["sentinelAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
+  ]);
+}
+function getInitializeConfigArgsDecoder() {
+  return kit.getStructDecoder([
+    ["migratorAllowlist", kit.getArrayDecoder(kit.getAddressDecoder())],
+    ["sentinelAllowlist", kit.getArrayDecoder(kit.getAddressDecoder())]
+  ]);
+}
+function getInitializeConfigArgsCodec() {
+  return kit.combineCodec(
+    getInitializeConfigArgsEncoder(),
+    getInitializeConfigArgsDecoder()
+  );
+}
+function getInitializeLaunchArgsEncoder() {
+  return kit.getStructEncoder([
+    ["namespace", kit.getAddressEncoder()],
+    ["launchId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["baseDecimals", kit.getU8Encoder()],
+    ["baseTotalSupply", kit.getU64Encoder()],
+    ["baseForDistribution", kit.getU64Encoder()],
+    ["baseForLiquidity", kit.getU64Encoder()],
+    ["curveVirtualBase", kit.getU64Encoder()],
+    ["curveVirtualQuote", kit.getU64Encoder()],
+    ["curveFeeBps", kit.getU16Encoder()],
+    ["curveKind", kit.getU8Encoder()],
+    ["curveParams", kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())],
+    ["allowBuy", kit.getU8Encoder()],
+    ["allowSell", kit.getU8Encoder()],
+    ["sentinelProgram", kit.getAddressEncoder()],
+    ["sentinelFlags", kit.getU32Encoder()],
+    [
+      "sentinelCalldata",
+      kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())
+    ],
+    ["migratorProgram", kit.getAddressEncoder()],
+    [
+      "migratorInitCalldata",
+      kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())
+    ],
+    [
+      "migratorMigrateCalldata",
+      kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())
+    ],
+    ["sentinelRemainingAccountsHash", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["migratorRemainingAccountsHash", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["metadataName", kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU32Encoder())],
+    ["metadataSymbol", kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU32Encoder())],
+    ["metadataUri", kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU32Encoder())]
+  ]);
+}
+function getInitializeLaunchArgsDecoder() {
+  return kit.getStructDecoder([
+    ["namespace", kit.getAddressDecoder()],
+    ["launchId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["baseDecimals", kit.getU8Decoder()],
+    ["baseTotalSupply", kit.getU64Decoder()],
+    ["baseForDistribution", kit.getU64Decoder()],
+    ["baseForLiquidity", kit.getU64Decoder()],
+    ["curveVirtualBase", kit.getU64Decoder()],
+    ["curveVirtualQuote", kit.getU64Decoder()],
+    ["curveFeeBps", kit.getU16Decoder()],
+    ["curveKind", kit.getU8Decoder()],
+    ["curveParams", kit.addDecoderSizePrefix(kit.getBytesDecoder(), kit.getU32Decoder())],
+    ["allowBuy", kit.getU8Decoder()],
+    ["allowSell", kit.getU8Decoder()],
+    ["sentinelProgram", kit.getAddressDecoder()],
+    ["sentinelFlags", kit.getU32Decoder()],
+    [
+      "sentinelCalldata",
+      kit.addDecoderSizePrefix(kit.getBytesDecoder(), kit.getU32Decoder())
+    ],
+    ["migratorProgram", kit.getAddressDecoder()],
+    [
+      "migratorInitCalldata",
+      kit.addDecoderSizePrefix(kit.getBytesDecoder(), kit.getU32Decoder())
+    ],
+    [
+      "migratorMigrateCalldata",
+      kit.addDecoderSizePrefix(kit.getBytesDecoder(), kit.getU32Decoder())
+    ],
+    ["sentinelRemainingAccountsHash", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["migratorRemainingAccountsHash", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["metadataName", kit.addDecoderSizePrefix(kit.getUtf8Decoder(), kit.getU32Decoder())],
+    ["metadataSymbol", kit.addDecoderSizePrefix(kit.getUtf8Decoder(), kit.getU32Decoder())],
+    ["metadataUri", kit.addDecoderSizePrefix(kit.getUtf8Decoder(), kit.getU32Decoder())]
+  ]);
+}
+function getInitializeLaunchArgsCodec() {
+  return kit.combineCodec(
+    getInitializeLaunchArgsEncoder(),
+    getInitializeLaunchArgsDecoder()
+  );
+}
+
+// src/solana/generated/initializer/accounts/launch.ts
+var LAUNCH_DISCRIMINATOR = new Uint8Array([
+  144,
+  51,
+  51,
+  163,
+  206,
+  85,
+  213,
+  38
+]);
+function getLaunchEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["authority", kit.getAddressEncoder()],
+      ["namespace", kit.getAddressEncoder()],
+      ["launchId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["phase", kit.getU8Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["launchAuthorityBump", kit.getU8Encoder()],
+      ["pad0", kit.fixEncoderSize(kit.getBytesEncoder(), 5)],
+      ["baseMint", kit.getAddressEncoder()],
+      ["quoteMint", kit.getAddressEncoder()],
+      ["baseVault", kit.getAddressEncoder()],
+      ["quoteVault", kit.getAddressEncoder()],
+      ["baseTotalSupply", kit.getU64Encoder()],
+      ["baseForDistribution", kit.getU64Encoder()],
+      ["baseForLiquidity", kit.getU64Encoder()],
+      ["baseForCurve", kit.getU64Encoder()],
+      ["curveVirtualBase", kit.getU64Encoder()],
+      ["curveVirtualQuote", kit.getU64Encoder()],
+      ["curveFeeBps", kit.getU16Encoder()],
+      ["pad1", kit.fixEncoderSize(kit.getBytesEncoder(), 6)],
+      ["allowBuy", kit.getU8Encoder()],
+      ["allowSell", kit.getU8Encoder()],
+      ["pad2", kit.fixEncoderSize(kit.getBytesEncoder(), 6)],
+      ["sentinelProgram", kit.getAddressEncoder()],
+      ["sentinelFlags", kit.getU32Encoder()],
+      ["pad3", kit.fixEncoderSize(kit.getBytesEncoder(), 4)],
+      ["sentinelCalldata", getCalldataBufEncoder()],
+      ["migratorProgram", kit.getAddressEncoder()],
+      ["migratorInitCalldata", getCalldataBufEncoder()],
+      ["migratorMigrateCalldata", getCalldataBufEncoder()],
+      ["curveKind", kit.getU8Encoder()],
+      ["swapLock", kit.getU8Encoder()],
+      ["pad4", kit.fixEncoderSize(kit.getBytesEncoder(), 6)],
+      ["curveParams", getCalldataBufEncoder()],
+      ["quoteDeposited", kit.getU64Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 64)]
+    ]),
+    (value) => ({ ...value, discriminator: LAUNCH_DISCRIMINATOR })
+  );
+}
+function getLaunchDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["authority", kit.getAddressDecoder()],
+    ["namespace", kit.getAddressDecoder()],
+    ["launchId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["phase", kit.getU8Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["launchAuthorityBump", kit.getU8Decoder()],
+    ["pad0", kit.fixDecoderSize(kit.getBytesDecoder(), 5)],
+    ["baseMint", kit.getAddressDecoder()],
+    ["quoteMint", kit.getAddressDecoder()],
+    ["baseVault", kit.getAddressDecoder()],
+    ["quoteVault", kit.getAddressDecoder()],
+    ["baseTotalSupply", kit.getU64Decoder()],
+    ["baseForDistribution", kit.getU64Decoder()],
+    ["baseForLiquidity", kit.getU64Decoder()],
+    ["baseForCurve", kit.getU64Decoder()],
+    ["curveVirtualBase", kit.getU64Decoder()],
+    ["curveVirtualQuote", kit.getU64Decoder()],
+    ["curveFeeBps", kit.getU16Decoder()],
+    ["pad1", kit.fixDecoderSize(kit.getBytesDecoder(), 6)],
+    ["allowBuy", kit.getU8Decoder()],
+    ["allowSell", kit.getU8Decoder()],
+    ["pad2", kit.fixDecoderSize(kit.getBytesDecoder(), 6)],
+    ["sentinelProgram", kit.getAddressDecoder()],
+    ["sentinelFlags", kit.getU32Decoder()],
+    ["pad3", kit.fixDecoderSize(kit.getBytesDecoder(), 4)],
+    ["sentinelCalldata", getCalldataBufDecoder()],
+    ["migratorProgram", kit.getAddressDecoder()],
+    ["migratorInitCalldata", getCalldataBufDecoder()],
+    ["migratorMigrateCalldata", getCalldataBufDecoder()],
+    ["curveKind", kit.getU8Decoder()],
+    ["swapLock", kit.getU8Decoder()],
+    ["pad4", kit.fixDecoderSize(kit.getBytesDecoder(), 6)],
+    ["curveParams", getCalldataBufDecoder()],
+    ["quoteDeposited", kit.getU64Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 64)]
+  ]);
+}
+function getLaunchCodec() {
+  return kit.combineCodec(getLaunchEncoder(), getLaunchDecoder());
+}
+var CURVE_SWAP_EXACT_IN_DISCRIMINATOR = new Uint8Array([
+  196,
+  247,
+  195,
+  126,
+  227,
+  27,
+  166,
+  93
+]);
+function getCurveSwapExactInInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["amountIn", kit.getU64Encoder()],
+      ["minAmountOut", kit.getU64Encoder()],
+      ["direction", kit.getU8Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CURVE_SWAP_EXACT_IN_DISCRIMINATOR })
+  );
+}
+var INITIALIZE_CONFIG_DISCRIMINATOR = new Uint8Array([
+  208,
+  127,
+  21,
+  1,
+  194,
+  190,
+  196,
+  70
+]);
+function getInitializeConfigInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["migratorAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())],
+      ["sentinelAllowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_CONFIG_DISCRIMINATOR })
+  );
+}
+var INITIALIZE_LAUNCH_DISCRIMINATOR = new Uint8Array([
+  90,
+  201,
+  220,
+  142,
+  112,
+  253,
+  100,
+  13
+]);
+function getInitializeLaunchInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["namespace", kit.getAddressEncoder()],
+      ["launchId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["baseDecimals", kit.getU8Encoder()],
+      ["baseTotalSupply", kit.getU64Encoder()],
+      ["baseForDistribution", kit.getU64Encoder()],
+      ["baseForLiquidity", kit.getU64Encoder()],
+      ["curveVirtualBase", kit.getU64Encoder()],
+      ["curveVirtualQuote", kit.getU64Encoder()],
+      ["curveFeeBps", kit.getU16Encoder()],
+      ["curveKind", kit.getU8Encoder()],
+      ["curveParams", kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())],
+      ["allowBuy", kit.getU8Encoder()],
+      ["allowSell", kit.getU8Encoder()],
+      ["sentinelProgram", kit.getAddressEncoder()],
+      ["sentinelFlags", kit.getU32Encoder()],
+      [
+        "sentinelCalldata",
+        kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())
+      ],
+      ["migratorProgram", kit.getAddressEncoder()],
+      [
+        "migratorInitCalldata",
+        kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())
+      ],
+      [
+        "migratorMigrateCalldata",
+        kit.addEncoderSizePrefix(kit.getBytesEncoder(), kit.getU32Encoder())
+      ],
+      ["sentinelRemainingAccountsHash", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["migratorRemainingAccountsHash", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["metadataName", kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU32Encoder())],
+      [
+        "metadataSymbol",
+        kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU32Encoder())
+      ],
+      ["metadataUri", kit.addEncoderSizePrefix(kit.getUtf8Encoder(), kit.getU32Encoder())]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_LAUNCH_DISCRIMINATOR })
+  );
+}
+var PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR = new Uint8Array([
+  50,
+  130,
+  31,
+  69,
+  147,
+  58,
+  222,
+  178
+]);
+function getPreviewSwapExactInInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["amountIn", kit.getU64Encoder()],
+      ["direction", kit.getU8Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: PREVIEW_SWAP_EXACT_IN_DISCRIMINATOR
+    })
+  );
+}
+var SET_MIGRATOR_ALLOWLIST_DISCRIMINATOR = new Uint8Array([
+  209,
+  90,
+  181,
+  104,
+  99,
+  108,
+  233,
+  168
+]);
+function getSetMigratorAllowlistInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["allowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: SET_MIGRATOR_ALLOWLIST_DISCRIMINATOR
+    })
+  );
+}
+var SET_SENTINEL_ALLOWLIST_DISCRIMINATOR = new Uint8Array([
+  233,
+  72,
+  180,
+  246,
+  171,
+  117,
+  21,
+  50
+]);
+function getSetSentinelAllowlistInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["allowlist", kit.getArrayEncoder(kit.getAddressEncoder())]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: SET_SENTINEL_ALLOWLIST_DISCRIMINATOR
+    })
+  );
+}
+if (process.env.NODE_ENV !== "production") ;
+var addressCodec2 = kit.getAddressCodec();
+var textEncoder2 = new TextEncoder();
+function encodeU64LE(value) {
+  const bytes = new Uint8Array(8);
+  const view = new DataView(bytes.buffer);
+  view.setBigUint64(0, value, true);
+  return bytes;
+}
+async function getConfigAddress2(programId = INITIALIZER_PROGRAM_ID) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder2.encode(SEED_CONFIG2)]
+  });
+}
+async function getProgramDataAddress(programId = INITIALIZER_PROGRAM_ID) {
+  return kit.getProgramDerivedAddress({
+    programAddress: BPF_LOADER_UPGRADEABLE_PROGRAM_ID,
+    seeds: [addressCodec2.encode(programId)]
+  });
+}
+async function getLaunchAddress(namespace, launchId, programId = INITIALIZER_PROGRAM_ID) {
+  if (launchId.length !== 32) {
+    throw new Error("launchId must be 32 bytes");
+  }
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder2.encode(SEED_LAUNCH),
+      addressCodec2.encode(namespace),
+      launchId
+    ]
+  });
+}
+async function getLaunchAuthorityAddress(launch, programId = INITIALIZER_PROGRAM_ID) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder2.encode(SEED_LAUNCH_AUTHORITY),
+      addressCodec2.encode(launch)
+    ]
+  });
+}
+function launchIdFromU64(launchId) {
+  const out = new Uint8Array(32);
+  out.set(encodeU64LE(launchId), 0);
+  return out;
+}
+function isTransactionSigner2(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createSignerAccountMeta2(value, role) {
+  if (isTransactionSigner2(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createInitializeConfigInstruction2(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
+  const {
+    admin,
+    config,
+    programData,
+    systemProgram = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    createSignerAccountMeta2(admin, kit.AccountRole.WRITABLE_SIGNER),
+    { address: config, role: kit.AccountRole.WRITABLE },
+    { address: programData, role: kit.AccountRole.READONLY },
+    { address: systemProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = new Uint8Array(
+    getInitializeConfigInstructionDataEncoder().encode(args)
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+function isTransactionSigner3(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createSignerAccountMeta3(value, role) {
+  if (isTransactionSigner3(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createSetMigratorAllowlistInstruction(accounts, allowlist, programId = INITIALIZER_PROGRAM_ID) {
+  const { admin, config } = accounts;
+  const keys = [
+    createSignerAccountMeta3(admin, kit.AccountRole.WRITABLE_SIGNER),
+    { address: config, role: kit.AccountRole.WRITABLE }
+  ];
+  const data = new Uint8Array(
+    getSetMigratorAllowlistInstructionDataEncoder().encode({ allowlist })
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+function isTransactionSigner4(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createSignerAccountMeta4(value, role) {
+  if (isTransactionSigner4(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createSetSentinelAllowlistInstruction(accounts, allowlist, programId = INITIALIZER_PROGRAM_ID) {
+  const { admin, config } = accounts;
+  const keys = [
+    createSignerAccountMeta4(admin, kit.AccountRole.WRITABLE_SIGNER),
+    { address: config, role: kit.AccountRole.WRITABLE }
+  ];
+  const data = new Uint8Array(
+    getSetSentinelAllowlistInstructionDataEncoder().encode({ allowlist })
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+var CPMM_MIGRATOR_PROGRAM_ID = kit.address(
+  "7WMUTNC41eMCo6eGH5Sy2xbgE3AycvLbFPo95AU9CSUd"
+);
+var SEED_STATE = "state";
+var MAX_RECIPIENTS = 2;
+var CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS = {
+  // SHA256("global:register_launch")[0:8]
+  registerLaunch: new Uint8Array([
+    114,
+    114,
+    67,
+    23,
+    41,
+    70,
+    0,
+    225
+  ]),
+  // SHA256("global:migrate")[0:8]
+  migrate: new Uint8Array([155, 234, 231, 146, 236, 158, 162, 30])
+};
+var CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS = {
+  // SHA256("account:CpmmMigratorState")[0:8]
+  CpmmMigratorState: new Uint8Array([
+    169,
+    86,
+    255,
+    187,
+    37,
+    248,
+    11,
+    176
+  ])
+};
+var addressCodec3 = kit.getAddressCodec();
+var textEncoder3 = new TextEncoder();
+async function getCpmmMigratorStateAddress(launch, programId = CPMM_MIGRATOR_PROGRAM_ID) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder3.encode(SEED_STATE), addressCodec3.encode(launch)]
+  });
+}
+var CLAIM_RECEIPT_DISCRIMINATOR = new Uint8Array([
+  223,
+  233,
+  11,
+  229,
+  124,
+  165,
+  207,
+  28
+]);
+function getClaimReceiptDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    CLAIM_RECEIPT_DISCRIMINATOR
+  );
+}
+function getClaimReceiptEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["market", kit.getAddressEncoder()],
+      ["claimer", kit.getAddressEncoder()],
+      ["burnedAmount", kit.getU64Encoder()],
+      ["rewardDebt", kit.getU128Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 7)]
+    ]),
+    (value) => ({ ...value, discriminator: CLAIM_RECEIPT_DISCRIMINATOR })
+  );
+}
+function getClaimReceiptDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["market", kit.getAddressDecoder()],
+    ["claimer", kit.getAddressDecoder()],
+    ["burnedAmount", kit.getU64Decoder()],
+    ["rewardDebt", kit.getU128Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 7)]
+  ]);
+}
+function getClaimReceiptCodec() {
+  return kit.combineCodec(getClaimReceiptEncoder(), getClaimReceiptDecoder());
+}
+function decodeClaimReceipt(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getClaimReceiptDecoder()
+  );
+}
+async function fetchClaimReceipt(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeClaimReceipt(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeClaimReceipt(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeClaimReceipt(maybeAccount);
+}
+async function fetchAllClaimReceipt(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeClaimReceipt(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeClaimReceipt(rpc, addresses, config) {
+  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeClaimReceipt(maybeAccount));
+}
+function getClaimReceiptSize() {
+  return 104;
+}
+var ENTRY_DISCRIMINATOR = new Uint8Array([
+  63,
+  18,
+  152,
+  113,
+  215,
+  246,
+  221,
+  250
+]);
+function getEntryDiscriminatorBytes() {
+  return kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(ENTRY_DISCRIMINATOR);
+}
+function getEntryEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["oracle", kit.getAddressEncoder()],
+      ["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["baseMint", kit.getAddressEncoder()],
+      ["contribution", kit.getU64Encoder()],
+      ["isMigrated", kit.getBooleanEncoder()],
+      ["bump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 14)]
+    ]),
+    (value) => ({ ...value, discriminator: ENTRY_DISCRIMINATOR })
+  );
+}
+function getEntryDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["oracle", kit.getAddressDecoder()],
+    ["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["baseMint", kit.getAddressDecoder()],
+    ["contribution", kit.getU64Decoder()],
+    ["isMigrated", kit.getBooleanDecoder()],
+    ["bump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 14)]
+  ]);
+}
+function getEntryCodec() {
+  return kit.combineCodec(getEntryEncoder(), getEntryDecoder());
+}
+function decodeEntry(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getEntryDecoder()
+  );
+}
+async function fetchEntry(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeEntry(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeEntry(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeEntry(maybeAccount);
+}
+async function fetchAllEntry(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeEntry(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeEntry(rpc, addresses, config) {
+  const maybeAccounts = await kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ENTRY_BY_MINT_DISCRIMINATOR
+  );
+}
+function getEntryByMintEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["oracle", kit.getAddressEncoder()],
+      ["baseMint", kit.getAddressEncoder()],
+      ["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["bump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 7)]
+    ]),
+    (value) => ({ ...value, discriminator: ENTRY_BY_MINT_DISCRIMINATOR })
+  );
+}
+function getEntryByMintDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["oracle", kit.getAddressDecoder()],
+    ["baseMint", kit.getAddressDecoder()],
+    ["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["bump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 7)]
+  ]);
+}
+function getEntryByMintCodec() {
+  return kit.combineCodec(getEntryByMintEncoder(), getEntryByMintDecoder());
+}
+function decodeEntryByMint(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getEntryByMintDecoder()
+  );
+}
+async function fetchEntryByMint(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeEntryByMint(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeEntryByMint(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeEntryByMint(maybeAccount);
+}
+async function fetchAllEntryByMint(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeEntryByMint(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeEntryByMint(rpc, addresses, config) {
+  const maybeAccounts = await kit.fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeEntryByMint(maybeAccount));
+}
+function getEntryByMintSize() {
+  return 112;
+}
+function getAccumulatorUpdatedEncoder() {
+  return kit.getStructEncoder([
+    ["market", kit.getAddressEncoder()],
+    ["newTotalPot", kit.getU64Encoder()],
+    ["newAccQuotePerToken", kit.getU128Encoder()]
+  ]);
+}
+function getAccumulatorUpdatedDecoder() {
+  return kit.getStructDecoder([
+    ["market", kit.getAddressDecoder()],
+    ["newTotalPot", kit.getU64Decoder()],
+    ["newAccQuotePerToken", kit.getU128Decoder()]
+  ]);
+}
+function getAccumulatorUpdatedCodec() {
+  return kit.combineCodec(
+    getAccumulatorUpdatedEncoder(),
+    getAccumulatorUpdatedDecoder()
+  );
+}
+function getCalldataBufEncoder2() {
+  return kit.getStructEncoder([
+    ["len", kit.getU16Encoder()],
+    ["bytes", kit.fixEncoderSize(kit.getBytesEncoder(), 256)]
+  ]);
+}
+function getCalldataBufDecoder2() {
+  return kit.getStructDecoder([
+    ["len", kit.getU16Decoder()],
+    ["bytes", kit.fixDecoderSize(kit.getBytesDecoder(), 256)]
+  ]);
+}
+function getCalldataBufCodec() {
+  return kit.combineCodec(getCalldataBufEncoder2(), getCalldataBufDecoder2());
+}
+function getEntryMigratedEncoder() {
+  return kit.getStructEncoder([
+    ["market", kit.getAddressEncoder()],
+    ["oracle", kit.getAddressEncoder()],
+    ["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["baseMint", kit.getAddressEncoder()],
+    ["contribution", kit.getU64Encoder()],
+    ["isWinner", kit.getBooleanEncoder()]
+  ]);
+}
+function getEntryMigratedDecoder() {
+  return kit.getStructDecoder([
+    ["market", kit.getAddressDecoder()],
+    ["oracle", kit.getAddressDecoder()],
+    ["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["baseMint", kit.getAddressDecoder()],
+    ["contribution", kit.getU64Decoder()],
+    ["isWinner", kit.getBooleanDecoder()]
+  ]);
+}
+function getEntryMigratedCodec() {
+  return kit.combineCodec(getEntryMigratedEncoder(), getEntryMigratedDecoder());
+}
+function getEntryRegisteredEncoder() {
+  return kit.getStructEncoder([
+    ["market", kit.getAddressEncoder()],
+    ["oracle", kit.getAddressEncoder()],
+    ["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+    ["baseMint", kit.getAddressEncoder()]
+  ]);
+}
+function getEntryRegisteredDecoder() {
+  return kit.getStructDecoder([
+    ["market", kit.getAddressDecoder()],
+    ["oracle", kit.getAddressDecoder()],
+    ["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["baseMint", kit.getAddressDecoder()]
+  ]);
+}
+function getEntryRegisteredCodec() {
+  return kit.combineCodec(getEntryRegisteredEncoder(), getEntryRegisteredDecoder());
+}
+function getMarketCreatedEncoder() {
+  return kit.getStructEncoder([
+    ["market", kit.getAddressEncoder()],
+    ["oracle", kit.getAddressEncoder()],
+    ["quoteMint", kit.getAddressEncoder()]
+  ]);
+}
+function getMarketCreatedDecoder() {
+  return kit.getStructDecoder([
+    ["market", kit.getAddressDecoder()],
+    ["oracle", kit.getAddressDecoder()],
+    ["quoteMint", kit.getAddressDecoder()]
+  ]);
+}
+function getMarketCreatedCodec() {
+  return kit.combineCodec(getMarketCreatedEncoder(), getMarketCreatedDecoder());
+}
+function getMarketResolvedEncoder() {
+  return kit.getStructEncoder([
+    ["market", kit.getAddressEncoder()],
+    ["oracle", kit.getAddressEncoder()],
+    ["winnerMint", kit.getAddressEncoder()],
+    ["claimableSupply", kit.getU64Encoder()],
+    ["totalPot", kit.getU64Encoder()]
+  ]);
+}
+function getMarketResolvedDecoder() {
+  return kit.getStructDecoder([
+    ["market", kit.getAddressDecoder()],
+    ["oracle", kit.getAddressDecoder()],
+    ["winnerMint", kit.getAddressDecoder()],
+    ["claimableSupply", kit.getU64Decoder()],
+    ["totalPot", kit.getU64Decoder()]
+  ]);
+}
+function getMarketResolvedCodec() {
+  return kit.combineCodec(getMarketResolvedEncoder(), getMarketResolvedDecoder());
+}
+function getMigrateEntryArgsEncoder() {
+  return kit.getStructEncoder([["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)]]);
+}
+function getMigrateEntryArgsDecoder() {
+  return kit.getStructDecoder([["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)]]);
+}
+function getMigrateEntryArgsCodec() {
+  return kit.combineCodec(
+    getMigrateEntryArgsEncoder(),
+    getMigrateEntryArgsDecoder()
+  );
+}
+function getPreviewPayoutIfWinnerArgsEncoder() {
+  return kit.getStructEncoder([
+    ["candidateWinnerMint", kit.getAddressEncoder()],
+    ["tokenAmount", kit.getU64Encoder()]
+  ]);
+}
+function getPreviewPayoutIfWinnerArgsDecoder() {
+  return kit.getStructDecoder([
+    ["candidateWinnerMint", kit.getAddressDecoder()],
+    ["tokenAmount", kit.getU64Decoder()]
+  ]);
+}
+function getPreviewPayoutIfWinnerArgsCodec() {
+  return kit.combineCodec(
+    getPreviewPayoutIfWinnerArgsEncoder(),
+    getPreviewPayoutIfWinnerArgsDecoder()
+  );
+}
+function getRegisterEntryArgsEncoder() {
+  return kit.getStructEncoder([["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)]]);
+}
+function getRegisterEntryArgsDecoder() {
+  return kit.getStructDecoder([["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)]]);
+}
+function getRegisterEntryArgsCodec() {
+  return kit.combineCodec(
+    getRegisterEntryArgsEncoder(),
+    getRegisterEntryArgsDecoder()
+  );
+}
+function getRewardsClaimedEncoder() {
+  return kit.getStructEncoder([
+    ["market", kit.getAddressEncoder()],
+    ["claimer", kit.getAddressEncoder()],
+    ["burnedAmount", kit.getU64Encoder()],
+    ["rewardAmount", kit.getU64Encoder()],
+    ["totalBurned", kit.getU64Encoder()]
+  ]);
+}
+function getRewardsClaimedDecoder() {
+  return kit.getStructDecoder([
+    ["market", kit.getAddressDecoder()],
+    ["claimer", kit.getAddressDecoder()],
+    ["burnedAmount", kit.getU64Decoder()],
+    ["rewardAmount", kit.getU64Decoder()],
+    ["totalBurned", kit.getU64Decoder()]
+  ]);
+}
+function getRewardsClaimedCodec() {
+  return kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(LAUNCH_DISCRIMINATOR2);
+}
+function getLaunchEncoder2() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["authority", kit.getAddressEncoder()],
+      ["namespace", kit.getAddressEncoder()],
+      ["launchId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)],
+      ["phase", kit.getU8Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["launchAuthorityBump", kit.getU8Encoder()],
+      ["pad0", kit.fixEncoderSize(kit.getBytesEncoder(), 5)],
+      ["baseMint", kit.getAddressEncoder()],
+      ["quoteMint", kit.getAddressEncoder()],
+      ["baseVault", kit.getAddressEncoder()],
+      ["quoteVault", kit.getAddressEncoder()],
+      ["baseTotalSupply", kit.getU64Encoder()],
+      ["baseForDistribution", kit.getU64Encoder()],
+      ["baseForLiquidity", kit.getU64Encoder()],
+      ["baseForCurve", kit.getU64Encoder()],
+      ["curveVirtualBase", kit.getU64Encoder()],
+      ["curveVirtualQuote", kit.getU64Encoder()],
+      ["curveFeeBps", kit.getU16Encoder()],
+      ["pad1", kit.fixEncoderSize(kit.getBytesEncoder(), 6)],
+      ["allowBuy", kit.getU8Encoder()],
+      ["allowSell", kit.getU8Encoder()],
+      ["pad2", kit.fixEncoderSize(kit.getBytesEncoder(), 6)],
+      ["sentinelProgram", kit.getAddressEncoder()],
+      ["sentinelFlags", kit.getU32Encoder()],
+      ["pad3", kit.fixEncoderSize(kit.getBytesEncoder(), 4)],
+      ["sentinelCalldata", getCalldataBufEncoder2()],
+      ["migratorProgram", kit.getAddressEncoder()],
+      ["migratorInitCalldata", getCalldataBufEncoder2()],
+      ["migratorMigrateCalldata", getCalldataBufEncoder2()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 64)]
+    ]),
+    (value) => ({ ...value, discriminator: LAUNCH_DISCRIMINATOR2 })
+  );
+}
+function getLaunchDecoder2() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["authority", kit.getAddressDecoder()],
+    ["namespace", kit.getAddressDecoder()],
+    ["launchId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)],
+    ["phase", kit.getU8Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["launchAuthorityBump", kit.getU8Decoder()],
+    ["pad0", kit.fixDecoderSize(kit.getBytesDecoder(), 5)],
+    ["baseMint", kit.getAddressDecoder()],
+    ["quoteMint", kit.getAddressDecoder()],
+    ["baseVault", kit.getAddressDecoder()],
+    ["quoteVault", kit.getAddressDecoder()],
+    ["baseTotalSupply", kit.getU64Decoder()],
+    ["baseForDistribution", kit.getU64Decoder()],
+    ["baseForLiquidity", kit.getU64Decoder()],
+    ["baseForCurve", kit.getU64Decoder()],
+    ["curveVirtualBase", kit.getU64Decoder()],
+    ["curveVirtualQuote", kit.getU64Decoder()],
+    ["curveFeeBps", kit.getU16Decoder()],
+    ["pad1", kit.fixDecoderSize(kit.getBytesDecoder(), 6)],
+    ["allowBuy", kit.getU8Decoder()],
+    ["allowSell", kit.getU8Decoder()],
+    ["pad2", kit.fixDecoderSize(kit.getBytesDecoder(), 6)],
+    ["sentinelProgram", kit.getAddressDecoder()],
+    ["sentinelFlags", kit.getU32Decoder()],
+    ["pad3", kit.fixDecoderSize(kit.getBytesDecoder(), 4)],
+    ["sentinelCalldata", getCalldataBufDecoder2()],
+    ["migratorProgram", kit.getAddressDecoder()],
+    ["migratorInitCalldata", getCalldataBufDecoder2()],
+    ["migratorMigrateCalldata", getCalldataBufDecoder2()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 64)]
+  ]);
+}
+function getLaunchCodec2() {
+  return kit.combineCodec(getLaunchEncoder2(), getLaunchDecoder2());
+}
+function decodeLaunch(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getLaunchDecoder2()
+  );
+}
+async function fetchLaunch(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeLaunch(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeLaunch(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeLaunch(maybeAccount);
+}
+async function fetchAllLaunch(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeLaunch(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeLaunch(rpc, addresses, config) {
+  const maybeAccounts = await kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(MARKET_DISCRIMINATOR);
+}
+function getMarketEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["oracle", kit.getAddressEncoder()],
+      ["quoteMint", kit.getAddressEncoder()],
+      ["potVault", kit.getAddressEncoder()],
+      ["totalPot", kit.getU64Encoder()],
+      ["totalClaimed", kit.getU64Encoder()],
+      ["winnerMint", kit.getAddressEncoder()],
+      ["claimableSupply", kit.getU64Encoder()],
+      ["accQuotePerToken", kit.getU128Encoder()],
+      ["isResolved", kit.getBooleanEncoder()],
+      ["bump", kit.getU8Encoder()],
+      ["marketAuthorityBump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 29)]
+    ]),
+    (value) => ({ ...value, discriminator: MARKET_DISCRIMINATOR })
+  );
+}
+function getMarketDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["oracle", kit.getAddressDecoder()],
+    ["quoteMint", kit.getAddressDecoder()],
+    ["potVault", kit.getAddressDecoder()],
+    ["totalPot", kit.getU64Decoder()],
+    ["totalClaimed", kit.getU64Decoder()],
+    ["winnerMint", kit.getAddressDecoder()],
+    ["claimableSupply", kit.getU64Decoder()],
+    ["accQuotePerToken", kit.getU128Decoder()],
+    ["isResolved", kit.getBooleanDecoder()],
+    ["bump", kit.getU8Decoder()],
+    ["marketAuthorityBump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 29)]
+  ]);
+}
+function getMarketCodec() {
+  return kit.combineCodec(getMarketEncoder(), getMarketDecoder());
+}
+function decodeMarket(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getMarketDecoder()
+  );
+}
+async function fetchMarket(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeMarket(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeMarket(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeMarket(maybeAccount);
+}
+async function fetchAllMarket(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeMarket(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeMarket(rpc, addresses, config) {
+  const maybeAccounts = await kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ORACLE_STATE_DISCRIMINATOR
+  );
+}
+function getOracleStateEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["oracleAuthority", kit.getAddressEncoder()],
+      ["quoteMint", kit.getAddressEncoder()],
+      ["isFinalized", kit.getBooleanEncoder()],
+      ["winningMint", kit.getAddressEncoder()],
+      ["nonce", kit.getU64Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 31)]
+    ]),
+    (value) => ({ ...value, discriminator: ORACLE_STATE_DISCRIMINATOR })
+  );
+}
+function getOracleStateDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["oracleAuthority", kit.getAddressDecoder()],
+    ["quoteMint", kit.getAddressDecoder()],
+    ["isFinalized", kit.getBooleanDecoder()],
+    ["winningMint", kit.getAddressDecoder()],
+    ["nonce", kit.getU64Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 31)]
+  ]);
+}
+function getOracleStateCodec() {
+  return kit.combineCodec(getOracleStateEncoder(), getOracleStateDecoder());
+}
+function decodeOracleState2(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getOracleStateDecoder()
+  );
+}
+async function fetchOracleState(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeOracleState(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeOracleState(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeOracleState2(maybeAccount);
+}
+async function fetchAllOracleState(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeOracleState(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeOracleState(rpc, addresses, config) {
+  const maybeAccounts = await kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(CLAIM_DISCRIMINATOR);
+}
+function getClaimInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["burnAmount", kit.getU64Encoder()]
+    ]),
+    (value) => ({ ...value, discriminator: CLAIM_DISCRIMINATOR })
+  );
+}
+function getClaimInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["burnAmount", kit.getU64Decoder()]
+  ]);
+}
+function getClaimInstructionDataCodec() {
+  return kit.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 kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            109,
+            97,
+            114,
+            107,
+            101,
+            116,
+            95,
+            97,
+            117,
+            116,
+            104,
+            111,
+            114,
+            105,
+            116,
+            121
+          ])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.receipt.value) {
+    accounts.receipt.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([114, 101, 99, 101, 105, 112, 116])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "claimer",
+            accounts.claimer.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = programClientCore.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 = programClientCore.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 kit.SolanaError(
+      kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    MIGRATE_ENTRY_DISCRIMINATOR
+  );
+}
+function getMigrateEntryInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)]
+    ]),
+    (value) => ({ ...value, discriminator: MIGRATE_ENTRY_DISCRIMINATOR })
+  );
+}
+function getMigrateEntryInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)]
+  ]);
+}
+function getMigrateEntryInstructionDataCodec() {
+  return kit.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 kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([109, 97, 114, 107, 101, 116])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.marketAuthority.value) {
+    accounts.marketAuthority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            109,
+            97,
+            114,
+            107,
+            101,
+            116,
+            95,
+            97,
+            117,
+            116,
+            104,
+            111,
+            114,
+            105,
+            116,
+            121
+          ])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.entryByMint.value) {
+    accounts.entryByMint.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            101,
+            110,
+            116,
+            114,
+            121,
+            95,
+            98,
+            121,
+            95,
+            109,
+            105,
+            110,
+            116
+          ])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "baseMint",
+            accounts.baseMint.value
+          )
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.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 = programClientCore.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 kit.SolanaError(
+      kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR
+  );
+}
+function getPreviewPayoutIfWinnerInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["candidateWinnerMint", kit.getAddressEncoder()],
+      ["tokenAmount", kit.getU64Encoder()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR
+    })
+  );
+}
+function getPreviewPayoutIfWinnerInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["candidateWinnerMint", kit.getAddressDecoder()],
+    ["tokenAmount", kit.getU64Decoder()]
+  ]);
+}
+function getPreviewPayoutIfWinnerInstructionDataCodec() {
+  return kit.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 = programClientCore.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 kit.SolanaError(
+      kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    REGISTER_ENTRY_DISCRIMINATOR
+  );
+}
+function getRegisterEntryInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["entryId", kit.fixEncoderSize(kit.getBytesEncoder(), 32)]
+    ]),
+    (value) => ({ ...value, discriminator: REGISTER_ENTRY_DISCRIMINATOR })
+  );
+}
+function getRegisterEntryInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["entryId", kit.fixDecoderSize(kit.getBytesDecoder(), 32)]
+  ]);
+}
+function getRegisterEntryInstructionDataCodec() {
+  return kit.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 kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(new Uint8Array([109, 97, 114, 107, 101, 116])),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.potVault.value) {
+    accounts.potVault.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([112, 111, 116, 95, 118, 97, 117, 108, 116])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.marketAuthority.value) {
+    accounts.marketAuthority.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            109,
+            97,
+            114,
+            107,
+            101,
+            116,
+            95,
+            97,
+            117,
+            116,
+            104,
+            111,
+            114,
+            105,
+            116,
+            121
+          ])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "market",
+            accounts.market.value
+          )
+        )
+      ]
+    });
+  }
+  if (!accounts.entryByMint.value) {
+    accounts.entryByMint.value = await kit.getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        kit.getBytesEncoder().encode(
+          new Uint8Array([
+            101,
+            110,
+            116,
+            114,
+            121,
+            95,
+            98,
+            121,
+            95,
+            109,
+            105,
+            110,
+            116
+          ])
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "oracle",
+            accounts.oracle.value
+          )
+        ),
+        kit.getAddressEncoder().encode(
+          programClientCore.getAddressFromResolvedInstructionAccount(
+            "baseMint",
+            accounts.baseMint.value
+          )
+        )
+      ]
+    });
+  }
+  const getAccountMeta = programClientCore.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 = programClientCore.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 kit.SolanaError(
+      kit.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 (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([223, 233, 11, 229, 124, 165, 207, 28])
+    ),
+    0
+  )) {
+    return 0 /* ClaimReceipt */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([63, 18, 152, 113, 215, 246, 221, 250])
+    ),
+    0
+  )) {
+    return 1 /* Entry */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([188, 191, 157, 194, 68, 82, 181, 126])
+    ),
+    0
+  )) {
+    return 2 /* EntryByMint */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([144, 51, 51, 163, 206, 85, 213, 38])
+    ),
+    0
+  )) {
+    return 3 /* Launch */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([219, 190, 213, 55, 0, 227, 198, 154])
+    ),
+    0
+  )) {
+    return 4 /* Market */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([97, 156, 157, 189, 194, 73, 8, 15])
+    ),
+    0
+  )) {
+    return 5 /* OracleState */;
+  }
+  throw new kit.SolanaError(
+    kit.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 (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([62, 198, 214, 193, 213, 159, 108, 210])
+    ),
+    0
+  )) {
+    return 0 /* Claim */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([239, 154, 55, 173, 110, 36, 188, 214])
+    ),
+    0
+  )) {
+    return 1 /* MigrateEntry */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([228, 144, 72, 185, 234, 186, 183, 143])
+    ),
+    0
+  )) {
+    return 2 /* PreviewPayoutIfWinner */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([198, 25, 1, 183, 73, 219, 215, 14])
+    ),
+    0
+  )) {
+    return 3 /* RegisterEntry */;
+  }
+  throw new kit.SolanaError(
+    kit.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "predictionMigrator" }
+  );
+}
+function parsePredictionMigratorInstruction(instruction) {
+  const instructionType = identifyPredictionMigratorInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* Claim */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 0 /* Claim */,
+        ...parseClaimInstruction(instruction)
+      };
+    }
+    case 1 /* MigrateEntry */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 1 /* MigrateEntry */,
+        ...parseMigrateEntryInstruction(instruction)
+      };
+    }
+    case 2 /* PreviewPayoutIfWinner */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 2 /* PreviewPayoutIfWinner */,
+        ...parsePreviewPayoutIfWinnerInstruction(instruction)
+      };
+    }
+    case 3 /* RegisterEntry */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 3 /* RegisterEntry */,
+        ...parseRegisterEntryInstruction(instruction)
+      };
+    }
+    default:
+      throw new kit.SolanaError(
+        kit.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType,
+          programName: "predictionMigrator"
+        }
+      );
+  }
+}
+function predictionMigratorProgram() {
+  return (client) => {
+    return {
+      ...client,
+      predictionMigrator: {
+        accounts: {
+          claimReceipt: programClientCore.addSelfFetchFunctions(client, getClaimReceiptCodec()),
+          entry: programClientCore.addSelfFetchFunctions(client, getEntryCodec()),
+          entryByMint: programClientCore.addSelfFetchFunctions(client, getEntryByMintCodec()),
+          launch: programClientCore.addSelfFetchFunctions(client, getLaunchCodec2()),
+          market: programClientCore.addSelfFetchFunctions(client, getMarketCodec()),
+          oracleState: programClientCore.addSelfFetchFunctions(client, getOracleStateCodec())
+        },
+        instructions: {
+          claim: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getClaimInstructionAsync({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          ),
+          migrateEntry: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getMigrateEntryInstructionAsync({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          ),
+          previewPayoutIfWinner: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getPreviewPayoutIfWinnerInstruction(input)
+          ),
+          registerEntry: (input) => programClientCore.addSelfPlanAndSendFunctions(
+            client,
+            getRegisterEntryInstructionAsync({
+              ...input,
+              payer: input.payer ?? client.payer
+            })
+          )
+        }
+      }
+    };
+  };
+}
+var addressCodec4 = kit.getAddressCodec();
+var textEncoder4 = new TextEncoder();
+async function getPredictionMarketAddress(oracleState, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder4.encode("market"), addressCodec4.encode(oracleState)]
+  });
+}
+async function getPredictionMarketAuthorityAddress(market, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder4.encode("market_authority"),
+      addressCodec4.encode(market)
+    ]
+  });
+}
+async function getPredictionPotVaultAddress(market, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder4.encode("pot_vault"), addressCodec4.encode(market)]
+  });
+}
+async function getPredictionEntryAddress(oracleState, entryId, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return kit.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder4.encode("entry"),
+      addressCodec4.encode(oracleState),
+      entryId
+    ]
+  });
+}
+async function getPredictionEntryByMintAddress(oracleState, mint, programId = PREDICTION_MIGRATOR_PROGRAM_ADDRESS) {
+  return kit.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 = kit.getAddressEncoder();
+  const [metadataAddress] = await kit.getProgramDerivedAddress({
+    programAddress: chunkDPKVNI6Q_cjs.TOKEN_METADATA_PROGRAM_ID,
+    seeds: [
+      new TextEncoder().encode("metadata"),
+      encoder.encode(chunkDPKVNI6Q_cjs.TOKEN_METADATA_PROGRAM_ID),
+      encoder.encode(mint)
+    ]
+  });
+  return metadataAddress;
+}
+var ALT_INDEX = {
+  [chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS]: 0,
+  [chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS]: 1,
+  SysvarRent111111111111111111111111111111111: 2,
+  [INITIALIZER_PROGRAM_ID]: 3,
+  [chunkDPKVNI6Q_cjs.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 = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS,
+    systemProgram = chunkDPKVNI6Q_cjs.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, kit.AccountRole.READONLY),
+    { address: launch, role: kit.AccountRole.WRITABLE },
+    { address: launchAuthority, role: kit.AccountRole.READONLY },
+    createAccountMeta(baseMint, kit.AccountRole.WRITABLE_SIGNER),
+    staticOrLookup(quoteMint, kit.AccountRole.READONLY),
+    createAccountMeta(baseVault, kit.AccountRole.WRITABLE_SIGNER),
+    createAccountMeta(quoteVault, kit.AccountRole.WRITABLE_SIGNER),
+    createAccountMeta(payer, kit.AccountRole.WRITABLE_SIGNER)
+  ];
+  if (authority) {
+    keys.push(createAccountMeta(authority, kit.AccountRole.READONLY_SIGNER));
+  }
+  if (migratorProgram) {
+    keys.push(staticOrLookup(migratorProgram, kit.AccountRole.READONLY));
+  }
+  keys.push(staticOrLookup(tokenProgram, kit.AccountRole.READONLY));
+  keys.push(staticOrLookup(systemProgram, kit.AccountRole.READONLY));
+  keys.push(staticOrLookup(rent, kit.AccountRole.READONLY));
+  if (withMetadata) {
+    keys.push({ address: metadataAccount, role: kit.AccountRole.WRITABLE });
+    keys.push(staticOrLookup(chunkDPKVNI6Q_cjs.TOKEN_METADATA_PROGRAM_ID, kit.AccountRole.READONLY));
+  }
+  const encoderArgs = {
+    ...args,
+    allowBuy: args.allowBuy ? 1 : 0,
+    allowSell: args.allowSell ? 1 : 0,
+    migratorProgram: migratorProgram ?? chunkDPKVNI6Q_cjs.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: kit.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: kit.AccountRole.READONLY });
+    keys.push({ address: market, role: kit.AccountRole.WRITABLE });
+    keys.push({ address: potVault, role: kit.AccountRole.WRITABLE });
+    keys.push({ address: marketAuthority, role: kit.AccountRole.READONLY });
+    keys.push({ address: entry, role: kit.AccountRole.WRITABLE });
+    keys.push({ address: entryByMint, role: kit.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 = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS,
+    tokenProgram = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: launch, role: kit.AccountRole.WRITABLE },
+    { address: launchAuthority, role: kit.AccountRole.READONLY },
+    { address: baseVault, role: kit.AccountRole.WRITABLE },
+    { address: quoteVault, role: kit.AccountRole.WRITABLE },
+    { address: userBaseAccount, role: kit.AccountRole.WRITABLE },
+    { address: userQuoteAccount, role: kit.AccountRole.WRITABLE },
+    { address: baseMint, role: kit.AccountRole.READONLY },
+    { address: quoteMint, role: kit.AccountRole.READONLY },
+    createAccountMeta2(user, kit.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: kit.AccountRole.READONLY },
+    { address: tokenProgram, role: kit.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 = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS,
+    systemProgram = chunkDPKVNI6Q_cjs.SYSTEM_PROGRAM_ADDRESS,
+    rent
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: launch, role: kit.AccountRole.WRITABLE },
+    { address: launchAuthority, role: kit.AccountRole.READONLY },
+    { address: baseMint, role: kit.AccountRole.READONLY },
+    { address: quoteMint, role: kit.AccountRole.READONLY },
+    { address: baseVault, role: kit.AccountRole.WRITABLE },
+    { address: quoteVault, role: kit.AccountRole.WRITABLE },
+    { address: migratorProgram, role: kit.AccountRole.READONLY },
+    createSignerAccountMeta5(payer, kit.AccountRole.WRITABLE_SIGNER),
+    { address: tokenProgram, role: kit.AccountRole.READONLY },
+    { address: systemProgram, role: kit.AccountRole.READONLY },
+    { address: rent, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.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 = chunkDPKVNI6Q_cjs.TOKEN_PROGRAM_ADDRESS
+  } = accounts;
+  const keys = [
+    { address: config, role: kit.AccountRole.READONLY },
+    { address: launch, role: kit.AccountRole.WRITABLE },
+    { address: launchAuthority, role: kit.AccountRole.READONLY },
+    { address: baseVault, role: kit.AccountRole.WRITABLE },
+    { address: quoteVault, role: kit.AccountRole.READONLY },
+    createAccountMeta3(authority, kit.AccountRole.READONLY_SIGNER),
+    { address: authorityBaseAccount, role: kit.AccountRole.WRITABLE },
+    { address: baseMint, role: kit.AccountRole.READONLY },
+    { address: tokenProgram, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.abortLaunch
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+var previewSwapExactInResultCodec = kit.getStructCodec([
+  ["amountOut", kit.getU64Codec()],
+  ["feePaid", kit.getU64Codec()]
+]);
+function createPreviewSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
+  const { launch, baseVault, quoteVault, sentinelProgram } = accounts;
+  const keys = [
+    { address: launch, role: kit.AccountRole.READONLY },
+    { address: baseVault, role: kit.AccountRole.READONLY },
+    { address: quoteVault, role: kit.AccountRole.READONLY }
+  ];
+  const accountsList = sentinelProgram ? [...keys, { address: sentinelProgram, role: kit.AccountRole.READONLY }] : keys;
+  const data = new Uint8Array(
+    getPreviewSwapExactInInstructionDataEncoder().encode(args)
+  );
+  return { programAddress: programId, accounts: accountsList, data };
+}
+function decodePreviewSwapExactInResult(data) {
+  return previewSwapExactInResultCodec.decode(data);
+}
+var previewMigrationResultCodec = kit.getStructCodec([
+  ["baseVaultAmount", kit.getU64Codec()],
+  ["quoteVaultAmount", kit.getU64Codec()],
+  ["baseMintSupply", kit.getU64Codec()]
+]);
+function createPreviewMigrationInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
+  const { launch, baseMint, baseVault, quoteVault } = accounts;
+  const keys = [
+    { address: launch, role: kit.AccountRole.READONLY },
+    { address: baseMint, role: kit.AccountRole.READONLY },
+    { address: baseVault, role: kit.AccountRole.READONLY },
+    { address: quoteVault, role: kit.AccountRole.READONLY }
+  ];
+  const data = chunkBXATWUGJ_cjs.encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.previewMigration
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+function decodePreviewMigrationResult(data) {
+  return previewMigrationResultCodec.decode(data);
+}
+function computeRemainingAccountsHash(addresses) {
+  const addressEncoder = kit.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 sha3_js.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 = kit.getAddressCodec();
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function base64ToBytes2(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function fetchLaunch2(rpc, address3, config) {
+  const response = await rpc.getAccountInfo(address3, {
+    encoding: "base64",
+    commitment: config?.commitment
+  }).send();
+  if (!response.value) {
+    return null;
+  }
+  return getLaunchDecoder().decode(base64ToBytes2(response.value.data[0]));
+}
+async function fetchAllLaunches(rpc, config) {
+  const programId = config?.programId ?? INITIALIZER_PROGRAM_ID;
+  const discriminatorFilter = {
+    memcmp: {
+      offset: 0n,
+      bytes: bytesToBase64(
+        INITIALIZER_ACCOUNT_DISCRIMINATORS.Launch
+      ),
+      encoding: "base64"
+    }
+  };
+  const response = await rpc.getProgramAccounts(programId, {
+    encoding: "base64",
+    commitment: config?.commitment,
+    filters: [discriminatorFilter]
+  }).send();
+  const accounts = Array.isArray(response) ? response : response.value;
+  const launches = [];
+  const decoder = getLaunchDecoder();
+  for (const account of accounts) {
+    try {
+      const launch = decoder.decode(base64ToBytes2(account.account.data[0]));
+      launches.push({ address: account.pubkey, account: launch });
+    } catch {
+      console.warn(`Failed to decode launch account: ${account.pubkey}`);
+    }
+  }
+  return launches;
+}
+async function fetchLaunchesByAuthority(rpc, authority, config) {
+  const programId = config?.programId ?? INITIALIZER_PROGRAM_ID;
+  const discriminatorFilter = {
+    memcmp: {
+      offset: 0n,
+      bytes: bytesToBase64(
+        INITIALIZER_ACCOUNT_DISCRIMINATORS.Launch
+      ),
+      encoding: "base64"
+    }
+  };
+  const authorityFilter = {
+    memcmp: {
+      offset: 8n,
+      bytes: bytesToBase64(
+        addressCodec5.encode(authority)
+      ),
+      encoding: "base64"
+    }
+  };
+  const response = await rpc.getProgramAccounts(programId, {
+    encoding: "base64",
+    commitment: config?.commitment,
+    filters: [discriminatorFilter, authorityFilter]
+  }).send();
+  const accounts = Array.isArray(response) ? response : response.value;
+  const launches = [];
+  const decoder = getLaunchDecoder();
+  for (const account of accounts) {
+    try {
+      const launch = decoder.decode(base64ToBytes2(account.account.data[0]));
+      launches.push({ address: account.pubkey, account: launch });
+    } catch {
+      console.warn(`Failed to decode launch account: ${account.pubkey}`);
+    }
+  }
+  return launches;
+}
+async function launchExists(rpc, namespace, launchId, config) {
+  const programId = config?.programId ?? INITIALIZER_PROGRAM_ID;
+  const [launchAddress] = await getLaunchAddress(
+    namespace,
+    launchId,
+    programId
+  );
+  const launch = await fetchLaunch2(rpc, launchAddress, config);
+  return launch !== null;
+}
+
+// src/solana/migrators/cpmmMigrator/index.ts
+var cpmmMigrator_exports = {};
+chunkQ7SFCCGT_cjs.__export(cpmmMigrator_exports, {
+  CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS: () => CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS,
+  CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS: () => CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS,
+  CPMM_MIGRATOR_PROGRAM_ID: () => CPMM_MIGRATOR_PROGRAM_ID,
+  MAX_RECIPIENTS: () => MAX_RECIPIENTS,
+  SEED_STATE: () => SEED_STATE,
+  encodeMigrateCalldata: () => encodeMigrateCalldata,
+  encodeRegisterLaunchCalldata: () => encodeRegisterLaunchCalldata,
+  fetchCpmmMigratorState: () => fetchCpmmMigratorState,
+  getCpmmMigratorStateAddress: () => getCpmmMigratorStateAddress,
+  getCpmmMigratorStateCodec: () => getCpmmMigratorStateCodec,
+  getCpmmMigratorStateDecoder: () => getCpmmMigratorStateDecoder,
+  getCpmmMigratorStateEncoder: () => getCpmmMigratorStateEncoder,
+  getMigrateArgsCodec: () => getMigrateArgsCodec,
+  getMigrateArgsDecoder: () => getMigrateArgsDecoder,
+  getMigrateArgsEncoder: () => getMigrateArgsEncoder,
+  getRecipientCodec: () => getRecipientCodec,
+  getRecipientDecoder: () => getRecipientDecoder,
+  getRecipientEncoder: () => getRecipientEncoder,
+  getRegisterLaunchArgsCodec: () => getRegisterLaunchArgsCodec,
+  getRegisterLaunchArgsDecoder: () => getRegisterLaunchArgsDecoder,
+  getRegisterLaunchArgsEncoder: () => getRegisterLaunchArgsEncoder
+});
+function getMigrateArgsEncoder() {
+  return kit.getStructEncoder([
+    ["baseForDistribution", kit.getU64Encoder()],
+    ["baseForLiquidity", kit.getU64Encoder()]
+  ]);
+}
+function getMigrateArgsDecoder() {
+  return kit.getStructDecoder([
+    ["baseForDistribution", kit.getU64Decoder()],
+    ["baseForLiquidity", kit.getU64Decoder()]
+  ]);
+}
+function getMigrateArgsCodec() {
+  return kit.combineCodec(getMigrateArgsEncoder(), getMigrateArgsDecoder());
+}
+function getRecipientEncoder() {
+  return kit.getStructEncoder([
+    ["wallet", kit.getAddressEncoder()],
+    ["amount", kit.getU64Encoder()]
+  ]);
+}
+function getRecipientDecoder() {
+  return kit.getStructDecoder([
+    ["wallet", kit.getAddressDecoder()],
+    ["amount", kit.getU64Decoder()]
+  ]);
+}
+function getRecipientCodec() {
+  return kit.combineCodec(getRecipientEncoder(), getRecipientDecoder());
+}
+function getRegisterLaunchArgsEncoder() {
+  return kit.getStructEncoder([
+    ["cpmmConfig", kit.getAddressEncoder()],
+    ["initialSwapFeeBps", kit.getU16Encoder()],
+    ["initialFeeSplitBps", kit.getU16Encoder()],
+    ["recipients", kit.getArrayEncoder(getRecipientEncoder())],
+    ["minRaiseQuote", kit.getU64Encoder()],
+    ["minMigrationPriceQ64Opt", kit.getOptionEncoder(kit.getU128Encoder())]
+  ]);
+}
+function getRegisterLaunchArgsDecoder() {
+  return kit.getStructDecoder([
+    ["cpmmConfig", kit.getAddressDecoder()],
+    ["initialSwapFeeBps", kit.getU16Decoder()],
+    ["initialFeeSplitBps", kit.getU16Decoder()],
+    ["recipients", kit.getArrayDecoder(getRecipientDecoder())],
+    ["minRaiseQuote", kit.getU64Decoder()],
+    ["minMigrationPriceQ64Opt", kit.getOptionDecoder(kit.getU128Decoder())]
+  ]);
+}
+function getRegisterLaunchArgsCodec() {
+  return kit.combineCodec(
+    getRegisterLaunchArgsEncoder(),
+    getRegisterLaunchArgsDecoder()
+  );
+}
+
+// src/solana/generated/cpmmMigrator/accounts/cpmmMigratorState.ts
+var CPMM_MIGRATOR_STATE_DISCRIMINATOR = new Uint8Array([
+  169,
+  86,
+  255,
+  187,
+  37,
+  248,
+  11,
+  176
+]);
+function getCpmmMigratorStateEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["launch", kit.getAddressEncoder()],
+      ["admin", kit.getAddressEncoder()],
+      ["cpmmConfig", kit.getAddressEncoder()],
+      ["initialSwapFeeBps", kit.getU16Encoder()],
+      ["initialFeeSplitBps", kit.getU16Encoder()],
+      ["pad0", kit.fixEncoderSize(kit.getBytesEncoder(), 4)],
+      ["recipients", kit.getArrayEncoder(getRecipientEncoder(), { size: 2 })],
+      ["minRaiseQuote", kit.getU64Encoder()],
+      ["minMigrationPriceQ64Opt", kit.getOptionEncoder(kit.getU128Encoder())],
+      ["isMigrated", kit.getBooleanEncoder()],
+      ["bump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 14)]
+    ]),
+    (value) => ({ ...value, discriminator: CPMM_MIGRATOR_STATE_DISCRIMINATOR })
+  );
+}
+function getCpmmMigratorStateDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["launch", kit.getAddressDecoder()],
+    ["admin", kit.getAddressDecoder()],
+    ["cpmmConfig", kit.getAddressDecoder()],
+    ["initialSwapFeeBps", kit.getU16Decoder()],
+    ["initialFeeSplitBps", kit.getU16Decoder()],
+    ["pad0", kit.fixDecoderSize(kit.getBytesDecoder(), 4)],
+    ["recipients", kit.getArrayDecoder(getRecipientDecoder(), { size: 2 })],
+    ["minRaiseQuote", kit.getU64Decoder()],
+    ["minMigrationPriceQ64Opt", kit.getOptionDecoder(kit.getU128Decoder())],
+    ["isMigrated", kit.getBooleanDecoder()],
+    ["bump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 14)]
+  ]);
+}
+function getCpmmMigratorStateCodec() {
+  return kit.combineCodec(
+    getCpmmMigratorStateEncoder(),
+    getCpmmMigratorStateDecoder()
+  );
+}
+if (process.env.NODE_ENV !== "production") ;
+
+// src/solana/migrators/cpmmMigrator/client.ts
+function base64ToBytes3(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function fetchCpmmMigratorState(rpc, address3) {
+  const response = await rpc.getAccountInfo(address3, { encoding: "base64" }).send();
+  if (!response.value) return null;
+  return getCpmmMigratorStateDecoder().decode(
+    base64ToBytes3(response.value.data[0])
+  );
+}
+
+// src/solana/migrators/cpmmMigrator/index.ts
+function encodeRegisterLaunchCalldata(args) {
+  const encoded = new Uint8Array(getRegisterLaunchArgsEncoder().encode(args));
+  return kit.mergeBytes([
+    CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS.registerLaunch,
+    encoded
+  ]);
+}
+function encodeMigrateCalldata(args) {
+  const encoded = new Uint8Array(getMigrateArgsEncoder().encode(args));
+  return kit.mergeBytes([
+    CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS.migrate,
+    encoded
+  ]);
+}
+
+// src/solana/migrators/predictionMigrator/index.ts
+var predictionMigrator_exports = {};
+chunkQ7SFCCGT_cjs.__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 kit.isProgramError(
+    error,
+    transactionMessage,
+    PREDICTION_MIGRATOR_PROGRAM_ADDRESS,
+    code
+  );
+}
+
+// src/solana/trustedOracle/index.ts
+var trustedOracle_exports = {};
+chunkQ7SFCCGT_cjs.__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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    ORACLE_STATE_DISCRIMINATOR2
+  );
+}
+function getOracleStateEncoder2() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["oracleAuthority", kit.getAddressEncoder()],
+      ["quoteMint", kit.getAddressEncoder()],
+      ["isFinalized", kit.getBooleanEncoder()],
+      ["winningMint", kit.getAddressEncoder()],
+      ["nonce", kit.getU64Encoder()],
+      ["bump", kit.getU8Encoder()],
+      ["reserved", kit.fixEncoderSize(kit.getBytesEncoder(), 31)]
+    ]),
+    (value) => ({ ...value, discriminator: ORACLE_STATE_DISCRIMINATOR2 })
+  );
+}
+function getOracleStateDecoder2() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["oracleAuthority", kit.getAddressDecoder()],
+    ["quoteMint", kit.getAddressDecoder()],
+    ["isFinalized", kit.getBooleanDecoder()],
+    ["winningMint", kit.getAddressDecoder()],
+    ["nonce", kit.getU64Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 31)]
+  ]);
+}
+function getOracleStateCodec2() {
+  return kit.combineCodec(getOracleStateEncoder2(), getOracleStateDecoder2());
+}
+function decodeOracleState3(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getOracleStateDecoder2()
+  );
+}
+async function fetchOracleState2(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeOracleState2(rpc, address3, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeOracleState2(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
+  return decodeOracleState3(maybeAccount);
+}
+async function fetchAllOracleState2(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeOracleState2(rpc, addresses, config);
+  kit.assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeOracleState2(rpc, addresses, config) {
+  const maybeAccounts = await kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(FINALIZE_DISCRIMINATOR);
+}
+function getFinalizeInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["winningMint", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: FINALIZE_DISCRIMINATOR })
+  );
+}
+function getFinalizeInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["winningMint", kit.getAddressDecoder()]
+  ]);
+}
+function getFinalizeInstructionDataCodec() {
+  return kit.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 = programClientCore.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 kit.SolanaError(
+      kit.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 kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+    INITIALIZE_ORACLE_DISCRIMINATOR
+  );
+}
+function getInitializeOracleInstructionDataEncoder() {
+  return kit.transformEncoder(
+    kit.getStructEncoder([
+      ["discriminator", kit.fixEncoderSize(kit.getBytesEncoder(), 8)],
+      ["nonce", kit.getU64Encoder()],
+      ["quoteMint", kit.getAddressEncoder()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_ORACLE_DISCRIMINATOR })
+  );
+}
+function getInitializeOracleInstructionDataDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["nonce", kit.getU64Decoder()],
+    ["quoteMint", kit.getAddressDecoder()]
+  ]);
+}
+function getInitializeOracleInstructionDataCodec() {
+  return kit.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 = programClientCore.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 kit.SolanaError(
+      kit.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 (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([97, 156, 157, 189, 194, 73, 8, 15])
+    ),
+    0
+  )) {
+    return 0 /* OracleState */;
+  }
+  throw new kit.SolanaError(
+    kit.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 (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([171, 61, 218, 56, 127, 115, 12, 217])
+    ),
+    0
+  )) {
+    return 0 /* Finalize */;
+  }
+  if (kit.containsBytes(
+    data,
+    kit.fixEncoderSize(kit.getBytesEncoder(), 8).encode(
+      new Uint8Array([144, 223, 131, 120, 196, 253, 181, 99])
+    ),
+    0
+  )) {
+    return 1 /* InitializeOracle */;
+  }
+  throw new kit.SolanaError(
+    kit.SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "trustedOracle" }
+  );
+}
+function parseTrustedOracleInstruction(instruction) {
+  const instructionType = identifyTrustedOracleInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* Finalize */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 0 /* Finalize */,
+        ...parseFinalizeInstruction(instruction)
+      };
+    }
+    case 1 /* InitializeOracle */: {
+      kit.assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: 1 /* InitializeOracle */,
+        ...parseInitializeOracleInstruction(instruction)
+      };
+    }
+    default:
+      throw new kit.SolanaError(
+        kit.SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType,
+          programName: "trustedOracle"
+        }
+      );
+  }
+}
+function trustedOracleProgram() {
+  return (client) => {
+    return {
+      ...client,
+      trustedOracle: {
+        accounts: {
+          oracleState: programClientCore.addSelfFetchFunctions(client, getOracleStateCodec2())
+        },
+        instructions: {
+          finalize: (input) => programClientCore.addSelfPlanAndSendFunctions(client, getFinalizeInstruction(input)),
+          initializeOracle: (input) => programClientCore.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 kit.isProgramError(
+    error,
+    transactionMessage,
+    TRUSTED_ORACLE_PROGRAM_ADDRESS,
+    code
+  );
+}
+function getInitializeOracleArgsEncoder() {
+  return kit.getStructEncoder([
+    ["nonce", kit.getU64Encoder()],
+    ["quoteMint", kit.getAddressEncoder()]
+  ]);
+}
+function getInitializeOracleArgsDecoder() {
+  return kit.getStructDecoder([
+    ["nonce", kit.getU64Decoder()],
+    ["quoteMint", kit.getAddressDecoder()]
+  ]);
+}
+function getInitializeOracleArgsCodec() {
+  return kit.combineCodec(
+    getInitializeOracleArgsEncoder(),
+    getInitializeOracleArgsDecoder()
+  );
+}
+async function getOracleStateAddress(oracleAuthority, nonce) {
+  const nonceBytes = new Uint8Array(8);
+  new DataView(nonceBytes.buffer).setBigUint64(0, nonce, true);
+  return kit.getProgramDerivedAddress({
+    programAddress: TRUSTED_ORACLE_PROGRAM_ADDRESS,
+    seeds: [
+      new TextEncoder().encode("oracle"),
+      kit.getAddressEncoder().encode(oracleAuthority),
+      nonceBytes
+    ]
+  });
+}
+
+exports.cpmm = cpmm_exports;
+exports.cpmmMigrator = cpmmMigrator_exports;
+exports.initializer = initializer_exports;
+exports.predictionMigrator = predictionMigrator_exports;
+exports.trustedOracle = trustedOracle_exports;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map