@picon-finance/dlmm-sdk 1.0.0

package/dist/utils/ata.js

@@ -0,0 +1,113 @@
+import { address, } from "@solana/kit";
+import { findAssociatedTokenPda, getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction, getSyncNativeInstruction, TOKEN_PROGRAM_ADDRESS, } from "@solana-program/token";
+import { findAssociatedTokenPda as findAssociatedToken2022Pda, getCreateAssociatedTokenIdempotentInstruction as getCreateAssociatedToken2022IdempotentInstruction, TOKEN_2022_PROGRAM_ADDRESS } from "@solana-program/token-2022";
+import { getTransferSolInstruction } from "@solana-program/system";
+export const NATIVE_MINT_ADDRESS = address("So11111111111111111111111111111111111111112");
+export async function findAssociatedTokenPdaByTokenProgram(params) {
+    const findAssociatedTokenPda = chooseFindAssociatedTokenPda(params.tokenProgram);
+    const [ata] = await findAssociatedTokenPda(params);
+    return ata;
+}
+// Position NFTs are always Token2022 — shared by every position-scoped instruction
+// (open_position, close_position, withdraw, claim_fee, claim_multiple_fees, deposit_by_weight).
+export function findPositionTokenAccount({ owner, positionMint, }) {
+    return findAssociatedTokenPdaByTokenProgram({ owner, mint: positionMint, tokenProgram: TOKEN_2022_PROGRAM_ADDRESS });
+}
+// A pool's X/Y vaults — shared by every instruction that moves tokens through a pool
+// (withdraw, claim_fee, claim_multiple_fees, claim_protocol_fee, deposit_by_weight, swap).
+export async function findPoolTokenVaults({ pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, }) {
+    const [tokenVaultX, tokenVaultY] = await Promise.all([
+        findAssociatedTokenPdaByTokenProgram({ owner: pool, mint: tokenMintX, tokenProgram: tokenProgramX }),
+        findAssociatedTokenPdaByTokenProgram({ owner: pool, mint: tokenMintY, tokenProgram: tokenProgramY }),
+    ]);
+    return { tokenVaultX, tokenVaultY };
+}
+export function processAssociatedTokenAccount(params) {
+    if (params.mint === NATIVE_MINT_ADDRESS) {
+        return processWsolAssociatedTokenAccount(params);
+    }
+    else {
+        return processRegularAssociatedTokenAccount(params);
+    }
+}
+// Shared by every instruction that moves both X and Y through a single owner's ATAs
+// (swap, withdraw, claim_fee, claim_protocol_fee, deposit_by_weight, claim_multiple_fees) —
+// processes both sides and flattens their pre/post instructions in X-then-Y order.
+export async function processAssociatedTokenAccountPair({ owner, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, amountX, amountY, }) {
+    const [x, y] = await Promise.all([
+        processAssociatedTokenAccount({ owner, mint: tokenMintX, amount: amountX, tokenProgram: tokenProgramX }),
+        processAssociatedTokenAccount({ owner, mint: tokenMintY, amount: amountY, tokenProgram: tokenProgramY }),
+    ]);
+    return {
+        ataX: x.ata,
+        ataY: y.ata,
+        preInstructions: [...x.preInstructions, ...y.preInstructions],
+        postInstructions: [...x.postInstructions, ...y.postInstructions],
+    };
+}
+async function processWsolAssociatedTokenAccount({ owner, amount, tokenProgram, }) {
+    if (tokenProgram !== TOKEN_PROGRAM_ADDRESS) {
+        throw new Error("Invalid program for wSOL");
+    }
+    const { ata, instructions: wrapIxs } = await getWrapWsolInstructions(owner, amount);
+    const unwrapIx = getUnwrapWsolInstruction(owner, ata);
+    return {
+        ata,
+        preInstructions: wrapIxs,
+        postInstructions: [unwrapIx],
+    };
+}
+async function processRegularAssociatedTokenAccount({ owner, mint, tokenProgram, }) {
+    const [findAssociatedTokenPda, getCreateAssociatedTokenIdempotentInstruction] = choosePdaFunctions(tokenProgram);
+    const [ata] = await findAssociatedTokenPda({ mint, owner: owner.address, tokenProgram });
+    const createAtaIx = getCreateAssociatedTokenIdempotentInstruction({ ata, mint, owner: owner.address, payer: owner, tokenProgram });
+    return {
+        ata,
+        preInstructions: [createAtaIx],
+        postInstructions: [],
+    };
+}
+function choosePdaFunctions(tokenProgram) {
+    switch (tokenProgram) {
+        case TOKEN_PROGRAM_ADDRESS: return [findAssociatedTokenPda, getCreateAssociatedTokenIdempotentInstruction];
+        case TOKEN_2022_PROGRAM_ADDRESS: return [findAssociatedToken2022Pda, getCreateAssociatedToken2022IdempotentInstruction];
+        default: throw new Error(`Unsupported token program: ${tokenProgram}`);
+    }
+}
+function chooseFindAssociatedTokenPda(tokenProgram) {
+    return choosePdaFunctions(tokenProgram)[0];
+}
+async function getWrapWsolInstructions(owner, amount) {
+    const [ata] = await findAssociatedTokenPda({
+        mint: NATIVE_MINT_ADDRESS,
+        owner: owner.address,
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    });
+    const instructions = [
+        getCreateAssociatedTokenIdempotentInstruction({
+            ata,
+            mint: NATIVE_MINT_ADDRESS,
+            owner: owner.address,
+            payer: owner,
+            tokenProgram: TOKEN_PROGRAM_ADDRESS,
+        }),
+        ...(amount
+            ? [
+                getTransferSolInstruction({
+                    source: owner,
+                    destination: ata,
+                    amount,
+                }),
+                getSyncNativeInstruction({ account: ata }),
+            ]
+            : []),
+    ];
+    return { ata, instructions };
+}
+function getUnwrapWsolInstruction(owner, ata) {
+    return getCloseAccountInstruction({
+        account: ata,
+        destination: owner.address,
+        owner,
+    });
+}

