@whetstone-research/doppler-sdk 0.0.24 → 1.0.0

package/dist/solana/index.js

@@ -0,0 +1,2209 @@
+import { encodeInstructionData, initializeConfigArgsCodec, initializePoolArgsCodec, initializeOracleArgsCodec, setFeesArgsCodec, setSentinelArgsCodec, setRouteArgsCodec, transferAdminArgsCodec, swapExactInArgsCodec, createPositionArgsCodec, removeLiquidityArgsCodec, collectProtocolFeesArgsCodec, oracleConsultArgsCodec, quoteToNumeraireArgsCodec, decodeAmmConfig } from '../chunk-RO6R66OM.js';
+export { MAX_FEE_AMOUNT, calculateAccruedFees, calculateTwap, calculateTwapNumber, ceilDiv, comparePoolAndOraclePrices, computePrice0Q64, computePrice1Q64, consultTwap, createCollectFeesInstruction, decodeAmmConfig, decodeOracleState, decodePool, decodePosition, fetchAllPools, fetchOracle, fetchOraclesBatch, fetchPool, fetchPoolPositions, fetchPoolsBatch, fetchPosition, fetchPositionByParams, fetchPositionsBatch, fetchUserPositions, filterActivePositions, filterPoolsByMint, getAddLiquidityQuote, getK, getOracleAddressFromPool, getOracleAge, getOracleBufferStats, getOracleDeviation, getOracleForPool, getOracleSpotPrices, getPendingFees, getPoolAddressFromMints, getPoolByMints, getPositionAddressFromParams, getPositionValue, getRemoveLiquidityQuote, getSpotPrice0, getSpotPrice1, getSwapQuote, getSwapQuoteExactOut, getTvl, isOracleStale, isqrt, maxBigInt, minBigInt, numberToQ64, poolExists, q64Div, q64Mul, q64ToNumber, ratioToNumber, sortPoolsByReserves, sortPositionsByShares } from '../chunk-RO6R66OM.js';
+import { SYSTEM_PROGRAM_ID, ACCOUNT_ROLE_WRITABLE, ACCOUNT_ROLE_READONLY, TOKEN_PROGRAM_ID, ACCOUNT_ROLE_WRITABLE_SIGNER, ACCOUNT_ROLE_SIGNER, PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, INSTRUCTION_DISCRIMINATORS, getConfigAddress } from '../chunk-3LTCKCJC.js';
+export { ACCOUNT_DISCRIMINATORS, ACCOUNT_ROLE_READONLY, ACCOUNT_ROLE_SIGNER, ACCOUNT_ROLE_WRITABLE, ACCOUNT_ROLE_WRITABLE_SIGNER, ACCOUNT_VERSION, BPS_DENOM, INSTRUCTION_DISCRIMINATORS, MAX_ORACLE_OBSERVATIONS, MAX_SENTINEL_ALLOWLIST, PROGRAM_ID, Q64_ONE, SEED_AUTHORITY, SEED_CONFIG, SEED_ORACLE, SEED_POOL, SEED_POSITION, SEED_PROTOCOL_POSITION, SENTINEL_NO_CHANGE, SENTINEL_PROGRAM_ID, SF_AFTER_ADD_LIQ, SF_AFTER_REMOVE_LIQ, SF_AFTER_SWAP, SF_BEFORE_ADD_LIQ, SF_BEFORE_REMOVE_LIQ, SF_BEFORE_SWAP, SYSTEM_PROGRAM_ID, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, areMintsOrdered, getConfigAddress, getLiquidityAddresses, getOracleAddress, getPoolAddress, getPoolAuthorityAddress, getPoolInitAddresses, getPositionAddress, getProtocolPositionAddress, getSwapAddresses, sortMints } from '../chunk-3LTCKCJC.js';
+import { __export } from '../chunk-PZ5AY32C.js';
+import { getAddressCodec, getStructCodec, getU64Codec, getU128Codec, getBooleanCodec, getU8Codec, address, transformEncoder, getStructEncoder, fixEncoderSize, getAddressEncoder, getU8Encoder, getArrayEncoder, getBytesEncoder, getStructDecoder, fixDecoderSize, getAddressDecoder, getU8Decoder, getArrayDecoder, getBytesDecoder, combineCodec, getU64Encoder, getU16Encoder, addEncoderSizePrefix, getU32Encoder, getUtf8Encoder, getU64Decoder, getU16Decoder, addDecoderSizePrefix, getU32Decoder, getUtf8Decoder, getProgramDerivedAddress, getOptionEncoder, getU128Encoder, getOptionDecoder, getU128Decoder, getBooleanEncoder, getBooleanDecoder, mergeBytes } from '@solana/kit';
+import '@solana/program-client-core';
+
+var addressCodec = getAddressCodec();
+var textEncoder = new TextEncoder();
+async function getMetadataAddress(mint) {
+  return getProgramDerivedAddress({
+    programAddress: TOKEN_METADATA_PROGRAM_ID,
+    seeds: [
+      textEncoder.encode("metadata"),
+      addressCodec.encode(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}`;
+}
+
+// src/solana/instructions/initializeConfig.ts
+function createInitializeConfigInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { config, payer, systemProgram = SYSTEM_PROGRAM_ID } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_WRITABLE },
+    { address: payer, role: ACCOUNT_ROLE_WRITABLE_SIGNER },
+    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.initializeConfig,
+    initializeConfigArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/initializePool.ts
+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 = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    protocolPosition,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    payer,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    systemProgram = SYSTEM_PROGRAM_ID,
+    rent
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    createSignerAccountMeta(vault0, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    createSignerAccountMeta(vault1, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    createSignerAccountMeta(payer, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY },
+    { address: systemProgram, role: ACCOUNT_ROLE_READONLY },
+    { address: rent, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.initializePool,
+    initializePoolArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/initializeOracle.ts
+function createInitializeOracleInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    oracle,
+    admin,
+    payer,
+    systemProgram = SYSTEM_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_READONLY },
+    { address: oracle, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER },
+    { address: payer, role: ACCOUNT_ROLE_WRITABLE_SIGNER },
+    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.initializeOracle,
+    initializeOracleArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/setFees.ts
+function createSetFeesInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { config, pool, admin } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.setFees,
+    setFeesArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/setSentinel.ts
+function createSetSentinelInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { config, pool, admin } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.setSentinel,
+    setSentinelArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/setRoute.ts
+function createSetRouteInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { config, pool, nextPool, admin } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE }
+  ];
+  if (nextPool) {
+    keys.push({ address: nextPool, role: ACCOUNT_ROLE_READONLY });
+  }
+  keys.push({ address: admin, role: ACCOUNT_ROLE_SIGNER });
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.setRoute,
+    setRouteArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/pause.ts
+function createPauseInstruction(accounts, programId = PROGRAM_ID) {
+  const { config, admin } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+  ];
+  const data = INSTRUCTION_DISCRIMINATORS.pause;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/unpause.ts
+function createUnpauseInstruction(accounts, programId = PROGRAM_ID) {
+  const { config, admin } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+  ];
+  const data = INSTRUCTION_DISCRIMINATORS.unpause;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/transferAdmin.ts
+function createTransferAdminInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { config, admin } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.transferAdmin,
+    transferAdminArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/skim.ts
+function createSkimInstruction(accounts, programId = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    admin,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    adminAta0,
+    adminAta1,
+    tokenProgram = TOKEN_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_READONLY },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: adminAta0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: adminAta1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = INSTRUCTION_DISCRIMINATORS.skim;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/swapExactIn.ts
+function createSwapExactInInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    authority,
+    vaultIn,
+    vaultOut,
+    token0Mint,
+    token1Mint,
+    userIn,
+    userOut,
+    user,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    oracle,
+    remainingAccounts = []
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    { address: vaultIn, role: ACCOUNT_ROLE_WRITABLE },
+    { address: vaultOut, role: ACCOUNT_ROLE_WRITABLE },
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: userIn, role: ACCOUNT_ROLE_WRITABLE },
+    { address: userOut, role: ACCOUNT_ROLE_WRITABLE },
+    { address: user, role: ACCOUNT_ROLE_SIGNER },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  if (oracle) {
+    keys.push({ address: oracle, role: ACCOUNT_ROLE_WRITABLE });
+  }
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+  }
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.swapExactIn,
+    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 = 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
+  );
+}
+
+// src/solana/instructions/createPosition.ts
+function createCreatePositionInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    pool,
+    position,
+    owner,
+    payer,
+    systemProgram = SYSTEM_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: pool, role: ACCOUNT_ROLE_READONLY },
+    { address: position, role: ACCOUNT_ROLE_WRITABLE },
+    { address: owner, role: ACCOUNT_ROLE_SIGNER },
+    { address: payer, role: ACCOUNT_ROLE_WRITABLE_SIGNER },
+    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.createPosition,
+    createPositionArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/closePosition.ts
+function createClosePositionInstruction(accounts, programId = PROGRAM_ID) {
+  const { pool, position, owner, rentRecipient } = accounts;
+  const keys = [
+    { address: pool, role: ACCOUNT_ROLE_READONLY },
+    { address: position, role: ACCOUNT_ROLE_WRITABLE },
+    { address: owner, role: ACCOUNT_ROLE_SIGNER },
+    { address: rentRecipient, role: ACCOUNT_ROLE_WRITABLE }
+  ];
+  const data = INSTRUCTION_DISCRIMINATORS.closePosition;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var addLiquidityArgsWithOracleCodec = getStructCodec([
+  ["amount0Max", getU64Codec()],
+  ["amount1Max", getU64Codec()],
+  ["minSharesOut", getU128Codec()],
+  ["updateOracle", getBooleanCodec()]
+]);
+function createAddLiquidityInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    position,
+    protocolPosition,
+    owner,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    user0,
+    user1,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    oracle,
+    remainingAccounts = []
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: position, role: ACCOUNT_ROLE_WRITABLE },
+    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
+    { address: owner, role: ACCOUNT_ROLE_SIGNER },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: user0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: user1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  if (oracle) {
+    keys.push({ address: oracle, role: ACCOUNT_ROLE_WRITABLE });
+  }
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+  }
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.addLiquidity,
+    addLiquidityArgsWithOracleCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/removeLiquidity.ts
+function createRemoveLiquidityInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    position,
+    protocolPosition,
+    owner,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    user0,
+    user1,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    oracle,
+    remainingAccounts = []
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: position, role: ACCOUNT_ROLE_WRITABLE },
+    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
+    { address: owner, role: ACCOUNT_ROLE_SIGNER },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: user0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: user1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  if (oracle) {
+    keys.push({ address: oracle, role: ACCOUNT_ROLE_WRITABLE });
+  }
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+  }
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.removeLiquidity,
+    removeLiquidityArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/collectProtocolFees.ts
+function createCollectProtocolFeesInstruction(accounts, args, programId = PROGRAM_ID) {
+  const {
+    config,
+    pool,
+    protocolPosition,
+    admin,
+    authority,
+    vault0,
+    vault1,
+    token0Mint,
+    token1Mint,
+    recipient0,
+    recipient1,
+    tokenProgram = TOKEN_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: pool, role: ACCOUNT_ROLE_WRITABLE },
+    { address: protocolPosition, role: ACCOUNT_ROLE_WRITABLE },
+    { address: admin, role: ACCOUNT_ROLE_SIGNER },
+    { address: authority, role: ACCOUNT_ROLE_READONLY },
+    { address: vault0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: vault1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: token0Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: token1Mint, role: ACCOUNT_ROLE_READONLY },
+    { address: recipient0, role: ACCOUNT_ROLE_WRITABLE },
+    { address: recipient1, role: ACCOUNT_ROLE_WRITABLE },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.collectProtocolFees,
+    collectProtocolFeesArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/instructions/oracleUpdate.ts
+function createOracleUpdateInstruction(accounts, programId = PROGRAM_ID) {
+  const { pool, oracle } = accounts;
+  const keys = [
+    { address: pool, role: ACCOUNT_ROLE_READONLY },
+    { address: oracle, role: ACCOUNT_ROLE_WRITABLE }
+  ];
+  const data = INSTRUCTION_DISCRIMINATORS.oracleUpdate;
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var oracleConsultResultCodec = getStructCodec([
+  ["price0Q64", getU128Codec()],
+  ["price1Q64", getU128Codec()]
+]);
+function decodeOracleConsultResult(data) {
+  return oracleConsultResultCodec.decode(data);
+}
+function createOracleConsultInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { pool, oracle } = accounts;
+  const keys = [
+    { address: pool, role: ACCOUNT_ROLE_READONLY },
+    { address: oracle, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.oracleConsult,
+    oracleConsultArgsCodec,
+    args
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+var quoteToNumeraireResultCodec = getStructCodec([
+  ["amountInNumeraire", getU128Codec()],
+  ["endMint", getAddressCodec()],
+  ["hopsUsed", getU8Codec()]
+]);
+function decodeQuoteToNumeraireResult(data) {
+  return quoteToNumeraireResultCodec.decode(data);
+}
+function createQuoteToNumeraireInstruction(accounts, args, programId = PROGRAM_ID) {
+  const { config, startPool, remainingAccounts = [] } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: startPool, role: ACCOUNT_ROLE_READONLY }
+  ];
+  for (const account of remainingAccounts) {
+    keys.push({ address: account, role: ACCOUNT_ROLE_READONLY });
+  }
+  const data = encodeInstructionData(
+    INSTRUCTION_DISCRIMINATORS.quoteToNumeraire,
+    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 = PROGRAM_ID, commitment) {
+  const [configAddress] = await getConfigAddress(programId);
+  const response = await rpc.getAccountInfo(configAddress, {
+    encoding: "base64",
+    commitment
+  }).send();
+  if (!response.value) {
+    return null;
+  }
+  return decodeAmmConfig(base64ToBytes(response.value.data[0]));
+}
+async function fetchConfigWithAddress(rpc, programId = PROGRAM_ID, commitment) {
+  const [configAddress] = await 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 = {};
+__export(initializer_exports, {
+  BPF_LOADER_UPGRADEABLE_PROGRAM_ID: () => BPF_LOADER_UPGRADEABLE_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,
+  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,
+  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,
+  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: () => fetchLaunch,
+  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,
+  launchExists: () => launchExists,
+  launchIdFromU64: () => launchIdFromU64
+});
+var INITIALIZER_PROGRAM_ID = address(
+  "4H9w6qMqqSh6DVW7BzYxPHFvLaQP7rbRiQnPYGPajQxq"
+);
+var BPF_LOADER_UPGRADEABLE_PROGRAM_ID = address(
+  "BPFLoaderUpgradeab1e11111111111111111111111"
+);
+var SEED_CONFIG2 = "config_v3";
+var SEED_LAUNCH = "launch_v3";
+var SEED_LAUNCH_AUTHORITY = "launch_authority_v3";
+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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["admin", getAddressEncoder()],
+      ["migratorAllowlistLen", getU8Encoder()],
+      ["migratorAllowlist", getArrayEncoder(getAddressEncoder(), { size: 32 })],
+      ["sentinelAllowlistLen", getU8Encoder()],
+      ["sentinelAllowlist", getArrayEncoder(getAddressEncoder(), { size: 32 })],
+      ["bump", getU8Encoder()],
+      ["version", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 31)]
+    ]),
+    (value) => ({ ...value, discriminator: INIT_CONFIG_DISCRIMINATOR })
+  );
+}
+function getInitConfigDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["admin", getAddressDecoder()],
+    ["migratorAllowlistLen", getU8Decoder()],
+    ["migratorAllowlist", getArrayDecoder(getAddressDecoder(), { size: 32 })],
+    ["sentinelAllowlistLen", getU8Decoder()],
+    ["sentinelAllowlist", getArrayDecoder(getAddressDecoder(), { size: 32 })],
+    ["bump", getU8Decoder()],
+    ["version", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 31)]
+  ]);
+}
+function getInitConfigCodec() {
+  return combineCodec(getInitConfigEncoder(), getInitConfigDecoder());
+}
+function getCalldataBufEncoder() {
+  return getStructEncoder([
+    ["len", getU16Encoder()],
+    ["bytes", fixEncoderSize(getBytesEncoder(), 256)]
+  ]);
+}
+function getCalldataBufDecoder() {
+  return getStructDecoder([
+    ["len", getU16Decoder()],
+    ["bytes", fixDecoderSize(getBytesDecoder(), 256)]
+  ]);
+}
+function getInitializeConfigArgsEncoder() {
+  return getStructEncoder([
+    ["migratorAllowlist", getArrayEncoder(getAddressEncoder())],
+    ["sentinelAllowlist", getArrayEncoder(getAddressEncoder())]
+  ]);
+}
+function getInitializeConfigArgsDecoder() {
+  return getStructDecoder([
+    ["migratorAllowlist", getArrayDecoder(getAddressDecoder())],
+    ["sentinelAllowlist", getArrayDecoder(getAddressDecoder())]
+  ]);
+}
+function getInitializeConfigArgsCodec() {
+  return combineCodec(
+    getInitializeConfigArgsEncoder(),
+    getInitializeConfigArgsDecoder()
+  );
+}
+function getInitializeLaunchArgsEncoder() {
+  return getStructEncoder([
+    ["namespace", getAddressEncoder()],
+    ["launchId", fixEncoderSize(getBytesEncoder(), 32)],
+    ["baseDecimals", getU8Encoder()],
+    ["baseTotalSupply", getU64Encoder()],
+    ["baseForDistribution", getU64Encoder()],
+    ["baseForLiquidity", getU64Encoder()],
+    ["curveVirtualBase", getU64Encoder()],
+    ["curveVirtualQuote", getU64Encoder()],
+    ["curveFeeBps", getU16Encoder()],
+    ["curveKind", getU8Encoder()],
+    ["curveParams", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+    ["allowBuy", getU8Encoder()],
+    ["allowSell", getU8Encoder()],
+    ["sentinelProgram", getAddressEncoder()],
+    ["sentinelFlags", getU32Encoder()],
+    [
+      "sentinelCalldata",
+      addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+    ],
+    ["migratorProgram", getAddressEncoder()],
+    [
+      "migratorInitCalldata",
+      addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+    ],
+    [
+      "migratorMigrateCalldata",
+      addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+    ],
+    ["sentinelRemainingAccountsHash", fixEncoderSize(getBytesEncoder(), 32)],
+    ["migratorRemainingAccountsHash", fixEncoderSize(getBytesEncoder(), 32)],
+    ["metadataName", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["metadataSymbol", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+    ["metadataUri", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())]
+  ]);
+}
+function getInitializeLaunchArgsDecoder() {
+  return getStructDecoder([
+    ["namespace", getAddressDecoder()],
+    ["launchId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["baseDecimals", getU8Decoder()],
+    ["baseTotalSupply", getU64Decoder()],
+    ["baseForDistribution", getU64Decoder()],
+    ["baseForLiquidity", getU64Decoder()],
+    ["curveVirtualBase", getU64Decoder()],
+    ["curveVirtualQuote", getU64Decoder()],
+    ["curveFeeBps", getU16Decoder()],
+    ["curveKind", getU8Decoder()],
+    ["curveParams", addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())],
+    ["allowBuy", getU8Decoder()],
+    ["allowSell", getU8Decoder()],
+    ["sentinelProgram", getAddressDecoder()],
+    ["sentinelFlags", getU32Decoder()],
+    [
+      "sentinelCalldata",
+      addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())
+    ],
+    ["migratorProgram", getAddressDecoder()],
+    [
+      "migratorInitCalldata",
+      addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())
+    ],
+    [
+      "migratorMigrateCalldata",
+      addDecoderSizePrefix(getBytesDecoder(), getU32Decoder())
+    ],
+    ["sentinelRemainingAccountsHash", fixDecoderSize(getBytesDecoder(), 32)],
+    ["migratorRemainingAccountsHash", fixDecoderSize(getBytesDecoder(), 32)],
+    ["metadataName", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["metadataSymbol", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())],
+    ["metadataUri", addDecoderSizePrefix(getUtf8Decoder(), getU32Decoder())]
+  ]);
+}
+function getInitializeLaunchArgsCodec() {
+  return 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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["authority", getAddressEncoder()],
+      ["namespace", getAddressEncoder()],
+      ["launchId", fixEncoderSize(getBytesEncoder(), 32)],
+      ["phase", getU8Encoder()],
+      ["bump", getU8Encoder()],
+      ["launchAuthorityBump", getU8Encoder()],
+      ["pad0", fixEncoderSize(getBytesEncoder(), 5)],
+      ["baseMint", getAddressEncoder()],
+      ["quoteMint", getAddressEncoder()],
+      ["baseVault", getAddressEncoder()],
+      ["quoteVault", getAddressEncoder()],
+      ["baseTotalSupply", getU64Encoder()],
+      ["baseForDistribution", getU64Encoder()],
+      ["baseForLiquidity", getU64Encoder()],
+      ["baseForCurve", getU64Encoder()],
+      ["curveVirtualBase", getU64Encoder()],
+      ["curveVirtualQuote", getU64Encoder()],
+      ["curveFeeBps", getU16Encoder()],
+      ["pad1", fixEncoderSize(getBytesEncoder(), 6)],
+      ["allowBuy", getU8Encoder()],
+      ["allowSell", getU8Encoder()],
+      ["pad2", fixEncoderSize(getBytesEncoder(), 6)],
+      ["sentinelProgram", getAddressEncoder()],
+      ["sentinelFlags", getU32Encoder()],
+      ["pad3", fixEncoderSize(getBytesEncoder(), 4)],
+      ["sentinelCalldata", getCalldataBufEncoder()],
+      ["migratorProgram", getAddressEncoder()],
+      ["migratorInitCalldata", getCalldataBufEncoder()],
+      ["migratorMigrateCalldata", getCalldataBufEncoder()],
+      ["curveKind", getU8Encoder()],
+      ["swapLock", getU8Encoder()],
+      ["pad4", fixEncoderSize(getBytesEncoder(), 6)],
+      ["curveParams", getCalldataBufEncoder()],
+      ["quoteDeposited", getU64Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 64)]
+    ]),
+    (value) => ({ ...value, discriminator: LAUNCH_DISCRIMINATOR })
+  );
+}
+function getLaunchDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["authority", getAddressDecoder()],
+    ["namespace", getAddressDecoder()],
+    ["launchId", fixDecoderSize(getBytesDecoder(), 32)],
+    ["phase", getU8Decoder()],
+    ["bump", getU8Decoder()],
+    ["launchAuthorityBump", getU8Decoder()],
+    ["pad0", fixDecoderSize(getBytesDecoder(), 5)],
+    ["baseMint", getAddressDecoder()],
+    ["quoteMint", getAddressDecoder()],
+    ["baseVault", getAddressDecoder()],
+    ["quoteVault", getAddressDecoder()],
+    ["baseTotalSupply", getU64Decoder()],
+    ["baseForDistribution", getU64Decoder()],
+    ["baseForLiquidity", getU64Decoder()],
+    ["baseForCurve", getU64Decoder()],
+    ["curveVirtualBase", getU64Decoder()],
+    ["curveVirtualQuote", getU64Decoder()],
+    ["curveFeeBps", getU16Decoder()],
+    ["pad1", fixDecoderSize(getBytesDecoder(), 6)],
+    ["allowBuy", getU8Decoder()],
+    ["allowSell", getU8Decoder()],
+    ["pad2", fixDecoderSize(getBytesDecoder(), 6)],
+    ["sentinelProgram", getAddressDecoder()],
+    ["sentinelFlags", getU32Decoder()],
+    ["pad3", fixDecoderSize(getBytesDecoder(), 4)],
+    ["sentinelCalldata", getCalldataBufDecoder()],
+    ["migratorProgram", getAddressDecoder()],
+    ["migratorInitCalldata", getCalldataBufDecoder()],
+    ["migratorMigrateCalldata", getCalldataBufDecoder()],
+    ["curveKind", getU8Decoder()],
+    ["swapLock", getU8Decoder()],
+    ["pad4", fixDecoderSize(getBytesDecoder(), 6)],
+    ["curveParams", getCalldataBufDecoder()],
+    ["quoteDeposited", getU64Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 64)]
+  ]);
+}
+function getLaunchCodec() {
+  return combineCodec(getLaunchEncoder(), getLaunchDecoder());
+}
+var CURVE_SWAP_EXACT_IN_DISCRIMINATOR = new Uint8Array([
+  196,
+  247,
+  195,
+  126,
+  227,
+  27,
+  166,
+  93
+]);
+function getCurveSwapExactInInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["amountIn", getU64Encoder()],
+      ["minAmountOut", getU64Encoder()],
+      ["direction", 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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["migratorAllowlist", getArrayEncoder(getAddressEncoder())],
+      ["sentinelAllowlist", getArrayEncoder(getAddressEncoder())]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_CONFIG_DISCRIMINATOR })
+  );
+}
+var INITIALIZE_LAUNCH_DISCRIMINATOR = new Uint8Array([
+  90,
+  201,
+  220,
+  142,
+  112,
+  253,
+  100,
+  13
+]);
+function getInitializeLaunchInstructionDataEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["namespace", getAddressEncoder()],
+      ["launchId", fixEncoderSize(getBytesEncoder(), 32)],
+      ["baseDecimals", getU8Encoder()],
+      ["baseTotalSupply", getU64Encoder()],
+      ["baseForDistribution", getU64Encoder()],
+      ["baseForLiquidity", getU64Encoder()],
+      ["curveVirtualBase", getU64Encoder()],
+      ["curveVirtualQuote", getU64Encoder()],
+      ["curveFeeBps", getU16Encoder()],
+      ["curveKind", getU8Encoder()],
+      ["curveParams", addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())],
+      ["allowBuy", getU8Encoder()],
+      ["allowSell", getU8Encoder()],
+      ["sentinelProgram", getAddressEncoder()],
+      ["sentinelFlags", getU32Encoder()],
+      [
+        "sentinelCalldata",
+        addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+      ],
+      ["migratorProgram", getAddressEncoder()],
+      [
+        "migratorInitCalldata",
+        addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+      ],
+      [
+        "migratorMigrateCalldata",
+        addEncoderSizePrefix(getBytesEncoder(), getU32Encoder())
+      ],
+      ["sentinelRemainingAccountsHash", fixEncoderSize(getBytesEncoder(), 32)],
+      ["migratorRemainingAccountsHash", fixEncoderSize(getBytesEncoder(), 32)],
+      ["metadataName", addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())],
+      [
+        "metadataSymbol",
+        addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder())
+      ],
+      ["metadataUri", addEncoderSizePrefix(getUtf8Encoder(), 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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["amountIn", getU64Encoder()],
+      ["direction", 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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["allowlist", getArrayEncoder(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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["allowlist", getArrayEncoder(getAddressEncoder())]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: SET_SENTINEL_ALLOWLIST_DISCRIMINATOR
+    })
+  );
+}
+if (process.env.NODE_ENV !== "production") ;
+var addressCodec2 = 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 getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder2.encode(SEED_CONFIG2)]
+  });
+}
+async function getProgramDataAddress(programId = INITIALIZER_PROGRAM_ID) {
+  return 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 getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [
+      textEncoder2.encode(SEED_LAUNCH),
+      addressCodec2.encode(namespace),
+      launchId
+    ]
+  });
+}
+async function getLaunchAuthorityAddress(launch, programId = INITIALIZER_PROGRAM_ID) {
+  return 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;
+}
+
+// src/solana/initializer/instructions/initializeConfig.ts
+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 = SYSTEM_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    createSignerAccountMeta2(admin, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: config, role: ACCOUNT_ROLE_WRITABLE },
+    { address: programData, role: ACCOUNT_ROLE_READONLY },
+    { address: systemProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = new Uint8Array(
+    getInitializeConfigInstructionDataEncoder().encode(args)
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+
+// src/solana/initializer/instructions/setMigratorAllowlist.ts
+function isTransactionSigner3(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+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, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: config, role: ACCOUNT_ROLE_WRITABLE }
+  ];
+  const data = new Uint8Array(
+    getSetMigratorAllowlistInstructionDataEncoder().encode({ allowlist })
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+
+// src/solana/initializer/instructions/setSentinelAllowlist.ts
+function isTransactionSigner4(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+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, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: config, role: ACCOUNT_ROLE_WRITABLE }
+  ];
+  const data = new Uint8Array(
+    getSetSentinelAllowlistInstructionDataEncoder().encode({ allowlist })
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+
+// 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 };
+}
+function validateInitializeLaunchCurveParams(args) {
+  if (args.curveKind !== CURVE_KIND_XYK) {
+    throw new Error(
+      `unsupported curve kind: ${args.curveKind}; only CURVE_KIND_XYK is currently enabled`
+    );
+  }
+  if (args.curveParams.length !== 1 || args.curveParams[0] !== CURVE_PARAMS_FORMAT_XYK_V0) {
+    throw new Error("xyk curve params must be [CURVE_PARAMS_FORMAT_XYK_V0]");
+  }
+}
+function createInitializeLaunchInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
+  validateInitializeLaunchCurveParams(args);
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseMint,
+    quoteMint,
+    baseVault,
+    quoteVault,
+    payer,
+    authority,
+    migratorProgram,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    systemProgram = SYSTEM_PROGRAM_ID,
+    rent
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
+    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
+    createAccountMeta(baseMint, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: quoteMint, role: ACCOUNT_ROLE_READONLY },
+    createAccountMeta(baseVault, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    createAccountMeta(quoteVault, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    createAccountMeta(payer, ACCOUNT_ROLE_WRITABLE_SIGNER)
+  ];
+  if (authority) {
+    keys.push(createAccountMeta(authority, ACCOUNT_ROLE_SIGNER));
+  }
+  if (migratorProgram) {
+    keys.push({ address: migratorProgram, role: ACCOUNT_ROLE_READONLY });
+  }
+  keys.push({ address: tokenProgram, role: ACCOUNT_ROLE_READONLY });
+  keys.push({ address: systemProgram, role: ACCOUNT_ROLE_READONLY });
+  keys.push({ address: rent, role: ACCOUNT_ROLE_READONLY });
+  const data = new Uint8Array(
+    getInitializeLaunchInstructionDataEncoder().encode(args)
+  );
+  return {
+    programAddress: programId,
+    accounts: keys,
+    data
+  };
+}
+
+// src/solana/initializer/instructions/curveSwapExactIn.ts
+function isTransactionSigner6(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function 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,
+    tokenProgram = TOKEN_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
+    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
+    { address: baseVault, role: ACCOUNT_ROLE_WRITABLE },
+    { address: quoteVault, role: ACCOUNT_ROLE_WRITABLE },
+    { address: userBaseAccount, role: ACCOUNT_ROLE_WRITABLE },
+    { address: userQuoteAccount, role: ACCOUNT_ROLE_WRITABLE },
+    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
+    { address: quoteMint, role: ACCOUNT_ROLE_READONLY },
+    createAccountMeta2(user, ACCOUNT_ROLE_SIGNER)
+  ];
+  if (sentinelProgram) {
+    keys.push({ address: sentinelProgram, role: ACCOUNT_ROLE_READONLY });
+  }
+  keys.push({ address: tokenProgram, role: ACCOUNT_ROLE_READONLY });
+  const data = new Uint8Array(
+    getCurveSwapExactInInstructionDataEncoder().encode(args)
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+
+// src/solana/initializer/instructions/migrateLaunch.ts
+function isTransactionSigner7(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createSignerAccountMeta5(value, role) {
+  if (isTransactionSigner7(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createMigrateLaunchInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseMint,
+    quoteMint,
+    baseVault,
+    quoteVault,
+    migratorProgram,
+    payer,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    systemProgram = SYSTEM_PROGRAM_ID,
+    rent
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
+    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
+    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
+    { address: quoteMint, role: ACCOUNT_ROLE_READONLY },
+    { address: baseVault, role: ACCOUNT_ROLE_WRITABLE },
+    { address: quoteVault, role: ACCOUNT_ROLE_WRITABLE },
+    { address: migratorProgram, role: ACCOUNT_ROLE_READONLY },
+    createSignerAccountMeta5(payer, ACCOUNT_ROLE_WRITABLE_SIGNER),
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY },
+    { address: systemProgram, role: ACCOUNT_ROLE_READONLY },
+    { address: rent, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.migrateLaunch
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+
+// src/solana/initializer/instructions/abortLaunch.ts
+function isTransactionSigner8(value) {
+  return typeof value === "object" && value !== null && "address" in value && "signTransactions" in value;
+}
+function createAccountMeta3(value, role) {
+  if (isTransactionSigner8(value)) {
+    return { address: value.address, role, signer: value };
+  }
+  return { address: value, role };
+}
+function createAbortLaunchInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
+  const {
+    config,
+    launch,
+    launchAuthority,
+    baseVault,
+    quoteVault,
+    authority,
+    authorityBaseAccount,
+    baseMint,
+    tokenProgram = TOKEN_PROGRAM_ID
+  } = accounts;
+  const keys = [
+    { address: config, role: ACCOUNT_ROLE_READONLY },
+    { address: launch, role: ACCOUNT_ROLE_WRITABLE },
+    { address: launchAuthority, role: ACCOUNT_ROLE_READONLY },
+    { address: baseVault, role: ACCOUNT_ROLE_WRITABLE },
+    { address: quoteVault, role: ACCOUNT_ROLE_READONLY },
+    createAccountMeta3(authority, ACCOUNT_ROLE_SIGNER),
+    { address: authorityBaseAccount, role: ACCOUNT_ROLE_WRITABLE },
+    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
+    { address: tokenProgram, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.abortLaunch
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+var previewSwapExactInResultCodec = getStructCodec([
+  ["amountOut", getU64Codec()],
+  ["feePaid", getU64Codec()]
+]);
+function createPreviewSwapExactInInstruction(accounts, args, programId = INITIALIZER_PROGRAM_ID) {
+  const { launch, baseVault, quoteVault, sentinelProgram } = accounts;
+  const keys = [
+    { address: launch, role: ACCOUNT_ROLE_READONLY },
+    { address: baseVault, role: ACCOUNT_ROLE_READONLY },
+    { address: quoteVault, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const accountsList = sentinelProgram ? [...keys, { address: sentinelProgram, role: ACCOUNT_ROLE_READONLY }] : keys;
+  const data = new Uint8Array(
+    getPreviewSwapExactInInstructionDataEncoder().encode(args)
+  );
+  return { programAddress: programId, accounts: accountsList, data };
+}
+function decodePreviewSwapExactInResult(data) {
+  return previewSwapExactInResultCodec.decode(data);
+}
+var previewMigrationResultCodec = getStructCodec([
+  ["baseVaultAmount", getU64Codec()],
+  ["quoteVaultAmount", getU64Codec()],
+  ["baseMintSupply", getU64Codec()]
+]);
+function createPreviewMigrationInstruction(accounts, programId = INITIALIZER_PROGRAM_ID) {
+  const { launch, baseMint, baseVault, quoteVault } = accounts;
+  const keys = [
+    { address: launch, role: ACCOUNT_ROLE_READONLY },
+    { address: baseMint, role: ACCOUNT_ROLE_READONLY },
+    { address: baseVault, role: ACCOUNT_ROLE_READONLY },
+    { address: quoteVault, role: ACCOUNT_ROLE_READONLY }
+  ];
+  const data = encodeInstructionData(
+    INITIALIZER_INSTRUCTION_DISCRIMINATORS.previewMigration
+  );
+  return { programAddress: programId, accounts: keys, data };
+}
+function decodePreviewMigrationResult(data) {
+  return previewMigrationResultCodec.decode(data);
+}
+var addressCodec3 = 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 fetchLaunch(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(
+        addressCodec3.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 fetchLaunch(rpc, launchAddress, config);
+  return launch !== null;
+}
+
+// src/solana/migrators/cpmmMigrator/index.ts
+var cpmmMigrator_exports = {};
+__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 getStructEncoder([
+    ["baseForDistribution", getU64Encoder()],
+    ["baseForLiquidity", getU64Encoder()]
+  ]);
+}
+function getMigrateArgsDecoder() {
+  return getStructDecoder([
+    ["baseForDistribution", getU64Decoder()],
+    ["baseForLiquidity", getU64Decoder()]
+  ]);
+}
+function getMigrateArgsCodec() {
+  return combineCodec(getMigrateArgsEncoder(), getMigrateArgsDecoder());
+}
+function getRecipientEncoder() {
+  return getStructEncoder([
+    ["wallet", getAddressEncoder()],
+    ["amount", getU64Encoder()]
+  ]);
+}
+function getRecipientDecoder() {
+  return getStructDecoder([
+    ["wallet", getAddressDecoder()],
+    ["amount", getU64Decoder()]
+  ]);
+}
+function getRecipientCodec() {
+  return combineCodec(getRecipientEncoder(), getRecipientDecoder());
+}
+function getRegisterLaunchArgsEncoder() {
+  return getStructEncoder([
+    ["cpmmConfig", getAddressEncoder()],
+    ["initialSwapFeeBps", getU16Encoder()],
+    ["initialFeeSplitBps", getU16Encoder()],
+    ["recipients", getArrayEncoder(getRecipientEncoder())],
+    ["minRaiseQuote", getU64Encoder()],
+    ["minMigrationPriceQ64Opt", getOptionEncoder(getU128Encoder())]
+  ]);
+}
+function getRegisterLaunchArgsDecoder() {
+  return getStructDecoder([
+    ["cpmmConfig", getAddressDecoder()],
+    ["initialSwapFeeBps", getU16Decoder()],
+    ["initialFeeSplitBps", getU16Decoder()],
+    ["recipients", getArrayDecoder(getRecipientDecoder())],
+    ["minRaiseQuote", getU64Decoder()],
+    ["minMigrationPriceQ64Opt", getOptionDecoder(getU128Decoder())]
+  ]);
+}
+function getRegisterLaunchArgsCodec() {
+  return 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 transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["launch", getAddressEncoder()],
+      ["admin", getAddressEncoder()],
+      ["cpmmConfig", getAddressEncoder()],
+      ["initialSwapFeeBps", getU16Encoder()],
+      ["initialFeeSplitBps", getU16Encoder()],
+      ["pad0", fixEncoderSize(getBytesEncoder(), 4)],
+      ["recipients", getArrayEncoder(getRecipientEncoder(), { size: 2 })],
+      ["minRaiseQuote", getU64Encoder()],
+      ["minMigrationPriceQ64Opt", getOptionEncoder(getU128Encoder())],
+      ["isMigrated", getBooleanEncoder()],
+      ["bump", getU8Encoder()],
+      ["reserved", fixEncoderSize(getBytesEncoder(), 14)]
+    ]),
+    (value) => ({ ...value, discriminator: CPMM_MIGRATOR_STATE_DISCRIMINATOR })
+  );
+}
+function getCpmmMigratorStateDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["launch", getAddressDecoder()],
+    ["admin", getAddressDecoder()],
+    ["cpmmConfig", getAddressDecoder()],
+    ["initialSwapFeeBps", getU16Decoder()],
+    ["initialFeeSplitBps", getU16Decoder()],
+    ["pad0", fixDecoderSize(getBytesDecoder(), 4)],
+    ["recipients", getArrayDecoder(getRecipientDecoder(), { size: 2 })],
+    ["minRaiseQuote", getU64Decoder()],
+    ["minMigrationPriceQ64Opt", getOptionDecoder(getU128Decoder())],
+    ["isMigrated", getBooleanDecoder()],
+    ["bump", getU8Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 14)]
+  ]);
+}
+function getCpmmMigratorStateCodec() {
+  return combineCodec(
+    getCpmmMigratorStateEncoder(),
+    getCpmmMigratorStateDecoder()
+  );
+}
+if (process.env.NODE_ENV !== "production") ;
+var CPMM_MIGRATOR_PROGRAM_ID = address(
+  "CpmmMig1111111111111111111111111111111111111"
+);
+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 addressCodec4 = getAddressCodec();
+var textEncoder3 = new TextEncoder();
+async function getCpmmMigratorStateAddress(launch, programId = CPMM_MIGRATOR_PROGRAM_ID) {
+  return getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [textEncoder3.encode(SEED_STATE), addressCodec4.encode(launch)]
+  });
+}
+
+// src/solana/migrators/cpmmMigrator/client.ts
+function base64ToBytes3(base64) {
+  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 mergeBytes([
+    CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS.registerLaunch,
+    encoded
+  ]);
+}
+function encodeMigrateCalldata(args) {
+  const encoded = new Uint8Array(getMigrateArgsEncoder().encode(args));
+  return mergeBytes([
+    CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS.migrate,
+    encoded
+  ]);
+}
+
+export { CPMM_ERROR_MESSAGES, CpmmError, CpmmErrorCode, cpmmMigrator_exports as cpmmMigrator, createAddLiquidityInstruction, createClosePositionInstruction, createCollectProtocolFeesInstruction, createCreatePositionInstruction, createInitializeConfigInstruction, createInitializeOracleInstruction, createInitializePoolInstruction, createOracleConsultInstruction, createOracleUpdateInstruction, createPauseInstruction, createQuoteToNumeraireInstruction, createRemoveLiquidityInstruction, createSetFeesInstruction, createSetRouteInstruction, createSetSentinelInstruction, createSkimInstruction, createSwapExactInInstruction, createSwapInstruction, createTransferAdminInstruction, createUnpauseInstruction, curveParamsToMarketCap, decodeOracleConsultResult, decodeQuoteToNumeraireResult, fetchConfig, fetchConfigWithAddress, getErrorMessage, getMetadataAddress, initializer_exports as initializer, isCpmmError, marketCapToCurveParams, marketCapToSingleCurveParams, marketCapToTokenPrice, parseErrorFromLogs, validateMarketCapParameters };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map