@picon-finance/dlmm-sdk 1.2.0 → 1.3.0

package/src/entities/dlmm_program.ts

@@ -0,0 +1,210 @@
+import {
+  createSolanaRpc,
+  parseBase64RpcAccount,
+  type Address,
+  type Account,
+  type Instruction,
+  type AccountInfoBase,
+  type TransactionSigner,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type AccountInfoWithPubkey,
+  type AccountInfoWithBase64EncodedData,
+} from "@solana/kit";
+import {
+  getTokenDecoder,
+  TOKEN_2022_PROGRAM_ADDRESS,
+} from "@solana-program/token-2022";
+
+import { MAINNET_PROGRAM_ADDRESS } from "../program_addresses";
+import type { QuoteOutput } from "../quote";
+import {
+  Pool,
+  createPool,
+} from "./pool";
+import { findAllPositionAddresses } from "./position";
+import { fetchAllMaybePositionPoolsChunked } from "./position_pool";
+import {
+  getAdminConfig,
+  createAdminConfig,
+  isAdminConfigActive,
+  acceptAdminAuthority,
+  transferAdminAuthority,
+  setMetadataUpdateAuthority,
+} from "./admin_config";
+import { generated } from "..";
+
+export class DlmmProgram {
+  #rpc: ReturnType<typeof createSolanaRpc>;
+  #programAddress: Address;
+
+  public constructor(
+    rpc: ReturnType<typeof createSolanaRpc>,
+    programAddress: Address = MAINNET_PROGRAM_ADDRESS,
+  ) {
+    this.#rpc = rpc;
+    this.#programAddress = programAddress;
+  }
+
+  public get rpc() { return this.#rpc; }
+  public get programAddress() { return this.#programAddress; }
+
+  public async getPool(
+    address: Address,
+    config?: FetchAccountConfig,
+  ): Promise<Pool> {
+    return await Pool.load(this.#rpc, address, this.#programAddress, config);
+  }
+
+  public async createPool(
+    authority: TransactionSigner,
+    params: {
+      binStep: number,
+      feeRate: number,
+      protocolShare: number,
+      activeBinId: number,
+      tokenMintX: Address,
+      tokenMintY: Address,
+      tokenProgramX: Address,
+      tokenProgramY: Address,
+    },
+  ): Promise<Instruction> {
+    return await createPool(
+      { authority, ...params },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async swap(
+    user: TransactionSigner,
+    poolAddress: Address,
+    params: { xToY: boolean, amountIn: bigint, minAmountOut: bigint },
+    config?: FetchAccountConfig,
+  ): Promise<Instruction[]> {
+    const pool = await this.getPool(poolAddress, config);
+    return await pool.swap(user, params);
+  }
+
+  public async quote(
+    poolAddress: Address,
+    params: { xToY: boolean, amountIn: bigint, slippageToleranceBps: number },
+    config?: FetchAccountConfig,
+  ): Promise<QuoteOutput> {
+    const pool = await this.getPool(poolAddress, config);
+    return await pool.quote(params);
+  }
+
+  public async quoteAndSwap(
+    user: TransactionSigner,
+    poolAddress: Address,
+    params: { xToY: boolean, amountIn: bigint, slippageToleranceBps: number },
+    config?: FetchAccountConfig,
+  ): Promise<{ quoteOutput: QuoteOutput, instructions: Instruction[] }> {
+    const pool = await this.getPool(poolAddress, config);
+    return await pool.quoteAndSwap(user, params);
+  }
+
+  public async getAllPositionMintsByOwner(
+    owner: Address,
+    config?: FetchAccountsConfig,
+  ): Promise<Map<Address, Address[]>> {
+    const { commitment, minContextSlot, abortSignal } = config ?? {};
+    const { value: tokenAccounts } = await this.#rpc
+      .getTokenAccountsByOwner(
+        owner,
+        { programId: TOKEN_2022_PROGRAM_ADDRESS },
+        { commitment, minContextSlot, encoding: "base64" },
+      )
+      .send({ abortSignal });
+    const candidateMints = decodeCandidatePositionMints(tokenAccounts);
+    if (candidateMints.length === 0) {
+      return new Map();
+    }
+
+    const positionAddresses = await findAllPositionAddresses(
+      { positionMints: candidateMints },
+      { programAddress: this.#programAddress },
+    );
+    const maybePools = await fetchAllMaybePositionPoolsChunked(
+      this.#rpc,
+      positionAddresses,
+      config,
+    );
+
+    return new Map(
+      Map.groupBy(
+        maybePools.flatMap((maybePool, i) =>
+          maybePool ? [{ pool: maybePool.pool, mint: candidateMints[i] }] : []),
+        ({ pool }) => pool,
+      ).entries().map(([pool, pairs]) => [pool, pairs.map(({ mint }) => mint)]),
+    );
+  }
+
+  public async createAdminConfig(
+    deployer: TransactionSigner,
+    params: { authority: Address, metadataUpdateAuthority?: Address },
+  ): Promise<Instruction> {
+    return await createAdminConfig(
+      { deployer, ...params },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async transferAdminAuthority(
+    authority: TransactionSigner,
+    newAuthority: Address,
+  ): Promise<Instruction> {
+    return await transferAdminAuthority(
+      { authority, newAuthority },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async acceptAdminAuthority(
+    pendingAuthority: TransactionSigner,
+  ): Promise<Instruction> {
+    return await acceptAdminAuthority(
+      { pendingAuthority },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async setMetadataUpdateAuthority(
+    authority: TransactionSigner,
+    metadataUpdateAuthority: Address,
+  ): Promise<Instruction> {
+    return await setMetadataUpdateAuthority(
+      { authority, metadataUpdateAuthority },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async getAdminConfig(
+    config?: FetchAccountConfig,
+  ): Promise<Account<generated.AdminConfig>> {
+    return await getAdminConfig(
+      this.#rpc,
+      { programAddress: this.#programAddress, ...config },
+    );
+  }
+
+  public async isAdminConfigActive(
+    config?: FetchAccountConfig,
+  ): Promise<boolean> {
+    return await isAdminConfigActive(
+      this.#rpc,
+      { programAddress: this.#programAddress, ...config },
+    );
+  }
+}
+
+const tokenDecoder = getTokenDecoder();
+
+function decodeCandidatePositionMints(
+  tokenAccounts: readonly AccountInfoWithPubkey<AccountInfoBase & AccountInfoWithBase64EncodedData>[],
+): Address[] {
+  return tokenAccounts
+    .map(({ pubkey, account }) => tokenDecoder.decode(parseBase64RpcAccount(pubkey, account).data))
+    .filter(token => token.amount === 1n)
+    .map(token => token.mint);
+}

package/src/entities/index.ts

@@ -0,0 +1,6 @@
+export * from "./admin_config";
+export * from "./bin_array";
+export * from "./dlmm_program";
+export * from "./pool";
+export * from "./position";
+export * from "./types";

package/src/entities/pool.ts

@@ -0,0 +1,392 @@
+import {
+  createSolanaRpc,
+  AccountRole,
+  type Address,
+  type Account,
+  type Instruction,
+  type TransactionSigner,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+} from "@solana/kit";
+import {
+  fetchAllMint,
+  type Mint,
+} from "@solana-program/token-2022";
+
+import { generated } from "..";
+import { quote, type QuoteOutput } from "../quote";
+import { isAccount } from "../utils/type_guards";
+import { resolveAdminConfigAddress } from "./admin_config";
+import { processAssociatedTokenAccountPair } from "../utils/ata";
+import {
+  generateBinArrayIndicesForSwap,
+  generateBinArrayIndicesForSync,
+} from "../utils/bin_location";
+import { resolveTransferFee } from "../utils/transfer_fee";
+import {
+  MAX_BIN_ARRAYS_PER_SWAP,
+  MAX_BIN_ARRAYS_PER_SYNC,
+} from "../utils/constants";
+import {
+  Position,
+  openPosition,
+  closePosition,
+  findPositionAddress,
+  findAllPositionAddresses,
+} from "./position";
+import { findAllBinArrayAddresses } from "./bin_array";
+import { type ProgramConfig } from "./types";
+
+export class Pool {
+  #programAddress: Address;
+  #rpc: ReturnType<typeof createSolanaRpc>;
+
+  #account: Account<generated.Pool>;
+  #mintX: Account<Mint>;
+  #mintY: Account<Mint>;
+
+  private constructor(
+    rpc: ReturnType<typeof createSolanaRpc>,
+    account: Account<generated.Pool>,
+    mintX: Account<Mint>,
+    mintY: Account<Mint>,
+    programAddress: Address,
+  ) {
+    this.#rpc = rpc;
+    this.#account = account;
+    this.#mintX = mintX;
+    this.#mintY = mintY;
+    this.#programAddress = programAddress;
+  }
+
+  public get rpc() { return this.#rpc; }
+
+  public get programAddress() { return this.#programAddress; }
+  public get address() { return this.#account.address; }
+  public get data() { return this.#account.data; }
+  public get activeBinId() { return this.data.activeBinId; }
+
+  public get tokenMintX() { return this.data.tokenMintX; }
+  public get tokenMintY() { return this.data.tokenMintY; }
+
+  public get tokenVaultX() { return this.data.tokenVaultX; }
+  public get tokenVaultY() { return this.data.tokenVaultY; }
+
+  public get tokenProgramX() { return this.#mintX.programAddress; }
+  public get tokenProgramY() { return this.#mintY.programAddress; }
+
+  public async refresh(data: Account<generated.Pool>): Promise<void>;
+  public async refresh(config?: FetchAccountConfig): Promise<void>;
+  public async refresh(arg?: Account<generated.Pool> | FetchAccountConfig) {
+    if (!isAccount<generated.Pool>(arg)) {
+      arg = await generated.fetchPool(this.#rpc, this.address, arg);
+    }
+    this.#account = arg;
+  }
+
+  public async getPosition(
+    address: Address,
+    config?: FetchAccountsConfig,
+  ): Promise<Position> {
+    return await Position.load(this, address, config);
+  }
+
+  public async getPositionByPositionMint(
+    positionMint: Address,
+    config?: FetchAccountsConfig,
+  ): Promise<Position> {
+    const address = await findPositionAddress(
+      { positionMint },
+      { programAddress: this.#programAddress },
+    );
+    return await Position.load(this, address, config);
+  }
+
+  public async getAllPositionsByPositionMints(
+    positionMints: Address[],
+    config?: FetchAccountsConfig,
+  ): Promise<Position[]> {
+    const addresses = await findAllPositionAddresses(
+      { positionMints },
+      { programAddress: this.#programAddress },
+    );
+    return await Position.loadAll(this, addresses, config);
+  }
+
+  public async openPosition(
+    owner: TransactionSigner,
+    positionMint: TransactionSigner,
+    { lowerBinId, upperBinId }: { lowerBinId: number, upperBinId: number },
+  ): Promise<Instruction[]> {
+    return await openPosition(
+      this.#rpc,
+      { owner, positionMint, pool: this.address, lowerBinId, upperBinId },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async closePosition(
+    owner: TransactionSigner,
+    positionMint: Address,
+  ): Promise<Instruction> {
+    return await closePosition(
+      { owner, positionMint },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async swap(
+    user: TransactionSigner,
+    {
+      xToY,
+      amountIn,
+      minAmountOut,
+    }: {
+      xToY: boolean,
+      amountIn: bigint,
+      minAmountOut: bigint,
+    }
+  ): Promise<Instruction[]> {
+    const indices = generateBinArrayIndicesForSwap(this.activeBinId, xToY, MAX_BIN_ARRAYS_PER_SWAP);
+    const [binArrayAddresses, {
+      ataX: tokenUserAccountX,
+      ataY: tokenUserAccountY,
+      preInstructions,
+      postInstructions,
+    }] = await Promise.all([
+      findAllBinArrayAddresses(
+        { pool: this.address, indices },
+        { programAddress: this.#programAddress },
+      ),
+      processAssociatedTokenAccountPair({
+        owner: user,
+        tokenMintX: this.tokenMintX,
+        tokenMintY: this.tokenMintY,
+        tokenProgramX: this.tokenProgramX,
+        tokenProgramY: this.tokenProgramY,
+        amountX: xToY ? amountIn : undefined,
+        amountY: xToY ? undefined : amountIn,
+      }),
+    ]);
+
+    const swapIx = generated.getSwapInstruction({
+      user,
+      pool: this.address,
+      tokenMintX: this.tokenMintX,
+      tokenMintY: this.tokenMintY,
+      tokenUserAccountX,
+      tokenUserAccountY,
+      tokenVaultX: this.tokenVaultX,
+      tokenVaultY: this.tokenVaultY,
+      tokenProgramX: this.tokenProgramX,
+      tokenProgramY: this.tokenProgramY,
+      amountIn,
+      minAmountOut,
+      xToY,
+    }, { programAddress: this.#programAddress });
+
+    const remainingAccounts = binArrayAddresses.map(address => ({ address, role: AccountRole.WRITABLE }));
+    const swapIxWithBinArrays = { ...swapIx, accounts: [...swapIx.accounts, ...remainingAccounts] };
+
+    return [...preInstructions, swapIxWithBinArrays, ...postInstructions];
+  }
+
+  public async quote(
+    {
+      xToY,
+      amountIn,
+      slippageToleranceBps,
+    }: {
+      xToY: boolean,
+      amountIn: bigint,
+      slippageToleranceBps: number,
+    }
+  ): Promise<QuoteOutput> {
+    const indices = generateBinArrayIndicesForSwap(this.activeBinId, xToY, MAX_BIN_ARRAYS_PER_SWAP);
+    const binArrayAddresses = await findAllBinArrayAddresses(
+      { pool: this.address, indices },
+      { programAddress: this.#programAddress },
+    );
+
+    const [maybeBinArrays, { epoch }] = await Promise.all([
+      generated.fetchAllMaybeBinArray(this.#rpc, binArrayAddresses),
+      this.#rpc.getEpochInfo().send(),
+    ]);
+    const binArrays = maybeBinArrays.map(maybeBinArray => maybeBinArray.exists ? maybeBinArray.data : undefined);
+
+    const transferFeeX = resolveTransferFee(this.#mintX.data, epoch);
+    const transferFeeY = resolveTransferFee(this.#mintY.data, epoch);
+
+    return await quote({
+      amountIn,
+      xToY,
+      slippageToleranceBps,
+      now: BigInt(Math.floor(Date.now() / 1000)),
+      poolState: this.data,
+      inputTransferFee: xToY ? transferFeeX : transferFeeY,
+      outputTransferFee: xToY ? transferFeeY : transferFeeX,
+      binArrays,
+    });
+  }
+
+  public async quoteAndSwap(
+    user: TransactionSigner,
+    {
+      xToY,
+      amountIn,
+      slippageToleranceBps,
+    }: {
+      xToY: boolean,
+      amountIn: bigint,
+      slippageToleranceBps: number,
+    }
+  ): Promise<{ quoteOutput: QuoteOutput, instructions: Instruction[] }> {
+    const quoteOutput = await this.quote({ xToY, amountIn, slippageToleranceBps });
+    const instructions = await this.swap(user, { xToY, amountIn, minAmountOut: quoteOutput.minAmountOut });
+    return { quoteOutput, instructions };
+  }
+
+  public async sync(
+    user: TransactionSigner,
+    desiredBinId: number,
+  ): Promise<Instruction[]> {
+    const indices = generateBinArrayIndicesForSync(this.activeBinId, desiredBinId, MAX_BIN_ARRAYS_PER_SYNC);
+    const binArrayAddresses = await findAllBinArrayAddresses(
+      { pool: this.address, indices },
+      { programAddress: this.#programAddress },
+    );
+
+    const syncPoolIx = generated.getSyncPoolInstruction(
+      { user, pool: this.address, desiredBinId },
+      { programAddress: this.#programAddress },
+    );
+    const remainingAccounts = binArrayAddresses.map(address => ({ address, role: AccountRole.READONLY }));
+
+    return [{ ...syncPoolIx, accounts: [...syncPoolIx.accounts, ...remainingAccounts] }];
+  }
+
+  public async setDynamicFeeConfig(
+    authority: TransactionSigner,
+    dynamicFeeConfig: generated.DynamicFeeConfig,
+  ): Promise<Instruction> {
+    const adminConfig = await resolveAdminConfigAddress(this.#programAddress);
+    return await generated.getSetPoolDynamicFeeConfigInstructionAsync(
+      { authority, pool: this.address, config: dynamicFeeConfig, adminConfig },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async setProtocolShare(
+    authority: TransactionSigner,
+    protocolShare: number,
+  ): Promise<Instruction> {
+    const adminConfig = await resolveAdminConfigAddress(this.#programAddress);
+    return await generated.getSetPoolProtocolShareInstructionAsync(
+      { authority, pool: this.address, protocolShare, adminConfig },
+      { programAddress: this.#programAddress },
+    );
+  }
+
+  public async claimProtocolFee(authority: TransactionSigner): Promise<Instruction[]> {
+    const [adminConfig, {
+      ataX: tokenAdminAccountX,
+      ataY: tokenAdminAccountY,
+      preInstructions,
+      postInstructions,
+    }] = await Promise.all([
+      resolveAdminConfigAddress(this.#programAddress),
+      processAssociatedTokenAccountPair({
+        owner: authority,
+        tokenMintX: this.tokenMintX,
+        tokenMintY: this.tokenMintY,
+        tokenProgramX: this.tokenProgramX,
+        tokenProgramY: this.tokenProgramY,
+      }),
+    ]);
+
+    const claimProtocolFeeIx = await generated.getClaimProtocolFeeInstructionAsync({
+      authority,
+      pool: this.address,
+      adminConfig,
+      tokenMintX: this.tokenMintX,
+      tokenMintY: this.tokenMintY,
+      tokenVaultX: this.tokenVaultX,
+      tokenVaultY: this.tokenVaultY,
+      tokenAdminAccountX,
+      tokenAdminAccountY,
+      tokenProgramX: this.tokenProgramX,
+      tokenProgramY: this.tokenProgramY,
+    }, { programAddress: this.#programAddress });
+
+    return [...preInstructions, claimProtocolFeeIx, ...postInstructions];
+  }
+
+  public static async load(
+    rpc: ReturnType<typeof createSolanaRpc>,
+    address: Address,
+    programAddress: Address,
+    config?: FetchAccountConfig,
+  ): Promise<Pool> {
+    const pool = await generated.fetchPool(rpc, address, config);
+    const { tokenMintX, tokenMintY } = pool.data;
+    const [mintX, mintY] = await fetchAllMint(rpc, [tokenMintX, tokenMintY], config);
+    return new Pool(
+      rpc,
+      pool,
+      mintX,
+      mintY,
+      programAddress,
+    );
+  }
+}
+
+export async function findPoolAddress(
+  seeds: { tokenMintX: Address, tokenMintY: Address, binStep: number, feeRate: number },
+  config: ProgramConfig,
+): Promise<Address> {
+  const [address] = await generated.findPoolPda(seeds, config);
+  return address;
+}
+
+export async function createPool(
+  {
+    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,
+  },
+  config: ProgramConfig,
+): Promise<Instruction> {
+  const [pool, adminConfig] = await Promise.all([
+    findPoolAddress({ tokenMintX, tokenMintY, binStep, feeRate }, config),
+    resolveAdminConfigAddress(config.programAddress),
+  ]);
+  return await generated.getCreatePoolInstructionAsync({
+    authority,
+    pool,
+    adminConfig,
+    binStep,
+    feeRate,
+    protocolShare,
+    activeBinId,
+    tokenMintX,
+    tokenMintY,
+    tokenProgramX,
+    tokenProgramY,
+  }, config);
+}