@picon-finance/dlmm-sdk 1.2.0 → 1.3.0

package/src/actions/sync_pool.ts

@@ -1,35 +0,0 @@
-import { type Address, type TransactionSigner, AccountRole } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, getSyncPoolInstruction } from "../generated";
-import { generateBinArrayIndicesForSync } from "../utils/bin_location";
-import { MAX_BIN_ARRAYS_PER_SYNC } from "../utils/constants";
-import { findBinArrayAddresses } from "../utils/bin_array";
-import { getPool } from "./get_pool";
-import { buildTransactionMessage, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-// The base sync_pool instruction only declares `user`/`pool` — the bin arrays are Anchor
-// `remaining_accounts`, not part of the typed account list, so they're appended manually here.
-// Read-only: sync_pool only ever reads bin data (`is_zero_liquidity`) to find the next active
-// bin, never mutates a bin array.
-export async function syncPool(
-  rpc: Rpc,
-  { user, pool, desiredBinId }: { user: TransactionSigner, pool: Address, desiredBinId: number },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const { activeBinId } = await getPool(rpc, pool, options);
-
-  const binArrayIndices = generateBinArrayIndicesForSync(activeBinId, desiredBinId, MAX_BIN_ARRAYS_PER_SYNC);
-  const binArrayAddresses = await findBinArrayAddresses(pool, binArrayIndices, programAddress);
-
-  const syncPoolIx = getSyncPoolInstruction({ user, pool, desiredBinId }, { programAddress });
-  const remainingAccounts = binArrayAddresses.map(address => ({
-    address,
-    role: AccountRole.READONLY,
-  }));
-
-  const instructions = [{
-    ...syncPoolIx,
-    accounts: [...syncPoolIx.accounts, ...remainingAccounts],
-  }];
-  return await buildTransactionMessage(rpc, { feePayer: user, instructions }, options);
-}

package/src/actions/transfer_admin_authority.ts

@@ -1,17 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, getTransferAdminAuthorityInstructionAsync } from "../generated";
-import { buildTransactionMessage, resolveAdminConfigAddress, type TransactionMessageOptions, type Rpc } from "./helpers";
-
-export async function transferAdminAuthority(
-  rpc: Rpc,
-  { authority, newAuthority }: { authority: TransactionSigner, newAuthority: Address },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  const adminConfig = await resolveAdminConfigAddress(programAddress);
-  const instruction = await getTransferAdminAuthorityInstructionAsync(
-    { authority, newAuthority, adminConfig },
-    { programAddress },
-  );
-  return await buildTransactionMessage(rpc, { feePayer: authority, instructions: [instruction] }, options);
-}

package/src/actions/withdraw.ts

@@ -1,87 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, findPositionPda, getWithdrawInstruction } from "../generated";
-import { findPositionBinArrayAddresses } from "../utils/bin_array";
-import { findPoolTokenVaults, findPositionTokenAccount, processAssociatedTokenAccountPair } from "../utils/ata";
-import {
-  resolvePositionRange,
-  resolveTokenMintsAndPrograms,
-  buildTransactionMessage,
-  type TransactionMessageOptions,
-  type Rpc,
-} from "./helpers";
-
-export async function withdraw(
-  rpc: Rpc,
-  {
-    owner,
-    positionMint,
-    bpsToRemove,
-    lowerBinId,
-    upperBinId,
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }: {
-    owner: TransactionSigner,
-    positionMint: Address,
-    bpsToRemove: number,
-    lowerBinId?: number,
-    upperBinId?: number,
-    pool?: Address,
-    tokenMintX?: Address,
-    tokenMintY?: Address,
-    tokenProgramX?: Address,
-    tokenProgramY?: Address,
-  },
-  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
-  options: TransactionMessageOptions = {},
-) {
-  ({ pool, lowerBinId, upperBinId } = await resolvePositionRange(rpc, positionMint, { pool, lowerBinId, upperBinId }, programAddress, options));
-
-  const tokenMintsAndPrograms = await resolveTokenMintsAndPrograms(rpc, {
-    pool,
-    tokenMintX,
-    tokenMintY,
-    tokenProgramX,
-    tokenProgramY,
-  }, options);
-
-  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 });
-
-  const { lowerBinArray, upperBinArray } = await findPositionBinArrayAddresses(pool, lowerBinId, upperBinId, programAddress);
-
-  const withdrawIx = getWithdrawInstruction({
-    owner,
-    pool,
-    position,
-    positionTokenAccount,
-    ...tokenMintsAndPrograms,
-    tokenOwnerAccountX,
-    tokenOwnerAccountY,
-    tokenVaultX,
-    tokenVaultY,
-    lowerBinArray,
-    upperBinArray,
-    lowerBinId,
-    upperBinId,
-    bpsToRemove,
-  }, { programAddress });
-
-  const instructions = [
-    ...preInstructionsAta,
-    withdrawIx,
-    ...postInstructionsAta,
-  ];
-  return await buildTransactionMessage(rpc, { feePayer: owner, instructions }, options);
-}

package/src/utils/admin_config.ts

@@ -1,6 +0,0 @@
-import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
-import { type AdminConfig } from "../generated";
-
-export function isAdminConfigActive(adminConfig: AdminConfig): boolean {
-  return adminConfig.authority !== SYSTEM_PROGRAM_ADDRESS;
-}

