@meteora-ag/dynamic-bonding-curve-sdk 1.4.0 → 1.4.1

package/dist/index.cjs

@@ -23161,8 +23161,8 @@ var StateService = class extends DynamicBondingCurveProgram {
    * @param partnerAddress - The address of the partner
    * @returns A partner metadata
    */
-  async getPartnerMetadata(walletAddress) {
-    const filters = createProgramAccountFilter(walletAddress, 8);
+  async getPartnerMetadata(partnerAddress) {
+    const filters = createProgramAccountFilter(partnerAddress, 8);
     const accounts = await this.program.account.partnerMetadata.all(filters);
     return accounts.map((account) => account.account);
   }
@@ -23270,24 +23270,24 @@ var MigrationService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create Locker (if there is lockedVesting)
-   * @param createLockerParam - The parameters for the locker
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
    * @returns A create locker transaction
    */
-  async createLocker(createLockerParam) {
-    const poolAuthority = deriveDbcPoolAuthority();
+  async createLocker(params) {
+    const { virtualPool, payer } = params;
     const lockerEventAuthority = deriveLockerEventAuthority();
-    const virtualPoolState = await this.state.getPool(
-      createLockerParam.virtualPool
-    );
+    const virtualPoolState = await this.state.getPool(virtualPool);
     if (!virtualPoolState) {
-      throw new Error(
-        `Pool not found: ${createLockerParam.virtualPool.toString()}`
-      );
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(
       virtualPoolState.config
     );
-    const base = deriveBaseKeyForLocker(createLockerParam.virtualPool);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
+    const base = deriveBaseKeyForLocker(virtualPool);
     const escrow = deriveEscrow(base);
     const tokenProgram = poolConfigState.tokenType === 0 ? _spltoken.TOKEN_PROGRAM_ID : _spltoken.TOKEN_2022_PROGRAM_ID;
     const escrowToken = findAssociatedTokenAddress(
@@ -23297,7 +23297,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     );
     const preInstructions = [];
     const createOwnerEscrowVaultTokenXIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-      createLockerParam.payer,
+      payer,
       escrowToken,
       escrow,
       virtualPoolState.baseMint,
@@ -23305,16 +23305,16 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     );
     preInstructions.push(createOwnerEscrowVaultTokenXIx);
     const accounts = {
-      virtualPool: createLockerParam.virtualPool,
+      virtualPool,
       config: virtualPoolState.config,
-      poolAuthority,
+      poolAuthority: this.poolAuthority,
       baseVault: virtualPoolState.baseVault,
       baseMint: virtualPoolState.baseMint,
       base,
       creator: virtualPoolState.creator,
       escrow,
       escrowToken,
-      payer: createLockerParam.payer,
+      payer,
       tokenProgram,
       lockerProgram: LOCKER_PROGRAM_ID,
       lockerEventAuthority,
@@ -23324,26 +23324,27 @@ var MigrationService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Withdraw leftover
-   * @param withdrawLeftoverParam - The parameters for the withdraw leftover
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
    * @returns A withdraw leftover transaction
    */
-  async withdrawLeftover(withdrawLeftoverParam) {
-    const poolState = await this.state.getPool(
-      withdrawLeftoverParam.virtualPool
-    );
+  async withdrawLeftover(params) {
+    const { virtualPool, payer } = params;
+    const poolState = await this.state.getPool(virtualPool);
     if (!poolState) {
-      throw new Error(
-        `Pool not found: ${withdrawLeftoverParam.virtualPool.toString()}`
-      );
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const tokenBaseProgram = getTokenProgram(poolConfigState.tokenType);
     const preInstructions = [];
     const { ataPubkey: tokenBaseAccount, ix: createBaseTokenAccountIx } = await getOrCreateATAInstruction(
       this.connection,
       poolState.baseMint,
       poolConfigState.leftoverReceiver,
-      withdrawLeftoverParam.payer,
+      payer,
       true,
       tokenBaseProgram
     );
@@ -23351,7 +23352,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     return this.program.methods.withdrawLeftover().accountsPartial({
       poolAuthority: this.poolAuthority,
       config: poolState.config,
-      virtualPool: withdrawLeftoverParam.virtualPool,
+      virtualPool,
       tokenBaseAccount,
       baseVault: poolState.baseVault,
       baseMint: poolState.baseMint,
@@ -23364,42 +23365,45 @@ var MigrationService = class extends DynamicBondingCurveProgram {
   ///////////////////////
   /**
    * Create metadata for the migration of Meteora DAMM V1
-   * @param createDammV1MigrationMetadataParam - The parameters for the migration
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
+   * @param config - The config address
    * @returns A migration transaction
    */
-  async createDammV1MigrationMetadata(createDammV1MigrationMetadataParam) {
-    const migrationMetadata = deriveDammV1MigrationMetadataAddress(
-      createDammV1MigrationMetadataParam.virtualPool
-    );
+  async createDammV1MigrationMetadata(params) {
+    const { virtualPool, config, payer } = params;
+    const migrationMetadata = deriveDammV1MigrationMetadataAddress(virtualPool);
     const accounts = {
-      virtualPool: createDammV1MigrationMetadataParam.virtualPool,
-      config: createDammV1MigrationMetadataParam.config,
+      virtualPool,
+      config,
       migrationMetadata,
-      payer: createDammV1MigrationMetadataParam.payer,
+      payer,
       systemProgram: _web3js.SystemProgram.programId
     };
     return this.program.methods.migrationMeteoraDammCreateMetadata().accountsPartial(accounts).transaction();
   }
   /**
    * Migrate to DAMM V1
-   * @param migrateToDammV1Param - The parameters for the migration
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
+   * @param dammConfig - The damm config address
    * @returns A migrate transaction
    */
-  async migrateToDammV1(migrateToDammV1Param) {
-    const poolState = await this.state.getPool(
-      migrateToDammV1Param.virtualPool
-    );
+  async migrateToDammV1(params) {
+    const { virtualPool, dammConfig, payer } = params;
+    const poolState = await this.state.getPool(virtualPool);
     if (!poolState) {
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
+    }
+    const poolConfigState = await this.state.getPoolConfig(poolState.config);
+    if (!poolConfigState) {
       throw new Error(
-        `Pool not found: ${migrateToDammV1Param.virtualPool.toString()}`
+        `Pool config not found for virtual pool: ${virtualPool.toString()}`
       );
     }
-    const poolConfigState = await this.state.getPoolConfig(poolState.config);
-    const migrationMetadata = deriveDammV1MigrationMetadataAddress(
-      migrateToDammV1Param.virtualPool
-    );
+    const migrationMetadata = deriveDammV1MigrationMetadataAddress(virtualPool);
     const dammPool = deriveDammV1PoolAddress(
-      migrateToDammV1Param.dammConfig,
+      dammConfig,
       poolState.baseMint,
       poolConfigState.quoteMint
     );
@@ -23435,7 +23439,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     if (!aVaultAccount) {
       const createVaultAIx = await createInitializePermissionlessDynamicVaultIx(
         poolState.baseMint,
-        migrateToDammV1Param.payer,
+        payer,
         vaultProgram
       );
       if (createVaultAIx) {
@@ -23447,7 +23451,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     if (!bVaultAccount) {
       const createVaultBIx = await createInitializePermissionlessDynamicVaultIx(
         poolConfigState.quoteMint,
-        migrateToDammV1Param.payer,
+        payer,
         vaultProgram
       );
       if (createVaultBIx) {
@@ -23468,12 +23472,12 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       _spltoken.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const transaction = await this.program.methods.migrateMeteoraDamm().accountsPartial({
-      virtualPool: migrateToDammV1Param.virtualPool,
+      virtualPool,
       migrationMetadata,
       config: poolState.config,
       poolAuthority: this.poolAuthority,
       pool: dammPool,
-      dammConfig: migrateToDammV1Param.dammConfig,
+      dammConfig,
       lpMint,
       tokenAMint: poolState.baseMint,
       tokenBMint: poolConfigState.quoteMint,
@@ -23490,7 +23494,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       virtualPoolLp,
       protocolTokenAFee,
       protocolTokenBFee,
-      payer: migrateToDammV1Param.payer,
+      payer,
       rent: _web3js.SYSVAR_RENT_PUBKEY,
       mintMetadata,
       metadataProgram: METAPLEX_PROGRAM_ID,
@@ -23507,27 +23511,28 @@ var MigrationService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Lock DAMM V1 LP token for creator or partner
-   * @param lockDammV1LpTokenParam - The parameters for the lock
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
+   * @param dammConfig - The damm config address
+   * @param isPartner - Whether the partner is locking the LP token
    * @returns A lock transaction
    */
-  async lockDammV1LpToken(lockDammV1LpTokenParam) {
-    const poolState = await this.state.getPool(
-      lockDammV1LpTokenParam.virtualPool
-    );
+  async lockDammV1LpToken(params) {
+    const { virtualPool, dammConfig, payer, isPartner } = params;
+    const poolState = await this.state.getPool(params.virtualPool);
     if (!poolState) {
-      throw new Error(
-        `Pool not found: ${lockDammV1LpTokenParam.virtualPool.toString()}`
-      );
+      throw new Error(`Pool not found: ${params.virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const dammPool = deriveDammV1PoolAddress(
-      lockDammV1LpTokenParam.dammConfig,
+      dammConfig,
       poolState.baseMint,
       poolConfigState.quoteMint
     );
-    const migrationMetadata = deriveDammV1MigrationMetadataAddress(
-      lockDammV1LpTokenParam.virtualPool
-    );
+    const migrationMetadata = deriveDammV1MigrationMetadataAddress(virtualPool);
     const vaultProgram = this.getVaultProgram();
     const [
       { vaultPda: aVault, lpMintPda: aLpMintPda },
@@ -23546,7 +23551,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     if (!aVaultAccount) {
       const createVaultAIx = await createInitializePermissionlessDynamicVaultIx(
         poolState.baseMint,
-        lockDammV1LpTokenParam.payer,
+        payer,
         vaultProgram
       );
       if (createVaultAIx) {
@@ -23558,7 +23563,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     if (!bVaultAccount) {
       const createVaultBIx = await createInitializePermissionlessDynamicVaultIx(
         poolConfigState.quoteMint,
-        lockDammV1LpTokenParam.payer,
+        payer,
         vaultProgram
       );
       if (createVaultBIx) {
@@ -23574,7 +23579,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     const lpMint = deriveDammV1LpMintAddress(dammPool);
     const dammV1Program = this.getDammV1Program();
     let lockEscrowKey;
-    if (lockDammV1LpTokenParam.isPartner) {
+    if (isPartner) {
       lockEscrowKey = deriveDammV1LockEscrowAddress(
         dammPool,
         poolConfigState.feeClaimer
@@ -23582,7 +23587,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       const lockEscrowData = await this.connection.getAccountInfo(lockEscrowKey);
       if (!lockEscrowData) {
         const ix = await createLockEscrowIx(
-          lockDammV1LpTokenParam.payer,
+          payer,
           dammPool,
           lpMint,
           poolConfigState.feeClaimer,
@@ -23599,7 +23604,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       const lockEscrowData = await this.connection.getAccountInfo(lockEscrowKey);
       if (!lockEscrowData) {
         const ix = await createLockEscrowIx(
-          lockDammV1LpTokenParam.payer,
+          payer,
           dammPool,
           lpMint,
           poolState.creator,
@@ -23617,7 +23622,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       _spltoken.ASSOCIATED_TOKEN_PROGRAM_ID
     );
     const createEscrowVaultIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-      lockDammV1LpTokenParam.payer,
+      payer,
       escrowVault,
       lockEscrowKey,
       lpMint,
@@ -23631,13 +23636,13 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       true
     );
     return this.program.methods.migrateMeteoraDammLockLpToken().accountsPartial({
-      virtualPool: lockDammV1LpTokenParam.virtualPool,
+      virtualPool,
       migrationMetadata,
       poolAuthority: this.poolAuthority,
       pool: dammPool,
       lpMint,
       lockEscrow: lockEscrowKey,
-      owner: lockDammV1LpTokenParam.isPartner ? poolConfigState.feeClaimer : poolState.creator,
+      owner: isPartner ? poolConfigState.feeClaimer : poolState.creator,
       sourceTokens,
       escrowVault,
       aVault,
@@ -23652,33 +23657,33 @@ var MigrationService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Claim DAMM V1 LP token for creator or partner
-   * @param claimDammV1LpTokenParam - The parameters for the claim
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
+   * @param dammConfig - The damm config address
+   * @param isPartner - Whether the partner is claiming the LP token
    * @returns A claim transaction
    */
-  async claimDammV1LpToken(claimDammV1LpTokenParam) {
-    const poolAuthority = deriveDbcPoolAuthority();
-    const virtualPoolState = await this.state.getPool(
-      claimDammV1LpTokenParam.virtualPool
-    );
+  async claimDammV1LpToken(params) {
+    const { virtualPool, dammConfig, payer, isPartner } = params;
+    const virtualPoolState = await this.state.getPool(virtualPool);
     if (!virtualPoolState) {
-      throw new Error(
-        `Pool not found: ${claimDammV1LpTokenParam.virtualPool.toString()}`
-      );
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(
       virtualPoolState.config
     );
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const dammPool = deriveDammV1PoolAddress(
-      claimDammV1LpTokenParam.dammConfig,
+      dammConfig,
       virtualPoolState.baseMint,
       poolConfigState.quoteMint
     );
-    const migrationMetadata = deriveDammV1MigrationMetadataAddress(
-      claimDammV1LpTokenParam.virtualPool
-    );
+    const migrationMetadata = deriveDammV1MigrationMetadataAddress(virtualPool);
     const lpMint = deriveDammV1LpMintAddress(dammPool);
     let destinationToken;
-    if (claimDammV1LpTokenParam.isPartner) {
+    if (isPartner) {
       destinationToken = findAssociatedTokenAddress(
         poolConfigState.feeClaimer,
         lpMint,
@@ -23693,27 +23698,27 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     }
     const preInstructions = [];
     const createDestinationTokenIx = _spltoken.createAssociatedTokenAccountIdempotentInstruction.call(void 0, 
-      claimDammV1LpTokenParam.payer,
+      payer,
       destinationToken,
-      claimDammV1LpTokenParam.isPartner ? poolConfigState.feeClaimer : virtualPoolState.creator,
+      isPartner ? poolConfigState.feeClaimer : virtualPoolState.creator,
       lpMint,
       _spltoken.TOKEN_PROGRAM_ID
     );
     preInstructions.push(createDestinationTokenIx);
     const sourceToken = _spltoken.getAssociatedTokenAddressSync.call(void 0, 
       lpMint,
-      poolAuthority,
+      this.poolAuthority,
       true
     );
     const accounts = {
-      virtualPool: claimDammV1LpTokenParam.virtualPool,
+      virtualPool,
       migrationMetadata,
-      poolAuthority,
+      poolAuthority: this.poolAuthority,
       lpMint,
       sourceToken,
       destinationToken,
-      owner: claimDammV1LpTokenParam.isPartner ? poolConfigState.feeClaimer : virtualPoolState.creator,
-      sender: claimDammV1LpTokenParam.payer,
+      owner: isPartner ? poolConfigState.feeClaimer : virtualPoolState.creator,
+      sender: payer,
       tokenProgram: _spltoken.TOKEN_PROGRAM_ID
     };
     return this.program.methods.migrateMeteoraDammClaimLpToken().accountsPartial(accounts).preInstructions(preInstructions).transaction();
@@ -23723,47 +23728,47 @@ var MigrationService = class extends DynamicBondingCurveProgram {
   ///////////////////////
   /**
    * Create metadata for the migration of Meteora DAMM V2
-   * @param createDammV2MigrationMetadataParam - The parameters for the migration
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
+   * @param config - The config address
    * @returns A migration transaction
    */
-  async createDammV2MigrationMetadata(createDammV2MigrationMetadataParam) {
-    const migrationMetadata = deriveDammV2MigrationMetadataAddress(
-      createDammV2MigrationMetadataParam.virtualPool
-    );
+  async createDammV2MigrationMetadata(params) {
+    const { virtualPool, config, payer } = params;
+    const migrationMetadata = deriveDammV2MigrationMetadataAddress(virtualPool);
     const accounts = {
-      virtualPool: createDammV2MigrationMetadataParam.virtualPool,
-      config: createDammV2MigrationMetadataParam.config,
+      virtualPool,
+      config,
       migrationMetadata,
-      payer: createDammV2MigrationMetadataParam.payer,
+      payer,
       systemProgram: _web3js.SystemProgram.programId
     };
     return this.program.methods.migrationDammV2CreateMetadata().accountsPartial(accounts).transaction();
   }
   /**
    * Migrate to DAMM V2
-   * @param migrateToDammV2Param - The parameters for the migration
+   * @param payer - The payer of the transaction
+   * @param virtualPool - The virtual pool address
+   * @param dammConfig - The damm config address
    * @returns A migrate transaction
    */
-  async migrateToDammV2(migrateToDammV2Param) {
-    const poolAuthority = deriveDbcPoolAuthority();
+  async migrateToDammV2(params) {
+    const { virtualPool, dammConfig, payer } = params;
     const dammPoolAuthority = deriveDammV2PoolAuthority();
     const dammEventAuthority = deriveDammV2EventAuthority();
-    const virtualPoolState = await this.state.getPool(
-      migrateToDammV2Param.virtualPool
-    );
+    const virtualPoolState = await this.state.getPool(virtualPool);
     if (!virtualPoolState) {
-      throw new Error(
-        `Pool not found: ${migrateToDammV2Param.virtualPool.toString()}`
-      );
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(
       virtualPoolState.config
     );
-    const migrationMetadata = deriveDammV2MigrationMetadataAddress(
-      migrateToDammV2Param.virtualPool
-    );
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
+    const migrationMetadata = deriveDammV2MigrationMetadataAddress(virtualPool);
     const dammPool = deriveDammV2PoolAddress(
-      migrateToDammV2Param.dammConfig,
+      dammConfig,
       virtualPoolState.baseMint,
       poolConfigState.quoteMint
     );
@@ -23792,10 +23797,10 @@ var MigrationService = class extends DynamicBondingCurveProgram {
     const tokenBaseProgram = poolConfigState.tokenType == 0 ? _spltoken.TOKEN_PROGRAM_ID : _spltoken.TOKEN_2022_PROGRAM_ID;
     const tokenQuoteProgram = poolConfigState.quoteTokenFlag == 0 ? _spltoken.TOKEN_PROGRAM_ID : _spltoken.TOKEN_2022_PROGRAM_ID;
     const tx = await this.program.methods.migrationDammV2().accountsStrict({
-      virtualPool: migrateToDammV2Param.virtualPool,
+      virtualPool,
       migrationMetadata,
       config: virtualPoolState.config,
-      poolAuthority,
+      poolAuthority: this.poolAuthority,
       pool: dammPool,
       firstPositionNftMint: firstPositionNftKP.publicKey,
       firstPosition,
@@ -23811,7 +23816,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       tokenBVault,
       baseVault: virtualPoolState.baseVault,
       quoteVault: virtualPoolState.quoteVault,
-      payer: migrateToDammV2Param.payer,
+      payer,
       tokenBaseProgram,
       tokenQuoteProgram,
       token2022Program: _spltoken.TOKEN_2022_PROGRAM_ID,
@@ -23821,7 +23826,7 @@ var MigrationService = class extends DynamicBondingCurveProgram {
       {
         isSigner: false,
         isWritable: false,
-        pubkey: migrateToDammV2Param.dammConfig
+        pubkey: dammConfig
       }
     ]).transaction();
     const modifyComputeUnits = _web3js.ComputeBudgetProgram.setComputeUnitLimit({
@@ -23851,10 +23856,15 @@ var PartnerService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create a new config
-   * @param createConfigParam - The parameters for the config
+   * @param createConfigParam - The config parameters
+   * @param config - The config address
+   * @param feeClaimer - The partner's fee claimer address
+   * @param leftoverReceiver - The leftover receiver address
+   * @param quoteMint - The quote mint
+   * @param payer - The payer of the transaction
    * @returns A new config
    */
-  async createConfig(createConfigParam) {
+  async createConfig(params) {
     const {
       config,
       feeClaimer,
@@ -23862,7 +23872,7 @@ var PartnerService = class extends DynamicBondingCurveProgram {
       quoteMint,
       payer,
       ...configParam
-    } = createConfigParam;
+    } = params;
     validateConfigParameters({ ...configParam, leftoverReceiver });
     return this.program.methods.createConfig(configParam).accountsPartial({
       config,
@@ -23874,32 +23884,44 @@ var PartnerService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create partner metadata
-   * @param createPartnerMetadataParam - The parameters for the partner metadata
+   * @param name - The name of the partner
+   * @param website - The website of the partner
+   * @param logo - The logo of the partner
+   * @param feeClaimer - The partner's fee claimer address
+   * @param payer - The payer of the transaction
    * @returns A create partner metadata transaction
    */
-  async createPartnerMetadata(createPartnerMetadataParam) {
-    const partnerMetadata = derivePartnerMetadata(
-      createPartnerMetadataParam.feeClaimer
-    );
+  async createPartnerMetadata(params) {
+    const { name, website, logo, feeClaimer, payer } = params;
+    const partnerMetadata = derivePartnerMetadata(feeClaimer);
     const partnerMetadataParam = {
       padding: new Array(96).fill(0),
-      name: createPartnerMetadataParam.name,
-      website: createPartnerMetadataParam.website,
-      logo: createPartnerMetadataParam.logo
+      name,
+      website,
+      logo
     };
     return this.program.methods.createPartnerMetadata(partnerMetadataParam).accountsPartial({
       partnerMetadata,
-      payer: createPartnerMetadataParam.payer,
-      feeClaimer: createPartnerMetadataParam.feeClaimer,
+      payer,
+      feeClaimer,
       systemProgram: _web3js.SystemProgram.programId
     }).transaction();
   }
   /**
    * Private method to claim trading fee with quote mint SOL
-   * @param claimWithQuoteMintSolParam - The parameters for the claim with quote mint SOL
+   * @param feeClaimer - The partner's fee claimer address
+   * @param payer - The payer of the transaction
+   * @param feeReceiver - The wallet that will receive the tokens
+   * @param config - The config address
+   * @param pool - The pool address
+   * @param poolState - The pool state
+   * @param poolConfigState - The pool config state
+   * @param tokenBaseProgram - The token base program
+   * @param tokenQuoteProgram - The token quote program
+   * @param tempWSolAcc - The temporary wallet that will receive the SOL
    * @returns A claim trading fee with quote mint SOL accounts, pre instructions and post instructions
    */
-  async claimWithQuoteMintSol(claimWithQuoteMintSolParam) {
+  async claimWithQuoteMintSol(params) {
     const {
       feeClaimer,
       payer,
@@ -23911,7 +23933,7 @@ var PartnerService = class extends DynamicBondingCurveProgram {
       poolConfigState,
       tokenBaseProgram,
       tokenQuoteProgram
-    } = claimWithQuoteMintSolParam;
+    } = params;
     const preInstructions = [];
     const postInstructions = [];
     const tokenBaseAccount = findAssociatedTokenAddress(
@@ -23960,10 +23982,18 @@ var PartnerService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Private method to claim trading fee with quote mint not SOL
-   * @param claimWithQuoteMintNotSolParam - The parameters for the claim with quote mint not SOL
+   * @param feeClaimer - The partner's fee claimer address
+   * @param payer - The payer of the transaction
+   * @param feeReceiver - The wallet that will receive the tokens
+   * @param config - The config address
+   * @param pool - The pool address
+   * @param poolState - The pool state
+   * @param poolConfigState - The pool config state
+   * @param tokenBaseProgram - The token base program
+   * @param tokenQuoteProgram - The token quote program
    * @returns A claim trading fee with quote mint not SOL accounts and pre instructions
    */
-  async claimWithQuoteMintNotSol(claimWithQuoteMintNotSolParam) {
+  async claimWithQuoteMintNotSol(params) {
     const {
       feeClaimer,
       payer,
@@ -23974,7 +24004,7 @@ var PartnerService = class extends DynamicBondingCurveProgram {
       poolConfigState,
       tokenBaseProgram,
       tokenQuoteProgram
-    } = claimWithQuoteMintNotSolParam;
+    } = params;
     const {
       ataTokenA: tokenBaseAccount,
       ataTokenB: tokenQuoteAccount,
@@ -24005,10 +24035,16 @@ var PartnerService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Claim partner trading fee
-   * @param claimTradingFeeParam - The parameters for the claim trading fee
+   * @param feeClaimer - The partner's fee claimer address
+   * @param payer - The payer of the transaction
+   * @param pool - The pool address
+   * @param maxBaseAmount - The maximum base amount
+   * @param maxQuoteAmount - The maximum quote amount
+   * @param receiver - The wallet that will receive the tokens (Optional)
+   * @param tempWSolAcc - The temporary wallet that will receive the SOL (Optional)
    * @returns A claim trading fee transaction
    */
-  async claimPartnerTradingFee(claimTradingFeeParam) {
+  async claimPartnerTradingFee(params) {
     const {
       feeClaimer,
       payer,
@@ -24017,14 +24053,14 @@ var PartnerService = class extends DynamicBondingCurveProgram {
       maxQuoteAmount,
       receiver,
       tempWSolAcc
-    } = claimTradingFeeParam;
+    } = params;
     const poolState = await this.state.getPool(pool);
     if (!poolState) {
       throw new Error(`Pool not found: ${pool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
     if (!poolConfigState) {
-      throw new Error(`Pool config not found: ${pool.toString()}`);
+      throw new Error(`Pool config not found for virtual pool`);
     }
     const tokenBaseProgram = getTokenProgram(poolConfigState.tokenType);
     const tokenQuoteProgram = getTokenProgram(
@@ -24065,10 +24101,15 @@ var PartnerService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Claim partner trading fee
-   * @param claimTradingFee2Param - The parameters for the claim trading fee
+   * @param feeClaimer - The partner's fee claimer address
+   * @param payer - The payer of the transaction
+   * @param pool - The pool address
+   * @param maxBaseAmount - The maximum base amount
+   * @param maxQuoteAmount - The maximum quote amount
+   * @param receiver - The wallet that will receive the tokens
    * @returns A claim trading fee transaction
    */
-  async claimPartnerTradingFee2(claimTradingFee2Param) {
+  async claimPartnerTradingFee2(params) {
     const {
       feeClaimer,
       payer,
@@ -24076,7 +24117,7 @@ var PartnerService = class extends DynamicBondingCurveProgram {
       maxBaseAmount,
       maxQuoteAmount,
       receiver
-    } = claimTradingFee2Param;
+    } = params;
     const poolState = await this.state.getPool(pool);
     if (!poolState) {
       throw new Error(`Pool not found: ${pool.toString()}`);
@@ -24152,19 +24193,20 @@ var PartnerService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Partner withdraw surplus
-   * @param partnerWithdrawSurplusParam - The parameters for the partner withdraw surplus
+   * @param feeClaimer - The partner's fee claimer address
+   * @param virtualPool - The virtual pool address
    * @returns A partner withdraw surplus transaction
    */
-  async partnerWithdrawSurplus(partnerWithdrawSurplusParam) {
-    const poolState = await this.state.getPool(
-      partnerWithdrawSurplusParam.virtualPool
-    );
+  async partnerWithdrawSurplus(params) {
+    const { virtualPool, feeClaimer } = params;
+    const poolState = await this.state.getPool(virtualPool);
     if (!poolState) {
-      throw new Error(
-        `Pool not found: ${partnerWithdrawSurplusParam.virtualPool.toString()}`
-      );
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const tokenQuoteProgram = getTokenProgram(
       poolConfigState.quoteTokenFlag
     );
@@ -24173,53 +24215,59 @@ var PartnerService = class extends DynamicBondingCurveProgram {
     const { ataPubkey: tokenQuoteAccount, ix: createQuoteTokenAccountIx } = await getOrCreateATAInstruction(
       this.connection,
       poolConfigState.quoteMint,
-      partnerWithdrawSurplusParam.feeClaimer,
-      partnerWithdrawSurplusParam.feeClaimer,
+      feeClaimer,
+      feeClaimer,
       true,
       tokenQuoteProgram
     );
     createQuoteTokenAccountIx && preInstructions.push(createQuoteTokenAccountIx);
     if (poolConfigState.quoteMint.equals(_spltoken.NATIVE_MINT)) {
-      const unwrapSolIx = unwrapSOLInstruction(
-        partnerWithdrawSurplusParam.feeClaimer,
-        partnerWithdrawSurplusParam.feeClaimer
-      );
+      const unwrapSolIx = unwrapSOLInstruction(feeClaimer, feeClaimer);
       unwrapSolIx && postInstructions.push(unwrapSolIx);
     }
     return this.program.methods.partnerWithdrawSurplus().accountsPartial({
       poolAuthority: this.poolAuthority,
       config: poolState.config,
-      virtualPool: partnerWithdrawSurplusParam.virtualPool,
+      virtualPool,
       tokenQuoteAccount,
       quoteVault: poolState.quoteVault,
       quoteMint: poolConfigState.quoteMint,
-      feeClaimer: partnerWithdrawSurplusParam.feeClaimer,
+      feeClaimer,
       tokenQuoteProgram
     }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
   }
   /**
    * Partner withdraw migration fee
-   * @param withdrawMigrationFeeParams - The parameters for the partner withdraw migration fee
+   * @param virtualPool - The virtual pool address
+   * @param sender - The sender of the pool
    * @returns A partner withdraw migration fee transaction
    */
-  async partnerWithdrawMigrationFee(withdrawMigrationFeeParams) {
-    const { virtualPool, sender, feePayer } = withdrawMigrationFeeParams;
+  async partnerWithdrawMigrationFee(params) {
+    const { virtualPool, sender } = params;
     const virtualPoolState = await this.state.getPool(virtualPool);
+    if (!virtualPoolState) {
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
+    }
     const configState = await this.state.getPoolConfig(
       virtualPoolState.config
     );
-    const { ataPubkey: tokenQuoteAccount, ix: preInstruction } = await getOrCreateATAInstruction(
+    if (!configState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
+    const preInstructions = [];
+    const postInstructions = [];
+    const { ataPubkey: tokenQuoteAccount, ix: createTokenQuoteAccountIx } = await getOrCreateATAInstruction(
       this.program.provider.connection,
       configState.quoteMint,
       sender,
-      _nullishCoalesce(feePayer, () => ( sender)),
+      sender,
       true,
       getTokenProgram(configState.quoteTokenFlag)
     );
-    const postInstruction = [];
+    createTokenQuoteAccountIx && preInstructions.push(createTokenQuoteAccountIx);
     if (configState.quoteMint.equals(_spltoken.NATIVE_MINT)) {
-      const unwarpSOLIx = unwrapSOLInstruction(sender, sender);
-      unwarpSOLIx && postInstruction.push(unwarpSOLIx);
+      const unwrapSolIx = unwrapSOLInstruction(sender, sender);
+      unwrapSolIx && postInstructions.push(unwrapSolIx);
     }
     const transaction = await this.program.methods.withdrawMigrationFee(0).accountsPartial({
       poolAuthority: this.poolAuthority,
@@ -24230,7 +24278,7 @@ var PartnerService = class extends DynamicBondingCurveProgram {
       quoteMint: configState.quoteMint,
       sender,
       tokenQuoteProgram: getTokenProgram(configState.quoteTokenFlag)
-    }).preInstructions([preInstruction]).postInstructions(postInstruction).transaction();
+    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     return transaction;
   }
 };
@@ -24251,10 +24299,21 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Private method to initialize a pool with SPL token
-   * @param initializeSplPoolParams - The parameters for the initialize SPL pool
+   * @param name - The name of the token
+   * @param symbol - The symbol of the token
+   * @param uri - The URI of the token
+   * @param pool - The pool address
+   * @param config - The config address
+   * @param payer - The payer address
+   * @param poolCreator - The pool creator address
+   * @param baseMint - The base mint address
+   * @param baseVault - The base vault address
+   * @param quoteVault - The quote vault address
+   * @param quoteMint - The quote mint address
+   * @param mintMetadata - The mint metadata address (Optional)
    * @returns A transaction that initializes the pool with SPL token
    */
-  async initializeSplPool(initializeSplPoolParams) {
+  async initializeSplPool(params) {
     const {
       name,
       symbol,
@@ -24268,7 +24327,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       baseVault,
       quoteVault,
       quoteMint
-    } = initializeSplPoolParams;
+    } = params;
     return this.program.methods.initializeVirtualPoolWithSplToken({
       name,
       symbol,
@@ -24291,10 +24350,21 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Private method to initialize a pool with Token2022
-   * @param initializeToken2022PoolParams - The parameters for the initialize Token2022 pool
+   * @param name - The name of the token
+   * @param symbol - The symbol of the token
+   * @param uri - The URI of the token
+   * @param pool - The pool address
+   * @param config - The config address
+   * @param payer - The payer address
+   * @param poolCreator - The pool creator address
+   * @param baseMint - The base mint address
+   * @param baseVault - The base vault address
+   * @param quoteVault - The quote vault address
+   * @param quoteMint - The quote mint address
+   * @param mintMetadata - The mint metadata address (Optional)
    * @returns A transaction that initializes the pool with Token2022
    */
-  async initializeToken2022Pool(initializeToken2022PoolParams) {
+  async initializeToken2022Pool(params) {
     const {
       name,
       symbol,
@@ -24307,7 +24377,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       baseVault,
       quoteVault,
       quoteMint
-    } = initializeToken2022PoolParams;
+    } = params;
     return this.program.methods.initializeVirtualPoolWithToken2022({
       name,
       symbol,
@@ -24329,8 +24399,8 @@ var PoolService = class extends DynamicBondingCurveProgram {
   /**
    * Private method to prepare swap parameters
    * @param swapBaseForQuote - Whether to swap base for quote
-   * @param virtualPoolState - The virtual pool state
-   * @param poolConfigState - The pool config state
+   * @param virtualPoolState - The virtual pool state consisting of baseMint and poolType
+   * @param poolConfigState - The pool config state consisting of quoteMint and quoteTokenFlag
    * @returns The prepare swap parameters
    */
   prepareSwapParams(swapBaseForQuote, virtualPoolState, poolConfigState) {
@@ -24376,7 +24446,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Private method to create pool transaction
-   * @param createPoolParam - The parameters for the pool
+   * @param createPoolParam - The parameters for the pool consisting of baseMint, name, symbol, uri, poolCreator, config, and payer
    * @param tokenType - The token type
    * @param quoteMint - The quote mint token
    * @returns A transaction that creates the pool
@@ -24408,10 +24478,12 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Private method to create first buy transaction
-   * @param firstBuyParam - The parameters for the first buy
+   * @param firstBuyParam - The parameters for the first buy consisting of buyer, receiver (optional), buyAmount, minimumAmountOut, and referralTokenAccount
    * @param baseMint - The base mint token
    * @param config - The config key
-   * @param baseFeeMode - The base fee mode
+   * @param baseFee - The base fee
+   * @param swapBaseForQuote - Whether to swap base for quote
+   * @param currentPoint - The current point
    * @param tokenType - The token type
    * @param quoteMint - The quote mint token
    * @returns Instructions for the first buy
@@ -24516,12 +24588,21 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create a new pool
-   * @param createPoolParam - The parameters for the pool
+   * @param name - The name of the token
+   * @param symbol - The symbol of the token
+   * @param uri - The URI of the token
+   * @param config - The config address
+   * @param payer - The payer address
+   * @param poolCreator - The pool creator address
+   * @param baseMint - The base mint address
    * @returns A new pool
    */
-  async createPool(createPoolParam) {
-    const { baseMint, config, name, symbol, uri, payer, poolCreator } = createPoolParam;
+  async createPool(params) {
+    const { baseMint, config, name, symbol, uri, payer, poolCreator } = params;
     const poolConfigState = await this.state.getPoolConfig(config);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const { quoteMint, tokenType } = poolConfigState;
     const pool = deriveDbcPoolAddress(quoteMint, baseMint, config);
     const baseVault = deriveDbcTokenVaultAddress(pool, baseMint);
@@ -24548,10 +24629,16 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create a new config and pool
-   * @param createConfigAndPoolParam - The parameters for the config and pool
+   * @param config - The config address
+   * @param feeClaimer - The fee claimer address
+   * @param leftoverReceiver - The leftover receiver address
+   * @param quoteMint - The quote mint address
+   * @param payer - The payer address
+   * @param configParam - The parameters for the config
+   * @param preCreatePoolParam - The parameters for the pool
    * @returns A new config and pool
    */
-  async createConfigAndPool(createConfigAndPoolParam) {
+  async createConfigAndPool(params) {
     const {
       config,
       feeClaimer,
@@ -24559,7 +24646,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       quoteMint,
       payer,
       ...configParam
-    } = createConfigAndPoolParam;
+    } = params;
     const configKey = new (0, _web3js.PublicKey)(config);
     const quoteMintToken = new (0, _web3js.PublicKey)(quoteMint);
     const payerAddress = new (0, _web3js.PublicKey)(payer);
@@ -24577,11 +24664,11 @@ var PoolService = class extends DynamicBondingCurveProgram {
     tx.add(createConfigTx);
     const createPoolTx = await this.createPoolTx(
       {
-        ...createConfigAndPoolParam.preCreatePoolParam,
+        ...params.preCreatePoolParam,
         config: configKey,
         payer: payerAddress
       },
-      createConfigAndPoolParam.tokenType,
+      params.tokenType,
       quoteMintToken
     );
     tx.add(createPoolTx);
@@ -24589,10 +24676,17 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create a new config and pool and buy tokens
-   * @param createConfigAndPoolWithFirstBuyParam - The parameters for the config and pool and buy
+   * @param config - The config address
+   * @param feeClaimer - The fee claimer address
+   * @param leftoverReceiver - The leftover receiver address
+   * @param quoteMint - The quote mint address
+   * @param payer - The payer address
+   * @param configParam - The parameters for the config
+   * @param preCreatePoolParam - The parameters for the pool
+   * @param firstBuyParam - The parameters for the first buy
    * @returns An object containing the new config transaction, new pool transaction, and first buy transaction
    */
-  async createConfigAndPoolWithFirstBuy(createConfigAndPoolWithFirstBuyParam) {
+  async createConfigAndPoolWithFirstBuy(params) {
     const {
       config,
       feeClaimer,
@@ -24600,7 +24694,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       quoteMint,
       payer,
       ...configParam
-    } = createConfigAndPoolWithFirstBuyParam;
+    } = params;
     const configKey = new (0, _web3js.PublicKey)(config);
     const quoteMintToken = new (0, _web3js.PublicKey)(quoteMint);
     const payerAddress = new (0, _web3js.PublicKey)(payer);
@@ -24616,11 +24710,11 @@ var PoolService = class extends DynamicBondingCurveProgram {
     );
     const createPoolTx = await this.createPoolTx(
       {
-        ...createConfigAndPoolWithFirstBuyParam.preCreatePoolParam,
+        ...params.preCreatePoolParam,
         config: configKey,
         payer: payerAddress
       },
-      createConfigAndPoolWithFirstBuyParam.tokenType,
+      params.tokenType,
       quoteMintToken
     );
     const currentPoint = await getCurrentPoint(
@@ -24628,17 +24722,15 @@ var PoolService = class extends DynamicBondingCurveProgram {
       configParam.activationType
     );
     let swapBuyTx;
-    if (createConfigAndPoolWithFirstBuyParam.firstBuyParam && createConfigAndPoolWithFirstBuyParam.firstBuyParam.buyAmount.gt(
-      new (0, _bnjs2.default)(0)
-    )) {
+    if (params.firstBuyParam && params.firstBuyParam.buyAmount.gt(new (0, _bnjs2.default)(0))) {
       swapBuyTx = await this.swapBuyTx(
-        createConfigAndPoolWithFirstBuyParam.firstBuyParam,
-        createConfigAndPoolWithFirstBuyParam.preCreatePoolParam.baseMint,
+        params.firstBuyParam,
+        params.preCreatePoolParam.baseMint,
         configKey,
         configParam.poolFees.baseFee,
         false,
         currentPoint,
-        createConfigAndPoolWithFirstBuyParam.tokenType,
+        params.tokenType,
         quoteMintToken
       );
     }
@@ -24650,15 +24742,20 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create a new pool and buy tokens
-   * @param createPoolWithFirstBuyParam - The parameters for the pool and buy
+   * @param createPoolParam - The parameters for the pool
+   * @param firstBuyParam - The parameters for the first buy
    * @returns An object containing the new pool transaction and swap buy transaction
    */
-  async createPoolWithFirstBuy(createPoolWithFirstBuyParam) {
-    const { config } = createPoolWithFirstBuyParam.createPoolParam;
+  async createPoolWithFirstBuy(params) {
+    const { createPoolParam, firstBuyParam } = params;
+    const { config } = createPoolParam;
     const poolConfigState = await this.state.getPoolConfig(config);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const { quoteMint, tokenType } = poolConfigState;
     const createPoolTx = await this.createPoolTx(
-      createPoolWithFirstBuyParam.createPoolParam,
+      createPoolParam,
       tokenType,
       quoteMint
     );
@@ -24667,10 +24764,10 @@ var PoolService = class extends DynamicBondingCurveProgram {
       poolConfigState.activationType
     );
     let swapBuyTx;
-    if (createPoolWithFirstBuyParam.firstBuyParam && createPoolWithFirstBuyParam.firstBuyParam.buyAmount.gt(new (0, _bnjs2.default)(0))) {
+    if (firstBuyParam && firstBuyParam.buyAmount.gt(new (0, _bnjs2.default)(0))) {
       swapBuyTx = await this.swapBuyTx(
-        createPoolWithFirstBuyParam.firstBuyParam,
-        createPoolWithFirstBuyParam.createPoolParam.baseMint,
+        firstBuyParam,
+        createPoolParam.baseMint,
         config,
         poolConfigState.poolFees.baseFee,
         false,
@@ -24686,15 +24783,18 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create a new pool and buy tokens with partner and creator
-   * @param createPoolWithPartnerAndCreatorFirstBuyParam - The parameters for the pool and buy
-   * @returns An object containing the new pool transaction and swap buy transactions
+   * @param createPoolParam - The parameters for the pool
+   * @param partnerFirstBuyParam - The parameters for the partner first buy
+   * @param creatorFirstBuyParam - The parameters for the creator first buy
+   * @returns An object containing the new pool transaction and swap buy transactions for partner and creator
    */
-  async createPoolWithPartnerAndCreatorFirstBuy(createPoolWithPartnerAndCreatorFirstBuyParam) {
-    const { config } = createPoolWithPartnerAndCreatorFirstBuyParam.createPoolParam;
+  async createPoolWithPartnerAndCreatorFirstBuy(params) {
+    const { createPoolParam, partnerFirstBuyParam, creatorFirstBuyParam } = params;
+    const { config } = createPoolParam;
     const poolConfigState = await this.state.getPoolConfig(config);
     const { quoteMint, tokenType } = poolConfigState;
     const createPoolTx = await this.createPoolTx(
-      createPoolWithPartnerAndCreatorFirstBuyParam.createPoolParam,
+      createPoolParam,
       tokenType,
       quoteMint
     );
@@ -24703,18 +24803,16 @@ var PoolService = class extends DynamicBondingCurveProgram {
       poolConfigState.activationType
     );
     let partnerSwapBuyTx;
-    if (createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam && createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam.buyAmount.gt(
-      new (0, _bnjs2.default)(0)
-    )) {
+    if (partnerFirstBuyParam && partnerFirstBuyParam.buyAmount.gt(new (0, _bnjs2.default)(0))) {
       partnerSwapBuyTx = await this.swapBuyTx(
         {
-          buyer: createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam.partner,
-          receiver: createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam.receiver,
-          buyAmount: createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam.buyAmount,
-          minimumAmountOut: createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam.minimumAmountOut,
-          referralTokenAccount: createPoolWithPartnerAndCreatorFirstBuyParam.partnerFirstBuyParam.referralTokenAccount
+          buyer: partnerFirstBuyParam.partner,
+          receiver: partnerFirstBuyParam.receiver,
+          buyAmount: partnerFirstBuyParam.buyAmount,
+          minimumAmountOut: partnerFirstBuyParam.minimumAmountOut,
+          referralTokenAccount: partnerFirstBuyParam.referralTokenAccount
         },
-        createPoolWithPartnerAndCreatorFirstBuyParam.createPoolParam.baseMint,
+        createPoolParam.baseMint,
         config,
         poolConfigState.poolFees.baseFee,
         false,
@@ -24724,18 +24822,16 @@ var PoolService = class extends DynamicBondingCurveProgram {
       );
     }
     let creatorSwapBuyTx;
-    if (createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam && createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam.buyAmount.gt(
-      new (0, _bnjs2.default)(0)
-    )) {
+    if (creatorFirstBuyParam && creatorFirstBuyParam.buyAmount.gt(new (0, _bnjs2.default)(0))) {
       creatorSwapBuyTx = await this.swapBuyTx(
         {
-          buyer: createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam.creator,
-          receiver: createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam.receiver,
-          buyAmount: createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam.buyAmount,
-          minimumAmountOut: createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam.minimumAmountOut,
-          referralTokenAccount: createPoolWithPartnerAndCreatorFirstBuyParam.creatorFirstBuyParam.referralTokenAccount
+          buyer: creatorFirstBuyParam.creator,
+          receiver: creatorFirstBuyParam.receiver,
+          buyAmount: creatorFirstBuyParam.buyAmount,
+          minimumAmountOut: creatorFirstBuyParam.minimumAmountOut,
+          referralTokenAccount: creatorFirstBuyParam.referralTokenAccount
         },
-        createPoolWithPartnerAndCreatorFirstBuyParam.createPoolParam.baseMint,
+        createPoolParam.baseMint,
         config,
         poolConfigState.poolFees.baseFee,
         false,
@@ -24752,17 +24848,33 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Swap between base and quote
+   * @param owner - The owner of the swap
    * @param pool - The pool address
-   * @param swapParam - The parameters for the swap
+   * @param amountIn - The amount in
+   * @param minimumAmountOut - The minimum amount out
+   * @param swapBaseForQuote - Whether to swap base for quote
+   * @param referralTokenAccount - The referral token account (nullible)
+   * @param payer - The payer of the swap (optional)
    * @returns A swap transaction
    */
-  async swap(swapParam) {
-    const poolState = await this.state.getPool(swapParam.pool);
+  async swap(params) {
+    const {
+      amountIn,
+      minimumAmountOut,
+      swapBaseForQuote,
+      owner,
+      payer,
+      pool,
+      referralTokenAccount
+    } = params;
+    const poolState = await this.state.getPool(pool);
     if (!poolState) {
-      throw new Error(`Pool not found: ${swapParam.pool.toString()}`);
+      throw new Error(`Pool not found: ${pool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
-    const { amountIn, minimumAmountOut, swapBaseForQuote, owner, payer } = swapParam;
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     validateSwapAmount(amountIn);
     const currentPoint = await getCurrentPoint(
       this.connection,
@@ -24818,12 +24930,12 @@ var PoolService = class extends DynamicBondingCurveProgram {
     }).accountsPartial({
       baseMint: poolState.baseMint,
       quoteMint: poolConfigState.quoteMint,
-      pool: swapParam.pool,
+      pool,
       baseVault: poolState.baseVault,
       quoteVault: poolState.quoteVault,
       config: poolState.config,
       poolAuthority: this.poolAuthority,
-      referralTokenAccount: swapParam.referralTokenAccount,
+      referralTokenAccount,
       inputTokenAccount,
       outputTokenAccount,
       payer: owner,
@@ -24833,10 +24945,19 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Swap V2 between base and quote (included SwapMode: ExactIn, PartialFill, ExactOut)
-   * @param swap2Param - The parameters for the swap
+   * @param owner - The owner of the swap
+   * @param pool - The pool address
+   * @param swapBaseForQuote - Whether to swap base for quote
+   * @param referralTokenAccount - The referral token account (nullible)
+   * @param payer - The payer of the swap (optional)
+   * @param swapMode - The swap mode (ExactIn: 0, PartialFill: 1, ExactOut: 2)
+   * @param amountIn - The amount in (for ExactIn and PartialFill)
+   * @param minimumAmountOut - The minimum amount out (for ExactIn and PartialFill)
+   * @param amountOut - The amount out (for ExactOut)
+   * @param maximumAmountIn - The maximum amount in (for ExactOut)
    * @returns A swap transaction
    */
-  async swap2(swap2Param) {
+  async swap2(params) {
     const {
       pool,
       swapBaseForQuote,
@@ -24844,15 +24965,15 @@ var PoolService = class extends DynamicBondingCurveProgram {
       owner,
       payer,
       referralTokenAccount
-    } = swap2Param;
+    } = params;
     let amount0;
     let amount1;
     if (swapMode === 2 /* ExactOut */) {
-      amount0 = swap2Param.amountOut;
-      amount1 = swap2Param.maximumAmountIn;
+      amount0 = params.amountOut;
+      amount1 = params.maximumAmountIn;
     } else {
-      amount0 = swap2Param.amountIn;
-      amount1 = swap2Param.minimumAmountOut;
+      amount0 = params.amountIn;
+      amount1 = params.minimumAmountOut;
     }
     validateSwapAmount(amount0);
     const poolState = await this.state.getPool(pool);
@@ -24860,6 +24981,9 @@ var PoolService = class extends DynamicBondingCurveProgram {
       throw new Error(`Pool not found: ${pool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
+    if (!poolConfigState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
     const currentPoint = await getCurrentPoint(
       this.connection,
       poolConfigState.activationType
@@ -24935,12 +25059,12 @@ var PoolService = class extends DynamicBondingCurveProgram {
    * @param config - The config
    * @param swapBaseForQuote - Whether to swap base for quote
    * @param amountIn - The amount in
-   * @param slippageBps - Slippage tolerance in basis points (100 = 1%)
+   * @param slippageBps - Slippage tolerance in basis points (100 = 1%) (optional)
    * @param hasReferral - Whether the referral is enabled
    * @param currentPoint - The current point
    * @returns The swap quote result
    */
-  swapQuote(swapQuoteParam) {
+  swapQuote(params) {
     const {
       virtualPool,
       config,
@@ -24949,7 +25073,7 @@ var PoolService = class extends DynamicBondingCurveProgram {
       slippageBps,
       hasReferral,
       currentPoint
-    } = swapQuoteParam;
+    } = params;
     return swapQuote(
       virtualPool,
       config,
@@ -24962,10 +25086,18 @@ var PoolService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Calculate the amount out for a swap (quote) based on swap mode (for swap2)
-   * @param swapQuoteParam - The unified parameters for the swap quote
+   * @param virtualPool - The virtual pool
+   * @param config - The config
+   * @param swapBaseForQuote - Whether to swap base for quote
+   * @param hasReferral - Whether the referral is enabled
+   * @param currentPoint - The current point
+   * @param slippageBps - Slippage tolerance in basis points (100 = 1%) (optional)
+   * @param swapMode - The swap mode (ExactIn: 0, PartialFill: 1, ExactOut: 2)
+   * @param amountIn - The amount in (for ExactIn and PartialFill)
+   * @param amountOut - The amount out (for ExactOut)
    * @returns The swap quote result
    */
-  swapQuote2(swapQuote2Param) {
+  swapQuote2(params) {
     const {
       virtualPool,
       config,
@@ -24974,15 +25106,15 @@ var PoolService = class extends DynamicBondingCurveProgram {
       hasReferral,
       currentPoint,
       slippageBps
-    } = swapQuote2Param;
+    } = params;
     switch (swapMode) {
       case 0 /* ExactIn */:
-        if ("amountIn" in swapQuote2Param) {
+        if ("amountIn" in params) {
           return swapQuoteExactIn(
             virtualPool,
             config,
             swapBaseForQuote,
-            swapQuote2Param.amountIn,
+            params.amountIn,
             slippageBps,
             hasReferral,
             currentPoint
@@ -24990,12 +25122,12 @@ var PoolService = class extends DynamicBondingCurveProgram {
         }
         throw new Error("amountIn is required for ExactIn swap mode");
       case 2 /* ExactOut */:
-        if ("amountOut" in swapQuote2Param) {
+        if ("amountOut" in params) {
           return swapQuoteExactOut(
             virtualPool,
             config,
             swapBaseForQuote,
-            swapQuote2Param.amountOut,
+            params.amountOut,
             slippageBps,
             hasReferral,
             currentPoint
@@ -25003,12 +25135,12 @@ var PoolService = class extends DynamicBondingCurveProgram {
         }
         throw new Error("outAmount is required for ExactOut swap mode");
       case 1 /* PartialFill */:
-        if ("amountIn" in swapQuote2Param) {
+        if ("amountIn" in params) {
           return swapQuotePartialFill(
             virtualPool,
             config,
             swapBaseForQuote,
-            swapQuote2Param.amountIn,
+            params.amountIn,
             slippageBps,
             hasReferral,
             currentPoint
@@ -25039,32 +25171,44 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Create virtual pool metadata
-   * @param createVirtualPoolMetadataParam - The parameters for the virtual pool metadata
+   * @param virtualPool - The virtual pool address
+   * @param name - The name of the pool
+   * @param website - The website of the pool
+   * @param logo - The logo of the pool
+   * @param creator - The creator of the pool
+   * @param payer - The payer of the transaction
    * @returns A create virtual pool metadata transaction
    */
-  async createPoolMetadata(createVirtualPoolMetadataParam) {
-    const virtualPoolMetadata = deriveDbcPoolMetadata(
-      createVirtualPoolMetadataParam.virtualPool
-    );
+  async createPoolMetadata(params) {
+    const { virtualPool, name, website, logo, creator, payer } = params;
+    const virtualPoolMetadata = deriveDbcPoolMetadata(virtualPool);
     return this.program.methods.createVirtualPoolMetadata({
       padding: new Array(96).fill(0),
-      name: createVirtualPoolMetadataParam.name,
-      website: createVirtualPoolMetadataParam.website,
-      logo: createVirtualPoolMetadataParam.logo
+      name,
+      website,
+      logo
     }).accountsPartial({
-      virtualPool: createVirtualPoolMetadataParam.virtualPool,
+      virtualPool,
       virtualPoolMetadata,
-      creator: createVirtualPoolMetadataParam.creator,
-      payer: createVirtualPoolMetadataParam.payer,
+      creator,
+      payer,
       systemProgram: _web3js.SystemProgram.programId
     }).transaction();
   }
   /**
    * Private method to claim trading fee with quote mint SOL
-   * @param claimWithQuoteMintSolParam - The parameters for the claim with quote mint SOL
+   * @param creator - The creator of the pool
+   * @param payer - The payer of the transaction
+   * @param feeReceiver - The wallet that will receive the tokens
+   * @param pool - The pool address
+   * @param poolState - The pool state
+   * @param poolConfigState - The pool config state
+   * @param tokenBaseProgram - The token base program
+   * @param tokenQuoteProgram - The token quote program
+   * @param tempWSolAcc - The temporary wallet that will receive the SOL
    * @returns A claim trading fee with quote mint SOL accounts, pre instructions and post instructions
    */
-  async claimWithQuoteMintSol(claimWithQuoteMintSolParam) {
+  async claimWithQuoteMintSol(params) {
     const {
       creator,
       payer,
@@ -25075,7 +25219,7 @@ var CreatorService = class extends DynamicBondingCurveProgram {
       poolConfigState,
       tokenBaseProgram,
       tokenQuoteProgram
-    } = claimWithQuoteMintSolParam;
+    } = params;
     const preInstructions = [];
     const postInstructions = [];
     const tokenBaseAccount = findAssociatedTokenAddress(
@@ -25123,10 +25267,17 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Private method to claim trading fee with quote mint not SOL
-   * @param claimWithQuoteMintNotSolParam - The parameters for the claim with quote mint not SOL
+   * @param creator - The creator of the pool
+   * @param payer - The payer of the transaction
+   * @param feeReceiver - The wallet that will receive the tokens
+   * @param pool - The pool address
+   * @param poolState - The pool state
+   * @param poolConfigState - The pool config state
+   * @param tokenBaseProgram - The token base program
+   * @param tokenQuoteProgram - The token quote program
    * @returns A claim trading fee with quote mint not SOL accounts and pre instructions
    */
-  async claimWithQuoteMintNotSol(claimWithQuoteMintNotSolParam) {
+  async claimWithQuoteMintNotSol(params) {
     const {
       creator,
       payer,
@@ -25136,7 +25287,7 @@ var CreatorService = class extends DynamicBondingCurveProgram {
       poolConfigState,
       tokenBaseProgram,
       tokenQuoteProgram
-    } = claimWithQuoteMintNotSolParam;
+    } = params;
     const {
       ataTokenA: tokenBaseAccount,
       ataTokenB: tokenQuoteAccount,
@@ -25166,10 +25317,16 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Claim creator trading fee
-   * @param claimCreatorTradingFeeParam - The parameters for the claim creator trading fee
+   * @param creator - The creator of the pool
+   * @param payer - The payer of the transaction
+   * @param pool - The pool address
+   * @param maxBaseAmount - The maximum base amount
+   * @param maxQuoteAmount - The maximum quote amount
+   * @param receiver - The wallet that will receive the tokens (Optional)
+   * @param tempWSolAcc - The temporary wallet that will receive the SOL (Optional)
    * @returns A claim creator trading fee transaction
    */
-  async claimCreatorTradingFee(claimCreatorTradingFeeParam) {
+  async claimCreatorTradingFee(params) {
     const {
       creator,
       pool,
@@ -25178,14 +25335,14 @@ var CreatorService = class extends DynamicBondingCurveProgram {
       receiver,
       payer,
       tempWSolAcc
-    } = claimCreatorTradingFeeParam;
+    } = params;
     const poolState = await this.state.getPool(pool);
     if (!poolState) {
       throw new Error(`Pool not found: ${pool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
     if (!poolConfigState) {
-      throw new Error(`Pool config not found: ${pool.toString()}`);
+      throw new Error(`Pool config not found for virtual pool`);
     }
     const tokenBaseProgram = getTokenProgram(poolConfigState.tokenType);
     const tokenQuoteProgram = getTokenProgram(
@@ -25224,10 +25381,15 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Claim creator trading fee
-   * @param claimCreatorTradingFeeParam - The parameters for the claim creator trading fee
+   * @param creator - The creator of the pool
+   * @param payer - The payer of the transaction
+   * @param pool - The pool address
+   * @param maxBaseAmount - The maximum base amount
+   * @param maxQuoteAmount - The maximum quote amount
+   * @param receiver - The wallet that will receive the tokens
    * @returns A claim creator trading fee transaction
    */
-  async claimCreatorTradingFee2(claimCreatorTradingFee2Param) {
+  async claimCreatorTradingFee2(params) {
     const {
       creator,
       pool,
@@ -25235,14 +25397,14 @@ var CreatorService = class extends DynamicBondingCurveProgram {
       maxQuoteAmount,
       receiver,
       payer
-    } = claimCreatorTradingFee2Param;
+    } = params;
     const poolState = await this.state.getPool(pool);
     if (!poolState) {
       throw new Error(`Pool not found: ${pool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
     if (!poolConfigState) {
-      throw new Error(`Pool config not found: ${pool.toString()}`);
+      throw new Error(`Pool config not found for virtual pool`);
     }
     const tokenBaseProgram = getTokenProgram(poolConfigState.tokenType);
     const tokenQuoteProgram = getTokenProgram(
@@ -25310,18 +25472,19 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Withdraw creator surplus
-   * @param creatorWithdrawSurplusParam - The parameters for the creator withdraw surplus
+   * @param creator - The creator of the pool
+   * @param virtualPool - The virtual pool address
    * @returns A creator withdraw surplus transaction
    */
-  async creatorWithdrawSurplus(creatorWithdrawSurplusParam) {
-    const { creator, virtualPool } = creatorWithdrawSurplusParam;
+  async creatorWithdrawSurplus(params) {
+    const { creator, virtualPool } = params;
     const poolState = await this.state.getPool(virtualPool);
     if (!poolState) {
       throw new Error(`Pool not found: ${virtualPool.toString()}`);
     }
     const poolConfigState = await this.state.getPoolConfig(poolState.config);
     if (!poolConfigState) {
-      throw new Error(`Pool config not found: ${virtualPool.toString()}`);
+      throw new Error(`Pool config not found for virtual pool`);
     }
     const preInstructions = [];
     const postInstructions = [];
@@ -25361,12 +25524,17 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Transfer pool creator
-   * @param transferPoolCreatorParams - The parameters for the transfer pool creator
+   * @param virtualPool - The virtual pool address
+   * @param creator - The creator of the pool
+   * @param newCreator - The new creator of the pool
    * @returns A transfer pool creator transaction
    */
-  async transferPoolCreator(transferPoolCreatorParams) {
-    const { virtualPool, creator, newCreator } = transferPoolCreatorParams;
+  async transferPoolCreator(params) {
+    const { virtualPool, creator, newCreator } = params;
     const virtualPoolState = await this.state.getPool(virtualPool);
+    if (!virtualPoolState) {
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
+    }
     const migrationMetadata = deriveDammV1MigrationMetadataAddress(virtualPool);
     const transaction = await this.program.methods.transferPoolCreator().accountsPartial({
       virtualPool,
@@ -25384,27 +25552,36 @@ var CreatorService = class extends DynamicBondingCurveProgram {
   }
   /**
    * Creator withdraw migration fee
-   * @param withdrawMigrationFeeParams - The parameters for the creator withdraw migration fee
+   * @param virtualPool - The virtual pool address
+   * @param sender - The sender of the pool
    * @returns A creator withdraw migration fee transaction
    */
-  async creatorWithdrawMigrationFee(withdrawMigrationFeeParams) {
-    const { virtualPool, sender, feePayer } = withdrawMigrationFeeParams;
+  async creatorWithdrawMigrationFee(params) {
+    const { virtualPool, sender } = params;
     const virtualPoolState = await this.state.getPool(virtualPool);
+    if (!virtualPoolState) {
+      throw new Error(`Pool not found: ${virtualPool.toString()}`);
+    }
     const configState = await this.state.getPoolConfig(
       virtualPoolState.config
     );
-    const { ataPubkey: tokenQuoteAccount, ix: preInstruction } = await getOrCreateATAInstruction(
+    if (!configState) {
+      throw new Error(`Pool config not found for virtual pool`);
+    }
+    const preInstructions = [];
+    const postInstructions = [];
+    const { ataPubkey: tokenQuoteAccount, ix: createTokenQuoteAccountIx } = await getOrCreateATAInstruction(
       this.program.provider.connection,
       configState.quoteMint,
       sender,
-      _nullishCoalesce(feePayer, () => ( sender)),
+      sender,
       true,
       getTokenProgram(configState.quoteTokenFlag)
     );
-    const postInstruction = [];
+    createTokenQuoteAccountIx && preInstructions.push(createTokenQuoteAccountIx);
     if (configState.quoteMint.equals(_spltoken.NATIVE_MINT)) {
-      const unwarpSOLIx = unwrapSOLInstruction(sender, sender);
-      unwarpSOLIx && postInstruction.push(unwarpSOLIx);
+      const unwrapSolIx = unwrapSOLInstruction(sender, sender);
+      unwrapSolIx && postInstructions.push(unwrapSolIx);
     }
     const transaction = await this.program.methods.withdrawMigrationFee(1).accountsPartial({
       poolAuthority: this.poolAuthority,
@@ -25415,7 +25592,7 @@ var CreatorService = class extends DynamicBondingCurveProgram {
       quoteMint: configState.quoteMint,
       sender,
       tokenQuoteProgram: getTokenProgram(configState.quoteTokenFlag)
-    }).preInstructions([preInstruction]).postInstructions(postInstruction).transaction();
+    }).preInstructions(preInstructions).postInstructions(postInstructions).transaction();
     return transaction;
   }
 };
@@ -25434,6 +25611,7 @@ var DynamicBondingCurveClient = class _DynamicBondingCurveClient {
   /**
    * Static method to create a client instance for a specific pool
    * @param connection - The connection to the Solana network
+   * @param commitment - The commitment to the Solana network
    * @returns A DynamicBondingCurveClient instance
    */
   static create(connection, commitment = "confirmed") {