@picon-finance/dlmm-sdk 1.2.0 → 1.4.0

package/src/utils/bin_location.ts

@@ -1,5 +1,10 @@
 import { BINS_PER_BIN_ARRAY } from "./constants";
 
+export type BinIdRange = {
+  lowerBinId: number,
+  upperBinId: number,
+};
+
 export function getBinArrayIndex(binId: number): number {
   return Math.floor(binId / BINS_PER_BIN_ARRAY);
 }
@@ -22,10 +27,6 @@ export function getBinArrayIndexSequence(
   );
 }
 
-// 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: number,
   upperBinId: number,
@@ -37,9 +38,6 @@ export function getPositionBinArrayIndices(
     : { 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: number,
   xToY: boolean,
@@ -52,11 +50,6 @@ export function generateBinArrayIndicesForSwap(
   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: number,
   desiredBinId: number,

package/src/utils/chunk.ts

@@ -5,3 +5,12 @@ export function chunk<T>(items: T[], size: number): T[][] {
   }
   return chunks;
 }
+
+export async function fetchInChunks<T, R>(
+  items: T[],
+  size: number,
+  fetcher: (chunkItems: T[]) => Promise<R[]>,
+): Promise<R[]> {
+  const chunks = await Promise.all(chunk(items, size).map(fetcher));
+  return chunks.flat();
+}

package/src/utils/type_guards.ts

@@ -1,3 +1,15 @@
+import { type Account } from "@solana/kit";
+
 export function isUndefined<T>(value: T | undefined): value is undefined {
   return value === undefined;
 }
+
+export function isAccount<TData extends object>(value: any): value is Account<TData> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    "address" in value &&
+    "data" in value &&
+    "executable" in value
+  );
+}

package/dist/actions/accept_admin_authority.d.ts

