@picon-finance/dlmm-sdk 1.2.0 → 1.4.0

package/dist/entities/position.js

@@ -0,0 +1,277 @@
+import { decodeAccount, assertAccountExists, fetchEncodedAccounts, } from "@solana/kit";
+import { generated } from "..";
+import { findPositionTokenAccount, processAssociatedTokenAccountPair, } from "../utils/ata";
+import { getBinIndex, getBinArrayIndex, getPositionBinArrayIndices, } from "../utils/bin_location";
+import { assertRangeWithinRange, assertPositionBelongsToPool, } from "../utils/assert";
+import { isUndefined } from "../utils/type_guards";
+import { fetchInChunks } from "../utils/chunk";
+import { resolveAdminConfigAddress } from "./admin_config";
+import { MAX_ACCOUNTS_PER_RPC_BATCH } from "../utils/constants";
+import { BinArray, decodeAllBinArrays, createAllBinArrays, fetchAllBinArraysChunked, } from "./bin_array";
+export class Position {
+    #pool;
+    #account;
+    #binArrays;
+    constructor(pool, account, binArrays) {
+        this.#pool = pool;
+        this.#account = account;
+        this.#binArrays = binArrays;
+    }
+    get address() { return this.#account.address; }
+    get data() { return this.#account.data; }
+    get positionMint() { return this.data.positionMint; }
+    get binArrayAddresses() {
+        const lowerBinArray = this.#binArrays[0].address;
+        const upperBinArray = this.#binArrays.length > 1 ? this.#binArrays[1].address : undefined;
+        return { lowerBinArray, upperBinArray };
+    }
+    getPendingFee() {
+        const { lowerBinId, upperBinId, feeStates } = this.data;
+        const lowerBinArrayIndex = getBinArrayIndex(lowerBinId);
+        return Array.from({ length: upperBinId - lowerBinId + 1 }, (_, i) => i)
+            .flatMap(i => {
+            const feeState = feeStates[i];
+            if (feeState.shares === 0n)
+                return [];
+            const binId = lowerBinId + i;
+            const binIndex = getBinIndex(binId);
+            const binArrayIndex = getBinArrayIndex(binId) - lowerBinArrayIndex;
+            const binArray = this.#binArrays[binArrayIndex];
+            const bin = binArray.bins[binIndex];
+            return bin.totalShares > 0n ? [{ feeState, bin }] : [];
+        })
+            .reduce((total, { feeState, bin }) => ({
+            amountX: total.amountX + earnedAmount(bin.feePerShareX, feeState.feePerShareCheckpointX, feeState.shares),
+            amountY: total.amountY + earnedAmount(bin.feePerShareY, feeState.feePerShareCheckpointY, feeState.shares),
+        }), { amountX: 0n, amountY: 0n });
+    }
+    async refresh(arg) {
+        if (!Array.isArray(arg)) {
+            arg = await fetchPositionWithBinArrays(this.#pool.rpc, this.address, this.#binArrays.map(b => b.address), arg);
+        }
+        const [position, binArrays] = arg;
+        this.#account = position;
+        this.#binArrays.forEach((b, i) => b.refresh(binArrays[i]));
+    }
+    async depositByWeight(owner, { amountX, amountY, lowerBinId, binWeights, maxActiveBinSlippage, distributionMode, }) {
+        const upperBinId = lowerBinId + binWeights.length - 1;
+        assertRangeWithinRange({ lowerBinId, upperBinId }, this.data);
+        const [positionTokenAccount, { ataX: tokenOwnerAccountX, ataY: tokenOwnerAccountY, preInstructions, postInstructions }] = await Promise.all([
+            findPositionTokenAccount({ owner: owner.address, positionMint: this.data.positionMint }),
+            processAssociatedTokenAccountPair({
+                owner,
+                tokenMintX: this.#pool.tokenMintX,
+                tokenMintY: this.#pool.tokenMintY,
+                tokenProgramX: this.#pool.tokenProgramX,
+                tokenProgramY: this.#pool.tokenProgramY,
+                amountX,
+                amountY,
+            }),
+        ]);
+        const { lowerBinArray, upperBinArray } = this.binArrayAddresses;
+        const depositByWeightIx = generated.getDepositByWeightInstruction({
+            owner,
+            pool: this.#pool.address,
+            position: this.address,
+            positionTokenAccount,
+            tokenMintX: this.#pool.tokenMintX,
+            tokenMintY: this.#pool.tokenMintY,
+            tokenOwnerAccountX,
+            tokenOwnerAccountY,
+            tokenVaultX: this.#pool.tokenVaultX,
+            tokenVaultY: this.#pool.tokenVaultY,
+            tokenProgramX: this.#pool.tokenProgramX,
+            tokenProgramY: this.#pool.tokenProgramY,
+            lowerBinArray,
+            upperBinArray,
+            amountX,
+            amountY,
+            activeBinId: this.#pool.activeBinId,
+            maxActiveBinSlippage,
+            distributionMode,
+            lowerBinId,
+            binWeights,
+        }, {
+            programAddress: this.#pool.programAddress
+        });
+        return [...preInstructions, depositByWeightIx, ...postInstructions];
+    }
+    async claimFee(owner, range) {
+        const { lowerBinId, upperBinId } = range ?? this.data;
+        assertRangeWithinRange({ lowerBinId, upperBinId }, this.data);
+        const [positionTokenAccount, { ataX: tokenOwnerAccountX, ataY: tokenOwnerAccountY, preInstructions, postInstructions }] = await Promise.all([
+            findPositionTokenAccount({ owner: owner.address, positionMint: this.data.positionMint }),
+            processAssociatedTokenAccountPair({
+                owner,
+                tokenMintX: this.#pool.tokenMintX,
+                tokenMintY: this.#pool.tokenMintY,
+                tokenProgramX: this.#pool.tokenProgramX,
+                tokenProgramY: this.#pool.tokenProgramY,
+            }),
+        ]);
+        const { lowerBinArray, upperBinArray } = this.binArrayAddresses;
+        const claimFeeIx = generated.getClaimFeeInstruction({
+            owner,
+            pool: this.#pool.address,
+            position: this.address,
+            positionTokenAccount,
+            tokenMintX: this.#pool.tokenMintX,
+            tokenMintY: this.#pool.tokenMintY,
+            tokenOwnerAccountX,
+            tokenOwnerAccountY,
+            tokenVaultX: this.#pool.tokenVaultX,
+            tokenVaultY: this.#pool.tokenVaultY,
+            tokenProgramX: this.#pool.tokenProgramX,
+            tokenProgramY: this.#pool.tokenProgramY,
+            lowerBinArray,
+            upperBinArray,
+            lowerBinId,
+            upperBinId,
+        }, {
+            programAddress: this.#pool.programAddress
+        });
+        return [...preInstructions, claimFeeIx, ...postInstructions];
+    }
+    async withdraw(owner, bpsToRemove, range) {
+        const { lowerBinId, upperBinId } = range ?? this.data;
+        assertRangeWithinRange({ lowerBinId, upperBinId }, this.data);
+        const [positionTokenAccount, { ataX: tokenOwnerAccountX, ataY: tokenOwnerAccountY, preInstructions, postInstructions }] = await Promise.all([
+            findPositionTokenAccount({ owner: owner.address, positionMint: this.data.positionMint }),
+            processAssociatedTokenAccountPair({
+                owner,
+                tokenMintX: this.#pool.tokenMintX,
+                tokenMintY: this.#pool.tokenMintY,
+                tokenProgramX: this.#pool.tokenProgramX,
+                tokenProgramY: this.#pool.tokenProgramY,
+            }),
+        ]);
+        const { lowerBinArray, upperBinArray } = this.binArrayAddresses;
+        const withdrawIx = generated.getWithdrawInstruction({
+            owner,
+            pool: this.#pool.address,
+            position: this.address,
+            positionTokenAccount,
+            tokenMintX: this.#pool.tokenMintX,
+            tokenMintY: this.#pool.tokenMintY,
+            tokenOwnerAccountX,
+            tokenOwnerAccountY,
+            tokenVaultX: this.#pool.tokenVaultX,
+            tokenVaultY: this.#pool.tokenVaultY,
+            tokenProgramX: this.#pool.tokenProgramX,
+            tokenProgramY: this.#pool.tokenProgramY,
+            lowerBinArray,
+            upperBinArray,
+            lowerBinId,
+            upperBinId,
+            bpsToRemove,
+        }, {
+            programAddress: this.#pool.programAddress
+        });
+        return [...preInstructions, withdrawIx, ...postInstructions];
+    }
+    async close(owner) {
+        return await closePosition({ owner, positionMint: this.data.positionMint, position: this.address }, { programAddress: this.#pool.programAddress });
+    }
+    static async load(pool, address, config) {
+        const position = await generated.fetchPosition(pool.rpc, address, config);
+        assertPositionBelongsToPool(position.data, pool);
+        const { lowerBinId, upperBinId } = position.data;
+        const indices = [...new Set([
+                getBinArrayIndex(lowerBinId),
+                getBinArrayIndex(upperBinId),
+            ])];
+        const binArrays = await BinArray.loadAll(pool.rpc, pool.address, indices, pool.programAddress, config);
+        return new Position(pool, position, binArrays);
+    }
+    static async loadAll(pool, addresses, config) {
+        const positions = await fetchAllPositionsChunked(pool.rpc, addresses, config);
+        const indicesByPosition = positions.map(position => [...new Set([getBinArrayIndex(position.data.lowerBinId), getBinArrayIndex(position.data.upperBinId)])]);
+        const binArrays = await BinArray.loadAll(pool.rpc, pool.address, [...new Set(indicesByPosition.flat())], pool.programAddress, config);
+        const binArrayByIndex = new Map(binArrays.map(binArray => [binArray.data.index, binArray]));
+        return positions.map((position, i) => {
+            assertPositionBelongsToPool(position.data, pool);
+            const positionBinArrays = indicesByPosition[i].map(index => binArrayByIndex.get(index));
+            return new Position(pool, position, positionBinArrays);
+        });
+    }
+    static async refreshAll(rpc, positions, config) {
+        if (positions.length === 0) {
+            return;
+        }
+        const addresses = positions.map(position => position.address);
+        const positionAccounts = await fetchAllPositionsChunked(rpc, addresses, config);
+        const binArrayAddresses = [...new Set(positions.flatMap(position => position.#binArrays.map(binArray => binArray.address)))];
+        const binArrayAccounts = await fetchAllBinArraysChunked(rpc, binArrayAddresses, config);
+        const binArrayByAddress = new Map(binArrayAccounts.map(account => [account.address, account]));
+        await Promise.all(positions.map((position, i) => position.refresh([
+            positionAccounts[i],
+            position.#binArrays.map(binArray => binArrayByAddress.get(binArray.address)),
+        ])));
+    }
+}
+export async function findPositionAddress(seeds, config) {
+    const [address] = await generated.findPositionPda(seeds, config);
+    return address;
+}
+export async function findAllPositionAddresses({ positionMints }, config) {
+    return await Promise.all(positionMints.map(positionMint => findPositionAddress({ positionMint }, config)));
+}
+export async function openPosition(rpc, { owner, positionMint, pool, lowerBinId, upperBinId, }, config) {
+    const [adminConfig, position] = await Promise.all([
+        resolveAdminConfigAddress(config.programAddress),
+        findPositionAddress({ positionMint: positionMint.address }, config),
+    ]);
+    const { metadataUpdateAuthority } = (await generated.fetchAdminConfig(rpc, adminConfig)).data;
+    const { lowerBinArrayIndex, upperBinArrayIndex } = getPositionBinArrayIndices(lowerBinId, upperBinId);
+    const indices = isUndefined(upperBinArrayIndex) ? [lowerBinArrayIndex] : [lowerBinArrayIndex, upperBinArrayIndex];
+    const createBinArraysIxs = await createAllBinArrays({ payer: owner, pool, indices, idempotent: true }, config);
+    const openPositionIx = await generated.getOpenPositionInstructionAsync({
+        pool,
+        lowerBinId,
+        upperBinId,
+        owner,
+        positionMint,
+        position,
+        adminConfig,
+        metadataUpdateAuthority,
+    }, config);
+    return [...createBinArraysIxs, openPositionIx];
+}
+export async function closePosition({ owner, positionMint, position, }, config) {
+    const [resolvedPosition, positionTokenAccount] = await Promise.all([
+        position ?? findPositionAddress({ positionMint }, config),
+        findPositionTokenAccount({ owner: owner.address, positionMint }),
+    ]);
+    return await generated.getClosePositionInstructionAsync({
+        owner,
+        position: resolvedPosition,
+        positionMint,
+        positionTokenAccount,
+    }, config);
+}
+async function fetchPositionWithBinArrays(rpc, positionAddress, binArrayAddresses, config) {
+    const [positionAccount, ...binArrayAccounts] = await fetchEncodedAccounts(rpc, [
+        positionAddress, ...binArrayAddresses,
+    ], config);
+    return [
+        decodePosition(positionAccount),
+        decodeAllBinArrays(binArrayAccounts)
+    ];
+}
+async function fetchAllPositionsChunked(rpc, addresses, config) {
+    return await fetchInChunks(addresses, MAX_ACCOUNTS_PER_RPC_BATCH, chunkAddresses => generated.fetchAllPosition(rpc, chunkAddresses, config));
+}
+const positionDecoder = generated.getPositionDecoder();
+function decodePosition(maybeAccount) {
+    assertAccountExists(maybeAccount);
+    return decodeAccount(maybeAccount, positionDecoder);
+}
+const U128_MODULUS = 1n << 128n;
+const SCALE_OFFSET = 64n; // shares and fee-per-share are both Q64.64 — see fee_state.rs
+// Mirrors fee_state.rs's earned_amount(): wrapping u128 subtraction (fee-per-share monotonically
+// increases and wraps on overflow), then floor((current - checkpoint) * (shares >> 64) / 2^64).
+function earnedAmount(feePerShareCurrent, feePerShareCheckpoint, shares) {
+    const delta = ((feePerShareCurrent - feePerShareCheckpoint) % U128_MODULUS + U128_MODULUS) % U128_MODULUS;
+    const naturalShares = shares >> SCALE_OFFSET;
+    return (delta * naturalShares) >> SCALE_OFFSET;
+}

package/dist/entities/position_pool.d.ts

@@ -0,0 +1,7 @@
+import { createSolanaRpc, type Address, type FetchAccountsConfig } from "@solana/kit";
+export type PositionPoolEntry = {
+    address: Address;
+    pool: Address;
+};
+export declare function fetchAllMaybePositionPoolsChunked(rpc: ReturnType<typeof createSolanaRpc>, addresses: Address[], config?: FetchAccountsConfig): Promise<(PositionPoolEntry | undefined)[]>;
+//# sourceMappingURL=position_pool.d.ts.map

package/dist/entities/position_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position_pool.d.ts","sourceRoot":"","sources":["../../src/entities/position_pool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAGf,KAAK,OAAO,EAEZ,KAAK,mBAAmB,EAEzB,MAAM,aAAa,CAAC;AAIrB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,wBAAsB,iCAAiC,CACrD,GAAG,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,EACvC,SAAS,EAAE,OAAO,EAAE,EACpB,MAAM,CAAC,EAAE,mBAAmB,GAC3B,OAAO,CAAC,CAAC,iBAAiB,GAAG,SAAS,CAAC,EAAE,CAAC,CAM5C"}

package/dist/entities/position_pool.js

@@ -0,0 +1,30 @@
+import { getAddressDecoder, parseBase64RpcAccount, } from "@solana/kit";
+import { fetchInChunks } from "../utils/chunk";
+import { MAX_ACCOUNTS_PER_RPC_BATCH } from "../utils/constants";
+export async function fetchAllMaybePositionPoolsChunked(rpc, addresses, config) {
+    return await fetchInChunks(addresses, MAX_ACCOUNTS_PER_RPC_BATCH, chunkAddresses => fetchAllMaybePositionPools(rpc, chunkAddresses, config));
+}
+const POSITION_POOL_SLICE = Object.freeze({ offset: 8, length: 32 });
+async function fetchAllMaybePositionPools(rpc, addresses, config) {
+    const { abortSignal, ...rpcConfig } = config ?? {};
+    const { value: accounts } = await rpc.getMultipleAccounts(addresses, {
+        ...rpcConfig,
+        dataSlice: POSITION_POOL_SLICE,
+        encoding: "base64",
+    }).send({ abortSignal });
+    return decodeAllMaybePositionPools(addresses, accounts);
+}
+const addressDecoder = getAddressDecoder();
+function decodeMaybePositionPool(address, account) {
+    if (!account) {
+        return;
+    }
+    const pool = addressDecoder.decode(parseBase64RpcAccount(address, account).data);
+    return { address, pool };
+}
+function decodeAllMaybePositionPools(addresses, accounts) {
+    return accounts.map((account, i) => {
+        const address = addresses[i];
+        return decodeMaybePositionPool(address, account);
+    });
+}

package/dist/entities/types.d.ts

@@ -0,0 +1,5 @@
+import { type Address } from "@solana/kit";
+export type ProgramConfig = {
+    programAddress: Address;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/entities/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/entities/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,MAAM,MAAM,aAAa,GAAG;IAAE,cAAc,EAAE,OAAO,CAAA;CAAE,CAAC"}

package/dist/events.d.ts

@@ -1,4 +1,4 @@
-import { type Address } from "@solana/kit";
+import { type Address, type Commitment, type createSolanaRpcSubscriptions } from "@solana/kit";
 export type CreatePoolEvent = {
     pool: Address;
     binStep: number;
@@ -90,4 +90,12 @@ export type DlmmEvent = {
 };
 export declare function decodeEventFromLogLine(logLine: string): DlmmEvent | undefined;
 export declare function decodeEventsFromLogs(logs: readonly string[], programAddress?: Address): DlmmEvent[];
+type RpcSubscriptions = ReturnType<typeof createSolanaRpcSubscriptions>;
+export declare function onEvent(rpcSubscriptions: RpcSubscriptions, handler: (event: DlmmEvent) => void, { address, programAddress, commitment, onError, }?: {
+    address?: Address;
+    programAddress?: Address;
+    commitment?: Commitment;
+    onError?: (error: unknown) => void;
+}): Promise<() => void>;
+export {};
 //# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"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"}

package/dist/events.js

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

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 export * as generated from "./generated";
 export { DistributionMode } from "./generated/types/distributionMode";
 export * as events from "./events";
+export * from "./entities";
 export * from "./utils/constants";
 export { NATIVE_MINT_ADDRESS } from "./utils/ata";
-export * from "./actions";
+export type { QuoteInput, QuoteOutput, PoolState, TransferFee } from "./quote";
 export * from "./program_addresses";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC/E,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,7 +1,7 @@
 export * as generated from "./generated";
 export { DistributionMode } from "./generated/types/distributionMode";
 export * as events from "./events";
+export * from "./entities";
 export * from "./utils/constants";
 export { NATIVE_MINT_ADDRESS } from "./utils/ata";
-export * from "./actions";
 export * from "./program_addresses";

package/dist/program_addresses.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"program_addresses.d.ts","sourceRoot":"","sources":["../src/program_addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAK3C,OAAO,EAAE,0BAA0B,IAAI,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAIpF,eAAO,MAAM,sBAAsB,EAAoD,OAAO,CAAC"}
+{"version":3,"file":"program_addresses.d.ts","sourceRoot":"","sources":["../src/program_addresses.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,0BAA0B,IAAI,uBAAuB,EAAE,MAAM,aAAa,CAAC;AACpF,eAAO,MAAM,sBAAsB,EAAoD,OAAO,CAAC"}

package/dist/program_addresses.js

@@ -1,7 +1,2 @@
-// SDK codegen always targets the mainnet IDL (see package.json's `copy-idl`), so this is the
-// same value as `generated.PICON_DLMM_PROGRAM_ADDRESS` — exported under a clearer name here
-// since it's meant to be read standalone, not discovered via the generated namespace.
 export { PICON_DLMM_PROGRAM_ADDRESS as MAINNET_PROGRAM_ADDRESS } from "./generated";
-// Not baked into codegen (the IDL's structure is identical across clusters — only the address
-// differs) — pass this as the `programAddress` argument on any SDK action to target devnet.
 export const DEVNET_PROGRAM_ADDRESS = "tDLMMKoxBt7UkZapYHsEgLGydmFvSQXh5mGzrRovoeM";

package/dist/utils/assert.d.ts

@@ -0,0 +1,9 @@
+import type { Address } from "@solana/kit";
+import type { BinIdRange } from "./bin_location";
+export declare function assertRangeWithinRange(inner: BinIdRange, outer: BinIdRange): void;
+export declare function assertPositionBelongsToPool(position: {
+    pool: Address;
+}, pool: {
+    address: Address;
+}): void;
+//# sourceMappingURL=assert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/utils/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,UAAU,GAChB,IAAI,CAMN;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,EAC3B,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACzB,IAAI,CAMN"}

package/dist/utils/assert.js

@@ -0,0 +1,10 @@
+export function assertRangeWithinRange(inner, outer) {
+    if (inner.lowerBinId < outer.lowerBinId || inner.upperBinId > outer.upperBinId) {
+        throw new RangeError(`Range (${inner.lowerBinId} to ${inner.upperBinId}) must be inside range (${outer.lowerBinId} to ${outer.upperBinId})`);
+    }
+}
+export function assertPositionBelongsToPool(position, pool) {
+    if (position.pool !== pool.address) {
+        throw new Error(`Position's pool (${position.pool}) does not match expected pool (${pool.address})`);
+    }
+}

package/dist/utils/bin_location.d.ts

@@ -1,3 +1,7 @@
+export type BinIdRange = {
+    lowerBinId: number;
+    upperBinId: number;
+};
 export declare function getBinArrayIndex(binId: number): number;
 export declare function getBinIndex(binId: number): number;
 export declare function getBinId(binArrayIndex: number, binIndex: number): number;

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

@@ -1 +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"}
+{"version":3,"file":"bin_location.d.ts","sourceRoot":"","sources":["../../src/utils/bin_location.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,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;AAED,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB;IAAE,kBAAkB,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,CAM7D;AAED,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,OAAO,EACb,YAAY,EAAE,MAAM,GACnB,MAAM,EAAE,CAMV;AAED,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,MAAM,EAAE,CAeV"}

package/dist/utils/bin_location.js

@@ -11,10 +11,6 @@ export function getBinId(binArrayIndex, 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);
@@ -22,9 +18,6 @@ export function getPositionBinArrayIndices(lowerBinId, upperBinId) {
         ? { 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
@@ -32,11 +25,6 @@ export function generateBinArrayIndicesForSwap(activeBinId, xToY, maxBinArrays)
         : [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);

package/dist/utils/chunk.d.ts

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

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

@@ -1 +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"}
+{"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;AAED,wBAAsB,aAAa,CAAC,CAAC,EAAE,CAAC,EACtC,KAAK,EAAE,CAAC,EAAE,EACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,CAAC,EAAE,CAAC,GACzC,OAAO,CAAC,CAAC,EAAE,CAAC,CAGd"}

package/dist/utils/chunk.js

@@ -5,3 +5,7 @@ export function chunk(items, size) {
     }
     return chunks;
 }
+export async function fetchInChunks(items, size, fetcher) {
+    const chunks = await Promise.all(chunk(items, size).map(fetcher));
+    return chunks.flat();
+}

package/dist/utils/type_guards.d.ts

@@ -1,2 +1,4 @@
+import { type Account } from "@solana/kit";
 export declare function isUndefined<T>(value: T | undefined): value is undefined;
+export declare function isAccount<TData extends object>(value: any): value is Account<TData>;
 //# sourceMappingURL=type_guards.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"type_guards.d.ts","sourceRoot":"","sources":["../../src/utils/type_guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,KAAK,IAAI,SAAS,CAEvE;AAED,wBAAgB,SAAS,CAAC,KAAK,SAAS,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,CAQnF"}

package/dist/utils/type_guards.js

@@ -1,3 +1,10 @@
 export function isUndefined(value) {
     return value === undefined;
 }
+export function isAccount(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "address" in value &&
+        "data" in value &&
+        "executable" in value);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@picon-finance/dlmm-sdk",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Typescript SDK for interacting with the Picon DLMM protocol",
   "author": "Picon Finance",
   "license": "MIT",
@@ -41,7 +41,6 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@solana-program/compute-budget": "^0.17.0",
     "@solana-program/system": "^0.13.0",
     "@solana-program/token": "^0.15.0",
     "@solana-program/token-2022": "^0.13.0",