package/dist/utils/bin_array.d.ts

@@ -0,0 +1,8 @@
+import { type Address } from "@solana/kit";
+export declare function findBinArrayAddresses(pool: Address, indices: number[], programAddress: Address): Promise<Address[]>;
+export declare function findSwapBinArrayAddresses(pool: Address, activeBinId: number, xToY: boolean, programAddress: Address): Promise<Address[]>;
+export declare function findPositionBinArrayAddresses(pool: Address, lowerBinId: number, upperBinId: number, programAddress: Address): Promise<{
+    lowerBinArray: Address;
+    upperBinArray?: Address;
+}>;
+//# sourceMappingURL=bin_array.d.ts.map

package/dist/utils/bin_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin_array.d.ts","sourceRoot":"","sources":["../../src/utils/bin_array.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAS3C,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEzH;AAID,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,EACb,cAAc,EAAE,OAAO,GACtB,OAAO,CAAC,OAAO,EAAE,CAAC,CAGpB;AAMD,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,OAAO,GACtB,OAAO,CAAC;IAAE,aAAa,EAAE,OAAO,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAU9D"}

package/dist/utils/bin_array.js

@@ -0,0 +1,29 @@
+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, indices, programAddress) {
+    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, activeBinId, xToY, programAddress) {
+    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, lowerBinId, upperBinId, programAddress) {
+    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/dist/utils/bin_location.d.ts

@@ -0,0 +1,11 @@
+export declare function getBinArrayIndex(binId: number): number;
+export declare function getBinIndex(binId: number): number;
+export declare function getBinId(binArrayIndex: number, binIndex: number): number;
+export declare function getBinArrayIndexSequence(lowerBinArrayIndex: number, upperBinArrayIndex: number): number[];
+export declare function getPositionBinArrayIndices(lowerBinId: number, upperBinId: number): {
+    lowerBinArrayIndex: number;
+    upperBinArrayIndex?: number;
+};
+export declare function generateBinArrayIndicesForSwap(activeBinId: number, xToY: boolean, maxBinArrays: number): number[];
+export declare function generateBinArrayIndicesForSync(activeBinId: number, desiredBinId: number, maxBinArrays: number): number[];
+//# sourceMappingURL=bin_location.d.ts.map

package/dist/utils/bin_location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin_location.d.ts","sourceRoot":"","sources":["../../src/utils/bin_location.ts"],"names":[],"mappings":"AAEA,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAExE;AAED,wBAAgB,wBAAwB,CACtC,kBAAkB,EAAE,MAAM,EAC1B,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,CAKV;AAMD,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB;IAAE,kBAAkB,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,CAM7D;AAKD,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,EACb,YAAY,EAAE,MAAM,GACnB,MAAM,EAAE,CAMV;AAOD,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,MAAM,EAAE,CAeV"}

package/dist/utils/bin_location.js

@@ -0,0 +1,55 @@
+import { BINS_PER_BIN_ARRAY } from "./constants";
+export function getBinArrayIndex(binId) {
+    return Math.floor(binId / BINS_PER_BIN_ARRAY);
+}
+export function getBinIndex(binId) {
+    return ((binId % BINS_PER_BIN_ARRAY) + BINS_PER_BIN_ARRAY) % BINS_PER_BIN_ARRAY;
+}
+export function getBinId(binArrayIndex, binIndex) {
+    return binArrayIndex * BINS_PER_BIN_ARRAY + binIndex;
+}
+export function getBinArrayIndexSequence(lowerBinArrayIndex, upperBinArrayIndex) {
+    return Array.from({ length: upperBinArrayIndex - lowerBinArrayIndex + 1 }, (_, i) => lowerBinArrayIndex + i);
+}
+// A position spans at most MAX_BIN_ARRAYS_PER_POSITION (2) bin arrays — the lower and
+// (only if distinct) upper one covering its range. Shared by every position-scoped
+// instruction that needs to enumerate exactly those arrays (open_position's bin-array
+// bootstrap, withdraw/claim_fee's account derivation).
+export function getPositionBinArrayIndices(lowerBinId, upperBinId) {
+    const lowerBinArrayIndex = getBinArrayIndex(lowerBinId);
+    const upperBinArrayIndex = getBinArrayIndex(upperBinId);
+    return lowerBinArrayIndex === upperBinArrayIndex
+        ? { lowerBinArrayIndex }
+        : { lowerBinArrayIndex, upperBinArrayIndex };
+}
+// One bin array of margin is kept on the opposite side of travel: if the live active bin
+// drifts one array against the expected direction between quote time and execution (e.g. a
+// competing swap lands first), it's still covered by this range instead of reverting.
+export function generateBinArrayIndicesForSwap(activeBinId, xToY, maxBinArrays) {
+    const activeBinArrayIndex = getBinArrayIndex(activeBinId);
+    const [lowerBinArrayIndex, upperBinArrayIndex] = xToY
+        ? [activeBinArrayIndex - (maxBinArrays - 2), activeBinArrayIndex + 1]
+        : [activeBinArrayIndex - 1, activeBinArrayIndex + (maxBinArrays - 2)];
+    return getBinArrayIndexSequence(lowerBinArrayIndex, upperBinArrayIndex);
+}
+// Spans from the live `activeBinId` to the caller's exact `desiredBinId` target, plus one
+// bin array of margin beyond the active end (the side subject to drift — `desiredBinId` is
+// a fixed target, but the live active bin could move further away from it before this tx
+// lands). Capped at `maxBinArrays`, trimming from the `desiredBinId` end so the active+margin
+// anchor stays intact — a sync toward a distant target simply converges partially in that case.
+export function generateBinArrayIndicesForSync(activeBinId, desiredBinId, maxBinArrays) {
+    const activeBinArrayIndex = getBinArrayIndex(activeBinId);
+    const desiredBinArrayIndex = getBinArrayIndex(desiredBinId);
+    const xToY = desiredBinId <= activeBinId;
+    let lowerBinArrayIndex;
+    let upperBinArrayIndex;
+    if (xToY) {
+        upperBinArrayIndex = activeBinArrayIndex + 1;
+        lowerBinArrayIndex = Math.max(desiredBinArrayIndex, upperBinArrayIndex - maxBinArrays + 1);
+    }
+    else {
+        lowerBinArrayIndex = activeBinArrayIndex - 1;
+        upperBinArrayIndex = Math.min(desiredBinArrayIndex, lowerBinArrayIndex + maxBinArrays - 1);
+    }
+    return getBinArrayIndexSequence(lowerBinArrayIndex, upperBinArrayIndex);
+}

package/dist/utils/chunk.d.ts

@@ -0,0 +1,2 @@
+export declare function chunk<T>(items: T[], size: number): T[][];
+//# sourceMappingURL=chunk.d.ts.map

package/dist/utils/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../src/utils/chunk.ts"],"names":[],"mappings":"AAAA,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAMxD"}

package/dist/utils/chunk.js

@@ -0,0 +1,7 @@
+export function chunk(items, size) {
+    const chunks = [];
+    for (let i = 0; i < items.length; i += size) {
+        chunks.push(items.slice(i, i + size));
+    }
+    return chunks;
+}

package/dist/utils/compute_budget.d.ts

@@ -0,0 +1,11 @@
+import { createSolanaRpc, estimateComputeUnitLimitFactory, type TransactionMessage, type TransactionMessageWithFeePayer } from "@solana/kit";
+export declare function withComputeBudget<TTransactionMessage extends TransactionMessage>(message: TTransactionMessage, { computeUnitLimit, computeUnitPrice, }?: {
+    computeUnitLimit?: number;
+    computeUnitPrice?: bigint;
+}): TTransactionMessage;
+export declare function withEstimatedComputeBudget<TTransactionMessage extends TransactionMessage & TransactionMessageWithFeePayer>(rpc: ReturnType<typeof createSolanaRpc>, message: TTransactionMessage, { estimateComputeUnitPrice, estimateComputeUnitLimit, bufferFactor, }?: {
+    estimateComputeUnitPrice?: bigint | ((computeUnitLimit: number) => bigint);
+    estimateComputeUnitLimit?: ReturnType<typeof estimateComputeUnitLimitFactory>;
+    bufferFactor?: number;
+}): Promise<TTransactionMessage>;
+//# sourceMappingURL=compute_budget.d.ts.map

package/dist/utils/compute_budget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_budget.d.ts","sourceRoot":"","sources":["../../src/utils/compute_budget.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,eAAe,EACf,+BAA+B,EAE/B,KAAK,kBAAkB,EACvB,KAAK,8BAA8B,EACpC,MAAM,aAAa,CAAC;AAGrB,wBAAgB,iBAAiB,CAAC,mBAAmB,SAAS,kBAAkB,EAC9E,OAAO,EAAE,mBAAmB,EAC5B,EACE,gBAAgB,EAChB,gBAAgB,GACjB,GAAE;IACD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACtB,GACL,mBAAmB,CAMrB;AAED,wBAAsB,0BAA0B,CAC9C,mBAAmB,SAAS,kBAAkB,GAAG,8BAA8B,EAE/E,GAAG,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,EACvC,OAAO,EAAE,mBAAmB,EAC5B,EACE,wBAAwB,EACxB,wBAAwB,EACxB,YAAkB,GACnB,GAAE;IACD,wBAAwB,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,gBAAgB,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAC3E,wBAAwB,CAAC,EAAE,UAAU,CAAC,OAAO,+BAA+B,CAAC,CAAC;IAC9E,YAAY,CAAC,EAAE,MAAM,CAAC;CAClB,GACL,OAAO,CAAC,mBAAmB,CAAC,CAa9B"}

package/dist/utils/compute_budget.js

@@ -0,0 +1,22 @@
+import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from "@solana-program/compute-budget";
+import { estimateComputeUnitLimitFactory, prependTransactionMessageInstructions, } from "@solana/kit";
+import { isUndefined } from "./type_guards";
+export function withComputeBudget(message, { computeUnitLimit, computeUnitPrice, } = {}) {
+    const ixs = [
+        ...(isUndefined(computeUnitLimit) ? [] : [getSetComputeUnitLimitInstruction({ units: computeUnitLimit })]),
+        ...(isUndefined(computeUnitPrice) ? [] : [getSetComputeUnitPriceInstruction({ microLamports: computeUnitPrice })]),
+    ];
+    return prependTransactionMessageInstructions(ixs, message);
+}
+export async function withEstimatedComputeBudget(rpc, message, { estimateComputeUnitPrice, estimateComputeUnitLimit, bufferFactor = 1.1, } = {}) {
+    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,
+    });
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const BINS_PER_BIN_ARRAY: number;
+export declare const MAX_BIN_ARRAYS_PER_POSITION: number;
+export declare const MAX_BIN_ARRAYS_PER_SWAP: number;
+export declare const MAX_BIN_ARRAYS_PER_SYNC: number;
+export declare const FEE_PRECISION: number;
+export declare const ONE_BPS_FEE_RATE: number;
+export declare const MAX_FEE_RATE: number;
+export declare const MAX_PROTOCOL_SHARE: number;
+export declare const MAX_BASIS_POINTS: number;
+export declare const MAX_POSITIONS_PER_CLAIM = 3;
+export declare const MAX_ACCOUNTS_PER_RPC_BATCH = 100;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/utils/constants.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,kBAAkB,QAAuC,CAAC;AACvE,eAAO,MAAM,2BAA2B,QAAgD,CAAC;AACzF,eAAO,MAAM,uBAAuB,QAA4C,CAAC;AACjF,eAAO,MAAM,uBAAuB,QAA4C,CAAC;AAEjF,eAAO,MAAM,aAAa,QAAkC,CAAC;AAC7D,eAAO,MAAM,gBAAgB,QAAqC,CAAC;AACnE,eAAO,MAAM,YAAY,QAAiC,CAAC;AAC3D,eAAO,MAAM,kBAAkB,QAAuC,CAAC;AACvE,eAAO,MAAM,gBAAgB,QAAqC,CAAC;AAEnE,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAGzC,eAAO,MAAM,0BAA0B,MAAM,CAAC"}

