@picon-finance/dlmm-sdk 1.0.0

package/src/actions/helpers/build_swap_transaction_message.ts

@@ -0,0 +1,86 @@
+import { type Address, type TransactionSigner, AccountRole } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS, getSwapInstruction } from "../../generated";
+import { processAssociatedTokenAccountPair, findPoolTokenVaults } from "../../utils/ata";
+import { buildTransactionMessage, type TransactionMessageOptions, type Rpc } from "./build_transaction_message";
+
+// Pure tx builder: every account is already resolved by the caller (`swap`, or `quote`'s
+// returned closure reusing the accounts its own quote was computed against) — no RPC calls,
+// no derivation beyond ATA/vault lookups, no fallbacks.
+//
+// The bin arrays are Anchor `remaining_accounts`, not part of the typed account list, so
+// they're appended manually here — writable, since swap mutates bins via `load_mut` (unlike
+// sync_pool's read-only remaining accounts). `binArrayAddresses` is caller-resolved.
+export async function buildSwapTransactionMessage(
+  rpc: Rpc,
+  {
+    user,
+    pool,
+    xToY,
+    amountIn,
+    minAmountOut,
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX,
+    tokenProgramY,
+    binArrayAddresses,
+  }: {
+    user: TransactionSigner,
+    pool: Address,
+    xToY: boolean,
+    amountIn: bigint,
+    minAmountOut: bigint,
+    tokenMintX: Address,
+    tokenMintY: Address,
+    tokenProgramX: Address,
+    tokenProgramY: Address,
+    binArrayAddresses: Address[],
+  },
+  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
+  options: TransactionMessageOptions = {},
+) {
+  const { tokenVaultX, tokenVaultY } = await findPoolTokenVaults({ pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY });
+
+  // Only the input side needs `amount` (to actually wrap/transfer in); the output side is
+  // receive-only, same as claim_fee/withdraw's ATAs.
+  const {
+    ataX: tokenUserAccountX,
+    ataY: tokenUserAccountY,
+    preInstructions: preInstructionsAta,
+    postInstructions: postInstructionsAta,
+  } = await processAssociatedTokenAccountPair({
+    owner: user,
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX,
+    tokenProgramY,
+    amountX: xToY ? amountIn : undefined,
+    amountY: xToY ? undefined : amountIn,
+  });
+
+  const swapIx = getSwapInstruction({
+    user,
+    pool,
+    tokenMintX,
+    tokenMintY,
+    tokenUserAccountX,
+    tokenUserAccountY,
+    tokenVaultX,
+    tokenVaultY,
+    tokenProgramX,
+    tokenProgramY,
+    amountIn,
+    minAmountOut,
+    xToY,
+  }, { programAddress });
+  const remainingAccounts = binArrayAddresses.map(address => ({
+    address,
+    role: AccountRole.WRITABLE,
+  }));
+
+  const instructions = [
+    ...preInstructionsAta,
+    { ...swapIx, accounts: [...swapIx.accounts, ...remainingAccounts] },
+    ...postInstructionsAta,
+  ];
+  return await buildTransactionMessage(rpc, { feePayer: user, instructions }, options);
+}

package/src/actions/helpers/build_transaction_message.ts

@@ -0,0 +1,45 @@
+import {
+  pipe,
+  createTransactionMessage,
+  setTransactionMessageFeePayerSigner,
+  appendTransactionMessageInstructions,
+  setTransactionMessageLifetimeUsingBlockhash,
+  type Slot,
+  type Commitment,
+  type Instruction,
+  type TransactionSigner,
+  type createSolanaRpc,
+  type BlockhashLifetimeConstraint,
+} from "@solana/kit";
+
+export type Rpc = ReturnType<typeof createSolanaRpc>;
+
+// Also accepted by every read-only action (fetches/reads) — matches @solana/kit's own
+// `FetchAccountConfig` shape, so it forwards straight into the generated `fetchX` calls.
+export interface TransactionMessageOptions {
+  commitment?: Commitment;
+  minContextSlot?: Slot;
+  abortSignal?: AbortSignal;
+}
+
+export async function buildTransactionMessage(
+  rpc: Rpc,
+  {
+    feePayer,
+    instructions,
+    latestBlockhash,
+  }: {
+    feePayer: TransactionSigner,
+    instructions: Instruction[],
+    latestBlockhash?: BlockhashLifetimeConstraint,
+  },
+  { commitment, minContextSlot, abortSignal }: TransactionMessageOptions = {},
+) {
+  latestBlockhash ??= (await rpc.getLatestBlockhash({ commitment, minContextSlot }).send({ abortSignal })).value;
+  return pipe(
+    createTransactionMessage({ version: 0 }),
+    msg => appendTransactionMessageInstructions(instructions, msg),
+    msg => setTransactionMessageFeePayerSigner(feePayer, msg),
+    msg => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, msg),
+  );
+}