package/src/utils/bin_array.ts

@@ -1,45 +0,0 @@
-import { type Address } from "@solana/kit";
-import { findBinArrayPda } from "../generated";
-import { generateBinArrayIndicesForSwap, getPositionBinArrayIndices } from "./bin_location";
-import { MAX_BIN_ARRAYS_PER_SWAP } from "./constants";
-import { isUndefined } from "./type_guards";
-
-// Shared by every instruction that enumerates an arbitrary span of bin arrays as Anchor
-// `remaining_accounts` (swap, sync_pool), as opposed to the fixed lower/upper pair a
-// position-scoped instruction uses.
-export async function findBinArrayAddresses(pool: Address, indices: number[], programAddress: Address): Promise<Address[]> {
-  return Promise.all(indices.map(async index => (await findBinArrayPda({ pool, index }, { programAddress }))[0]));
-}
-
-// Pure local PDA derivation — no RPC. Shared by `swap` (which only needs the addresses for
-// remaining accounts) and `quote` (which additionally fetches each account's data).
-export function findSwapBinArrayAddresses(
-  pool: Address,
-  activeBinId: number,
-  xToY: boolean,
-  programAddress: Address,
-): Promise<Address[]> {
-  const binArrayIndices = generateBinArrayIndicesForSwap(activeBinId, xToY, MAX_BIN_ARRAYS_PER_SWAP);
-  return findBinArrayAddresses(pool, binArrayIndices, programAddress);
-}
-
-// Shared by every position-scoped instruction (open_position, deposit_by_weight, withdraw,
-// claim_fee) — derives the lower and (optionally) upper bin array covering the position's
-// range, matching the program's own `lowerBinArray` + `upperBinArray: Option<UncheckedAccount>`
-// account pair. `upperBinArray` is omitted when both ends fall in the same bin array.
-export async function findPositionBinArrayAddresses(
-  pool: Address,
-  lowerBinId: number,
-  upperBinId: number,
-  programAddress: Address,
-): Promise<{ lowerBinArray: Address; upperBinArray?: Address }> {
-  const { lowerBinArrayIndex, upperBinArrayIndex } = getPositionBinArrayIndices(lowerBinId, upperBinId);
-
-  const [lowerBinArray] = await findBinArrayPda({ pool, index: lowerBinArrayIndex }, { programAddress });
-  if (isUndefined(upperBinArrayIndex)) {
-    return { lowerBinArray };
-  }
-
-  const [upperBinArray] = await findBinArrayPda({ pool, index: upperBinArrayIndex }, { programAddress });
-  return { lowerBinArray, upperBinArray };
-}

package/src/utils/compute_budget.ts

@@ -1,58 +0,0 @@
-import {
-  getSetComputeUnitLimitInstruction,
-  getSetComputeUnitPriceInstruction,
-} from "@solana-program/compute-budget";
-import {
-  createSolanaRpc,
-  estimateComputeUnitLimitFactory,
-  prependTransactionMessageInstructions,
-  type TransactionMessage,
-  type TransactionMessageWithFeePayer,
-} from "@solana/kit";
-import { isUndefined } from "./type_guards";
-
-export function withComputeBudget<TTransactionMessage extends TransactionMessage>(
-  message: TTransactionMessage,
-  {
-    computeUnitLimit,
-    computeUnitPrice,
-  }: {
-    computeUnitLimit?: number,
-    computeUnitPrice?: bigint,
-  } = {},
-): TTransactionMessage {
-  const ixs = [
-    ...(isUndefined(computeUnitLimit) ? [] : [getSetComputeUnitLimitInstruction({ units: computeUnitLimit })]),
-    ...(isUndefined(computeUnitPrice) ? [] : [getSetComputeUnitPriceInstruction({ microLamports: computeUnitPrice })]),
-  ];
-  return prependTransactionMessageInstructions(ixs, message) as TTransactionMessage;
-}
-
-export async function withEstimatedComputeBudget<
-  TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer
->(
-  rpc: ReturnType<typeof createSolanaRpc>,
-  message: TTransactionMessage,
-  {
-    estimateComputeUnitPrice,
-    estimateComputeUnitLimit,
-    bufferFactor = 1.1,
-  }: {
-    estimateComputeUnitPrice?: bigint | ((computeUnitLimit: number) => bigint),
-    estimateComputeUnitLimit?: ReturnType<typeof estimateComputeUnitLimitFactory>,
-    bufferFactor?: number,
-  } = {},
-): Promise<TTransactionMessage> {
-  estimateComputeUnitLimit = estimateComputeUnitLimit ?? estimateComputeUnitLimitFactory({ rpc });
-
-  const computeUnitBase = await estimateComputeUnitLimit(message);
-  const computeUnitLimit = Math.ceil(computeUnitBase * bufferFactor);
-  const computeUnitPrice = estimateComputeUnitPrice instanceof Function
-    ? estimateComputeUnitPrice(computeUnitLimit)
-    : estimateComputeUnitPrice;
-
-  return withComputeBudget(message, {
-    computeUnitLimit: computeUnitLimit,
-    computeUnitPrice,
-  });
-}