@picon-finance/dlmm-sdk 2.0.5 → 2.0.7

package/dist/generated/programs/piconDlmm.js

@@ -295,7 +295,7 @@ export function parsePiconDlmmInstruction(instruction) {
             });
     }
 }
-export function piconDlmmProgram() {
+export function piconDlmmProgram(config = {}) {
     return (client) => {
         return extendClient(client, {
             piconDlmm: {
@@ -306,34 +306,77 @@ export function piconDlmmProgram() {
                     position: addSelfFetchFunctions(client, getPositionCodec()),
                 },
                 instructions: {
-                    acceptAdminAuthority: (input) => addSelfPlanAndSendFunctions(client, getAcceptAdminAuthorityInstructionAsync(input)),
-                    claimFee: (input) => addSelfPlanAndSendFunctions(client, getClaimFeeInstruction(input)),
-                    claimProtocolFee: (input) => addSelfPlanAndSendFunctions(client, getClaimProtocolFeeInstructionAsync(input)),
-                    closePosition: (input) => addSelfPlanAndSendFunctions(client, getClosePositionInstructionAsync(input)),
-                    createAdminConfig: (input) => addSelfPlanAndSendFunctions(client, getCreateAdminConfigInstructionAsync(input)),
-                    createBinArray: (input) => addSelfPlanAndSendFunctions(client, getCreateBinArrayInstructionAsync({
-                        ...input,
-                        payer: input.payer ?? client.payer,
+                    acceptAdminAuthority: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getAcceptAdminAuthorityInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    claimFee: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getClaimFeeInstruction(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    claimProtocolFee: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getClaimProtocolFeeInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    closePosition: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getClosePositionInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    createAdminConfig: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getCreateAdminConfigInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    createBinArray: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getCreateBinArrayInstructionAsync({ ...input, payer: input.payer ?? client.payer }, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    createPool: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getCreatePoolInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    deleteBinArray: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getDeleteBinArrayInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    depositByWeight: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getDepositByWeightInstruction(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    openPosition: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getOpenPositionInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    resetAdminAuthority: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getResetAdminAuthorityInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    setMetadataUpdateAuthority: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getSetMetadataUpdateAuthorityInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    setPoolDynamicFeeConfig: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getSetPoolDynamicFeeConfigInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    setPoolProtocolShare: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getSetPoolProtocolShareInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    swapExactIn: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getSwapExactInInstruction(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    swapExactOut: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getSwapExactOutInstruction(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    syncPool: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getSyncPoolInstruction(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    transferAdminAuthority: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getTransferAdminAuthorityInstructionAsync(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
+                    })),
+                    withdraw: (input, instructionConfig) => addSelfPlanAndSendFunctions(client, getWithdrawInstruction(input, {
+                        programAddress: instructionConfig?.programAddress ?? config.programAddress,
                     })),
-                    createPool: (input) => addSelfPlanAndSendFunctions(client, getCreatePoolInstructionAsync(input)),
-                    deleteBinArray: (input) => addSelfPlanAndSendFunctions(client, getDeleteBinArrayInstructionAsync(input)),
-                    depositByWeight: (input) => addSelfPlanAndSendFunctions(client, getDepositByWeightInstruction(input)),
-                    openPosition: (input) => addSelfPlanAndSendFunctions(client, getOpenPositionInstructionAsync(input)),
-                    resetAdminAuthority: (input) => addSelfPlanAndSendFunctions(client, getResetAdminAuthorityInstructionAsync(input)),
-                    setMetadataUpdateAuthority: (input) => addSelfPlanAndSendFunctions(client, getSetMetadataUpdateAuthorityInstructionAsync(input)),
-                    setPoolDynamicFeeConfig: (input) => addSelfPlanAndSendFunctions(client, getSetPoolDynamicFeeConfigInstructionAsync(input)),
-                    setPoolProtocolShare: (input) => addSelfPlanAndSendFunctions(client, getSetPoolProtocolShareInstructionAsync(input)),
-                    swapExactIn: (input) => addSelfPlanAndSendFunctions(client, getSwapExactInInstruction(input)),
-                    swapExactOut: (input) => addSelfPlanAndSendFunctions(client, getSwapExactOutInstruction(input)),
-                    syncPool: (input) => addSelfPlanAndSendFunctions(client, getSyncPoolInstruction(input)),
-                    transferAdminAuthority: (input) => addSelfPlanAndSendFunctions(client, getTransferAdminAuthorityInstructionAsync(input)),
-                    withdraw: (input) => addSelfPlanAndSendFunctions(client, getWithdrawInstruction(input)),
                 },
                 pdas: {
-                    adminConfig: findAdminConfigPda,
-                    position: findPositionPda,
-                    binArray: findBinArrayPda,
-                    pool: findPoolPda,
+                    adminConfig: (pdaConfig) => findAdminConfigPda({
+                        programAddress: pdaConfig?.programAddress ?? config.programAddress,
+                    }),
+                    position: (seeds, pdaConfig) => findPositionPda(seeds, {
+                        programAddress: pdaConfig?.programAddress ?? config.programAddress,
+                    }),
+                    binArray: (seeds, pdaConfig) => findBinArrayPda(seeds, {
+                        programAddress: pdaConfig?.programAddress ?? config.programAddress,
+                    }),
+                    pool: (seeds, pdaConfig) => findPoolPda(seeds, {
+                        programAddress: pdaConfig?.programAddress ?? config.programAddress,
+                    }),
                 },
                 identifyAccount: identifyPiconDlmmAccount,
                 identifyInstruction: identifyPiconDlmmInstruction,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@picon-finance/dlmm-sdk",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Typescript SDK for interacting with the Picon DLMM protocol",
   "author": "Picon Finance",
   "license": "MIT",
@@ -43,17 +43,18 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@solana-program/system": "^0.15.0",
-    "@solana-program/token": "^0.17.0",
-    "@solana-program/token-2022": "^0.19.0",
-    "@solana/kit": "^8.3.0",
-    "@solana/program-client-core": "^8.3.0",
-    "@solana/transaction-messages": "^8.3.0"
+    "@solana-program/system": "^0.16.0",
+    "@solana-program/token": "^0.18.0",
+    "@solana-program/token-2022": "^0.20.0",
+    "@solana/kit": "^8.5.0",
+    "@solana/program-client-core": "^8.5.0",
+    "@solana/transaction-messages": "^8.5.0"
   },
   "devDependencies": {
-    "@types/bun": "latest",
     "@codama/nodes-from-anchor": "^1.5.6",
-    "@codama/renderers-js": "^2.5.0",
-    "codama": "^1.11.0"
+    "@codama/renderers-js": "^2.7.0",
+    "@types/bun": "latest",
+    "codama": "^1.11.0",
+    "typescript": "^6.0.3"
   }
 }

package/src/generated/accounts/adminConfig.ts

@@ -30,6 +30,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type MaybeAccount,
   type MaybeEncodedAccount,
   type ReadonlyUint8Array,
@@ -53,9 +54,9 @@ export type AdminConfig = {
 };
 
 export type AdminConfigArgs = {
-  authority: Address;
-  pendingAuthority: Address;
-  metadataUpdateAuthority: Address;
+  authority: Address | HasAddress;
+  pendingAuthority: Address | HasAddress;
+  metadataUpdateAuthority: Address | HasAddress;
 };
 
 /** Gets the encoder for {@link AdminConfigArgs} account data. */
@@ -106,7 +107,7 @@ export function decodeAdminConfig<TAddress extends string = string>(
 
 export async function fetchAdminConfig<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<Account<AdminConfig, TAddress>> {
   const maybeAccount = await fetchMaybeAdminConfig(rpc, address, config);
@@ -116,16 +117,20 @@ export async function fetchAdminConfig<TAddress extends string = string>(
 
 export async function fetchMaybeAdminConfig<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<MaybeAccount<AdminConfig, TAddress>> {
-  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount(
+    rpc,
+    typeof address === "string" ? address : address.address,
+    config,
+  );
   return decodeAdminConfig(maybeAccount);
 }
 
 export async function fetchAllAdminConfig(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<Account<AdminConfig>[]> {
   const maybeAccounts = await fetchAllMaybeAdminConfig(rpc, addresses, config);
@@ -135,10 +140,14 @@ export async function fetchAllAdminConfig(
 
 export async function fetchAllMaybeAdminConfig(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<AdminConfig>[]> {
-  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts(
+    rpc,
+    addresses.map((a) => (typeof a === "string" ? a : a.address)),
+    config,
+  );
   return maybeAccounts.map((maybeAccount) => decodeAdminConfig(maybeAccount));
 }
 

package/src/generated/accounts/binArray.ts

@@ -34,6 +34,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type MaybeAccount,
   type MaybeEncodedAccount,
   type ReadonlyUint8Array,
@@ -64,8 +65,8 @@ export type BinArray = {
 
 export type BinArrayArgs = {
   index: number;
-  pool: Address;
-  payer: Address;
+  pool: Address | HasAddress;
+  payer: Address | HasAddress;
   padding: ReadonlyUint8Array;
   bins: Array<BinArgs>;
 };
@@ -119,7 +120,7 @@ export function decodeBinArray<TAddress extends string = string>(
 
 export async function fetchBinArray<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<Account<BinArray, TAddress>> {
   const maybeAccount = await fetchMaybeBinArray(rpc, address, config);
@@ -129,16 +130,20 @@ export async function fetchBinArray<TAddress extends string = string>(
 
 export async function fetchMaybeBinArray<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<MaybeAccount<BinArray, TAddress>> {
-  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount(
+    rpc,
+    typeof address === "string" ? address : address.address,
+    config,
+  );
   return decodeBinArray(maybeAccount);
 }
 
 export async function fetchAllBinArray(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<Account<BinArray>[]> {
   const maybeAccounts = await fetchAllMaybeBinArray(rpc, addresses, config);
@@ -148,10 +153,14 @@ export async function fetchAllBinArray(
 
 export async function fetchAllMaybeBinArray(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<BinArray>[]> {
-  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts(
+    rpc,
+    addresses.map((a) => (typeof a === "string" ? a : a.address)),
+    config,
+  );
   return maybeAccounts.map((maybeAccount) => decodeBinArray(maybeAccount));
 }
 

package/src/generated/accounts/pool.ts

@@ -38,6 +38,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type MaybeAccount,
   type MaybeEncodedAccount,
   type ReadonlyUint8Array,
@@ -80,10 +81,10 @@ export type PoolArgs = {
   bump: ReadonlyUint8Array;
   activeBinId: number;
   dynamicFeeState: DynamicFeeStateArgs;
-  tokenMintX: Address;
-  tokenMintY: Address;
-  tokenVaultX: Address;
-  tokenVaultY: Address;
+  tokenMintX: Address | HasAddress;
+  tokenMintY: Address | HasAddress;
+  tokenVaultX: Address | HasAddress;
+  tokenVaultY: Address | HasAddress;
   protocolFeeX: number | bigint;
   protocolFeeY: number | bigint;
 };
@@ -151,7 +152,7 @@ export function decodePool<TAddress extends string = string>(
 
 export async function fetchPool<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<Account<Pool, TAddress>> {
   const maybeAccount = await fetchMaybePool(rpc, address, config);
@@ -161,16 +162,20 @@ export async function fetchPool<TAddress extends string = string>(
 
 export async function fetchMaybePool<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<MaybeAccount<Pool, TAddress>> {
-  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount(
+    rpc,
+    typeof address === "string" ? address : address.address,
+    config,
+  );
   return decodePool(maybeAccount);
 }
 
 export async function fetchAllPool(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<Account<Pool>[]> {
   const maybeAccounts = await fetchAllMaybePool(rpc, addresses, config);
@@ -180,10 +185,14 @@ export async function fetchAllPool(
 
 export async function fetchAllMaybePool(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<Pool>[]> {
-  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts(
+    rpc,
+    addresses.map((a) => (typeof a === "string" ? a : a.address)),
+    config,
+  );
   return maybeAccounts.map((maybeAccount) => decodePool(maybeAccount));
 }
 

package/src/generated/accounts/position.ts

@@ -34,6 +34,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type MaybeAccount,
   type MaybeEncodedAccount,
   type ReadonlyUint8Array,
@@ -64,8 +65,8 @@ export type Position = {
 };
 
 export type PositionArgs = {
-  pool: Address;
-  positionMint: Address;
+  pool: Address | HasAddress;
+  positionMint: Address | HasAddress;
   lowerBinId: number;
   upperBinId: number;
   padding: ReadonlyUint8Array;
@@ -123,7 +124,7 @@ export function decodePosition<TAddress extends string = string>(
 
 export async function fetchPosition<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<Account<Position, TAddress>> {
   const maybeAccount = await fetchMaybePosition(rpc, address, config);
@@ -133,16 +134,20 @@ export async function fetchPosition<TAddress extends string = string>(
 
 export async function fetchMaybePosition<TAddress extends string = string>(
   rpc: Parameters<typeof fetchEncodedAccount>[0],
-  address: Address<TAddress>,
+  address: Address<TAddress> | HasAddress<TAddress>,
   config?: FetchAccountConfig,
 ): Promise<MaybeAccount<Position, TAddress>> {
-  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount(
+    rpc,
+    typeof address === "string" ? address : address.address,
+    config,
+  );
   return decodePosition(maybeAccount);
 }
 
 export async function fetchAllPosition(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<Account<Position>[]> {
   const maybeAccounts = await fetchAllMaybePosition(rpc, addresses, config);
@@ -152,10 +157,14 @@ export async function fetchAllPosition(
 
 export async function fetchAllMaybePosition(
   rpc: Parameters<typeof fetchEncodedAccounts>[0],
-  addresses: Array<Address>,
+  addresses: Array<Address | HasAddress>,
   config?: FetchAccountsConfig,
 ): Promise<MaybeAccount<Position>[]> {
-  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts(
+    rpc,
+    addresses.map((a) => (typeof a === "string" ? a : a.address)),
+    config,
+  );
   return maybeAccounts.map((maybeAccount) => decodePosition(maybeAccount));
 }
 

package/src/generated/errors/piconDlmm.ts

@@ -9,6 +9,7 @@
 import {
   isProgramError,
   type Address,
+  type HasAddress,
   type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM,
   type SolanaError,
 } from "@solana/kit";
@@ -125,12 +126,19 @@ export function isPiconDlmmError<TProgramErrorCode extends PiconDlmmError>(
     instructions: Record<number, { programAddress: Address }>;
   },
   code?: TProgramErrorCode,
+  config: { programAddress?: Address | HasAddress } = {},
 ): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
   Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+  const programAddressInput =
+    config.programAddress ?? PICON_DLMM_PROGRAM_ADDRESS;
+  const programAddress =
+    typeof programAddressInput === "string"
+      ? programAddressInput
+      : programAddressInput.address;
   return isProgramError<TProgramErrorCode>(
     error,
     transactionMessage,
-    PICON_DLMM_PROGRAM_ADDRESS,
+    programAddress,
     code,
   );
 }

package/src/generated/events/claimFeeEvent.ts

@@ -27,6 +27,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -52,9 +53,9 @@ export type ClaimFeeEventEvent = {
 };
 
 export type ClaimFeeEventEventArgs = {
-  pool: Address;
-  position: Address;
-  owner: Address;
+  pool: Address | HasAddress;
+  position: Address | HasAddress;
+  owner: Address | HasAddress;
   lowerBinId: number;
   upperBinId: number;
   amountX: number | bigint;

package/src/generated/events/closePositionEvent.ts

@@ -25,6 +25,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -45,7 +46,13 @@ export type ClosePositionEventEvent = {
   upperBinId: number;
 };
 
-export type ClosePositionEventEventArgs = ClosePositionEventEvent;
+export type ClosePositionEventEventArgs = {
+  pool: Address | HasAddress;
+  position: Address | HasAddress;
+  owner: Address | HasAddress;
+  lowerBinId: number;
+  upperBinId: number;
+};
 
 /** Gets the encoder for {@link ClosePositionEventEventArgs} event data. */
 export function getClosePositionEventEventEncoder(): FixedSizeEncoder<ClosePositionEventEventArgs> {

package/src/generated/events/createPoolEvent.ts

@@ -27,6 +27,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -47,7 +48,13 @@ export type CreatePoolEventEvent = {
   tokenMintY: Address;
 };
 
-export type CreatePoolEventEventArgs = CreatePoolEventEvent;
+export type CreatePoolEventEventArgs = {
+  pool: Address | HasAddress;
+  binStep: number;
+  feeRate: number;
+  tokenMintX: Address | HasAddress;
+  tokenMintY: Address | HasAddress;
+};
 
 /** Gets the encoder for {@link CreatePoolEventEventArgs} event data. */
 export function getCreatePoolEventEventEncoder(): FixedSizeEncoder<CreatePoolEventEventArgs> {

package/src/generated/events/depositEvent.ts

@@ -27,6 +27,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -52,9 +53,9 @@ export type DepositEventEvent = {
 };
 
 export type DepositEventEventArgs = {
-  pool: Address;
-  position: Address;
-  owner: Address;
+  pool: Address | HasAddress;
+  position: Address | HasAddress;
+  owner: Address | HasAddress;
   lowerBinId: number;
   upperBinId: number;
   amountX: number | bigint;

package/src/generated/events/openPositionEvent.ts

@@ -25,6 +25,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -45,7 +46,13 @@ export type OpenPositionEventEvent = {
   upperBinId: number;
 };
 
-export type OpenPositionEventEventArgs = OpenPositionEventEvent;
+export type OpenPositionEventEventArgs = {
+  pool: Address | HasAddress;
+  position: Address | HasAddress;
+  owner: Address | HasAddress;
+  lowerBinId: number;
+  upperBinId: number;
+};
 
 /** Gets the encoder for {@link OpenPositionEventEventArgs} event data. */
 export function getOpenPositionEventEventEncoder(): FixedSizeEncoder<OpenPositionEventEventArgs> {

package/src/generated/events/swapEvent.ts

@@ -29,6 +29,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -55,7 +56,7 @@ export type SwapEventEvent = {
 };
 
 export type SwapEventEventArgs = {
-  pool: Address;
+  pool: Address | HasAddress;
   xToY: boolean;
   preBinId: number;
   postBinId: number;

package/src/generated/events/withdrawEvent.ts

@@ -29,6 +29,7 @@ import {
   type FixedSizeCodec,
   type FixedSizeDecoder,
   type FixedSizeEncoder,
+  type HasAddress,
   type ReadonlyUint8Array,
 } from "@solana/kit";
 
@@ -55,9 +56,9 @@ export type WithdrawEventEvent = {
 };
 
 export type WithdrawEventEventArgs = {
-  pool: Address;
-  position: Address;
-  owner: Address;
+  pool: Address | HasAddress;
+  position: Address | HasAddress;
+  owner: Address | HasAddress;
   lowerBinId: number;
   upperBinId: number;
   bpsRemoved: number;

package/src/generated/instructions/acceptAdminAuthority.ts

@@ -120,7 +120,9 @@ export async function getAcceptAdminAuthorityInstructionAsync<
     TAccountPendingAuthority,
     TAccountAdminConfig
   >,
-  config?: { programAddress?: TProgramAddress },
+  config?: {
+    programAddress?: TProgramAddress | { readonly address: TProgramAddress };
+  },
 ): Promise<
   AcceptAdminAuthorityInstruction<
     TProgramAddress,
@@ -135,7 +137,12 @@ export async function getAcceptAdminAuthorityInstructionAsync<
   >
 > {
   // Program address.
-  const programAddress = config?.programAddress ?? PICON_DLMM_PROGRAM_ADDRESS;
+  const programAddressInput =
+    config?.programAddress ?? PICON_DLMM_PROGRAM_ADDRESS;
+  const programAddress =
+    typeof programAddressInput === "string"
+      ? programAddressInput
+      : programAddressInput.address;
 
   // Account meta helper.
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
@@ -201,7 +208,9 @@ export function getAcceptAdminAuthorityInstruction<
     TAccountPendingAuthority,
     TAccountAdminConfig
   >,
-  config?: { programAddress?: TProgramAddress },
+  config?: {
+    programAddress?: TProgramAddress | { readonly address: TProgramAddress };
+  },
 ): AcceptAdminAuthorityInstruction<
   TProgramAddress,
   ResolvedInstructionAccountMeta<
@@ -214,7 +223,12 @@ export function getAcceptAdminAuthorityInstruction<
   >
 > {
   // Program address.
-  const programAddress = config?.programAddress ?? PICON_DLMM_PROGRAM_ADDRESS;
+  const programAddressInput =
+    config?.programAddress ?? PICON_DLMM_PROGRAM_ADDRESS;
+  const programAddress =
+    typeof programAddressInput === "string"
+      ? programAddressInput
+      : programAddressInput.address;
 
   // Account meta helper.
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");