package/src/actions/helpers/index.ts

@@ -0,0 +1,7 @@
+export { buildTransactionMessage, type TransactionMessageOptions, type Rpc } from "./build_transaction_message";
+export { buildSwapTransactionMessage } from "./build_swap_transaction_message";
+export { resolveTokenMintsAndPrograms } from "./resolve_token_mints_and_programs";
+export { resolveActiveBinAndMints } from "./resolve_active_bin_and_mints";
+export { resolveMintInfo } from "./resolve_mint_info";
+export { resolvePositionRange } from "./resolve_position_range";
+export { resolveAdminConfigAddress } from "./resolve_admin_config_address";

package/src/actions/helpers/resolve_active_bin_and_mints.ts

@@ -0,0 +1,21 @@
+import type { Address } from "@solana/kit";
+import { getPool } from "../get_pool";
+import { isUndefined } from "../../utils/type_guards";
+import type { Rpc, TransactionMessageOptions } from "./build_transaction_message";
+
+// No programAddress here — this only ever reads an already-known pool account by its explicit
+// address (getPool), no PDA derivation, so there's nothing for it to affect.
+export async function resolveActiveBinAndMints(
+  rpc: Rpc,
+  pool: Address,
+  { activeBinId, tokenMintX, tokenMintY }: { activeBinId?: number, tokenMintX?: Address, tokenMintY?: Address },
+  options: TransactionMessageOptions = {},
+): Promise<{ activeBinId: number, tokenMintX: Address, tokenMintY: Address }> {
+  if (isUndefined(activeBinId) || isUndefined(tokenMintX) || isUndefined(tokenMintY)) {
+    const poolData = await getPool(rpc, pool, options);
+    activeBinId ??= poolData.activeBinId;
+    tokenMintX ??= poolData.tokenMintX;
+    tokenMintY ??= poolData.tokenMintY;
+  }
+  return { activeBinId, tokenMintX, tokenMintY };
+}

package/src/actions/helpers/resolve_admin_config_address.ts

@@ -0,0 +1,11 @@
+import type { Address } from "@solana/kit";
+import { findAdminConfigPda } from "../../generated";
+
+// The generated instruction builders' own default resolution for the `adminConfig` account
+// (every instruction that touches it) always derives against the mainnet
+// PICON_DLMM_PROGRAM_ADDRESS baked in at codegen time, ignoring that call's own `programAddress`
+// argument — so every action passes this explicitly instead of relying on the generated default.
+export async function resolveAdminConfigAddress(programAddress: Address): Promise<Address> {
+  const [adminConfig] = await findAdminConfigPda({ programAddress });
+  return adminConfig;
+}

package/src/actions/helpers/resolve_mint_info.ts

@@ -0,0 +1,36 @@
+import type { Address } from "@solana/kit";
+import { fetchAllMaybeMint } from "@solana-program/token-2022";
+import { resolveTransferFee } from "../../utils/transfer_fee";
+import type { TransferFee } from "../../quote";
+import type { Rpc, TransactionMessageOptions } from "./build_transaction_message";
+
+export async function resolveMintInfo(
+  rpc: Rpc,
+  tokenMintX: Address,
+  tokenMintY: Address,
+  { commitment, minContextSlot, abortSignal }: TransactionMessageOptions = {},
+): Promise<{
+  transferFeeX?: TransferFee,
+  transferFeeY?: TransferFee,
+  tokenProgramX: Address,
+  tokenProgramY: Address,
+}> {
+  const [{ epoch }, [maybeMintX, maybeMintY]] = await Promise.all([
+    rpc.getEpochInfo({ commitment, minContextSlot }).send({ abortSignal }),
+    fetchAllMaybeMint(rpc, [tokenMintX, tokenMintY], { commitment, minContextSlot, abortSignal }),
+  ]);
+
+  if (!maybeMintX.exists) {
+    throw new Error(`Mint account not found: ${tokenMintX}`);
+  }
+  if (!maybeMintY.exists) {
+    throw new Error(`Mint account not found: ${tokenMintY}`);
+  }
+
+  return {
+    transferFeeX: resolveTransferFee(maybeMintX.data, epoch),
+    transferFeeY: resolveTransferFee(maybeMintY.data, epoch),
+    tokenProgramX: maybeMintX.programAddress,
+    tokenProgramY: maybeMintY.programAddress,
+  };
+}