package/dist/utils/constants.js

@@ -0,0 +1,20 @@
+import IDL from "./../picon_dlmm.json";
+import { isUndefined } from "./type_guards";
+function getIdlConstant(name) {
+    const constant = IDL.constants.find(c => c.name === name);
+    if (isUndefined(constant))
+        throw new Error(`${name} constant not found in IDL`);
+    return Number.parseInt(constant.value);
+}
+export const BINS_PER_BIN_ARRAY = getIdlConstant("BINS_PER_BIN_ARRAY");
+export const MAX_BIN_ARRAYS_PER_POSITION = getIdlConstant("MAX_BIN_ARRAYS_PER_POSITION");
+export const MAX_BIN_ARRAYS_PER_SWAP = getIdlConstant("MAX_BIN_ARRAYS_PER_SWAP");
+export const MAX_BIN_ARRAYS_PER_SYNC = getIdlConstant("MAX_BIN_ARRAYS_PER_SYNC");
+export const FEE_PRECISION = getIdlConstant("FEE_PRECISION");
+export const ONE_BPS_FEE_RATE = getIdlConstant("ONE_BPS_FEE_RATE");
+export const MAX_FEE_RATE = getIdlConstant("MAX_FEE_RATE");
+export const MAX_PROTOCOL_SHARE = getIdlConstant("MAX_PROTOCOL_SHARE");
+export const MAX_BASIS_POINTS = getIdlConstant("MAX_BASIS_POINTS");
+export const MAX_POSITIONS_PER_CLAIM = 3;
+// Solana RPC's own hard cap on addresses per getMultipleAccounts request.
+export const MAX_ACCOUNTS_PER_RPC_BATCH = 100;

