@picon-finance/dlmm-sdk 1.2.0 → 1.3.0

package/src/actions/claim_multiple_fees.ts

@@ -1,123 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, getClaimFeeInstruction } from "../generated";
-import { findPositionTokenAccount, processAssociatedTokenAccountPair, findPoolTokenVaults } from "../utils/ata";
-import { findPositionBinArrayAddresses } from "../utils/bin_array";
-import { isUndefined } from "../utils/type_guards";
-import { MAX_POSITIONS_PER_CLAIM } from "../utils/constants";
-import { getPositionsByPositionMints } from "./get_positions_by_position_mints";
-import {
-  resolveTokenMintsAndPrograms,
-  buildTransactionMessage,
-  type TransactionMessageOptions,
-  type Rpc,
-} from "./helpers";
-
-// No on-chain batch claim_fee — this chunks positions into multiple transactions bounded
-// by MAX_POSITIONS_PER_CLAIM, deduplicating the owner's ATAs and any shared bin arrays
-// within each chunk. All positions must belong to the same pool, since a single transaction
-// can only touch one pool's vaults.
-//
-// Returns one builder per chunk (not pre-built messages): only the first tx creates the
-// owner's ATAs (and only the last unwraps WSOL), so the chunks aren't independent — the
-// caller must call each builder and submit+confirm its transaction in order before calling
-// the next, since a later chunk's claim_fee assumes the first chunk's ATA already landed.
-export async function claimMultipleFees(
-  rpc: Rpc,
-  {
-    owner,
-    positionMints,
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }: {
-    owner: TransactionSigner,
-    positionMints: Address[],
-    pool?: Address,
-    tokenMintX?: Address,
-    tokenMintY?: Address,
-    tokenProgramX?: Address,
-    tokenProgramY?: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  if (positionMints.length === 0) {
-    return [];
-  }
-
-  const positions = await getPositionsByPositionMints(rpc, positionMints, programAddress, options);
-
-  const actualPool = positions[0].data.pool;
-  if (positions.some(({ data }) => data.pool !== actualPool)) {
-    throw new Error("claimMultipleFees: all positions must belong to the same pool");
-  }
-  if (!isUndefined(pool) && pool !== actualPool) {
-    throw new Error("claimMultipleFees: provided pool does not match the positions' pool");
-  }
-  pool = actualPool;
-
-  const tokenMintsAndPrograms = await resolveTokenMintsAndPrograms(rpc, {
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }, options);
-
-  // ATAs are persistent accounts: only the first tx needs to create them (and wrap WSOL,
-  // though claim's ATAs are receive-only so there's nothing to transfer in), and only the
-  // last needs to unwrap WSOL back to native SOL, once every chunk has landed in it.
-  const {
-    ataX: tokenOwnerAccountX,
-    ataY: tokenOwnerAccountY,
-    preInstructions: preInstructionsAta,
-    postInstructions: postInstructionsAta,
-  } = await processAssociatedTokenAccountPair({ owner, ...tokenMintsAndPrograms });
-
-  const { tokenVaultX, tokenVaultY } = await findPoolTokenVaults({ pool, ...tokenMintsAndPrograms });
-
-  const chunks = [];
-  for (let i = 0; i < positions.length; i += MAX_POSITIONS_PER_CLAIM) {
-    chunks.push(positions.slice(i, i + MAX_POSITIONS_PER_CLAIM));
-  }
-
-  // Returns one builder per chunk instead of pre-built messages: the caller submits and
-  // confirms chunks strictly in order (see the contract above), and confirmation takes real
-  // wall-clock time, so a blockhash fetched once up front for every chunk can outlive its
-  // ~60-90s validity window before later chunks are ever submitted. Each builder fetches its
-  // own blockhash (via buildTransactionMessage's default) at the moment it's actually called,
-  // right before that chunk is submitted.
-  return chunks.map((chunkPositions, i) => async () => {
-    // One claim_fee per position in this chunk — deliberately excludes the owner's ATA
-    // setup/teardown, which is account-level, not chunk-level (handled above/below instead).
-    const coreInstructions = await Promise.all(chunkPositions.map(async ({ address: position, data }) => {
-      const positionTokenAccount = await findPositionTokenAccount({ owner: owner.address, positionMint: data.positionMint });
-      const { lowerBinArray, upperBinArray } = await findPositionBinArrayAddresses(pool, data.lowerBinId, data.upperBinId, programAddress);
-
-      return getClaimFeeInstruction({
-        owner,
-        pool,
-        position,
-        positionTokenAccount,
-        ...tokenMintsAndPrograms,
-        tokenOwnerAccountX,
-        tokenOwnerAccountY,
-        tokenVaultX,
-        tokenVaultY,
-        lowerBinArray,
-        upperBinArray,
-        lowerBinId: data.lowerBinId,
-        upperBinId: data.upperBinId,
-      }, { programAddress });
-    }));
-
-    const instructions = [
-      ...(i === 0 ? preInstructionsAta : []),
-      ...coreInstructions,
-      ...(i === chunks.length - 1 ? postInstructionsAta : []),
-    ];
-    return await buildTransactionMessage(rpc, { feePayer: owner, instructions }, options);
-  });
-}

package/src/actions/claim_protocol_fee.ts

@@ -1,68 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, getClaimProtocolFeeInstructionAsync } from "../generated";
-import { findPoolTokenVaults, processAssociatedTokenAccountPair } from "../utils/ata";
-import {
-  resolveTokenMintsAndPrograms,
-  resolveAdminConfigAddress,
-  buildTransactionMessage,
-  type TransactionMessageOptions,
-  type Rpc,
-} from "./helpers";
-
-export async function claimProtocolFee(
-  rpc: Rpc,
-  {
-    authority,
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }: {
-    authority: TransactionSigner,
-    pool: Address,
-    tokenMintX?: Address,
-    tokenMintY?: Address,
-    tokenProgramX?: Address,
-    tokenProgramY?: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const [tokenMintsAndPrograms, adminConfig] = await Promise.all([
-    resolveTokenMintsAndPrograms(rpc, {
-      pool,
-      tokenMintX,
-      tokenMintY,
-      tokenProgramX,
-      tokenProgramY,
-    }, options),
-    resolveAdminConfigAddress(programAddress),
-  ]);
-  const { tokenVaultX, tokenVaultY } = await findPoolTokenVaults({ pool, ...tokenMintsAndPrograms });
-
-  const {
-    ataX: tokenAdminAccountX,
-    ataY: tokenAdminAccountY,
-    preInstructions: preInstructionsAta,
-    postInstructions: postInstructionsAta,
-  } = await processAssociatedTokenAccountPair({ owner: authority, ...tokenMintsAndPrograms });
-
-  const claimProtocolFeeIx = await getClaimProtocolFeeInstructionAsync({
-    authority,
-    pool,
-    adminConfig,
-    ...tokenMintsAndPrograms,
-    tokenVaultX,
-    tokenVaultY,
-    tokenAdminAccountX,
-    tokenAdminAccountY,
-  }, { programAddress });
-
-  const instructions = [
-    ...preInstructionsAta,
-    claimProtocolFeeIx,
-    ...postInstructionsAta,
-  ];
-  return await buildTransactionMessage(rpc, { feePayer: authority, instructions }, options);
-}

package/src/actions/close_position.ts

@@ -1,21 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, findPositionPda, getClosePositionInstructionAsync } from "../generated";
-import { findPositionTokenAccount } from "../utils/ata";
-import { buildTransactionMessage, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-export async function closePosition(
-  rpc: Rpc,
-  { owner, positionMint }: { owner: TransactionSigner, positionMint: Address },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const [position] = await findPositionPda({ positionMint }, { programAddress });
-  const positionTokenAccount = await findPositionTokenAccount({ owner: owner.address, positionMint });
-  const closePositionIx = await getClosePositionInstructionAsync({
-    owner,
-    positionMint,
-    position,
-    positionTokenAccount,
-  }, { programAddress });
-  return await buildTransactionMessage(rpc, { feePayer: owner, instructions: [closePositionIx] }, options);
-}

package/src/actions/create_admin_config.ts

@@ -1,51 +0,0 @@
-import {
-  type Address,
-  type TransactionSigner,
-  getAddressEncoder,
-  getProgramDerivedAddress,
-} from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, getCreateAdminConfigInstructionAsync } from "../generated";
-import { buildTransactionMessage, resolveAdminConfigAddress, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-const LOADER_V3_PROGRAM_ADDRESS = "BPFLoaderUpgradeab1e11111111111111111111111" as Address;
-
-async function findProgramDataAddress(programAddress: Address): Promise<Address> {
-  const [programData] = await getProgramDerivedAddress({
-    programAddress: LOADER_V3_PROGRAM_ADDRESS,
-    seeds: [getAddressEncoder().encode(programAddress)],
-  });
-  return programData;
-}
-
-export async function createAdminConfig(
-  rpc: Rpc,
-  {
-    deployer,
-    authority,
-    metadataUpdateAuthority,
-  }: {
-    deployer: TransactionSigner,
-    authority: Address,
-    metadataUpdateAuthority?: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  // The generated builder's default account resolution for `adminConfig`/`program` doesn't
-  // honor this call's `programAddress` argument (always resolves against the mainnet
-  // PICON_DLMM_PROGRAM_ADDRESS baked in at codegen time) — both are derived and passed
-  // explicitly here instead.
-  const [adminConfig, programData] = await Promise.all([
-    resolveAdminConfigAddress(programAddress),
-    findProgramDataAddress(programAddress),
-  ]);
-  const createAdminConfigIx = await getCreateAdminConfigInstructionAsync({
-    deployer,
-    authority,
-    metadataUpdateAuthority: metadataUpdateAuthority ?? null,
-    adminConfig,
-    program: programAddress,
-    programData,
-  }, { programAddress });
-  return await buildTransactionMessage(rpc, { feePayer: deployer, instructions: [createAdminConfigIx] }, options);
-}

package/src/actions/create_bin_array.ts

@@ -1,30 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, findBinArrayPda, getCreateBinArrayInstructionAsync } from "../generated";
-import { buildTransactionMessage, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-// Standalone escape hatch for manually recreating a bin array — e.g. restoring one an
-// admin deleted while a position still had unclaimed fee or an untouched share in it.
-// Idempotent by default: harmless no-op if the array is already alive.
-export async function createBinArray(
-  rpc: Rpc,
-  {
-    payer,
-    pool,
-    index,
-    idempotent = true,
-  }: {
-    payer: TransactionSigner,
-    pool: Address,
-    index: number,
-    idempotent?: boolean,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const [binArray] = await findBinArrayPda({ pool, index }, { programAddress });
-  const instruction = await getCreateBinArrayInstructionAsync(
-    { payer, pool, index, idempotent, binArray },
-    { programAddress },
-  );
-  return await buildTransactionMessage(rpc, { feePayer: payer, instructions: [instruction] }, options);
-}

package/src/actions/create_pool.ts

@@ -1,49 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, findPoolPda, getCreatePoolInstructionAsync } from "../generated";
-import { buildTransactionMessage, resolveAdminConfigAddress, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-export async function createPool(
-  rpc: Rpc,
-  {
-    authority,
-    binStep,
-    feeRate,
-    protocolShare,
-    activeBinId,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }: {
-    authority: TransactionSigner,
-    binStep: number,
-    feeRate: number,
-    protocolShare: number,
-    activeBinId: number,
-    tokenMintX: Address,
-    tokenMintY: Address,
-    tokenProgramX: Address,
-    tokenProgramY: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const [[pool], adminConfig] = await Promise.all([
-    findPoolPda({ tokenMintX, tokenMintY, binStep, feeRate }, { programAddress }),
-    resolveAdminConfigAddress(programAddress),
-  ]);
-  const instruction = await getCreatePoolInstructionAsync({
-    authority,
-    pool,
-    adminConfig,
-    binStep,
-    feeRate,
-    protocolShare,
-    activeBinId,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }, { programAddress });
-  return await buildTransactionMessage(rpc, { feePayer: authority, instructions: [instruction] }, options);
-}

package/src/actions/delete_bin_array.ts

@@ -1,33 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, fetchBinArray, findBinArrayPda, getDeleteBinArrayInstructionAsync } from "../generated";
-import { isUndefined } from "../utils/type_guards";
-import { buildTransactionMessage, resolveAdminConfigAddress, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-export async function deleteBinArray(
-  rpc: Rpc,
-  {
-    authority,
-    pool,
-    index,
-    receiver,
-  }: {
-    authority: TransactionSigner,
-    pool: Address,
-    index: number,
-    receiver?: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const [binArray] = await findBinArrayPda({ pool, index }, { programAddress });
-  if (isUndefined(receiver)) {
-    const { data } = await fetchBinArray(rpc, binArray, options);
-    receiver = data.payer;
-  }
-  const adminConfig = await resolveAdminConfigAddress(programAddress);
-  const instruction = await getDeleteBinArrayInstructionAsync(
-    { authority, pool, index, receiver, binArray, adminConfig },
-    { programAddress },
-  );
-  return await buildTransactionMessage(rpc, { feePayer: authority, instructions: [instruction] }, options);
-}

package/src/actions/deposit_by_weight.ts

@@ -1,107 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, type DistributionMode, findPositionPda, getDepositByWeightInstruction } from "../generated";
-import { findPositionBinArrayAddresses } from "../utils/bin_array";
-import { processAssociatedTokenAccountPair, findPositionTokenAccount, findPoolTokenVaults } from "../utils/ata";
-import { isUndefined } from "../utils/type_guards";
-import { getPositionByPositionMint } from "./get_position_by_position_mint";
-import {
-  resolveActiveBinAndMints,
-  resolveTokenMintsAndPrograms,
-  buildTransactionMessage,
-  type TransactionMessageOptions,
-  type Rpc,
-} from "./helpers";
-
-export async function depositByWeight(
-  rpc: Rpc,
-  {
-    owner,
-    positionMint,
-    activeBinId,
-    amountX,
-    amountY,
-    lowerBinId,
-    binWeights,
-    maxActiveBinSlippage,
-    distributionMode,
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }: {
-    owner: TransactionSigner,
-    positionMint: Address,
-    activeBinId?: number,
-    amountX: bigint,
-    amountY: bigint,
-    lowerBinId: number,
-    binWeights: number[],
-    maxActiveBinSlippage: number,
-    distributionMode: DistributionMode,
-    pool?: Address,
-    tokenMintX?: Address,
-    tokenMintY?: Address,
-    tokenProgramX?: Address,
-    tokenProgramY?: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  if (isUndefined(pool)) {
-    const positionData = await getPositionByPositionMint(rpc, positionMint, programAddress, options);
-    pool = positionData.pool;
-  }
-  ({ activeBinId, tokenMintX, tokenMintY } = await resolveActiveBinAndMints(rpc, pool, { activeBinId, tokenMintX, tokenMintY }, options));
-
-  const tokenMintsAndPrograms = await resolveTokenMintsAndPrograms(rpc, {
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }, options);
-
-  const upperBinId = lowerBinId + binWeights.length - 1;
-
-  const [position] = await findPositionPda({ positionMint }, { programAddress });
-  const positionTokenAccount = await findPositionTokenAccount({ owner: owner.address, positionMint });
-  const { tokenVaultX, tokenVaultY } = await findPoolTokenVaults({ pool, ...tokenMintsAndPrograms });
-
-  const {
-    ataX: tokenOwnerAccountX,
-    ataY: tokenOwnerAccountY,
-    preInstructions: preInstructionsAta,
-    postInstructions: postInstructionsAta,
-  } = await processAssociatedTokenAccountPair({ owner, ...tokenMintsAndPrograms, amountX, amountY });
-
-  const { lowerBinArray, upperBinArray } = await findPositionBinArrayAddresses(pool, lowerBinId, upperBinId, programAddress);
-
-  const depositByWeightIx = getDepositByWeightInstruction({
-    owner,
-    pool,
-    position,
-    positionTokenAccount,
-    ...tokenMintsAndPrograms,
-    tokenOwnerAccountX,
-    tokenOwnerAccountY,
-    tokenVaultX,
-    tokenVaultY,
-    lowerBinArray,
-    upperBinArray,
-    amountX,
-    amountY,
-    activeBinId,
-    maxActiveBinSlippage,
-    distributionMode,
-    lowerBinId,
-    binWeights,
-  }, { programAddress });
-
-  const instructions = [
-    ...preInstructionsAta,
-    depositByWeightIx,
-    ...postInstructionsAta,
-  ];
-  return await buildTransactionMessage(rpc, { feePayer: owner, instructions }, options);
-}

package/src/actions/get_admin_config.ts

@@ -1,13 +0,0 @@
-import type { Address } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, fetchAdminConfig } from "../generated";
-import { resolveAdminConfigAddress, type Rpc, type TransactionMessageOptions } from "./helpers";
-
-export async function getAdminConfig(
-  rpc: Rpc,
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const adminConfig = await resolveAdminConfigAddress(programAddress);
-  const { data } = await fetchAdminConfig(rpc, adminConfig, options);
-  return data;
-}

package/src/actions/get_bin_arrays_by_indices.ts

@@ -1,15 +0,0 @@
-import type { Address, Account } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, type BinArray, fetchAllBinArray } from "../generated";
-import { findBinArrayAddresses } from "../utils/bin_array";
-import type { Rpc, TransactionMessageOptions } from "./helpers";
-
-export async function getBinArraysByIndices(
-  rpc: Rpc,
-  pool: Address,
-  indices: number[],
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-): Promise<Account<BinArray>[]> {
-  const binArrayAddresses = await findBinArrayAddresses(pool, indices, programAddress);
-  return await fetchAllBinArray(rpc, binArrayAddresses, options);
-}

package/src/actions/get_pool.ts

@@ -1,8 +0,0 @@
-import type { Address } from "@solana/kit";
-import { fetchPool } from "../generated";
-import type { Rpc, TransactionMessageOptions } from "./helpers";
-
-export async function getPool(rpc: Rpc, pool: Address, options: TransactionMessageOptions = {}) {
-  const { data } = await fetchPool(rpc, pool, options);
-  return data;
-}

package/src/actions/get_position.ts

@@ -1,8 +0,0 @@
-import type { Address } from "@solana/kit";
-import { fetchPosition } from "../generated";
-import type { Rpc, TransactionMessageOptions } from "./helpers";
-
-export async function getPosition(rpc: Rpc, position: Address, options: TransactionMessageOptions = {}) {
-  const { data } = await fetchPosition(rpc, position, options);
-  return data;
-}

package/src/actions/get_position_by_position_mint.ts

@@ -1,14 +0,0 @@
-import type { Address } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, findPositionPda } from "../generated";
-import { getPosition } from "./get_position";
-import type { Rpc, TransactionMessageOptions } from "./helpers";
-
-export async function getPositionByPositionMint(
-  rpc: Rpc,
-  positionMint: Address,
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const [position] = await findPositionPda({ positionMint }, { programAddress });
-  return await getPosition(rpc, position, options);
-}

package/src/actions/get_positions_by_owner.ts

@@ -1,48 +0,0 @@
-import { type Address, parseBase64RpcAccount } from "@solana/kit";
-import { getTokenDecoder, TOKEN_2022_PROGRAM_ADDRESS } from "@solana-program/token-2022";
-import { PICON_DLMM_PROGRAM_ADDRESS, type Position, findPositionPda, fetchAllMaybePosition } from "../generated";
-import { chunk } from "../utils/chunk";
-import { MAX_ACCOUNTS_PER_RPC_BATCH } from "../utils/constants";
-import type { Rpc, TransactionMessageOptions } from "./helpers";
-
-export async function getPositionsByOwner(
-  rpc: Rpc,
-  owner: Address,
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  { commitment, minContextSlot, abortSignal }: TransactionMessageOptions = {},
-): Promise<Map<Address, Position[]>> {
-  const { value: tokenAccounts } = await rpc
-    .getTokenAccountsByOwner(owner, { programId: TOKEN_2022_PROGRAM_ADDRESS }, { commitment, minContextSlot, encoding: "base64" })
-    .send({ abortSignal });
-
-  const tokenDecoder = getTokenDecoder();
-  const candidateMints = tokenAccounts
-    .map(({ pubkey, account }) => tokenDecoder.decode(parseBase64RpcAccount(pubkey, account).data))
-    .filter(token => token.amount === 1n)
-    .map(token => token.mint);
-
-  const positionsByPool = new Map<Address, Position[]>();
-  if (candidateMints.length === 0) {
-    return positionsByPool;
-  }
-
-  const positionAddresses = await Promise.all(
-    candidateMints.map(async positionMint => (await findPositionPda({ positionMint }, { programAddress }))[0]),
-  );
-  // getMultipleAccounts caps out at MAX_ACCOUNTS_PER_RPC_BATCH addresses per request.
-  const maybePositionChunks = await Promise.all(
-    chunk(positionAddresses, MAX_ACCOUNTS_PER_RPC_BATCH).map(addresses => fetchAllMaybePosition(rpc, addresses, { commitment, minContextSlot, abortSignal })),
-  );
-  const maybePositions = maybePositionChunks.flat();
-
-  for (const maybePosition of maybePositions) {
-    if (!maybePosition.exists) {
-      continue;
-    }
-    const position = maybePosition.data;
-    const positions = positionsByPool.get(position.pool) ?? [];
-    positions.push(position);
-    positionsByPool.set(position.pool, positions);
-  }
-  return positionsByPool;
-}

package/src/actions/get_positions_by_position_mints.ts

@@ -1,21 +0,0 @@
-import type { Address, Account } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, type Position, findPositionPda, fetchAllPosition } from "../generated";
-import { chunk } from "../utils/chunk";
-import { MAX_ACCOUNTS_PER_RPC_BATCH } from "../utils/constants";
-import type { Rpc, TransactionMessageOptions } from "./helpers";
-
-export async function getPositionsByPositionMints(
-  rpc: Rpc,
-  positionMints: Address[],
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-): Promise<Account<Position>[]> {
-  const positionAddresses = await Promise.all(
-    positionMints.map(async positionMint => (await findPositionPda({ positionMint }, { programAddress }))[0]),
-  );
-  // getMultipleAccounts caps out at MAX_ACCOUNTS_PER_RPC_BATCH addresses per request.
-  const positionChunks = await Promise.all(
-    chunk(positionAddresses, MAX_ACCOUNTS_PER_RPC_BATCH).map(addresses => fetchAllPosition(rpc, addresses, options)),
-  );
-  return positionChunks.flat();
-}