package/src/actions/helpers/resolve_position_range.ts

@@ -0,0 +1,21 @@
+import type { Address } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS } from "../../generated";
+import { getPositionByPositionMint } from "../get_position_by_position_mint";
+import { isUndefined } from "../../utils/type_guards";
+import type { Rpc, TransactionMessageOptions } from "./build_transaction_message";
+
+export async function resolvePositionRange(
+  rpc: Rpc,
+  positionMint: Address,
+  { pool, lowerBinId, upperBinId }: { pool?: Address, lowerBinId?: number, upperBinId?: number },
+  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
+  options: TransactionMessageOptions = {},
+): Promise<{ pool: Address, lowerBinId: number, upperBinId: number }> {
+  if (isUndefined(pool) || isUndefined(lowerBinId) || isUndefined(upperBinId)) {
+    const positionData = await getPositionByPositionMint(rpc, positionMint, programAddress, options);
+    pool ??= positionData.pool;
+    lowerBinId ??= positionData.lowerBinId;
+    upperBinId ??= positionData.upperBinId;
+  }
+  return { pool, lowerBinId, upperBinId };
+}

package/src/actions/helpers/resolve_token_mints_and_programs.ts

@@ -0,0 +1,56 @@
+import type { Address } from "@solana/kit";
+import { fetchAllMaybeMint } from "@solana-program/token-2022";
+import { getPool } from "../get_pool";
+import { isUndefined } from "../../utils/type_guards";
+import type { Rpc, TransactionMessageOptions } from "./build_transaction_message";
+
+// No programAddress here — this only ever reads an already-known pool account by its explicit
+// address (getPool), no PDA derivation, so there's nothing for it to affect.
+export async function resolveTokenMintsAndPrograms(
+  rpc: Rpc,
+  {
+    pool,
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX,
+    tokenProgramY,
+  }: {
+    pool: Address,
+    tokenMintX?: Address,
+    tokenMintY?: Address,
+    tokenProgramX?: Address,
+    tokenProgramY?: Address,
+  },
+  options: TransactionMessageOptions = {},
+): Promise<{
+  tokenMintX: Address,
+  tokenMintY: Address,
+  tokenProgramX: Address,
+  tokenProgramY: Address,
+}> {
+  if (isUndefined(tokenMintX) || isUndefined(tokenMintY)) {
+    const poolData = await getPool(rpc, pool, options);
+    tokenMintX ??= poolData.tokenMintX;
+    tokenMintY ??= poolData.tokenMintY;
+  }
+
+  if (tokenProgramX !== undefined && tokenProgramY !== undefined) {
+    return { tokenMintX, tokenMintY, tokenProgramX, tokenProgramY };
+  }
+
+  // One batched getMultipleAccounts instead of up to two separate getAccountInfo requests.
+  const [maybeMintX, maybeMintY] = await fetchAllMaybeMint(rpc, [tokenMintX, tokenMintY], options);
+  if (!maybeMintX.exists) {
+    throw new Error(`Mint account not found: ${tokenMintX}`);
+  }
+  if (!maybeMintY.exists) {
+    throw new Error(`Mint account not found: ${tokenMintY}`);
+  }
+
+  return {
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX: tokenProgramX ?? maybeMintX.programAddress,
+    tokenProgramY: tokenProgramY ?? maybeMintY.programAddress,
+  };
+}

package/src/actions/index.ts

