@picon-finance/dlmm-sdk 1.2.0 → 1.4.0

package/src/entities/admin_config.ts

@@ -0,0 +1,122 @@
+import {
+  createSolanaRpc,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  type Address,
+  type Account,
+  type Instruction,
+  type TransactionSigner,
+  type FetchAccountConfig,
+} from "@solana/kit";
+import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
+
+import { generated } from "..";
+import { findAdminConfigPda, type AdminConfig } from "../generated";
+import { type ProgramConfig } from "./types";
+
+const LOADER_V3_PROGRAM_ADDRESS = "BPFLoaderUpgradeab1e11111111111111111111111" as Address;
+
+async function findProgramDataAddress(programAddress: Address): Promise<Address> {
+  const [programData] = await getProgramDerivedAddress({
+    programAddress: LOADER_V3_PROGRAM_ADDRESS,
+    seeds: [getAddressEncoder().encode(programAddress)],
+  });
+  return programData;
+}
+
+export async function resolveAdminConfigAddress(programAddress: Address): Promise<Address> {
+  const [adminConfig] = await findAdminConfigPda({ programAddress });
+  return adminConfig;
+}
+
+export async function createAdminConfig(
+  {
+    deployer,
+    authority,
+    metadataUpdateAuthority,
+  }: {
+    deployer: TransactionSigner,
+    authority: Address,
+    metadataUpdateAuthority?: Address,
+  },
+  config: ProgramConfig,
+): Promise<Instruction> {
+  const [adminConfig, programData] = await Promise.all([
+    resolveAdminConfigAddress(config.programAddress),
+    findProgramDataAddress(config.programAddress),
+  ]);
+  return await generated.getCreateAdminConfigInstructionAsync({
+    deployer,
+    authority,
+    metadataUpdateAuthority: metadataUpdateAuthority ?? null,
+    adminConfig,
+    program: config.programAddress,
+    programData,
+  }, config);
+}
+
+export async function transferAdminAuthority(
+  {
+    authority,
+    newAuthority,
+  }: {
+    authority: TransactionSigner,
+    newAuthority: Address,
+  },
+  config: ProgramConfig,
+): Promise<Instruction> {
+  const adminConfig = await resolveAdminConfigAddress(config.programAddress);
+  return await generated.getTransferAdminAuthorityInstructionAsync(
+    { authority, newAuthority, adminConfig },
+    config,
+  );
+}
+
+export async function acceptAdminAuthority(
+  { pendingAuthority }: { pendingAuthority: TransactionSigner },
+  config: ProgramConfig,
+): Promise<Instruction> {
+  const adminConfig = await resolveAdminConfigAddress(config.programAddress);
+  return await generated.getAcceptAdminAuthorityInstructionAsync(
+    { pendingAuthority, adminConfig },
+    config,
+  );
+}
+
+export async function setMetadataUpdateAuthority(
+  {
+    authority,
+    metadataUpdateAuthority,
+  }: {
+    authority: TransactionSigner,
+    metadataUpdateAuthority: Address,
+  },
+  config: ProgramConfig,
+): Promise<Instruction> {
+  const adminConfig = await resolveAdminConfigAddress(config.programAddress);
+  return await generated.getSetMetadataUpdateAuthorityInstructionAsync(
+    { authority, metadataUpdateAuthority, adminConfig },
+    config,
+  );
+}
+
+export async function getAdminConfig(
+  rpc: ReturnType<typeof createSolanaRpc>,
+  config: ProgramConfig & FetchAccountConfig,
+): Promise<Account<generated.AdminConfig>> {
+  const adminConfig = await resolveAdminConfigAddress(config.programAddress);
+  return await generated.fetchAdminConfig(rpc, adminConfig, config);
+}
+
+function isActive(adminConfig: AdminConfig): boolean {
+  return adminConfig.authority !== SYSTEM_PROGRAM_ADDRESS;
+}
+
+export async function isAdminConfigActive(
+  rpc: ReturnType<typeof createSolanaRpc>,
+  config: ProgramConfig & FetchAccountConfig,
+): Promise<boolean> {
+  const adminConfig = await resolveAdminConfigAddress(config.programAddress);
+  const maybeAdminConfig = await generated.fetchMaybeAdminConfig(rpc, adminConfig, config);
+  return maybeAdminConfig.exists && isActive(maybeAdminConfig.data);
+}

package/src/entities/bin_array.ts

