@picon-finance/dlmm-sdk 1.0.0

package/src/actions/sync_pool.ts

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,87 @@
+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/events.ts

@@ -0,0 +1,279 @@
+// Hand-written event decoding — Codama's Anchor-IDL conversion (`@codama/nodes-from-anchor`)
+// currently drops the IDL's `events` field entirely, so there's nothing to generate this from
+// yet (confirmed: `SwapEvent` etc. don't even survive as plain defined types in the
+// intermediate Codama IDL, let alone get rendered). Once Codama adds event support, this file
+// should be deleted in favor of the generated equivalent — the codec style below matches
+// `generated/types/*.ts` exactly for that reason.
+import {
+  type Address,
+  getAddressDecoder,
+  getBase64Encoder,
+  getBooleanDecoder,
+  getI32Decoder,
+  getStructDecoder,
+  getU16Decoder,
+  getU32Decoder,
+  getU64Decoder,
+  type FixedSizeDecoder,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS } from "./generated";
+
+export type CreatePoolEvent = {
+  pool: Address;
+  binStep: number;
+  feeRate: number;
+  tokenMintX: Address;
+  tokenMintY: Address;
+};
+
+export type OpenPositionEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+};
+
+export type ClosePositionEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+};
+
+export type DepositEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+  amountX: bigint;
+  amountY: bigint;
+  transferFeeX: bigint;
+  transferFeeY: bigint;
+};
+
+export type WithdrawEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+  bpsRemoved: number;
+  amountX: bigint;
+  amountY: bigint;
+  transferFeeX: bigint;
+  transferFeeY: bigint;
+};
+
+export type ClaimFeeEvent = {
+  pool: Address;
+  position: Address;
+  owner: Address;
+  lowerBinId: number;
+  upperBinId: number;
+  amountX: bigint;
+  amountY: bigint;
+  transferFeeX: bigint;
+  transferFeeY: bigint;
+};
+
+export type SwapEvent = {
+  pool: Address;
+  xToY: boolean;
+  preBinId: number;
+  postBinId: number;
+  amountIn: bigint;
+  amountOut: bigint;
+  inputTransferFee: bigint;
+  outputTransferFee: bigint;
+  lpFee: bigint;
+  protocolFee: bigint;
+};
+
+function getCreatePoolEventDecoder(): FixedSizeDecoder<CreatePoolEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["binStep", getU16Decoder()],
+    ["feeRate", getU32Decoder()],
+    ["tokenMintX", getAddressDecoder()],
+    ["tokenMintY", getAddressDecoder()],
+  ]);
+}
+
+function getOpenPositionEventDecoder(): FixedSizeDecoder<OpenPositionEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["position", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["lowerBinId", getI32Decoder()],
+    ["upperBinId", getI32Decoder()],
+  ]);
+}
+
+function getClosePositionEventDecoder(): FixedSizeDecoder<ClosePositionEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["position", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["lowerBinId", getI32Decoder()],
+    ["upperBinId", getI32Decoder()],
+  ]);
+}
+
+function getDepositEventDecoder(): FixedSizeDecoder<DepositEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["position", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["lowerBinId", getI32Decoder()],
+    ["upperBinId", getI32Decoder()],
+    ["amountX", getU64Decoder()],
+    ["amountY", getU64Decoder()],
+    ["transferFeeX", getU64Decoder()],
+    ["transferFeeY", getU64Decoder()],
+  ]);
+}
+
+function getWithdrawEventDecoder(): FixedSizeDecoder<WithdrawEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["position", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["lowerBinId", getI32Decoder()],
+    ["upperBinId", getI32Decoder()],
+    ["bpsRemoved", getU16Decoder()],
+    ["amountX", getU64Decoder()],
+    ["amountY", getU64Decoder()],
+    ["transferFeeX", getU64Decoder()],
+    ["transferFeeY", getU64Decoder()],
+  ]);
+}
+
+function getClaimFeeEventDecoder(): FixedSizeDecoder<ClaimFeeEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["position", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["lowerBinId", getI32Decoder()],
+    ["upperBinId", getI32Decoder()],
+    ["amountX", getU64Decoder()],
+    ["amountY", getU64Decoder()],
+    ["transferFeeX", getU64Decoder()],
+    ["transferFeeY", getU64Decoder()],
+  ]);
+}
+
+function getSwapEventDecoder(): FixedSizeDecoder<SwapEvent> {
+  return getStructDecoder([
+    ["pool", getAddressDecoder()],
+    ["xToY", getBooleanDecoder()],
+    ["preBinId", getI32Decoder()],
+    ["postBinId", getI32Decoder()],
+    ["amountIn", getU64Decoder()],
+    ["amountOut", getU64Decoder()],
+    ["inputTransferFee", getU64Decoder()],
+    ["outputTransferFee", getU64Decoder()],
+    ["lpFee", getU64Decoder()],
+    ["protocolFee", getU64Decoder()],
+  ]);
+}
+
+// Discriminators are the first 8 bytes of sha256("event:<EventName>") — copied from the IDL's
+// `events` array (`ts-sdk/src/picon_dlmm.json`), same derivation Anchor uses for accounts.
+const DISCRIMINATORS = {
+  CreatePoolEvent: [177, 49, 12, 210, 160, 118, 167, 116],
+  OpenPositionEvent: [83, 43, 164, 147, 169, 87, 81, 172],
+  ClosePositionEvent: [198, 217, 115, 95, 191, 120, 142, 137],
+  DepositEvent: [120, 248, 61, 83, 31, 142, 107, 144],
+  WithdrawEvent: [22, 9, 133, 26, 160, 44, 71, 192],
+  ClaimFeeEvent: [173, 80, 235, 15, 116, 19, 144, 33],
+  SwapEvent: [64, 198, 205, 232, 38, 8, 113, 226],
+} as const satisfies Record<string, number[]>;
+
+export type DlmmEvent =
+  | { name: "CreatePoolEvent", data: CreatePoolEvent }
+  | { name: "OpenPositionEvent", data: OpenPositionEvent }
+  | { name: "ClosePositionEvent", data: ClosePositionEvent }
+  | { name: "DepositEvent", data: DepositEvent }
+  | { name: "WithdrawEvent", data: WithdrawEvent }
+  | { name: "ClaimFeeEvent", data: ClaimFeeEvent }
+  | { name: "SwapEvent", data: SwapEvent };
+
+const DECODERS: { [K in DlmmEvent["name"]]: FixedSizeDecoder<Extract<DlmmEvent, { name: K }>["data"]> } = {
+  CreatePoolEvent: getCreatePoolEventDecoder(),
+  OpenPositionEvent: getOpenPositionEventDecoder(),
+  ClosePositionEvent: getClosePositionEventDecoder(),
+  DepositEvent: getDepositEventDecoder(),
+  WithdrawEvent: getWithdrawEventDecoder(),
+  ClaimFeeEvent: getClaimFeeEventDecoder(),
+  SwapEvent: getSwapEventDecoder(),
+};
+
+const PROGRAM_DATA_PREFIX = "Program data: ";
+
+// `emit!` (not `emit_cpi!`) writes each event as a `Program data: <base64>` log line — the
+// base64 payload is [8-byte discriminator][borsh-encoded fields], same layout as an account.
+function decodeEventBytes(bytes: ReadonlyUint8Array): DlmmEvent | undefined {
+  const discriminator = bytes.subarray(0, 8);
+  const body = bytes.subarray(8);
+
+  for (const name of Object.keys(DISCRIMINATORS) as DlmmEvent["name"][]) {
+    const expected = DISCRIMINATORS[name];
+    if (expected.every((byte, i) => byte === discriminator[i])) {
+      return { name, data: DECODERS[name].decode(body) } as DlmmEvent;
+    }
+  }
+
+  return undefined;
+}
+
+// Decodes a single `Program data: ...` log line, or returns undefined if the line isn't one
+// (or belongs to an event this SDK doesn't know about).
+export function decodeEventFromLogLine(logLine: string): DlmmEvent | undefined {
+  if (!logLine.startsWith(PROGRAM_DATA_PREFIX)) {
+    return undefined;
+  }
+  const base64Payload = logLine.slice(PROGRAM_DATA_PREFIX.length);
+  const bytes = getBase64Encoder().encode(base64Payload);
+  return decodeEventBytes(bytes);
+}
+
+// Matches the "Program <address> invoke [<depth>]" / "Program <address> success"/"failed"
+// bracket Solana emits around every top-level call and CPI.
+const INVOKE_LOG = /^Program (\w+) invoke \[\d+\]$/;
+const RESULT_LOG = /^Program (\w+) (?:success|failed)/;
+
+// Decodes every recognized event out of a transaction's full log array, in log order —
+// scoped to lines logged while this program is the currently-executing one, tracked via the
+// invoke/success bracket above. Without this, a "Program data:" line from a CPI'd program that
+// happens to emit an identically-named (and thus identically-discriminated, since Anchor
+// derives discriminators from the event name alone) event would be mis-decoded as ours, or
+// throw if its body doesn't match our layout.
+export function decodeEventsFromLogs(logs: readonly string[], programAddress: Address = PICON_DLMM_PROGRAM_ADDRESS): DlmmEvent[] {
+  const events: DlmmEvent[] = [];
+  const programStack: string[] = [];
+
+  for (const line of logs) {
+    const invokeMatch = INVOKE_LOG.exec(line);
+    if (invokeMatch !== null) {
+      programStack.push(invokeMatch[1]);
+      continue;
+    }
+    if (RESULT_LOG.test(line)) {
+      programStack.pop();
+      continue;
+    }
+    if (programStack[programStack.length - 1] !== programAddress) {
+      continue;
+    }
+
+    const event = decodeEventFromLogLine(line);
+    if (event !== undefined) {
+      events.push(event);
+    }
+  }
+  return events;
+}