@@ -0,0 +1,34 @@
+export { type TransactionMessageOptions, type Rpc } from "./helpers";
+export type { QuoteInput, QuoteOutput, PoolState, TransferFee } from "../quote";
+
+export { getPool } from "./get_pool";
+export { getAdminConfig } from "./get_admin_config";
+export { isAdminConfigActive } from "./is_admin_config_active";
+export { getPosition } from "./get_position";
+export { getPositionByPositionMint } from "./get_position_by_position_mint";
+export { getPositionsByPositionMints } from "./get_positions_by_position_mints";
+export { getBinArraysByIndices } from "./get_bin_arrays_by_indices";
+export { getPositionsByOwner } from "./get_positions_by_owner";
+
+export { createPool } from "./create_pool";
+export { syncPool } from "./sync_pool";
+export { openPosition } from "./open_position";
+export { closePosition } from "./close_position";
+export { withdraw } from "./withdraw";
+export { claimFee } from "./claim_fee";
+export { claimMultipleFees } from "./claim_multiple_fees";
+export { depositByWeight } from "./deposit_by_weight";
+export { swap } from "./swap";
+export { quote } from "./quote";
+
+export { createAdminConfig } from "./create_admin_config";
+export { transferAdminAuthority } from "./transfer_admin_authority";
+export { acceptAdminAuthority } from "./accept_admin_authority";
+export { setMetadataUpdateAuthority } from "./set_metadata_update_authority";
+export { claimProtocolFee } from "./claim_protocol_fee";
+export { setPoolDynamicFeeConfig } from "./set_pool_dynamic_fee_config";
+export { setPoolProtocolShare } from "./set_pool_protocol_share";
+export { createBinArray } from "./create_bin_array";
+export { deleteBinArray } from "./delete_bin_array";
+
+export { onEvent } from "./on_event";

package/src/actions/is_admin_config_active.ts

@@ -0,0 +1,14 @@
+import type { Address } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS, fetchMaybeAdminConfig, findAdminConfigPda } from "../generated";
+import { isAdminConfigActive as checkAdminConfigActive } from "../utils/admin_config";
+import type { Rpc, TransactionMessageOptions } from "./helpers";
+
+export async function isAdminConfigActive(
+  rpc: Rpc,
+  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
+  options: TransactionMessageOptions = {},
+): Promise<boolean> {
+  const [adminConfig] = await findAdminConfigPda({ programAddress });
+  const maybeAdminConfig = await fetchMaybeAdminConfig(rpc, adminConfig, options);
+  return maybeAdminConfig.exists && checkAdminConfigActive(maybeAdminConfig.data);
+}

package/src/actions/on_event.ts

@@ -0,0 +1,78 @@
+import { type Address, type Commitment, type createSolanaRpcSubscriptions } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS } from "../generated";
+import { decodeEventsFromLogs, type DlmmEvent } from "../events";
+
+type RpcSubscriptions = ReturnType<typeof createSolanaRpcSubscriptions>;
+
+// `address` defaults to `programAddress` (every pool the program touches); pass a pool
+// address to scope it. `programAddress` also scopes CPI-log filtering (see events.ts), so it
+// should match whatever cluster's program this subscription is watching — defaults to mainnet.
+// Resolves once the subscription is active, with an unsubscribe function. Errors — from the
+// stream itself (e.g. a dropped websocket) or thrown by `handler` — are reported to `onError`
+// instead of rejecting an unheld promise; a `handler` throw only drops that one event, the
+// subscription keeps running.
+export async function onEvent(
+  rpcSubscriptions: RpcSubscriptions,
+  handler: (event: DlmmEvent) => void,
+  {
+    address,
+    programAddress = PICON_DLMM_PROGRAM_ADDRESS,
+    commitment,
+    onError,
+  }: { address?: Address, programAddress?: Address, commitment?: Commitment, onError?: (error: unknown) => void } = {},
+): Promise<() => void> {
+  const abortController = new AbortController();
+  const eventStream = await subscribeToEvents(rpcSubscriptions, {
+    address: address ?? programAddress,
+    programAddress,
+    commitment,
+    abortSignal: abortController.signal,
+  });
+
+  (async () => {
+    try {
+      for await (const event of eventStream) {
+        try {
+          handler(event);
+        } catch (error) {
+          onError?.(error);
+        }
+      }
+    } catch (error) {
+      if (!abortController.signal.aborted) {
+        onError?.(error);
+      }
+    }
+  })();
+
+  return () => abortController.abort();
+}
+
+// Resolves once the subscription is active, so callers know they won't miss anything.
+async function subscribeToEvents(
+  rpcSubscriptions: RpcSubscriptions,
+  {
+    address,
+    programAddress,
+    commitment = "confirmed",
+    abortSignal,
+  }: {
+    address: Address,
+    programAddress: Address,
+    commitment?: Commitment,
+    abortSignal: AbortSignal,
+  },
+): Promise<AsyncIterable<DlmmEvent>> {
+  const notifications = await rpcSubscriptions
+    .logsNotifications({ mentions: [address] }, { commitment })
+    .subscribe({ abortSignal });
+
+  return (async function* () {
+    for await (const notification of notifications) {
+      if (notification.value.err != null) {
+        continue;
+      }
+      yield* decodeEventsFromLogs(notification.value.logs, programAddress);
+    }
+  })();
+}