@@ -0,0 +1,157 @@
+import {
+  decodeAccount,
+  createSolanaRpc,
+  assertAccountsExist,
+  type Address,
+  type Account,
+  type Instruction,
+  type TransactionSigner,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type MaybeEncodedAccount,
+} from "@solana/kit";
+
+import { generated } from "..";
+import { isAccount } from "../utils/type_guards";
+import { fetchInChunks } from "../utils/chunk";
+import { MAX_ACCOUNTS_PER_RPC_BATCH } from "../utils/constants";
+import { resolveAdminConfigAddress } from "./admin_config";
+import { type ProgramConfig } from "./types";
+
+export class BinArray {
+  #rpc: ReturnType<typeof createSolanaRpc>;
+  #account: Account<generated.BinArray>;
+  #programAddress: Address;
+
+  private constructor(
+    rpc: ReturnType<typeof createSolanaRpc>,
+    account: Account<generated.BinArray>,
+    programAddress: Address,
+  ) {
+    this.#rpc = rpc;
+    this.#account = account;
+    this.#programAddress = programAddress;
+  }
+
+  public get address() { return this.#account.address; }
+  public get data() { return this.#account.data; }
+  public get bins() { return this.data.bins; }
+
+  public async refresh(data: Account<generated.BinArray>): Promise<void>;
+  public async refresh(config?: FetchAccountConfig): Promise<void>;
+  public async refresh(arg?: Account<generated.BinArray> | FetchAccountConfig) {
+    if (!isAccount<generated.BinArray>(arg)) {
+      arg = await generated.fetchBinArray(this.#rpc, this.address, arg);
+    }
+    this.#account = arg;
+  }
+
+  public static async loadAll(
+    rpc: ReturnType<typeof createSolanaRpc>,
+    pool: Address,
+    indices: number[],
+    programAddress: Address,
+    config?: FetchAccountsConfig,
+  ): Promise<BinArray[]> {
+    const addresses = await findAllBinArrayAddresses(
+      { indices, pool },
+      { programAddress },
+    );
+    const accounts = await fetchAllBinArraysChunked(rpc, addresses, config);
+    return accounts.map(account => new BinArray(rpc, account, programAddress));
+  }
+
+  public async delete(authority: TransactionSigner): Promise<Instruction> {
+    const adminConfig = await resolveAdminConfigAddress(this.#programAddress);
+    return await generated.getDeleteBinArrayInstructionAsync({
+      authority,
+      pool: this.data.pool,
+      index: this.data.index,
+      receiver: this.data.payer,
+      binArray: this.address,
+      adminConfig,
+    }, { programAddress: this.#programAddress });
+  }
+}
+
+export async function createBinArray(
+  {
+    payer,
+    pool,
+    index,
+    idempotent = true,
+  }: {
+    payer: TransactionSigner,
+    pool: Address,
+    index: number,
+    idempotent?: boolean,
+  },
+  config: ProgramConfig,
+): Promise<Instruction> {
+  const binArray = await findBinArrayAddress(
+    { pool, index },
+    config,
+  );
+  return await generated.getCreateBinArrayInstructionAsync(
+    { payer, pool, index, idempotent, binArray },
+    config,
+  );
+}
+
+export async function createAllBinArrays(
+  {
+    payer,
+    pool,
+    indices,
+    idempotent = true,
+  }: {
+    payer: TransactionSigner,
+    pool: Address,
+    indices: number[],
+    idempotent?: boolean,
+  },
+  config: ProgramConfig,
+): Promise<Instruction[]> {
+  return await Promise.all(
+    indices.map(index =>
+      createBinArray({ payer, pool, index, idempotent }, config)),
+  );
+}
+
+export async function findBinArrayAddress(
+  seeds: { pool: Address, index: number },
+  config: ProgramConfig,
+): Promise<Address> {
+  const [address] = await generated.findBinArrayPda(seeds, config);
+  return address;
+}
+
+export async function findAllBinArrayAddresses(
+  { pool, indices }: { pool: Address, indices: number[] },
+  config: ProgramConfig,
+): Promise<Address[]> {
+  return await Promise.all(
+    indices.map(index => findBinArrayAddress({ index, pool }, config)),
+  );
+}
+
+export async function fetchAllBinArraysChunked(
+  rpc: ReturnType<typeof createSolanaRpc>,
+  addresses: Address[],
+  config?: FetchAccountsConfig,
+) {
+  return await fetchInChunks(
+    addresses,
+    MAX_ACCOUNTS_PER_RPC_BATCH,
+    chunkAddresses => generated.fetchAllBinArray(rpc, chunkAddresses, config),
+  );
+}
+
+const binArrayDecoder = generated.getBinArrayDecoder();
+
+export function decodeAllBinArrays(
+  maybeAccounts: MaybeEncodedAccount<string>[],
+): Account<generated.BinArray>[] {
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts.map(a => decodeAccount(a, binArrayDecoder));
+}

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";