package/src/generated/accounts/adminConfig.ts

@@ -0,0 +1,147 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  transformEncoder,
+  type Account,
+  type Address,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+
+export const ADMIN_CONFIG_DISCRIMINATOR: ReadonlyUint8Array = new Uint8Array([
+  156, 10, 79, 161, 71, 9, 62, 77,
+]);
+
+export function getAdminConfigDiscriminatorBytes(): ReadonlyUint8Array {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(
+    ADMIN_CONFIG_DISCRIMINATOR,
+  );
+}
+
+export type AdminConfig = {
+  discriminator: ReadonlyUint8Array;
+  authority: Address;
+  pendingAuthority: Address;
+  metadataUpdateAuthority: Address;
+};
+
+export type AdminConfigArgs = {
+  authority: Address;
+  pendingAuthority: Address;
+  metadataUpdateAuthority: Address;
+};
+
+/** Gets the encoder for {@link AdminConfigArgs} account data. */
+export function getAdminConfigEncoder(): FixedSizeEncoder<AdminConfigArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["authority", getAddressEncoder()],
+      ["pendingAuthority", getAddressEncoder()],
+      ["metadataUpdateAuthority", getAddressEncoder()],
+    ]),
+    (value) => ({ ...value, discriminator: ADMIN_CONFIG_DISCRIMINATOR }),
+  );
+}
+
+/** Gets the decoder for {@link AdminConfig} account data. */
+export function getAdminConfigDecoder(): FixedSizeDecoder<AdminConfig> {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["authority", getAddressDecoder()],
+    ["pendingAuthority", getAddressDecoder()],
+    ["metadataUpdateAuthority", getAddressDecoder()],
+  ]);
+}
+
+/** Gets the codec for {@link AdminConfig} account data. */
+export function getAdminConfigCodec(): FixedSizeCodec<
+  AdminConfigArgs,
+  AdminConfig
+> {
+  return combineCodec(getAdminConfigEncoder(), getAdminConfigDecoder());
+}
+
+export function decodeAdminConfig<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<AdminConfig, TAddress>;
+export function decodeAdminConfig<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<AdminConfig, TAddress>;
+export function decodeAdminConfig<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<AdminConfig, TAddress> | MaybeAccount<AdminConfig, TAddress> {
+  return decodeAccount(
+    encodedAccount as MaybeEncodedAccount<TAddress>,
+    getAdminConfigDecoder(),
+  );
+}
+
+export async function fetchAdminConfig<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<AdminConfig, TAddress>> {
+  const maybeAccount = await fetchMaybeAdminConfig(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeAdminConfig<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<AdminConfig, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeAdminConfig(maybeAccount);
+}
+
+export async function fetchAllAdminConfig(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<AdminConfig>[]> {
+  const maybeAccounts = await fetchAllMaybeAdminConfig(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeAdminConfig(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<AdminConfig>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAdminConfig(maybeAccount));
+}
+
+export function getAdminConfigSize(): number {
+  return 104;
+}