package/src/actions/open_position.ts

@@ -0,0 +1,66 @@
+import type { Address, TransactionSigner } from "@solana/kit";
+import {
+  PICON_DLMM_PROGRAM_ADDRESS,
+  fetchAdminConfig,
+  findBinArrayPda,
+  findPositionPda,
+  getOpenPositionInstructionAsync,
+  getCreateBinArrayInstructionAsync,
+} from "../generated";
+import { getPositionBinArrayIndices } from "../utils/bin_location";
+import { isUndefined } from "../utils/type_guards";
+import { buildTransactionMessage, resolveAdminConfigAddress, type TransactionMessageOptions, type Rpc } from "./helpers";
+
+export async function openPosition(
+  rpc: Rpc,
+  {
+    owner,
+    positionMint,
+    pool,
+    lowerBinId,
+    upperBinId,
+  }: {
+    owner: TransactionSigner,
+    positionMint: TransactionSigner,
+    pool: Address,
+    lowerBinId: number,
+    upperBinId: number,
+  },
+  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
+  options: TransactionMessageOptions = {},
+) {
+  const [adminConfig, [position]] = await Promise.all([
+    resolveAdminConfigAddress(programAddress),
+    findPositionPda({ positionMint: positionMint.address }, { programAddress }),
+  ]);
+  const { metadataUpdateAuthority } = (await fetchAdminConfig(rpc, adminConfig, options)).data;
+
+  const { lowerBinArrayIndex, upperBinArrayIndex } = getPositionBinArrayIndices(lowerBinId, upperBinId);
+  const binArrayIndices = isUndefined(upperBinArrayIndex) ? [lowerBinArrayIndex] : [lowerBinArrayIndex, upperBinArrayIndex];
+
+  // Always idempotent, so no RPC existence check is needed first — the on-chain instruction
+  // is itself a harmless no-op when the bin array already exists (create_bin_array.rs).
+  const createBinArraysIxs = await Promise.all(
+    binArrayIndices.map(async index => {
+      const [binArray] = await findBinArrayPda({ pool, index }, { programAddress });
+      return getCreateBinArrayInstructionAsync(
+        { payer: owner, pool, index, idempotent: true, binArray },
+        { programAddress },
+      );
+    }),
+  );
+
+  const openPositionIx = await getOpenPositionInstructionAsync({
+    pool,
+    lowerBinId,
+    upperBinId,
+    owner,
+    positionMint,
+    position,
+    adminConfig,
+    metadataUpdateAuthority,
+  }, { programAddress });
+
+  const instructions = [...createBinArraysIxs, openPositionIx];
+  return await buildTransactionMessage(rpc, { feePayer: owner, instructions }, options);
+}

package/src/actions/quote.ts