@@ -1,13 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare function acceptAdminAuthority(rpc: Rpc, { pendingAuthority }: {
-    pendingAuthority: TransactionSigner;
-}, programAddress?: Address, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=accept_admin_authority.d.ts.map

package/dist/actions/accept_admin_authority.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"accept_admin_authority.d.ts","sourceRoot":"","sources":["../../src/actions/accept_admin_authority.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,EAAsD,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAEzH,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,GAAG,EACR,EAAE,gBAAgB,EAAE,EAAE;IAAE,gBAAgB,EAAE,iBAAiB,CAAA;CAAE,EAC7D,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAQxC"}

package/dist/actions/accept_admin_authority.js

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

package/dist/actions/claim_fee.d.ts

@@ -1,21 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare 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, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=claim_fee.d.ts.map

package/dist/actions/claim_fee.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claim_fee.d.ts","sourceRoot":"","sources":["../../src/actions/claim_fee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAI9D,OAAO,EAIL,KAAK,yBAAyB,EAC9B,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAEnB,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,GAAG,EACR,EACE,KAAK,EACL,YAAY,EACZ,UAAU,EACV,UAAU,EACV,IAAI,EACJ,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,EAAE;IACD,KAAK,EAAE,iBAAiB,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NA+CxC"}

package/dist/actions/claim_fee.js

@@ -1,40 +0,0 @@
-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, } from "./helpers";
-export async function claimFee(rpc, { owner, positionMint, lowerBinId, upperBinId, pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    ({ 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);
-}

package/dist/actions/claim_multiple_fees.d.ts

@@ -1,19 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare 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, options?: TransactionMessageOptions): Promise<(() => Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>)[]>;
-//# sourceMappingURL=claim_multiple_fees.d.ts.map

package/dist/actions/claim_multiple_fees.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claim_multiple_fees.d.ts","sourceRoot":"","sources":["../../src/actions/claim_multiple_fees.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAO9D,OAAO,EAGL,KAAK,yBAAyB,EAC9B,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAWnB,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,GAAG,EACR,EACE,KAAK,EACL,aAAa,EACb,IAAI,EACJ,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,EAAE;IACD,KAAK,EAAE,iBAAiB,CAAC;IACzB,aAAa,EAAE,OAAO,EAAE,CAAC;IACzB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;gOA+ExC"}

package/dist/actions/claim_multiple_fees.js

@@ -1,81 +0,0 @@
-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, } 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, { owner, positionMints, pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    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/dist/actions/claim_protocol_fee.d.ts

@@ -1,18 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare function claimProtocolFee(rpc: Rpc, { authority, pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, }: {
-    authority: TransactionSigner;
-    pool: Address;
-    tokenMintX?: Address;
-    tokenMintY?: Address;
-    tokenProgramX?: Address;
-    tokenProgramY?: Address;
-}, programAddress?: Address, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=claim_protocol_fee.d.ts.map

package/dist/actions/claim_protocol_fee.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claim_protocol_fee.d.ts","sourceRoot":"","sources":["../../src/actions/claim_protocol_fee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAG9D,OAAO,EAIL,KAAK,yBAAyB,EAC9B,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAEnB,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,GAAG,EACR,EACE,SAAS,EACT,IAAI,EACJ,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,EAAE;IACD,SAAS,EAAE,iBAAiB,CAAC;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAsCxC"}

package/dist/actions/claim_protocol_fee.js

@@ -1,33 +0,0 @@
-import { PICON_DLMM_PROGRAM_ADDRESS, getClaimProtocolFeeInstructionAsync } from "../generated";
-import { findPoolTokenVaults, processAssociatedTokenAccountPair } from "../utils/ata";
-import { resolveTokenMintsAndPrograms, resolveAdminConfigAddress, buildTransactionMessage, } from "./helpers";
-export async function claimProtocolFee(rpc, { authority, pool, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    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/dist/actions/close_position.d.ts

@@ -1,14 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare function closePosition(rpc: Rpc, { owner, positionMint }: {
-    owner: TransactionSigner;
-    positionMint: Address;
-}, programAddress?: Address, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=close_position.d.ts.map

package/dist/actions/close_position.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"close_position.d.ts","sourceRoot":"","sources":["../../src/actions/close_position.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAG9D,OAAO,EAA2B,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAE9F,wBAAsB,aAAa,CACjC,GAAG,EAAE,GAAG,EACR,EAAE,KAAK,EAAE,YAAY,EAAE,EAAE;IAAE,KAAK,EAAE,iBAAiB,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,EAC5E,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAWxC"}

package/dist/actions/close_position.js

@@ -1,14 +0,0 @@
-import { PICON_DLMM_PROGRAM_ADDRESS, findPositionPda, getClosePositionInstructionAsync } from "../generated";
-import { findPositionTokenAccount } from "../utils/ata";
-import { buildTransactionMessage } from "./helpers";
-export async function closePosition(rpc, { owner, positionMint }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    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/dist/actions/create_admin_config.d.ts

@@ -1,15 +0,0 @@
-import { type Address, type TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare function createAdminConfig(rpc: Rpc, { deployer, authority, metadataUpdateAuthority, }: {
-    deployer: TransactionSigner;
-    authority: Address;
-    metadataUpdateAuthority?: Address;
-}, programAddress?: Address, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=create_admin_config.d.ts.map

package/dist/actions/create_admin_config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create_admin_config.d.ts","sourceRoot":"","sources":["../../src/actions/create_admin_config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,iBAAiB,EAGvB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAsD,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAYzH,wBAAsB,iBAAiB,CACrC,GAAG,EAAE,GAAG,EACR,EACE,QAAQ,EACR,SAAS,EACT,uBAAuB,GACxB,EAAE;IACD,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,SAAS,EAAE,OAAO,CAAC;IACnB,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAmBxC"}

package/dist/actions/create_admin_config.js

@@ -1,30 +0,0 @@
-import { getAddressEncoder, getProgramDerivedAddress, } from "@solana/kit";
-import { PICON_DLMM_PROGRAM_ADDRESS, getCreateAdminConfigInstructionAsync } from "../generated";
-import { buildTransactionMessage, resolveAdminConfigAddress } from "./helpers";
-const LOADER_V3_PROGRAM_ADDRESS = "BPFLoaderUpgradeab1e11111111111111111111111";
-async function findProgramDataAddress(programAddress) {
-    const [programData] = await getProgramDerivedAddress({
-        programAddress: LOADER_V3_PROGRAM_ADDRESS,
-        seeds: [getAddressEncoder().encode(programAddress)],
-    });
-    return programData;
-}
-export async function createAdminConfig(rpc, { deployer, authority, metadataUpdateAuthority, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    // 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/dist/actions/create_bin_array.d.ts

@@ -1,16 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare function createBinArray(rpc: Rpc, { payer, pool, index, idempotent, }: {
-    payer: TransactionSigner;
-    pool: Address;
-    index: number;
-    idempotent?: boolean;
-}, programAddress?: Address, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=create_bin_array.d.ts.map

package/dist/actions/create_bin_array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create_bin_array.d.ts","sourceRoot":"","sources":["../../src/actions/create_bin_array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,EAA2B,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAK9F,wBAAsB,cAAc,CAClC,GAAG,EAAE,GAAG,EACR,EACE,KAAK,EACL,IAAI,EACJ,KAAK,EACL,UAAiB,GAClB,EAAE;IACD,KAAK,EAAE,iBAAiB,CAAC;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAQxC"}

package/dist/actions/create_bin_array.js

@@ -1,10 +0,0 @@
-import { PICON_DLMM_PROGRAM_ADDRESS, findBinArrayPda, getCreateBinArrayInstructionAsync } from "../generated";
-import { buildTransactionMessage } 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, { payer, pool, index, idempotent = true, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    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/dist/actions/create_pool.d.ts

@@ -1,21 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare 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, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=create_pool.d.ts.map

package/dist/actions/create_pool.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create_pool.d.ts","sourceRoot":"","sources":["../../src/actions/create_pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,EAAsD,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAEzH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,GAAG,EACR,EACE,SAAS,EACT,OAAO,EACP,OAAO,EACP,aAAa,EACb,WAAW,EACX,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,EAAE;IACD,SAAS,EAAE,iBAAiB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;CACxB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAoBxC"}

package/dist/actions/create_pool.js

@@ -1,22 +0,0 @@
-import { PICON_DLMM_PROGRAM_ADDRESS, findPoolPda, getCreatePoolInstructionAsync } from "../generated";
-import { buildTransactionMessage, resolveAdminConfigAddress } from "./helpers";
-export async function createPool(rpc, { authority, binStep, feeRate, protocolShare, activeBinId, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    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/dist/actions/delete_bin_array.d.ts

@@ -1,16 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare function deleteBinArray(rpc: Rpc, { authority, pool, index, receiver, }: {
-    authority: TransactionSigner;
-    pool: Address;
-    index: number;
-    receiver?: Address;
-}, programAddress?: Address, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=delete_bin_array.d.ts.map

package/dist/actions/delete_bin_array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete_bin_array.d.ts","sourceRoot":"","sources":["../../src/actions/delete_bin_array.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAG9D,OAAO,EAAsD,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAEzH,wBAAsB,cAAc,CAClC,GAAG,EAAE,GAAG,EACR,EACE,SAAS,EACT,IAAI,EACJ,KAAK,EACL,QAAQ,GACT,EAAE;IACD,SAAS,EAAE,iBAAiB,CAAC;IAC7B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NAaxC"}

package/dist/actions/delete_bin_array.js

@@ -1,13 +0,0 @@
-import { PICON_DLMM_PROGRAM_ADDRESS, fetchBinArray, findBinArrayPda, getDeleteBinArrayInstructionAsync } from "../generated";
-import { isUndefined } from "../utils/type_guards";
-import { buildTransactionMessage, resolveAdminConfigAddress } from "./helpers";
-export async function deleteBinArray(rpc, { authority, pool, index, receiver, }, programAddress = PICON_DLMM_PROGRAM_ADDRESS, options = {}) {
-    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/dist/actions/deposit_by_weight.d.ts

@@ -1,27 +0,0 @@
-import type { Address, TransactionSigner } from "@solana/kit";
-import { type DistributionMode } from "../generated";
-import { type TransactionMessageOptions, type Rpc } from "./helpers";
-export declare 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, options?: TransactionMessageOptions): Promise<Omit<Omit<Omit<import("@solana/transaction-messages").ExcludeTransactionMessageWithinSizeLimit<Omit<Readonly<{
-    instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-    version: 0;
-}>, "instructions"> & import("@solana/transaction-messages").TransactionMessageWithinSizeLimit & {
-    instructions: readonly [];
-}>, "instructions"> & {
-    readonly instructions: readonly import("@solana/instructions").Instruction<string, readonly (import("@solana/instructions").AccountLookupMeta<string, string> | import("@solana/instructions").AccountMeta<string>)[]>[];
-}, "feePayer"> & import("@solana/signers").TransactionMessageWithFeePayerSigner<string, TransactionSigner<string>>, "lifetimeConstraint"> & import("@solana/transaction-messages").TransactionMessageWithBlockhashLifetime>;
-//# sourceMappingURL=deposit_by_weight.d.ts.map

package/dist/actions/deposit_by_weight.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"deposit_by_weight.d.ts","sourceRoot":"","sources":["../../src/actions/deposit_by_weight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,EAA8B,KAAK,gBAAgB,EAAkD,MAAM,cAAc,CAAC;AAKjI,OAAO,EAIL,KAAK,yBAAyB,EAC9B,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAEnB,wBAAsB,eAAe,CACnC,GAAG,EAAE,GAAG,EACR,EACE,KAAK,EACL,YAAY,EACZ,WAAW,EACX,OAAO,EACP,OAAO,EACP,UAAU,EACV,UAAU,EACV,oBAAoB,EACpB,gBAAgB,EAChB,IAAI,EACJ,UAAU,EACV,UAAU,EACV,aAAa,EACb,aAAa,GACd,EAAE;IACD,KAAK,EAAE,iBAAiB,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,EACD,cAAc,GAAE,OAAoC,EACpD,OAAO,GAAE,yBAA8B;;;;;;;4NA0DxC"}