@picon-finance/dlmm-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Picon Finance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,48 @@
+# @picon-finance/dlmm-sdk
+
+TypeScript SDK for the [Picon DLMM](https://github.com/picon-finance) protocol on Solana, built on [`@solana/kit`](https://github.com/anza-xyz/kit).
+
+## Install
+
+```bash
+npm install @picon-finance/dlmm-sdk
+```
+
+## Usage
+
+Every action returns an unsigned `TransactionMessage` — sign and send it with `@solana/kit`. Actions default to mainnet; pass a `programAddress` to target another cluster.
+
+```ts
+import { createSolanaRpc, signTransactionMessageWithSigners, sendAndConfirmTransactionFactory } from "@solana/kit";
+import { createPool, swap, quote, getPool, DEVNET_PROGRAM_ADDRESS } from "@picon-finance/dlmm-sdk";
+
+const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
+
+// Read
+const pool = await getPool(rpc, poolAddress);
+
+// Quote, then build the matching swap transaction
+const { quoteOutput, swap: buildSwap } = await quote(rpc, {
+  pool: poolAddress,
+  xToY: true,
+  amountIn: 1_000_000n,
+  slippageToleranceBps: 50,
+});
+const swapMessage = await buildSwap(userSigner);
+
+// Write — target devnet by passing programAddress
+const createPoolMessage = await createPool(
+  rpc,
+  { authority, binStep, feeRate, protocolShare, activeBinId, tokenMintX, tokenMintY, tokenProgramX, tokenProgramY },
+  DEVNET_PROGRAM_ADDRESS,
+);
+
+// Sign and send however you normally do with @solana/kit
+const signed = await signTransactionMessageWithSigners(swapMessage);
+```
+
+`MAINNET_PROGRAM_ADDRESS` and `DEVNET_PROGRAM_ADDRESS` are both exported for convenience; omitting `programAddress` defaults to mainnet.
+
+## License
+
+MIT

package/dist/actions/accept_admin_authority.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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;AAGrB,OAAO,EAAsD,KAAK,yBAAyB,EAAE,KAAK,GAAG,EAAE,MAAM,WAAW,CAAC;AAUzH,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

@@ -0,0 +1,30 @@
+import { getAddressEncoder, getProgramDerivedAddress, } from "@solana/kit";
+import { LOADER_V3_PROGRAM_ADDRESS } from "@solana-program/loader-v3";
+import { PICON_DLMM_PROGRAM_ADDRESS, getCreateAdminConfigInstructionAsync } from "../generated";
+import { buildTransactionMessage, resolveAdminConfigAddress } from "./helpers";
+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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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"}