@meteora-ag/dynamic-bonding-curve-sdk 1.5.9 → 1.5.11

package/dist/index.cjs

@@ -29014,999 +29014,997 @@ async function createLockEscrowIx(payer, pool, lpMint, escrowOwner, lockEscrowKe
 
 
 
-var DynamicBondingCurveProgram = class {
-  constructor(connection, commitment, state) {
+
+// src/services/state.ts
+
+
+
+
+
+var StateService = class {
+  constructor(connection, commitment) {
     const { program } = createDbcProgram(connection, commitment);
     this.program = program;
-    this.connection = connection;
-    this.poolAuthority = deriveDbcPoolAuthority();
     this.commitment = commitment;
-    this.state = state;
   }
-  async getPoolWithConfig(pool) {
-    const virtualPool = await this.state.getPool(pool);
-    if (!virtualPool) {
-      throw new Error(`Pool not found: ${pool.toString()}`);
+  getProgram() {
+    return this.program;
+  }
+  /**
+   * Fetch virtual pools across both the standard and transfer-hook account variants.
+   */
+  async fetchVirtualPools(filters) {
+    const [pools, transferHookPools] = await Promise.all([
+      this.program.account.virtualPool.all(filters),
+      this.program.account.transferHookPool.all(filters)
+    ]);
+    return [...pools, ...transferHookPools];
+  }
+  /**
+   * Fetch pool configs across both the standard and transfer-hook account variants.
+   */
+  async fetchPoolConfigs(filters) {
+    const [configs, transferHookConfigs] = await Promise.all([
+      this.program.account.poolConfig.all(filters),
+      this.program.account.configWithTransferHook.all(filters)
+    ]);
+    return [
+      ...configs,
+      ...transferHookConfigs.map((account) => ({
+        publicKey: account.publicKey,
+        account: account.account.config
+      }))
+    ];
+  }
+  /**
+   * Fetch a pool config account.
+   */
+  async getPoolConfig(configAddress) {
+    const address = configAddress instanceof _web3js.PublicKey ? configAddress : new (0, _web3js.PublicKey)(configAddress);
+    try {
+      const poolConfig = await this.program.account.poolConfig.fetchNullable(
+        address,
+        this.commitment
+      );
+      if (poolConfig) {
+        return poolConfig;
+      }
+    } catch (e3) {
     }
-    const poolConfigState = await this.state.getPoolConfig(
-      virtualPool.poolState.config
+    const configWithTransferHook = await this.program.account.configWithTransferHook.fetchNullable(
+      address,
+      this.commitment
     );
-    if (!poolConfigState) {
-      throw new Error(`Pool config not found for virtual pool`);
-    }
-    return { virtualPool, poolConfigState };
+    return _nullishCoalesce(_optionalChain([configWithTransferHook, 'optionalAccess', _29 => _29.config]), () => ( null));
   }
-  prepareSwapParams(swapBaseForQuote, virtualPoolState, poolConfigState) {
-    if (swapBaseForQuote) {
-      return {
-        inputMint: new (0, _web3js.PublicKey)(virtualPoolState.baseMint),
-        outputMint: new (0, _web3js.PublicKey)(poolConfigState.quoteMint),
-        inputTokenProgram: getTokenProgram(virtualPoolState.poolType),
-        outputTokenProgram: getTokenProgram(
-          poolConfigState.quoteTokenFlag
-        )
-      };
-    }
-    return {
-      inputMint: new (0, _web3js.PublicKey)(poolConfigState.quoteMint),
-      outputMint: new (0, _web3js.PublicKey)(virtualPoolState.baseMint),
-      inputTokenProgram: getTokenProgram(poolConfigState.quoteTokenFlag),
-      outputTokenProgram: getTokenProgram(virtualPoolState.poolType)
-    };
+  /**
+   * Fetch all pool config accounts.
+   */
+  async getPoolConfigs() {
+    return this.fetchPoolConfigs();
   }
-  async buildCreateConfigTx(configParam, config, feeClaimer, leftoverReceiver, quoteMint, payer) {
-    validateConfigParameters({ ...configParam, leftoverReceiver });
-    return this.program.methods.createConfig(configParam).accountsPartial({
-      config,
-      feeClaimer,
-      leftoverReceiver,
-      quoteMint,
-      payer
-    }).transaction();
+  /**
+   * Fetch all pool configs owned by a wallet.
+   */
+  async getPoolConfigsByOwner(owner) {
+    const filters = createProgramAccountFilter(owner, 72);
+    return this.fetchPoolConfigs(filters);
   }
-  async buildCreateConfigWithTransferHookTx(configParam, config, feeClaimer, leftoverReceiver, quoteMint, transferHookProgram, payer) {
-    validateConfigParameters(
-      { ...configParam, leftoverReceiver },
-      { isTransferHook: true, transferHookProgram }
+  /**
+   * Fetch a virtual pool account.
+   */
+  async getPool(poolAddress) {
+    const address = poolAddress instanceof _web3js.PublicKey ? poolAddress : new (0, _web3js.PublicKey)(poolAddress);
+    try {
+      const virtualPool = await this.program.account.virtualPool.fetchNullable(
+        address,
+        this.commitment
+      );
+      if (virtualPool) {
+        return virtualPool;
+      }
+    } catch (e4) {
+    }
+    return await this.program.account.transferHookPool.fetchNullable(
+      address,
+      this.commitment
     );
-    return this.program.methods.createConfigWithTransferHook(configParam).accountsPartial({
-      config,
-      feeClaimer,
-      leftoverReceiver,
-      quoteMint,
-      transferHookProgram,
-      payer
-    }).transaction();
   }
-  async initializeSplPool(params) {
-    const {
-      name,
-      symbol,
-      uri,
-      pool,
-      config,
-      payer,
-      poolCreator,
-      mintMetadata,
-      baseMint,
-      baseVault,
-      quoteVault,
-      quoteMint
-    } = params;
-    return this.program.methods.initializeVirtualPoolWithSplToken({
-      name,
-      symbol,
-      uri
-    }).accountsPartial({
-      pool,
-      config,
-      payer,
-      creator: poolCreator,
-      mintMetadata,
-      baseMint,
-      poolAuthority: this.poolAuthority,
-      baseVault,
-      quoteVault,
-      quoteMint,
-      tokenQuoteProgram: _spltoken.TOKEN_PROGRAM_ID,
-      metadataProgram: METAPLEX_PROGRAM_ID,
-      tokenProgram: _spltoken.TOKEN_PROGRAM_ID
-    }).transaction();
+  /**
+   * Fetch all virtual pool accounts.
+   */
+  async getPools() {
+    return this.fetchVirtualPools();
   }
-  async initializeToken2022Pool(params) {
-    const {
-      name,
-      symbol,
-      uri,
-      pool,
-      config,
-      payer,
-      poolCreator,
-      baseMint,
-      baseVault,
-      quoteVault,
-      quoteMint
-    } = params;
-    return this.program.methods.initializeVirtualPoolWithToken2022({
-      name,
-      symbol,
-      uri
-    }).accountsPartial({
-      pool,
-      config,
-      payer,
-      creator: poolCreator,
-      baseMint,
-      poolAuthority: this.poolAuthority,
-      baseVault,
-      quoteVault,
-      quoteMint,
-      tokenQuoteProgram: _spltoken.TOKEN_PROGRAM_ID,
-      tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
-    }).transaction();
+  /**
+   * Fetch all virtual pools that use a config.
+   */
+  async getPoolsByConfig(configAddress) {
+    const filters = createProgramAccountFilter(configAddress, 72);
+    return this.fetchVirtualPools(filters);
   }
-  async initializeToken2022PoolWithTransferHook(params) {
-    const {
-      name,
-      symbol,
-      uri,
-      pool,
-      config,
-      payer,
-      poolCreator,
-      baseMint,
-      baseVault,
-      quoteVault,
-      quoteMint,
-      transferHookProgram,
-      tokenQuoteProgram
-    } = params;
-    return this.program.methods.initializeVirtualPoolWithToken2022TransferHook({
-      name,
-      symbol,
-      uri
-    }).accountsPartial({
-      pool,
-      config,
-      payer,
-      creator: poolCreator,
-      baseMint,
-      poolAuthority: this.poolAuthority,
-      baseVault,
-      quoteVault,
-      quoteMint,
-      transferHookProgram,
-      tokenQuoteProgram,
-      tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
-    }).transaction();
+  /**
+   * Fetch all virtual pools created by a wallet.
+   */
+  async getPoolsByCreator(creatorAddress) {
+    const filters = createProgramAccountFilter(creatorAddress, 104);
+    return this.fetchVirtualPools(filters);
   }
-  async buildCreatePoolTx(createPoolParam, tokenType, quoteMint) {
-    const { baseMint, name, symbol, uri, poolCreator, config, payer } = createPoolParam;
-    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
-    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
-    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
-    const baseParams = {
-      name,
-      symbol,
-      uri,
-      pool,
-      config,
-      payer,
-      poolCreator,
-      baseMint,
-      baseVault,
-      quoteVault,
-      quoteMint
-    };
-    if (tokenType === 0 /* SPLToken */) {
-      const mintMetadata = deriveMintMetadata(baseMint);
-      return this.initializeSplPool({ ...baseParams, mintMetadata });
+  /**
+   * Fetch the first virtual pool that uses a base mint.
+   */
+  async getPoolByBaseMint(baseMint) {
+    const filters = createProgramAccountFilter(baseMint, 136);
+    const pools = await this.fetchVirtualPools(filters);
+    return pools.length > 0 ? pools[0] : null;
+  }
+  /**
+   * Fetch the migration quote threshold for a pool.
+   */
+  async getPoolMigrationQuoteThreshold(poolAddress) {
+    const pool = await this.getPool(poolAddress);
+    if (!pool) {
+      throw new Error(`Pool not found: ${poolAddress.toString()}`);
     }
-    return this.initializeToken2022Pool(baseParams);
+    const configAddress = pool.poolState.config;
+    const config = await this.getPoolConfig(configAddress);
+    return config.migrationQuoteThreshold;
   }
-  async buildCreatePoolWithTransferHookTx(createPoolParam, quoteMint, tokenQuoteProgram) {
-    const {
-      baseMint,
-      name,
-      symbol,
-      uri,
-      poolCreator,
-      config,
-      payer,
-      transferHookProgram
-    } = createPoolParam;
-    if (!validateTransferHookProgram(transferHookProgram)) {
-      throw new Error(
-        "Invalid transfer hook program: cannot be the DBC program, SPL Token, SPL Token-2022, or the default pubkey"
-      );
+  /**
+   * Return quote-token curve progress as a ratio between 0 and 1.
+   */
+  async getPoolQuoteTokenCurveProgress(poolAddress) {
+    const pool = await this.getPool(poolAddress);
+    if (!pool) {
+      throw new Error(`Pool not found: ${poolAddress.toString()}`);
     }
-    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
-    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
-    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
-    return this.initializeToken2022PoolWithTransferHook({
-      name,
-      symbol,
-      uri,
-      pool,
-      config,
-      payer,
-      poolCreator,
-      baseMint,
-      baseVault,
-      quoteVault,
-      quoteMint,
-      transferHookProgram,
-      tokenQuoteProgram
-    });
+    const config = await this.getPoolConfig(pool.poolState.config);
+    const quoteReserve = pool.poolState.quoteReserve;
+    const migrationThreshold = config.migrationQuoteThreshold;
+    const quoteReserveDecimal = new (0, _decimaljs2.default)(quoteReserve.toString());
+    const thresholdDecimal = new (0, _decimaljs2.default)(migrationThreshold.toString());
+    const progress = quoteReserveDecimal.div(thresholdDecimal).toNumber();
+    return Math.min(Math.max(progress, 0), 1);
   }
-  async buildSwapBuyTx(firstBuyParam, baseMint, config, baseFee, swapBaseForQuote, activationType, tokenType, quoteMint, enableFirstSwapWithMinFee) {
-    const {
-      buyer,
-      receiver,
-      buyAmount,
-      minimumAmountOut,
-      referralTokenAccount
-    } = firstBuyParam;
-    validateSwapAmount(buyAmount);
-    let rateLimiterApplied = false;
-    if (baseFee.baseFeeMode === 2 /* RateLimiter */) {
-      const currentPoint = await getCurrentPoint(
-        this.connection,
-        activationType
-      );
-      rateLimiterApplied = isRateLimiterApplied(
-        currentPoint,
-        new (0, _bnjs2.default)(0),
-        swapBaseForQuote ? 0 /* BaseToQuote */ : 1 /* QuoteToBase */,
-        baseFee.secondFactor,
-        baseFee.thirdFactor,
-        new (0, _bnjs2.default)(baseFee.firstFactor)
-      );
+  /**
+   * Return base-token curve progress as a ratio between 0 and 1.
+   */
+  async getPoolBaseTokenCurveProgress(poolAddress) {
+    const pool = await this.getPool(poolAddress);
+    if (!pool) {
+      throw new Error(`Pool not found: ${poolAddress.toString()}`);
     }
-    const quoteTokenFlag = await getTokenType(this.connection, quoteMint);
-    const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(
-      false,
-      {
-        baseMint,
-        poolType: tokenType
+    const config = await this.getPoolConfig(pool.poolState.config);
+    const baseSold = new (0, _decimaljs2.default)(
+      getBaseTokenForSwap(
+        config.sqrtStartPrice,
+        pool.poolState.sqrtPrice,
+        config.curve
+      ).toString()
+    );
+    const totalBaseCouldBeSold = new (0, _decimaljs2.default)(
+      getBaseTokenForSwap(
+        config.sqrtStartPrice,
+        config.migrationSqrtPrice,
+        config.curve
+      ).toString()
+    );
+    const progress = baseSold.div(totalBaseCouldBeSold).toNumber();
+    return Math.min(Math.max(progress, 0), 1);
+  }
+  /**
+   * Fetch metadata accounts for a virtual pool.
+   */
+  async getPoolMetadata(poolAddress) {
+    const filters = createProgramAccountFilter(poolAddress, 8);
+    const accounts = await this.program.account.virtualPoolMetadata.all(filters);
+    return accounts.map((account) => account.account);
+  }
+  /**
+   * Fetch metadata accounts for a partner.
+   */
+  async getPartnerMetadata(partnerAddress) {
+    const filters = createProgramAccountFilter(partnerAddress, 8);
+    const accounts = await this.program.account.partnerMetadata.all(filters);
+    return accounts.map((account) => account.account);
+  }
+  /**
+   * Fetch current unclaimed fees and lifetime trading fee metrics for a pool.
+   */
+  async getPoolFeeMetrics(poolAddress) {
+    const pool = await this.getPool(poolAddress);
+    if (!pool) {
+      throw new Error(`Pool not found: ${poolAddress.toString()}`);
+    }
+    return {
+      current: {
+        partnerBaseFee: pool.poolState.partnerBaseFee,
+        partnerQuoteFee: pool.poolState.partnerQuoteFee,
+        creatorBaseFee: pool.poolState.creatorBaseFee,
+        creatorQuoteFee: pool.poolState.creatorQuoteFee
       },
-      {
-        quoteMint,
-        quoteTokenFlag
+      total: {
+        totalTradingBaseFee: pool.poolState.metrics.totalTradingBaseFee,
+        totalTradingQuoteFee: pool.poolState.metrics.totalTradingQuoteFee
       }
-    );
-    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
-    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
-    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
-    const preInstructions = [];
-    const [
-      { ataPubkey: inputTokenAccount, ix: createAtaTokenAIx },
-      { ataPubkey: outputTokenAccount, ix: createAtaTokenBIx }
-    ] = await Promise.all([
-      getOrCreateATAInstruction(
-        this.connection,
-        inputMint,
-        buyer,
-        buyer,
-        true,
-        inputTokenProgram
-      ),
-      getOrCreateATAInstruction(
-        this.connection,
-        outputMint,
-        receiver ? receiver : buyer,
-        buyer,
-        true,
-        outputTokenProgram
-      )
-    ]);
-    createAtaTokenAIx && preInstructions.push(createAtaTokenAIx);
-    createAtaTokenBIx && preInstructions.push(createAtaTokenBIx);
-    if (inputMint.equals(_spltoken.NATIVE_MINT)) {
-      preInstructions.push(
-        ...wrapSOLInstruction(
-          buyer,
-          inputTokenAccount,
-          BigInt(buyAmount.toString())
-        )
-      );
+    };
+  }
+  /**
+   * Calculate claimed, unclaimed, and total trading fees split by creator and partner.
+   */
+  async getPoolFeeBreakdown(poolAddress) {
+    const pool = await this.getPool(poolAddress);
+    if (!pool) {
+      throw new Error(`Pool not found: ${poolAddress.toString()}`);
     }
-    const postInstructions = [];
-    if ([inputMint.toBase58(), outputMint.toBase58()].includes(
-      _spltoken.NATIVE_MINT.toBase58()
-    )) {
-      const unwrapIx = unwrapSOLInstruction(buyer, buyer);
-      unwrapIx && postInstructions.push(unwrapIx);
+    const config = await this.getPoolConfig(pool.poolState.config);
+    if (!config) {
+      throw new Error(
+        `Config not found: ${pool.poolState.config.toString()}`
+      );
     }
-    const remainingAccounts = [];
-    if (rateLimiterApplied || enableFirstSwapWithMinFee) {
-      remainingAccounts.push({
-        isSigner: false,
-        isWritable: false,
-        pubkey: _web3js.SYSVAR_INSTRUCTIONS_PUBKEY
-      });
+    const creatorTradingFeePercentage = config.creatorTradingFeePercentage;
+    const totalTradingBaseFee = pool.poolState.metrics.totalTradingBaseFee;
+    const totalTradingQuoteFee = pool.poolState.metrics.totalTradingQuoteFee;
+    let creatorTotalTradingBaseFee = new (0, _bnjs2.default)(0);
+    let creatorTotalTradingQuoteFee = new (0, _bnjs2.default)(0);
+    let partnerTotalTradingBaseFee = totalTradingBaseFee;
+    let partnerTotalTradingQuoteFee = totalTradingQuoteFee;
+    if (creatorTradingFeePercentage > 0) {
+      creatorTotalTradingBaseFee = totalTradingBaseFee.mul(new (0, _bnjs2.default)(creatorTradingFeePercentage)).div(new (0, _bnjs2.default)(100));
+      creatorTotalTradingQuoteFee = totalTradingQuoteFee.mul(new (0, _bnjs2.default)(creatorTradingFeePercentage)).div(new (0, _bnjs2.default)(100));
+      partnerTotalTradingBaseFee = totalTradingBaseFee.sub(
+        creatorTotalTradingBaseFee
+      );
+      partnerTotalTradingQuoteFee = totalTradingQuoteFee.sub(
+        creatorTotalTradingQuoteFee
+      );
     }
-    return this.program.methods.swap({
-      amountIn: buyAmount,
-      minimumAmountOut
-    }).accountsPartial({
-      baseMint,
-      quoteMint,
-      pool,
-      baseVault,
-      quoteVault,
-      config,
-      poolAuthority: this.poolAuthority,
-      referralTokenAccount,
-      inputTokenAccount,
-      outputTokenAccount,
-      payer: buyer,
-      tokenBaseProgram: outputTokenProgram,
-      tokenQuoteProgram: inputTokenProgram
-    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
-  }
-  async buildSwap2WithTransferHookBuyTx(firstBuyParam, baseMint, config, baseFee, activationType, quoteMint, enableFirstSwapWithMinFee) {
-    const {
-      buyer,
-      receiver,
-      buyAmount,
-      minimumAmountOut,
-      referralTokenAccount
-    } = firstBuyParam;
-    validateSwapAmount(buyAmount);
-    let rateLimiterApplied = false;
-    if (baseFee.baseFeeMode === 2 /* RateLimiter */) {
-      const currentPoint = await getCurrentPoint(
-        this.connection,
-        activationType
-      );
-      rateLimiterApplied = isRateLimiterApplied(
-        currentPoint,
-        new (0, _bnjs2.default)(0),
-        1 /* QuoteToBase */,
-        baseFee.secondFactor,
-        baseFee.thirdFactor,
-        new (0, _bnjs2.default)(baseFee.firstFactor)
-      );
-    }
-    const quoteTokenFlag = await getTokenType(this.connection, quoteMint);
-    const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(
-      false,
-      {
-        baseMint,
-        poolType: 1 /* Token2022 */
+    const creatorUnclaimedBaseFee = pool.poolState.creatorBaseFee;
+    const creatorUnclaimedQuoteFee = pool.poolState.creatorQuoteFee;
+    const partnerUnclaimedBaseFee = pool.poolState.partnerBaseFee;
+    const partnerUnclaimedQuoteFee = pool.poolState.partnerQuoteFee;
+    const creatorClaimedBaseFee = creatorTotalTradingBaseFee.sub(
+      creatorUnclaimedBaseFee
+    );
+    const creatorClaimedQuoteFee = creatorTotalTradingQuoteFee.sub(
+      creatorUnclaimedQuoteFee
+    );
+    const partnerClaimedBaseFee = partnerTotalTradingBaseFee.sub(
+      partnerUnclaimedBaseFee
+    );
+    const partnerClaimedQuoteFee = partnerTotalTradingQuoteFee.sub(
+      partnerUnclaimedQuoteFee
+    );
+    return {
+      creator: {
+        unclaimedBaseFee: creatorUnclaimedBaseFee,
+        unclaimedQuoteFee: creatorUnclaimedQuoteFee,
+        claimedBaseFee: creatorClaimedBaseFee,
+        claimedQuoteFee: creatorClaimedQuoteFee,
+        totalBaseFee: creatorTotalTradingBaseFee,
+        totalQuoteFee: creatorTotalTradingQuoteFee
       },
-      {
-        quoteMint,
-        quoteTokenFlag
+      partner: {
+        unclaimedBaseFee: partnerUnclaimedBaseFee,
+        unclaimedQuoteFee: partnerUnclaimedQuoteFee,
+        claimedBaseFee: partnerClaimedBaseFee,
+        claimedQuoteFee: partnerClaimedQuoteFee,
+        totalBaseFee: partnerTotalTradingBaseFee,
+        totalQuoteFee: partnerTotalTradingQuoteFee
       }
+    };
+  }
+  /**
+   * Fetch fee metrics for every pool linked to a config.
+   */
+  async getPoolsFeesByConfig(configAddress) {
+    const filteredPools = await this.getPoolsByConfig(configAddress);
+    return filteredPools.map((pool) => ({
+      poolAddress: pool.publicKey,
+      partnerBaseFee: pool.account.poolState.partnerBaseFee,
+      partnerQuoteFee: pool.account.poolState.partnerQuoteFee,
+      creatorBaseFee: pool.account.poolState.creatorBaseFee,
+      creatorQuoteFee: pool.account.poolState.creatorQuoteFee,
+      totalTradingBaseFee: pool.account.poolState.metrics.totalTradingBaseFee,
+      totalTradingQuoteFee: pool.account.poolState.metrics.totalTradingQuoteFee
+    }));
+  }
+  /**
+   * Fetch fee metrics for every pool linked to a creator.
+   */
+  async getPoolsFeesByCreator(creatorAddress) {
+    const filteredPools = await this.getPoolsByCreator(creatorAddress);
+    return filteredPools.map((pool) => ({
+      poolAddress: pool.publicKey,
+      partnerBaseFee: pool.account.poolState.partnerBaseFee,
+      partnerQuoteFee: pool.account.poolState.partnerQuoteFee,
+      creatorBaseFee: pool.account.poolState.creatorBaseFee,
+      creatorQuoteFee: pool.account.poolState.creatorQuoteFee,
+      totalTradingBaseFee: pool.account.poolState.metrics.totalTradingBaseFee,
+      totalTradingQuoteFee: pool.account.poolState.metrics.totalTradingQuoteFee
+    }));
+  }
+  /**
+   * Fetch DAMM V1 migration metadata for a pool.
+   */
+  async getDammV1MigrationMetadata(poolAddress) {
+    const migrationMetadataAddress = deriveDammV1MigrationMetadataAddress(poolAddress);
+    const metadata = await this.program.account.meteoraDammMigrationMetadata.fetch(
+      migrationMetadataAddress
     );
-    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
-    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
-    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
-    const preInstructions = [];
-    const [
-      { ataPubkey: inputTokenAccount, ix: createAtaTokenAIx },
-      { ataPubkey: outputTokenAccount, ix: createAtaTokenBIx }
-    ] = await Promise.all([
-      getOrCreateATAInstruction(
-        this.connection,
-        inputMint,
-        buyer,
-        buyer,
-        true,
-        inputTokenProgram
-      ),
-      getOrCreateATAInstruction(
-        this.connection,
-        outputMint,
-        receiver ? receiver : buyer,
-        buyer,
-        true,
-        outputTokenProgram
-      )
-    ]);
-    createAtaTokenAIx && preInstructions.push(createAtaTokenAIx);
-    createAtaTokenBIx && preInstructions.push(createAtaTokenBIx);
-    if (inputMint.equals(_spltoken.NATIVE_MINT)) {
-      preInstructions.push(
-        ...wrapSOLInstruction(
-          buyer,
-          inputTokenAccount,
-          BigInt(buyAmount.toString())
-        )
-      );
-    }
-    const postInstructions = [];
-    if ([inputMint.toBase58(), outputMint.toBase58()].includes(
-      _spltoken.NATIVE_MINT.toBase58()
-    )) {
-      const unwrapIx = unwrapSOLInstruction(buyer, buyer);
-      unwrapIx && postInstructions.push(unwrapIx);
+    return metadata;
+  }
+};
+
+// src/services/program.ts
+var DynamicBondingCurveProgram = class {
+  constructor(connection, commitment) {
+    const { program } = createDbcProgram(connection, commitment);
+    this.program = program;
+    this.connection = connection;
+    this.poolAuthority = deriveDbcPoolAuthority();
+    this.commitment = commitment;
+    this.state = new StateService(connection, commitment);
+  }
+  async getPoolWithConfig(pool) {
+    const virtualPool = await this.state.getPool(pool);
+    if (!virtualPool) {
+      throw new Error(`Pool not found: ${pool.toString()}`);
     }
-    const remainingAccounts = [];
-    if (rateLimiterApplied || enableFirstSwapWithMinFee) {
-      remainingAccounts.push({
-        isSigner: false,
-        isWritable: false,
-        pubkey: _web3js.SYSVAR_INSTRUCTIONS_PUBKEY
-      });
+    const poolConfigState = await this.state.getPoolConfig(
+      virtualPool.poolState.config
+    );
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
     }
-    const transferHookAccountTypes = referralTokenAccount != null ? [
-      AccountsType.TransferHookBase,
-      AccountsType.TransferHookBaseReferral
-    ] : [AccountsType.TransferHookBase];
-    let transferHookAccountsResult;
-    if (firstBuyParam.transferHookAccountsInfo && firstBuyParam.transferHookAccounts) {
-      transferHookAccountsResult = {
-        info: firstBuyParam.transferHookAccountsInfo,
-        accounts: firstBuyParam.transferHookAccounts
+    return { virtualPool, poolConfigState };
+  }
+  prepareSwapParams(swapBaseForQuote, virtualPoolState, poolConfigState) {
+    if (swapBaseForQuote) {
+      return {
+        inputMint: new (0, _web3js.PublicKey)(virtualPoolState.baseMint),
+        outputMint: new (0, _web3js.PublicKey)(poolConfigState.quoteMint),
+        inputTokenProgram: getTokenProgram(virtualPoolState.poolType),
+        outputTokenProgram: getTokenProgram(
+          poolConfigState.quoteTokenFlag
+        )
       };
-    } else {
-      try {
-        transferHookAccountsResult = await this.getRemainingAccountsForTransferHook(
-          baseMint,
-          transferHookAccountTypes
-        );
-      } catch (e3) {
-        throw new Error(
-          `Unable to resolve transfer-hook remaining accounts for ${baseMint.toString()}. When bundling pool initialization with the first buy, pass transferHookAccountsInfo and transferHookAccounts on the first-buy params.`
-        );
-      }
     }
-    remainingAccounts.push(...transferHookAccountsResult.accounts);
-    return this.program.methods.swap2WithTransferHook(
-      {
-        amount0: buyAmount,
-        amount1: minimumAmountOut,
-        swapMode: 0 /* ExactIn */
-      },
-      transferHookAccountsResult.info
-    ).accountsPartial({
-      baseMint,
-      quoteMint,
-      pool,
-      baseVault,
-      quoteVault,
+    return {
+      inputMint: new (0, _web3js.PublicKey)(poolConfigState.quoteMint),
+      outputMint: new (0, _web3js.PublicKey)(virtualPoolState.baseMint),
+      inputTokenProgram: getTokenProgram(poolConfigState.quoteTokenFlag),
+      outputTokenProgram: getTokenProgram(virtualPoolState.poolType)
+    };
+  }
+  async buildCreateConfigTx(configParam, config, feeClaimer, leftoverReceiver, quoteMint, payer) {
+    validateConfigParameters({ ...configParam, leftoverReceiver });
+    return this.program.methods.createConfig(configParam).accountsPartial({
       config,
-      poolAuthority: this.poolAuthority,
-      referralTokenAccount,
-      inputTokenAccount,
-      outputTokenAccount,
-      payer: buyer,
-      tokenBaseProgram: outputTokenProgram,
-      tokenQuoteProgram: inputTokenProgram
-    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+      feeClaimer,
+      leftoverReceiver,
+      quoteMint,
+      payer
+    }).transaction();
   }
-  async buildClaimTradingFeeAccountsForSol(params) {
+  async buildCreateConfigWithTransferHookTx(configParam, config, feeClaimer, leftoverReceiver, quoteMint, transferHookProgram, payer) {
+    validateConfigParameters(
+      { ...configParam, leftoverReceiver },
+      { isTransferHook: true, transferHookProgram }
+    );
+    return this.program.methods.createConfigWithTransferHook(configParam).accountsPartial({
+      config,
+      feeClaimer,
+      leftoverReceiver,
+      quoteMint,
+      transferHookProgram,
+      payer
+    }).transaction();
+  }
+  async initializeSplPool(params) {
     const {
-      payer,
-      feeReceiver,
-      tempWSolAcc,
+      name,
+      symbol,
+      uri,
       pool,
-      virtualPool,
-      poolConfigState,
-      tokenBaseProgram,
-      tokenQuoteProgram
+      config,
+      payer,
+      poolCreator,
+      mintMetadata,
+      baseMint,
+      baseVault,
+      quoteVault,
+      quoteMint
     } = params;
-    const preInstructions = [];
-    const postInstructions = [];
-    const tokenBaseAccount = findAssociatedTokenAddress(
-      feeReceiver,
-      virtualPool.poolState.baseMint,
-      tokenBaseProgram
-    );
-    const tokenQuoteAccount = findAssociatedTokenAddress(
-      tempWSolAcc,
-      poolConfigState.quoteMint,
-      tokenQuoteProgram
-    );
-    preInstructions.push(
-      _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-        payer,
-        tokenBaseAccount,
-        feeReceiver,
-        virtualPool.poolState.baseMint,
-        tokenBaseProgram
-      ),
-      _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-        payer,
-        tokenQuoteAccount,
-        tempWSolAcc,
-        poolConfigState.quoteMint,
-        tokenQuoteProgram
-      )
-    );
-    const unwrapSolIx = unwrapSOLInstruction(tempWSolAcc, feeReceiver);
-    unwrapSolIx && postInstructions.push(unwrapSolIx);
-    const accounts = {
-      poolAuthority: this.poolAuthority,
+    return this.program.methods.initializeVirtualPoolWithSplToken({
+      name,
+      symbol,
+      uri
+    }).accountsPartial({
       pool,
-      tokenAAccount: tokenBaseAccount,
-      tokenBAccount: tokenQuoteAccount,
-      baseVault: virtualPool.poolState.baseVault,
-      quoteVault: virtualPool.poolState.quoteVault,
-      baseMint: virtualPool.poolState.baseMint,
-      quoteMint: poolConfigState.quoteMint,
-      tokenBaseProgram,
-      tokenQuoteProgram
-    };
-    return { accounts, preInstructions, postInstructions };
+      config,
+      payer,
+      creator: poolCreator,
+      mintMetadata,
+      baseMint,
+      poolAuthority: this.poolAuthority,
+      baseVault,
+      quoteVault,
+      quoteMint,
+      tokenQuoteProgram: _spltoken.TOKEN_PROGRAM_ID,
+      metadataProgram: METAPLEX_PROGRAM_ID,
+      tokenProgram: _spltoken.TOKEN_PROGRAM_ID
+    }).transaction();
   }
-  async buildClaimTradingFeeAccountsForNonSol(params) {
+  async initializeToken2022Pool(params) {
     const {
-      payer,
-      feeReceiver,
+      name,
+      symbol,
+      uri,
       pool,
-      virtualPool,
-      poolConfigState,
-      tokenBaseProgram,
-      tokenQuoteProgram
+      config,
+      payer,
+      poolCreator,
+      baseMint,
+      baseVault,
+      quoteVault,
+      quoteMint
     } = params;
+    return this.program.methods.initializeVirtualPoolWithToken2022({
+      name,
+      symbol,
+      uri
+    }).accountsPartial({
+      pool,
+      config,
+      payer,
+      creator: poolCreator,
+      baseMint,
+      poolAuthority: this.poolAuthority,
+      baseVault,
+      quoteVault,
+      quoteMint,
+      tokenQuoteProgram: _spltoken.TOKEN_PROGRAM_ID,
+      tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
+    }).transaction();
+  }
+  async initializeToken2022PoolWithTransferHook(params) {
     const {
-      ataTokenA: tokenBaseAccount,
-      ataTokenB: tokenQuoteAccount,
-      instructions: preInstructions
-    } = await this.prepareTokenAccounts(
-      feeReceiver,
+      name,
+      symbol,
+      uri,
+      pool,
+      config,
       payer,
-      virtualPool.poolState.baseMint,
-      poolConfigState.quoteMint,
-      tokenBaseProgram,
+      poolCreator,
+      baseMint,
+      baseVault,
+      quoteVault,
+      quoteMint,
+      transferHookProgram,
       tokenQuoteProgram
-    );
-    const accounts = {
+    } = params;
+    return this.program.methods.initializeVirtualPoolWithToken2022TransferHook({
+      name,
+      symbol,
+      uri
+    }).accountsPartial({
+      pool,
+      config,
+      payer,
+      creator: poolCreator,
+      baseMint,
       poolAuthority: this.poolAuthority,
+      baseVault,
+      quoteVault,
+      quoteMint,
+      transferHookProgram,
+      tokenQuoteProgram,
+      tokenProgram: _spltoken.TOKEN_2022_PROGRAM_ID
+    }).transaction();
+  }
+  async buildCreatePoolTx(createPoolParam, tokenType, quoteMint) {
+    const { baseMint, name, symbol, uri, poolCreator, config, payer } = createPoolParam;
+    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
+    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
+    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
+    const baseParams = {
+      name,
+      symbol,
+      uri,
       pool,
-      tokenAAccount: tokenBaseAccount,
-      tokenBAccount: tokenQuoteAccount,
-      baseVault: virtualPool.poolState.baseVault,
-      quoteVault: virtualPool.poolState.quoteVault,
-      baseMint: virtualPool.poolState.baseMint,
-      quoteMint: poolConfigState.quoteMint,
-      tokenBaseProgram,
-      tokenQuoteProgram
+      config,
+      payer,
+      poolCreator,
+      baseMint,
+      baseVault,
+      quoteVault,
+      quoteMint
     };
-    return { accounts, preInstructions };
-  }
-  async getRemainingAccountsForTransferHook(mint, accountTypes = [AccountsType.TransferHookBase]) {
-    const emptyAccounts = { info: { slices: [] }, accounts: [] };
-    const mintInfo = await this.connection.getAccountInfo(
-      mint,
-      this.commitment
-    );
-    if (!mintInfo) {
-      throw new Error(`Invalid mint: ${mint.toString()}`);
-    }
-    if (mintInfo.owner.equals(_spltoken.TOKEN_PROGRAM_ID)) {
-      return emptyAccounts;
-    }
-    const mintState = _spltoken.unpackMint.call(void 0, mint, mintInfo, _spltoken.TOKEN_2022_PROGRAM_ID);
-    const transferHook = _spltoken.getTransferHook.call(void 0, mintState);
-    if (!transferHook || transferHook.programId.equals(_web3js.PublicKey.default)) {
-      return emptyAccounts;
+    if (tokenType === 0 /* SPLToken */) {
+      const mintMetadata = deriveMintMetadata(baseMint);
+      return this.initializeSplPool({ ...baseParams, mintMetadata });
     }
-    const transferWithHookIx = await _spltoken.createTransferCheckedWithTransferHookInstruction.call(void 0, 
-      this.connection,
-      _web3js.PublicKey.default,
-      mint,
-      _web3js.PublicKey.default,
-      _web3js.PublicKey.default,
-      BigInt(0),
-      mintState.decimals,
-      [],
-      this.commitment,
-      _spltoken.TOKEN_2022_PROGRAM_ID
-    );
-    const transferHookAccounts = transferWithHookIx.keys.slice(4);
-    const slices = accountTypes.map((accountsType) => ({
-      accountsType,
-      length: transferHookAccounts.length
-    }));
-    const accounts = accountTypes.flatMap(() => transferHookAccounts);
-    return { info: { slices }, accounts };
+    return this.initializeToken2022Pool(baseParams);
   }
-  async buildWithdrawMigrationFeeTx(role, pool, sender) {
-    const { virtualPool, poolConfigState } = await this.getPoolWithConfig(pool);
-    const tokenQuoteProgram = getTokenProgram(
-      poolConfigState.quoteTokenFlag
-    );
-    const preInstructions = [];
-    const postInstructions = [];
-    const { ataPubkey: tokenQuoteAccount, ix: createTokenQuoteAccountIx } = await getOrCreateATAInstruction(
-      this.connection,
-      poolConfigState.quoteMint,
-      sender,
-      sender,
-      true,
-      tokenQuoteProgram
-    );
-    createTokenQuoteAccountIx && preInstructions.push(createTokenQuoteAccountIx);
-    if (poolConfigState.quoteMint.equals(_spltoken.NATIVE_MINT)) {
-      const unwrapSolIx = unwrapSOLInstruction(sender, sender);
-      unwrapSolIx && postInstructions.push(unwrapSolIx);
-    }
-    return this.program.methods.withdrawMigrationFee(role === "partner" ? 0 : 1).accountsPartial({
-      poolAuthority: this.poolAuthority,
-      config: virtualPool.poolState.config,
-      virtualPool: pool,
-      tokenQuoteAccount,
-      quoteVault: virtualPool.poolState.quoteVault,
-      quoteMint: poolConfigState.quoteMint,
-      sender,
+  async buildCreatePoolWithTransferHookTx(createPoolParam, quoteMint, tokenQuoteProgram) {
+    const {
+      baseMint,
+      name,
+      symbol,
+      uri,
+      poolCreator,
+      config,
+      payer,
+      transferHookProgram
+    } = createPoolParam;
+    if (!validateTransferHookProgram(transferHookProgram)) {
+      throw new Error(
+        "Invalid transfer hook program: cannot be the DBC program, SPL Token, SPL Token-2022, or the default pubkey"
+      );
+    }
+    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
+    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
+    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
+    return this.initializeToken2022PoolWithTransferHook({
+      name,
+      symbol,
+      uri,
+      pool,
+      config,
+      payer,
+      poolCreator,
+      baseMint,
+      baseVault,
+      quoteVault,
+      quoteMint,
+      transferHookProgram,
       tokenQuoteProgram
-    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+    });
   }
-  async prepareTokenAccounts(owner, payer, tokenAMint, tokenBMint, tokenAProgram, tokenBProgram) {
-    const instructions = [];
+  async buildSwapBuyTx(firstBuyParam, baseMint, config, baseFee, swapBaseForQuote, activationType, tokenType, quoteMint, enableFirstSwapWithMinFee) {
+    const {
+      buyer,
+      receiver,
+      buyAmount,
+      minimumAmountOut,
+      referralTokenAccount
+    } = firstBuyParam;
+    validateSwapAmount(buyAmount);
+    let rateLimiterApplied = false;
+    if (baseFee.baseFeeMode === 2 /* RateLimiter */) {
+      const currentPoint = await getCurrentPoint(
+        this.connection,
+        activationType
+      );
+      rateLimiterApplied = isRateLimiterApplied(
+        currentPoint,
+        new (0, _bnjs2.default)(0),
+        swapBaseForQuote ? 0 /* BaseToQuote */ : 1 /* QuoteToBase */,
+        baseFee.secondFactor,
+        baseFee.thirdFactor,
+        new (0, _bnjs2.default)(baseFee.firstFactor)
+      );
+    }
+    const quoteTokenFlag = await getTokenType(this.connection, quoteMint);
+    const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(
+      false,
+      {
+        baseMint,
+        poolType: tokenType
+      },
+      {
+        quoteMint,
+        quoteTokenFlag
+      }
+    );
+    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
+    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
+    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
+    const preInstructions = [];
     const [
-      { ataPubkey: ataTokenA, ix: createAtaTokenAIx },
-      { ataPubkey: ataTokenB, ix: createAtaTokenBIx }
+      { ataPubkey: inputTokenAccount, ix: createAtaTokenAIx },
+      { ataPubkey: outputTokenAccount, ix: createAtaTokenBIx }
     ] = await Promise.all([
       getOrCreateATAInstruction(
         this.connection,
-        tokenAMint,
-        owner,
-        payer,
+        inputMint,
+        buyer,
+        buyer,
         true,
-        tokenAProgram
+        inputTokenProgram
       ),
       getOrCreateATAInstruction(
         this.connection,
-        tokenBMint,
-        owner,
-        payer,
+        outputMint,
+        receiver ? receiver : buyer,
+        buyer,
         true,
-        tokenBProgram
+        outputTokenProgram
       )
     ]);
-    createAtaTokenAIx && instructions.push(createAtaTokenAIx);
-    createAtaTokenBIx && instructions.push(createAtaTokenBIx);
-    return { ataTokenA, ataTokenB, instructions };
-  }
-  /**
-   * Return the underlying Anchor program client.
-   */
-  getProgram() {
-    return this.program;
-  }
-};
-
-// src/services/migration.ts
-
-
-
-
-
-
-
-
-// src/services/state.ts
-
-
-
-
-
-var StateService = class extends DynamicBondingCurveProgram {
-  constructor(connection, commitment) {
-    super(connection, commitment);
-  }
-  /**
-   * Fetch virtual pools across both the standard and transfer-hook account variants.
-   */
-  async fetchVirtualPools(filters) {
-    const [pools, transferHookPools] = await Promise.all([
-      this.program.account.virtualPool.all(filters),
-      this.program.account.transferHookPool.all(filters)
-    ]);
-    return [...pools, ...transferHookPools];
-  }
-  /**
-   * Fetch pool configs across both the standard and transfer-hook account variants.
-   */
-  async fetchPoolConfigs(filters) {
-    const [configs, transferHookConfigs] = await Promise.all([
-      this.program.account.poolConfig.all(filters),
-      this.program.account.configWithTransferHook.all(filters)
-    ]);
-    return [
-      ...configs,
-      ...transferHookConfigs.map((account) => ({
-        publicKey: account.publicKey,
-        account: account.account.config
-      }))
-    ];
-  }
-  /**
-   * Fetch a pool config account.
-   */
-  async getPoolConfig(configAddress) {
-    const address = configAddress instanceof _web3js.PublicKey ? configAddress : new (0, _web3js.PublicKey)(configAddress);
-    try {
-      const poolConfig = await this.program.account.poolConfig.fetchNullable(
-        address,
-        this.commitment
+    createAtaTokenAIx && preInstructions.push(createAtaTokenAIx);
+    createAtaTokenBIx && preInstructions.push(createAtaTokenBIx);
+    if (inputMint.equals(_spltoken.NATIVE_MINT)) {
+      preInstructions.push(
+        ...wrapSOLInstruction(
+          buyer,
+          inputTokenAccount,
+          BigInt(buyAmount.toString())
+        )
       );
-      if (poolConfig) {
-        return poolConfig;
-      }
-    } catch (e4) {
     }
-    const configWithTransferHook = await this.program.account.configWithTransferHook.fetchNullable(
-      address,
-      this.commitment
-    );
-    return _nullishCoalesce(_optionalChain([configWithTransferHook, 'optionalAccess', _29 => _29.config]), () => ( null));
-  }
-  /**
-   * Fetch all pool config accounts.
-   */
-  async getPoolConfigs() {
-    return this.fetchPoolConfigs();
-  }
-  /**
-   * Fetch all pool configs owned by a wallet.
-   */
-  async getPoolConfigsByOwner(owner) {
-    const filters = createProgramAccountFilter(owner, 72);
-    return this.fetchPoolConfigs(filters);
-  }
-  /**
-   * Fetch a virtual pool account.
-   */
-  async getPool(poolAddress) {
-    const address = poolAddress instanceof _web3js.PublicKey ? poolAddress : new (0, _web3js.PublicKey)(poolAddress);
-    try {
-      const virtualPool = await this.program.account.virtualPool.fetchNullable(
-        address,
-        this.commitment
-      );
-      if (virtualPool) {
-        return virtualPool;
-      }
-    } catch (e5) {
+    const postInstructions = [];
+    if ([inputMint.toBase58(), outputMint.toBase58()].includes(
+      _spltoken.NATIVE_MINT.toBase58()
+    )) {
+      const unwrapIx = unwrapSOLInstruction(buyer, buyer);
+      unwrapIx && postInstructions.push(unwrapIx);
     }
-    return await this.program.account.transferHookPool.fetchNullable(
-      address,
-      this.commitment
-    );
-  }
-  /**
-   * Fetch all virtual pool accounts.
-   */
-  async getPools() {
-    return this.fetchVirtualPools();
+    const remainingAccounts = [];
+    if (rateLimiterApplied || enableFirstSwapWithMinFee) {
+      remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: _web3js.SYSVAR_INSTRUCTIONS_PUBKEY
+      });
+    }
+    return this.program.methods.swap({
+      amountIn: buyAmount,
+      minimumAmountOut
+    }).accountsPartial({
+      baseMint,
+      quoteMint,
+      pool,
+      baseVault,
+      quoteVault,
+      config,
+      poolAuthority: this.poolAuthority,
+      referralTokenAccount,
+      inputTokenAccount,
+      outputTokenAccount,
+      payer: buyer,
+      tokenBaseProgram: outputTokenProgram,
+      tokenQuoteProgram: inputTokenProgram
+    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
   }
-  /**
-   * Fetch all virtual pools that use a config.
-   */
-  async getPoolsByConfig(configAddress) {
-    const filters = createProgramAccountFilter(configAddress, 72);
-    return this.fetchVirtualPools(filters);
-  }
-  /**
-   * Fetch all virtual pools created by a wallet.
-   */
-  async getPoolsByCreator(creatorAddress) {
-    const filters = createProgramAccountFilter(creatorAddress, 104);
-    return this.fetchVirtualPools(filters);
-  }
-  /**
-   * Fetch the first virtual pool that uses a base mint.
-   */
-  async getPoolByBaseMint(baseMint) {
-    const filters = createProgramAccountFilter(baseMint, 136);
-    const pools = await this.fetchVirtualPools(filters);
-    return pools.length > 0 ? pools[0] : null;
-  }
-  /**
-   * Fetch the migration quote threshold for a pool.
-   */
-  async getPoolMigrationQuoteThreshold(poolAddress) {
-    const pool = await this.getPool(poolAddress);
-    if (!pool) {
-      throw new Error(`Pool not found: ${poolAddress.toString()}`);
+  async buildSwap2WithTransferHookBuyTx(firstBuyParam, baseMint, config, baseFee, activationType, quoteMint, enableFirstSwapWithMinFee) {
+    const {
+      buyer,
+      receiver,
+      buyAmount,
+      minimumAmountOut,
+      referralTokenAccount
+    } = firstBuyParam;
+    validateSwapAmount(buyAmount);
+    let rateLimiterApplied = false;
+    if (baseFee.baseFeeMode === 2 /* RateLimiter */) {
+      const currentPoint = await getCurrentPoint(
+        this.connection,
+        activationType
+      );
+      rateLimiterApplied = isRateLimiterApplied(
+        currentPoint,
+        new (0, _bnjs2.default)(0),
+        1 /* QuoteToBase */,
+        baseFee.secondFactor,
+        baseFee.thirdFactor,
+        new (0, _bnjs2.default)(baseFee.firstFactor)
+      );
     }
-    const configAddress = pool.poolState.config;
-    const config = await this.getPoolConfig(configAddress);
-    return config.migrationQuoteThreshold;
-  }
-  /**
-   * Return quote-token curve progress as a ratio between 0 and 1.
-   */
-  async getPoolQuoteTokenCurveProgress(poolAddress) {
-    const pool = await this.getPool(poolAddress);
-    if (!pool) {
-      throw new Error(`Pool not found: ${poolAddress.toString()}`);
+    const quoteTokenFlag = await getTokenType(this.connection, quoteMint);
+    const { inputMint, outputMint, inputTokenProgram, outputTokenProgram } = this.prepareSwapParams(
+      false,
+      {
+        baseMint,
+        poolType: 1 /* Token2022 */
+      },
+      {
+        quoteMint,
+        quoteTokenFlag
+      }
+    );
+    const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
+    const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
+    const quoteVault = deriveDbcTokenVaultAddress(pool, quoteMint);
+    const preInstructions = [];
+    const [
+      { ataPubkey: inputTokenAccount, ix: createAtaTokenAIx },
+      { ataPubkey: outputTokenAccount, ix: createAtaTokenBIx }
+    ] = await Promise.all([
+      getOrCreateATAInstruction(
+        this.connection,
+        inputMint,
+        buyer,
+        buyer,
+        true,
+        inputTokenProgram
+      ),
+      getOrCreateATAInstruction(
+        this.connection,
+        outputMint,
+        receiver ? receiver : buyer,
+        buyer,
+        true,
+        outputTokenProgram
+      )
+    ]);
+    createAtaTokenAIx && preInstructions.push(createAtaTokenAIx);
+    createAtaTokenBIx && preInstructions.push(createAtaTokenBIx);
+    if (inputMint.equals(_spltoken.NATIVE_MINT)) {
+      preInstructions.push(
+        ...wrapSOLInstruction(
+          buyer,
+          inputTokenAccount,
+          BigInt(buyAmount.toString())
+        )
+      );
     }
-    const config = await this.getPoolConfig(pool.poolState.config);
-    const quoteReserve = pool.poolState.quoteReserve;
-    const migrationThreshold = config.migrationQuoteThreshold;
-    const quoteReserveDecimal = new (0, _decimaljs2.default)(quoteReserve.toString());
-    const thresholdDecimal = new (0, _decimaljs2.default)(migrationThreshold.toString());
-    const progress = quoteReserveDecimal.div(thresholdDecimal).toNumber();
-    return Math.min(Math.max(progress, 0), 1);
-  }
-  /**
-   * Return base-token curve progress as a ratio between 0 and 1.
-   */
-  async getPoolBaseTokenCurveProgress(poolAddress) {
-    const pool = await this.getPool(poolAddress);
-    if (!pool) {
-      throw new Error(`Pool not found: ${poolAddress.toString()}`);
+    const postInstructions = [];
+    if ([inputMint.toBase58(), outputMint.toBase58()].includes(
+      _spltoken.NATIVE_MINT.toBase58()
+    )) {
+      const unwrapIx = unwrapSOLInstruction(buyer, buyer);
+      unwrapIx && postInstructions.push(unwrapIx);
     }
-    const config = await this.getPoolConfig(pool.poolState.config);
-    const baseSold = new (0, _decimaljs2.default)(
-      getBaseTokenForSwap(
-        config.sqrtStartPrice,
-        pool.poolState.sqrtPrice,
-        config.curve
-      ).toString()
+    const remainingAccounts = [];
+    if (rateLimiterApplied || enableFirstSwapWithMinFee) {
+      remainingAccounts.push({
+        isSigner: false,
+        isWritable: false,
+        pubkey: _web3js.SYSVAR_INSTRUCTIONS_PUBKEY
+      });
+    }
+    const transferHookAccountTypes = referralTokenAccount != null ? [
+      AccountsType.TransferHookBase,
+      AccountsType.TransferHookBaseReferral
+    ] : [AccountsType.TransferHookBase];
+    let transferHookAccountsResult;
+    if (firstBuyParam.transferHookAccountsInfo && firstBuyParam.transferHookAccounts) {
+      transferHookAccountsResult = {
+        info: firstBuyParam.transferHookAccountsInfo,
+        accounts: firstBuyParam.transferHookAccounts
+      };
+    } else {
+      try {
+        transferHookAccountsResult = await this.getRemainingAccountsForTransferHook(
+          baseMint,
+          transferHookAccountTypes
+        );
+      } catch (e5) {
+        throw new Error(
+          `Unable to resolve transfer-hook remaining accounts for ${baseMint.toString()}. When bundling pool initialization with the first buy, pass transferHookAccountsInfo and transferHookAccounts on the first-buy params.`
+        );
+      }
+    }
+    remainingAccounts.push(...transferHookAccountsResult.accounts);
+    return this.program.methods.swap2WithTransferHook(
+      {
+        amount0: buyAmount,
+        amount1: minimumAmountOut,
+        swapMode: 0 /* ExactIn */
+      },
+      transferHookAccountsResult.info
+    ).accountsPartial({
+      baseMint,
+      quoteMint,
+      pool,
+      baseVault,
+      quoteVault,
+      config,
+      poolAuthority: this.poolAuthority,
+      referralTokenAccount,
+      inputTokenAccount,
+      outputTokenAccount,
+      payer: buyer,
+      tokenBaseProgram: outputTokenProgram,
+      tokenQuoteProgram: inputTokenProgram
+    }).remainingAccounts(remainingAccounts).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
+  }
+  async buildClaimTradingFeeAccountsForSol(params) {
+    const {
+      payer,
+      feeReceiver,
+      tempWSolAcc,
+      pool,
+      virtualPool,
+      poolConfigState,
+      tokenBaseProgram,
+      tokenQuoteProgram
+    } = params;
+    const preInstructions = [];
+    const postInstructions = [];
+    const tokenBaseAccount = findAssociatedTokenAddress(
+      feeReceiver,
+      virtualPool.poolState.baseMint,
+      tokenBaseProgram
     );
-    const totalBaseCouldBeSold = new (0, _decimaljs2.default)(
-      getBaseTokenForSwap(
-        config.sqrtStartPrice,
-        config.migrationSqrtPrice,
-        config.curve
-      ).toString()
+    const tokenQuoteAccount = findAssociatedTokenAddress(
+      tempWSolAcc,
+      poolConfigState.quoteMint,
+      tokenQuoteProgram
     );
-    const progress = baseSold.div(totalBaseCouldBeSold).toNumber();
-    return Math.min(Math.max(progress, 0), 1);
-  }
-  /**
-   * Fetch metadata accounts for a virtual pool.
-   */
-  async getPoolMetadata(poolAddress) {
-    const filters = createProgramAccountFilter(poolAddress, 8);
-    const accounts = await this.program.account.virtualPoolMetadata.all(filters);
-    return accounts.map((account) => account.account);
-  }
-  /**
-   * Fetch metadata accounts for a partner.
-   */
-  async getPartnerMetadata(partnerAddress) {
-    const filters = createProgramAccountFilter(partnerAddress, 8);
-    const accounts = await this.program.account.partnerMetadata.all(filters);
-    return accounts.map((account) => account.account);
+    preInstructions.push(
+      _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+        payer,
+        tokenBaseAccount,
+        feeReceiver,
+        virtualPool.poolState.baseMint,
+        tokenBaseProgram
+      ),
+      _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
+        payer,
+        tokenQuoteAccount,
+        tempWSolAcc,
+        poolConfigState.quoteMint,
+        tokenQuoteProgram
+      )
+    );
+    const unwrapSolIx = unwrapSOLInstruction(tempWSolAcc, feeReceiver);
+    unwrapSolIx && postInstructions.push(unwrapSolIx);
+    const accounts = {
+      poolAuthority: this.poolAuthority,
+      pool,
+      tokenAAccount: tokenBaseAccount,
+      tokenBAccount: tokenQuoteAccount,
+      baseVault: virtualPool.poolState.baseVault,
+      quoteVault: virtualPool.poolState.quoteVault,
+      baseMint: virtualPool.poolState.baseMint,
+      quoteMint: poolConfigState.quoteMint,
+      tokenBaseProgram,
+      tokenQuoteProgram
+    };
+    return { accounts, preInstructions, postInstructions };
   }
-  /**
-   * Fetch current unclaimed fees and lifetime trading fee metrics for a pool.
-   */
-  async getPoolFeeMetrics(poolAddress) {
-    const pool = await this.getPool(poolAddress);
-    if (!pool) {
-      throw new Error(`Pool not found: ${poolAddress.toString()}`);
-    }
-    return {
-      current: {
-        partnerBaseFee: pool.poolState.partnerBaseFee,
-        partnerQuoteFee: pool.poolState.partnerQuoteFee,
-        creatorBaseFee: pool.poolState.creatorBaseFee,
-        creatorQuoteFee: pool.poolState.creatorQuoteFee
-      },
-      total: {
-        totalTradingBaseFee: pool.poolState.metrics.totalTradingBaseFee,
-        totalTradingQuoteFee: pool.poolState.metrics.totalTradingQuoteFee
-      }
+  async buildClaimTradingFeeAccountsForNonSol(params) {
+    const {
+      payer,
+      feeReceiver,
+      pool,
+      virtualPool,
+      poolConfigState,
+      tokenBaseProgram,
+      tokenQuoteProgram
+    } = params;
+    const {
+      ataTokenA: tokenBaseAccount,
+      ataTokenB: tokenQuoteAccount,
+      instructions: preInstructions
+    } = await this.prepareTokenAccounts(
+      feeReceiver,
+      payer,
+      virtualPool.poolState.baseMint,
+      poolConfigState.quoteMint,
+      tokenBaseProgram,
+      tokenQuoteProgram
+    );
+    const accounts = {
+      poolAuthority: this.poolAuthority,
+      pool,
+      tokenAAccount: tokenBaseAccount,
+      tokenBAccount: tokenQuoteAccount,
+      baseVault: virtualPool.poolState.baseVault,
+      quoteVault: virtualPool.poolState.quoteVault,
+      baseMint: virtualPool.poolState.baseMint,
+      quoteMint: poolConfigState.quoteMint,
+      tokenBaseProgram,
+      tokenQuoteProgram
     };
+    return { accounts, preInstructions };
   }
-  /**
-   * Calculate claimed, unclaimed, and total trading fees split by creator and partner.
-   */
-  async getPoolFeeBreakdown(poolAddress) {
-    const pool = await this.getPool(poolAddress);
-    if (!pool) {
-      throw new Error(`Pool not found: ${poolAddress.toString()}`);
+  async getRemainingAccountsForTransferHook(mint, accountTypes = [AccountsType.TransferHookBase]) {
+    const emptyAccounts = { info: { slices: [] }, accounts: [] };
+    const mintInfo = await this.connection.getAccountInfo(
+      mint,
+      this.commitment
+    );
+    if (!mintInfo) {
+      throw new Error(`Invalid mint: ${mint.toString()}`);
     }
-    const config = await this.getPoolConfig(pool.poolState.config);
-    if (!config) {
-      throw new Error(
-        `Config not found: ${pool.poolState.config.toString()}`
-      );
+    if (mintInfo.owner.equals(_spltoken.TOKEN_PROGRAM_ID)) {
+      return emptyAccounts;
     }
-    const creatorTradingFeePercentage = config.creatorTradingFeePercentage;
-    const totalTradingBaseFee = pool.poolState.metrics.totalTradingBaseFee;
-    const totalTradingQuoteFee = pool.poolState.metrics.totalTradingQuoteFee;
-    let creatorTotalTradingBaseFee = new (0, _bnjs2.default)(0);
-    let creatorTotalTradingQuoteFee = new (0, _bnjs2.default)(0);
-    let partnerTotalTradingBaseFee = totalTradingBaseFee;
-    let partnerTotalTradingQuoteFee = totalTradingQuoteFee;
-    if (creatorTradingFeePercentage > 0) {
-      creatorTotalTradingBaseFee = totalTradingBaseFee.mul(new (0, _bnjs2.default)(creatorTradingFeePercentage)).div(new (0, _bnjs2.default)(100));
-      creatorTotalTradingQuoteFee = totalTradingQuoteFee.mul(new (0, _bnjs2.default)(creatorTradingFeePercentage)).div(new (0, _bnjs2.default)(100));
-      partnerTotalTradingBaseFee = totalTradingBaseFee.sub(
-        creatorTotalTradingBaseFee
-      );
-      partnerTotalTradingQuoteFee = totalTradingQuoteFee.sub(
-        creatorTotalTradingQuoteFee
-      );
+    const mintState = _spltoken.unpackMint.call(void 0, mint, mintInfo, _spltoken.TOKEN_2022_PROGRAM_ID);
+    const transferHook = _spltoken.getTransferHook.call(void 0, mintState);
+    if (!transferHook || transferHook.programId.equals(_web3js.PublicKey.default)) {
+      return emptyAccounts;
     }
-    const creatorUnclaimedBaseFee = pool.poolState.creatorBaseFee;
-    const creatorUnclaimedQuoteFee = pool.poolState.creatorQuoteFee;
-    const partnerUnclaimedBaseFee = pool.poolState.partnerBaseFee;
-    const partnerUnclaimedQuoteFee = pool.poolState.partnerQuoteFee;
-    const creatorClaimedBaseFee = creatorTotalTradingBaseFee.sub(
-      creatorUnclaimedBaseFee
-    );
-    const creatorClaimedQuoteFee = creatorTotalTradingQuoteFee.sub(
-      creatorUnclaimedQuoteFee
+    const transferWithHookIx = await _spltoken.createTransferCheckedWithTransferHookInstruction.call(void 0, 
+      this.connection,
+      _web3js.PublicKey.default,
+      mint,
+      _web3js.PublicKey.default,
+      _web3js.PublicKey.default,
+      BigInt(0),
+      mintState.decimals,
+      [],
+      this.commitment,
+      _spltoken.TOKEN_2022_PROGRAM_ID
     );
-    const partnerClaimedBaseFee = partnerTotalTradingBaseFee.sub(
-      partnerUnclaimedBaseFee
+    const transferHookAccounts = transferWithHookIx.keys.slice(4);
+    const slices = accountTypes.map((accountsType) => ({
+      accountsType,
+      length: transferHookAccounts.length
+    }));
+    const accounts = accountTypes.flatMap(() => transferHookAccounts);
+    return { info: { slices }, accounts };
+  }
+  async buildWithdrawMigrationFeeTx(role, pool, sender) {
+    const { virtualPool, poolConfigState } = await this.getPoolWithConfig(pool);
+    const tokenQuoteProgram = getTokenProgram(
+      poolConfigState.quoteTokenFlag
     );
-    const partnerClaimedQuoteFee = partnerTotalTradingQuoteFee.sub(
-      partnerUnclaimedQuoteFee
+    const preInstructions = [];
+    const postInstructions = [];
+    const { ataPubkey: tokenQuoteAccount, ix: createTokenQuoteAccountIx } = await getOrCreateATAInstruction(
+      this.connection,
+      poolConfigState.quoteMint,
+      sender,
+      sender,
+      true,
+      tokenQuoteProgram
     );
-    return {
-      creator: {
-        unclaimedBaseFee: creatorUnclaimedBaseFee,
-        unclaimedQuoteFee: creatorUnclaimedQuoteFee,
-        claimedBaseFee: creatorClaimedBaseFee,
-        claimedQuoteFee: creatorClaimedQuoteFee,
-        totalBaseFee: creatorTotalTradingBaseFee,
-        totalQuoteFee: creatorTotalTradingQuoteFee
-      },
-      partner: {
-        unclaimedBaseFee: partnerUnclaimedBaseFee,
-        unclaimedQuoteFee: partnerUnclaimedQuoteFee,
-        claimedBaseFee: partnerClaimedBaseFee,
-        claimedQuoteFee: partnerClaimedQuoteFee,
-        totalBaseFee: partnerTotalTradingBaseFee,
-        totalQuoteFee: partnerTotalTradingQuoteFee
-      }
-    };
-  }
-  /**
-   * Fetch fee metrics for every pool linked to a config.
-   */
-  async getPoolsFeesByConfig(configAddress) {
-    const filteredPools = await this.getPoolsByConfig(configAddress);
-    return filteredPools.map((pool) => ({
-      poolAddress: pool.publicKey,
-      partnerBaseFee: pool.account.poolState.partnerBaseFee,
-      partnerQuoteFee: pool.account.poolState.partnerQuoteFee,
-      creatorBaseFee: pool.account.poolState.creatorBaseFee,
-      creatorQuoteFee: pool.account.poolState.creatorQuoteFee,
-      totalTradingBaseFee: pool.account.poolState.metrics.totalTradingBaseFee,
-      totalTradingQuoteFee: pool.account.poolState.metrics.totalTradingQuoteFee
-    }));
+    createTokenQuoteAccountIx && preInstructions.push(createTokenQuoteAccountIx);
+    if (poolConfigState.quoteMint.equals(_spltoken.NATIVE_MINT)) {
+      const unwrapSolIx = unwrapSOLInstruction(sender, sender);
+      unwrapSolIx && postInstructions.push(unwrapSolIx);
+    }
+    return this.program.methods.withdrawMigrationFee(role === "partner" ? 0 : 1).accountsPartial({
+      poolAuthority: this.poolAuthority,
+      config: virtualPool.poolState.config,
+      virtualPool: pool,
+      tokenQuoteAccount,
+      quoteVault: virtualPool.poolState.quoteVault,
+      quoteMint: poolConfigState.quoteMint,
+      sender,
+      tokenQuoteProgram
+    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
   }
-  /**
-   * Fetch fee metrics for every pool linked to a creator.
-   */
-  async getPoolsFeesByCreator(creatorAddress) {
-    const filteredPools = await this.getPoolsByCreator(creatorAddress);
-    return filteredPools.map((pool) => ({
-      poolAddress: pool.publicKey,
-      partnerBaseFee: pool.account.poolState.partnerBaseFee,
-      partnerQuoteFee: pool.account.poolState.partnerQuoteFee,
-      creatorBaseFee: pool.account.poolState.creatorBaseFee,
-      creatorQuoteFee: pool.account.poolState.creatorQuoteFee,
-      totalTradingBaseFee: pool.account.poolState.metrics.totalTradingBaseFee,
-      totalTradingQuoteFee: pool.account.poolState.metrics.totalTradingQuoteFee
-    }));
+  async prepareTokenAccounts(owner, payer, tokenAMint, tokenBMint, tokenAProgram, tokenBProgram) {
+    const instructions = [];
+    const [
+      { ataPubkey: ataTokenA, ix: createAtaTokenAIx },
+      { ataPubkey: ataTokenB, ix: createAtaTokenBIx }
+    ] = await Promise.all([
+      getOrCreateATAInstruction(
+        this.connection,
+        tokenAMint,
+        owner,
+        payer,
+        true,
+        tokenAProgram
+      ),
+      getOrCreateATAInstruction(
+        this.connection,
+        tokenBMint,
+        owner,
+        payer,
+        true,
+        tokenBProgram
+      )
+    ]);
+    createAtaTokenAIx && instructions.push(createAtaTokenAIx);
+    createAtaTokenBIx && instructions.push(createAtaTokenBIx);
+    return { ataTokenA, ataTokenB, instructions };
   }
   /**
-   * Fetch DAMM V1 migration metadata for a pool.
+   * Return the underlying Anchor program client.
    */
-  async getDammV1MigrationMetadata(poolAddress) {
-    const migrationMetadataAddress = deriveDammV1MigrationMetadataAddress(poolAddress);
-    const metadata = await this.program.account.meteoraDammMigrationMetadata.fetch(
-      migrationMetadataAddress
-    );
-    return metadata;
+  getProgram() {
+    return this.program;
   }
 };
 
 // src/services/migration.ts
+
+
+
+
+
+
+
 var MigrationService = class extends DynamicBondingCurveProgram {
-  constructor(connection, commitment, state) {
-    super(
-      connection,
-      commitment,
-      _nullishCoalesce(state, () => ( new StateService(connection, commitment)))
-    );
-  }
   /**
    * Create a Dynamic Vault program client.
    */
@@ -30510,13 +30508,6 @@ var MigrationService = class extends DynamicBondingCurveProgram {
 
 
 var PartnerService = class extends DynamicBondingCurveProgram {
-  constructor(connection, commitment, state) {
-    super(
-      connection,
-      commitment,
-      _nullishCoalesce(state, () => ( new StateService(connection, commitment)))
-    );
-  }
   /**
    * Build a transaction that creates a partner-owned pool config.
    */
@@ -31003,13 +30994,6 @@ var PartnerService = class extends DynamicBondingCurveProgram {
 
 
 var PoolService = class extends DynamicBondingCurveProgram {
-  constructor(connection, commitment, state) {
-    super(
-      connection,
-      commitment,
-      _nullishCoalesce(state, () => ( new StateService(connection, commitment)))
-    );
-  }
   /**
    * Build an exact-in swap transaction for an existing pool.
    *
@@ -31409,6 +31393,128 @@ var PoolService = class extends DynamicBondingCurveProgram {
         throw new Error(`Unsupported swap mode: ${swapMode}`);
     }
   }
+  /**
+   * Reconcile the only two fields that differ between an on-chain `PoolConfig`
+   * and a `buildCurve` output (`ConfigParameters`) so the quote math can
+   * consume either directly:
+   * - `migrationSqrtPrice`: used when present, otherwise derived from the
+   *   curve and migration quote threshold (it is the swap stop price).
+   * - `dynamicFee`: a null/undefined object becomes a disabled one, and a
+   *   present object is treated as enabled unless `initialized` says otherwise.
+   *
+   * Everything else is already in the right shape and passed through.
+   */
+  normalizeQuoteConfig(config) {
+    if (!config.curve || config.curve.length === 0) {
+      throw new Error("config.curve is empty");
+    }
+    const migrationSqrtPrice = _nullishCoalesce(config.migrationSqrtPrice, () => ( getMigrationThresholdPrice(
+      config.migrationQuoteThreshold,
+      config.sqrtStartPrice,
+      config.curve
+    )));
+    const dynamicFee = config.poolFees.dynamicFee;
+    return {
+      ...config,
+      migrationSqrtPrice,
+      poolFees: {
+        ...config.poolFees,
+        dynamicFee: dynamicFee ? {
+          ...dynamicFee,
+          initialized: _nullishCoalesce(dynamicFee.initialized, () => ( 1))
+        } : { initialized: 0, binStep: 0, variableFeeControl: 0 }
+      }
+    };
+  }
+  /**
+   * creates a virtual pool state at launch with zeroed reserves and volatility, start price set.
+   */
+  buildSimulatedVirtualPool(sqrtStartPrice) {
+    return {
+      poolState: {
+        sqrtPrice: new (0, _bnjs2.default)(sqrtStartPrice),
+        baseReserve: new (0, _bnjs2.default)(0),
+        quoteReserve: new (0, _bnjs2.default)(0),
+        activationPoint: new (0, _bnjs2.default)(0),
+        volatilityTracker: {
+          lastUpdateTimestamp: new (0, _bnjs2.default)(0),
+          sqrtPriceReference: new (0, _bnjs2.default)(0),
+          volatilityAccumulator: new (0, _bnjs2.default)(0),
+          volatilityReference: new (0, _bnjs2.default)(0),
+          padding: []
+        }
+      }
+    };
+  }
+  /**
+   * quotes a swap from an input amount before any pool exists.
+   */
+  getQuoteFromInputAmount(params) {
+    const {
+      config,
+      swapBaseForQuote,
+      amountIn,
+      swapMode = 0 /* ExactIn */,
+      slippageBps = 0,
+      hasReferral = false,
+      eligibleForFirstSwapWithMinFee = false,
+      currentPoint = new (0, _bnjs2.default)(0)
+    } = params;
+    const poolConfig = this.normalizeQuoteConfig(config);
+    const virtualPool = this.buildSimulatedVirtualPool(
+      poolConfig.sqrtStartPrice
+    );
+    if (swapMode === 1 /* PartialFill */) {
+      return swapQuotePartialFill(
+        virtualPool,
+        poolConfig,
+        swapBaseForQuote,
+        amountIn,
+        slippageBps,
+        hasReferral,
+        currentPoint,
+        eligibleForFirstSwapWithMinFee
+      );
+    }
+    return swapQuoteExactIn(
+      virtualPool,
+      poolConfig,
+      swapBaseForQuote,
+      amountIn,
+      slippageBps,
+      hasReferral,
+      currentPoint,
+      eligibleForFirstSwapWithMinFee
+    );
+  }
+  /**
+   * quotes a swap from an exact output amount (`SwapMode.ExactOut`)
+   */
+  getQuoteFromOutputAmount(params) {
+    const {
+      config,
+      swapBaseForQuote,
+      amountOut,
+      slippageBps = 0,
+      hasReferral = false,
+      eligibleForFirstSwapWithMinFee = false,
+      currentPoint = new (0, _bnjs2.default)(0)
+    } = params;
+    const poolConfig = this.normalizeQuoteConfig(config);
+    const virtualPool = this.buildSimulatedVirtualPool(
+      poolConfig.sqrtStartPrice
+    );
+    return swapQuoteExactOut(
+      virtualPool,
+      poolConfig,
+      swapBaseForQuote,
+      amountOut,
+      slippageBps,
+      hasReferral,
+      currentPoint,
+      eligibleForFirstSwapWithMinFee
+    );
+  }
 };
 
 // src/services/creator.ts
@@ -31421,13 +31527,6 @@ var PoolService = class extends DynamicBondingCurveProgram {
 
 
 var CreatorService = class extends DynamicBondingCurveProgram {
-  constructor(connection, commitment, state) {
-    super(
-      connection,
-      commitment,
-      _nullishCoalesce(state, () => ( new StateService(connection, commitment)))
-    );
-  }
   /**
    * Build a transaction that creates metadata for a virtual pool.
    */
@@ -31877,19 +31976,15 @@ var CreatorService = class extends DynamicBondingCurveProgram {
 var DynamicBondingCurveClient = class _DynamicBondingCurveClient {
   constructor(connection, commitment) {
     this.state = new StateService(connection, commitment);
-    this.pool = new PoolService(connection, commitment, this.state);
-    this.partner = new PartnerService(connection, commitment, this.state);
-    this.creator = new CreatorService(connection, commitment, this.state);
-    this.migration = new MigrationService(
-      connection,
-      commitment,
-      this.state
-    );
+    this.pool = new PoolService(connection, commitment);
+    this.partner = new PartnerService(connection, commitment);
+    this.creator = new CreatorService(connection, commitment);
+    this.migration = new MigrationService(connection, commitment);
     this.commitment = commitment;
     this.connection = connection;
   }
   /**
-   * Create a client with shared service state.
+   * Create a client with all DBC services.
    */
   static create(connection, commitment = "confirmed") {
     return new _DynamicBondingCurveClient(connection, commitment);