package/dist/utils/transfer_fee.d.ts

@@ -0,0 +1,4 @@
+import { type Mint } from "@solana-program/token-2022";
+import type { TransferFee } from "../quote";
+export declare function resolveTransferFee(mint: Mint, epoch: bigint): TransferFee | undefined;
+//# sourceMappingURL=transfer_fee.d.ts.map

package/dist/utils/transfer_fee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer_fee.d.ts","sourceRoot":"","sources":["../../src/utils/transfer_fee.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAkB,MAAM,4BAA4B,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAW5C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAerF"}

package/dist/utils/transfer_fee.js

@@ -0,0 +1,21 @@
+import { unwrapOption } from "@solana/kit";
+function isTransferFeeConfig(extension) {
+    return extension.__kind === "TransferFeeConfig";
+}
+// TransferFeeConfig carries two rates — olderTransferFee/newerTransferFee — so the
+// program can phase in a fee change without retroactively affecting in-flight swaps.
+// newerTransferFee takes effect once the current epoch reaches its `epoch` field.
+export function resolveTransferFee(mint, epoch) {
+    const extensions = unwrapOption(mint.extensions) ?? [];
+    const transferFeeConfig = extensions.find(isTransferFeeConfig);
+    if (!transferFeeConfig) {
+        return undefined;
+    }
+    const activeTransferFee = epoch >= transferFeeConfig.newerTransferFee.epoch
+        ? transferFeeConfig.newerTransferFee
+        : transferFeeConfig.olderTransferFee;
+    return {
+        feeBps: activeTransferFee.transferFeeBasisPoints,
+        maxFee: activeTransferFee.maximumFee,
+    };
+}