@@ -0,0 +1,70 @@
+import type { Address, TransactionSigner } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS, fetchAllMaybeBinArray } from "../generated";
+import { quote as computeQuote, type QuoteOutput } from "../quote";
+import { findSwapBinArrayAddresses } from "../utils/bin_array";
+import { getPool } from "./get_pool";
+import {
+  resolveMintInfo,
+  buildSwapTransactionMessage,
+  type TransactionMessageOptions,
+  type Rpc,
+} from "./helpers";
+
+export async function quote(
+  rpc: Rpc,
+  {
+    pool,
+    xToY,
+    amountIn,
+    slippageToleranceBps,
+  }: {
+    pool: Address,
+    amountIn: bigint,
+    xToY: boolean,
+    slippageToleranceBps: number,
+  },
+  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
+  options: TransactionMessageOptions = {},
+): Promise<{
+  quoteOutput: QuoteOutput,
+  swap: (user: TransactionSigner, options?: TransactionMessageOptions) => ReturnType<typeof buildSwapTransactionMessage>,
+}> {
+  const poolData = await getPool(rpc, pool, options);
+  const { activeBinId, tokenMintX, tokenMintY } = poolData;
+  const binArrayAddresses = await findSwapBinArrayAddresses(pool, activeBinId, xToY, programAddress);
+  const [maybeBinArrays, { transferFeeX, transferFeeY, tokenProgramX, tokenProgramY }] = await Promise.all([
+    fetchAllMaybeBinArray(rpc, binArrayAddresses, options),
+    resolveMintInfo(rpc, tokenMintX, tokenMintY, options),
+  ]);
+  const binArrays = maybeBinArrays.map(maybeBinArray => maybeBinArray.exists ? maybeBinArray.data : undefined);
+
+  const quoteOutput = await computeQuote({
+    amountIn,
+    xToY,
+    slippageToleranceBps,
+    now: BigInt(Math.floor(Date.now() / 1000)),
+    poolState: poolData,
+    inputTransferFee: xToY ? transferFeeX : transferFeeY,
+    outputTransferFee: xToY ? transferFeeY : transferFeeX,
+    binArrays,
+  });
+
+  return {
+    quoteOutput,
+    // Reuses the exact accounts (activeBinId, mints, bin arrays) this quote was computed
+    // against, so the built swap tx can't drift from what the caller inspected the quote
+    // against — and never re-resolves anything `buildSwapTransactionMessage` doesn't ask for.
+    swap: (user, options = {}) => buildSwapTransactionMessage(rpc, {
+      user,
+      pool,
+      xToY,
+      amountIn,
+      minAmountOut: quoteOutput.minAmountOut,
+      tokenMintX,
+      tokenMintY,
+      tokenProgramX,
+      tokenProgramY,
+      binArrayAddresses,
+    }, programAddress, options),
+  };
+}

package/src/actions/set_metadata_update_authority.ts

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

package/src/actions/set_pool_dynamic_fee_config.ts

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

package/src/actions/set_pool_protocol_share.ts

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

package/src/actions/swap.ts

@@ -0,0 +1,56 @@
+import type { Address, TransactionSigner } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS } from "../generated";
+import { findSwapBinArrayAddresses } from "../utils/bin_array";
+import {
+  resolveActiveBinAndMints,
+  resolveTokenMintsAndPrograms,
+  buildSwapTransactionMessage,
+  type TransactionMessageOptions,
+  type Rpc,
+} from "./helpers";
+
+export async function swap(
+  rpc: Rpc,
+  {
+    user,
+    pool,
+    activeBinId,
+    xToY,
+    amountIn,
+    minAmountOut,
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX,
+    tokenProgramY,
+  }: {
+    user: TransactionSigner,
+    pool: Address,
+    activeBinId?: number,
+    xToY: boolean,
+    amountIn: bigint,
+    minAmountOut: bigint,
+    tokenMintX?: Address,
+    tokenMintY?: Address,
+    tokenProgramX?: Address,
+    tokenProgramY?: Address,
+  },
+  programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS,
+  options: TransactionMessageOptions = {},
+) {
+  ({ activeBinId, tokenMintX, tokenMintY } = await resolveActiveBinAndMints(rpc, pool, { activeBinId, tokenMintX, tokenMintY }, options));
+
+  const [binArrayAddresses, tokenMintsAndPrograms] = await Promise.all([
+    findSwapBinArrayAddresses(pool, activeBinId, xToY, programAddress),
+    resolveTokenMintsAndPrograms(rpc, { pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY }, options),
+  ]);
+
+  return await buildSwapTransactionMessage(rpc, {
+    user,
+    pool,
+    xToY,
+    amountIn,
+    minAmountOut,
+    binArrayAddresses,
+    ...tokenMintsAndPrograms,
+  }, programAddress, options);
+}