package/dist/utils/type_guards.d.ts

@@ -0,0 +1,2 @@
+export declare function isUndefined<T>(value: T | undefined): value is undefined;
+//# sourceMappingURL=type_guards.d.ts.map

package/dist/utils/type_guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type_guards.d.ts","sourceRoot":"","sources":["../../src/utils/type_guards.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,KAAK,IAAI,SAAS,CAEvE"}

package/dist/utils/type_guards.js

@@ -0,0 +1,3 @@
+export function isUndefined(value) {
+    return value === undefined;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@picon-finance/dlmm-sdk",
+  "version": "1.0.0",
+  "description": "Typescript SDK for interacting with the Picon DLMM protocol",
+  "author": "Picon Finance",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "imports": {
+    "#wasm": {
+      "bun": "./src/quote/wasm-node-loader.ts",
+      "browser": "./dist/quote/wasm-web-loader.js",
+      "node": "./dist/quote/wasm-node-loader.js",
+      "default": "./dist/quote/wasm-node-loader.js"
+    }
+  },
+  "files": [
+    "./dist/",
+    "./src/"
+  ],
+  "scripts": {
+    "clean": "rm -rf ./dist/",
+    "generate-mainnet-idl": "cd .. && anchor run idl-mainnet",
+    "copy-idl": "bun run generate-mainnet-idl && cp ../target/deploy-mainnet/picon_dlmm.json ./src/picon_dlmm.json",
+    "codama-generate-js": "bun run copy-idl && npx codama run js",
+    "build-wasm-crate": "cargo build -p picon-dlmm-quote --target wasm32-unknown-unknown --no-default-features --features wasm --release",
+    "clean-wasm": "rm -rf ./src/quote/wasm-node/* ./src/quote/wasm-web/*",
+    "build-wasm-bindings-node": "wasm-bindgen ../target/wasm32-unknown-unknown/release/picon_dlmm_quote.wasm --out-dir ./src/quote/wasm-node --target experimental-nodejs-module --typescript",
+    "build-wasm-bindings-web": "wasm-bindgen ../target/wasm32-unknown-unknown/release/picon_dlmm_quote.wasm --out-dir ./src/quote/wasm-web --target web --typescript",
+    "build-wasm": "bun run build-wasm-crate && bun run clean-wasm && bun run build-wasm-bindings-node && bun run build-wasm-bindings-web",
+    "copy-wasm-binaries": "cp ./src/quote/wasm-node/*.wasm ./dist/quote/wasm-node/ && cp ./src/quote/wasm-web/*.wasm ./dist/quote/wasm-web/",
+    "compile": "bun run clean && npx tsc && bun run copy-wasm-binaries",
+    "build": "bun run codama-generate-js && bun run build-wasm && bun run compile",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@solana-program/compute-budget": "^0.16.0",
+    "@solana-program/loader-v3": "^0.4.0",
+    "@solana-program/system": "^0.12.2",
+    "@solana-program/token": "^0.14.0",
+    "@solana-program/token-2022": "^0.12.0",
+    "@solana/kit": "^6.10.0",
+    "@solana/program-client-core": "^6.10.0",
+    "@solana/transaction-messages": "^6.10.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@codama/nodes-from-anchor": "^1.5.1",
+    "@codama/renderers-js": "^2.3.0",
+    "codama": "^1.8.0"
+  }
+}

package/src/actions/accept_admin_authority.ts

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

package/src/actions/claim_fee.ts

@@ -0,0 +1,84 @@
+import type { Address, TransactionSigner } from "@solana/kit";
+import { PICON_DLMM_PROGRAM_ADDRESS, findPositionPda, getClaimFeeInstruction } 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 claimFee(
+  rpc: Rpc,
+  {
+    owner,
+    positionMint,
+    lowerBinId,
+    upperBinId,
+    pool,
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX,
+    tokenProgramY,
+  }: {
+    owner: TransactionSigner,
+    positionMint: Address,
+    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 claimFeeIx = getClaimFeeInstruction({
+    owner,
+    pool,
+    position,
+    positionTokenAccount,
+    ...tokenMintsAndPrograms,
+    tokenOwnerAccountX,
+    tokenOwnerAccountY,
+    tokenVaultX,
+    tokenVaultY,
+    lowerBinArray,
+    upperBinArray,
+    lowerBinId,
+    upperBinId,
+  }, { programAddress });
+
+  const instructions = [
+    ...preInstructionsAta,
+    claimFeeIx,
+    ...postInstructionsAta,
+  ];
+  return await buildTransactionMessage(rpc, { feePayer: owner, instructions }, options);
+}