@meteora-ag/dynamic-bonding-curve-sdk 1.0.0

package/src/types.ts

@@ -0,0 +1,465 @@
+import type {
+    Accounts,
+    BN,
+    IdlAccounts,
+    IdlTypes,
+    Program,
+} from '@coral-xyz/anchor'
+import type { DynamicBondingCurve } from './idl/dynamic-bonding-curve/idl'
+import type { Keypair, PublicKey, Transaction } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+
+// Program Type
+export type DynamicBondingCurveProgram = Program<DynamicBondingCurve>
+
+/////////////////
+// IX ACCOUNTS //
+/////////////////
+
+export type ClaimProtocolFeeAccounts = Accounts<
+    DynamicBondingCurve['instructions']['0']
+>['claimProtocolFee']
+
+export type ClaimTradingFeeAccounts = Accounts<
+    DynamicBondingCurve['instructions']['1']
+>['claimTradingFee']
+
+export type CloseClaimFeeOperatorAccounts = Accounts<
+    DynamicBondingCurve['instructions']['2']
+>['closeClaimFeeOperator']
+
+export type CreateClaimFeeOperatorAccounts = Accounts<
+    DynamicBondingCurve['instructions']['3']
+>['createClaimFeeOperator']
+
+export type CreateConfigAccounts = Accounts<
+    DynamicBondingCurve['instructions']['4']
+>['createConfig']
+
+export type CreateLockerAccounts = Accounts<
+    DynamicBondingCurve['instructions']['5']
+>['createLocker']
+
+export type CreatePartnerMetadata = Accounts<
+    DynamicBondingCurve['instructions']['6']
+>['createPartnerMetadata']
+
+export type CreateVirtualPoolMetadata = Accounts<
+    DynamicBondingCurve['instructions']['7']
+>['createVirtualPoolMetadata']
+
+export type InitializeVirtualPoolWithSplTokenAccounts = Accounts<
+    DynamicBondingCurve['instructions']['8']
+>['initializeVirtualPoolWithSplToken']
+
+export type InitializeVirtualPoolWithToken2022Accounts = Accounts<
+    DynamicBondingCurve['instructions']['9']
+>['initializeVirtualPoolWithToken2022']
+
+export type MigrateMeteoraDammAccounts = Accounts<
+    DynamicBondingCurve['instructions']['10']
+>['migrateMeteoraDamm']
+
+export type MigrateMeteoraDammClaimLpTokenAccounts = Accounts<
+    DynamicBondingCurve['instructions']['11']
+>['migrateMeteoraDammClaimLpToken']
+
+export type MigrateMeteoraDammLockLpTokenAccounts = Accounts<
+    DynamicBondingCurve['instructions']['12']
+>['migrateMeteoraDammLockLpToken']
+
+export type MigrationDammV2Accounts = Accounts<
+    DynamicBondingCurve['instructions']['13']
+>['migrationDammV2']
+
+export type MigrationDammV2CreateMetadataAccounts = Accounts<
+    DynamicBondingCurve['instructions']['14']
+>['migrationDammV2CreateMetadata']
+
+export type MigrationMeteoraDammCreateMetadataAccounts = Accounts<
+    DynamicBondingCurve['instructions']['15']
+>['migrationMeteoraDammCreateMetadata']
+
+export type PartnerWithdrawSurplusAccounts = Accounts<
+    DynamicBondingCurve['instructions']['16']
+>['partnerWithdrawSurplus']
+
+export type SwapAccounts = Accounts<
+    DynamicBondingCurve['instructions']['18']
+>['swap']
+
+///////////////
+// IDL Types //
+///////////////
+
+export type ConfigParameters = IdlTypes<DynamicBondingCurve>['configParameters']
+export type InitializePoolParameters =
+    IdlTypes<DynamicBondingCurve>['initializePoolParameters']
+export type SwapParameters = IdlTypes<DynamicBondingCurve>['swapParameters']
+export type PoolFeeParameters =
+    IdlTypes<DynamicBondingCurve>['poolFeeParameters']
+export type DynamicFeeParameters =
+    IdlTypes<DynamicBondingCurve>['dynamicFeeParameters']
+export type LiquidityDistributionParameters =
+    IdlTypes<DynamicBondingCurve>['liquidityDistributionParameters']
+export type PoolFeesConfig = IdlTypes<DynamicBondingCurve>['poolFeesConfig']
+export type DynamicFeeConfig = IdlTypes<DynamicBondingCurve>['dynamicFeeConfig']
+export type BaseFeeConfig = IdlTypes<DynamicBondingCurve>['baseFeeConfig']
+export type PoolFees = IdlTypes<DynamicBondingCurve>['poolFees']
+export type PoolMetrics = IdlTypes<DynamicBondingCurve>['poolMetrics']
+export type SwapResult = IdlTypes<DynamicBondingCurve>['swapResult']
+export type CreatePartnerMetadataParameters =
+    IdlTypes<DynamicBondingCurve>['createPartnerMetadataParameters']
+export type CreateVirtualPoolMetadataParameters =
+    IdlTypes<DynamicBondingCurve>['createVirtualPoolMetadataParameters']
+
+//////////////////
+// IDL ACCOUNTS //
+//////////////////
+
+export type ClaimFeeOperator =
+    IdlAccounts<DynamicBondingCurve>['claimFeeOperator']
+export type Config = IdlAccounts<DynamicBondingCurve>['config']
+export type MeteoraDammMigrationMetadata =
+    IdlAccounts<DynamicBondingCurve>['meteoraDammMigrationMetadata']
+export type LockEscrow = IdlAccounts<DynamicBondingCurve>['lockEscrow']
+export type VolatilityTracker =
+    IdlTypes<DynamicBondingCurve>['volatilityTracker']
+export type VirtualPool = IdlAccounts<DynamicBondingCurve>['virtualPool']
+export type PoolConfig = IdlAccounts<DynamicBondingCurve>['poolConfig']
+export type PartnerMetadata =
+    IdlAccounts<DynamicBondingCurve>['partnerMetadata']
+export type VirtualPoolMetadata =
+    IdlAccounts<DynamicBondingCurve>['virtualPoolMetadata']
+
+///////////
+// ENUMS //
+///////////
+
+export enum ActivationType {
+    Slot = 0,
+    Timestamp = 1,
+}
+
+export enum TokenType {
+    SPL = 0,
+    Token2022 = 1,
+}
+
+export enum CollectFeeMode {
+    OnlyQuote = 0,
+    Both = 1,
+}
+
+export enum MigrationOption {
+    MET_DAMM = 0,
+    MET_DAMM_V2 = 1,
+}
+
+export enum CollectFeeMode {
+    QuoteToken = 0,
+    OutputToken = 1,
+}
+
+export enum FeeSchedulerMode {
+    Linear = 0,
+    Exponential = 1,
+}
+
+export enum MigrationFeeOption {
+    FixedBps25 = 0,
+    FixedBps30 = 1,
+    FixedBps100 = 2,
+    FixedBps200 = 3,
+}
+
+export enum TokenDecimal {
+    SIX = 6,
+    NINE = 9,
+}
+
+export enum TradeDirection {
+    BaseToQuote = 0,
+    QuoteToBase = 1,
+}
+
+export enum Rounding {
+    Up,
+    Down,
+}
+
+///////////
+// TYPES //
+///////////
+
+export type CreateConfigParam = Omit<
+    CreateConfigAccounts,
+    'program' | 'eventAuthority' | 'systemProgram'
+> &
+    ConfigParameters
+
+export type CreateDammMigrationMetadataParam = {
+    payer: PublicKey
+    virtualPool: PublicKey
+    config: PublicKey
+    migrateToDammV2: boolean
+}
+
+export type CreateConstantProductConfigWithLockVestingParam = {
+    lockVestingParams: {
+        percentageSupplyVesting: number
+        frequency: number
+        numberOfPeriod: number
+        cliffUnlockEnabled: boolean
+    }
+    totalTokenSupply: number
+    percentageSupplyOnMigration: number
+    startPrice: Decimal
+    migrationPrice: Decimal
+    tokenBaseDecimal: number
+    tokenQuoteDecimal: number
+    swapBufferPercentage: number
+    baseFeeBps: number
+    dynamicFeeEnabled: boolean
+    activationType: ActivationType
+    collectFeeMode: CollectFeeMode
+    migrationOption: MigrationOption
+    migrationFeeOption: MigrationFeeOption
+    tokenType: TokenType
+    partnerLpPercentage: number
+    creatorLpPercentage: number
+    partnerLockedLpPercentage: number
+    creatorLockedLpPercentage: number
+    feeClaimer: PublicKey
+    leftoverReceiver: PublicKey
+    payer: PublicKey
+    quoteMint: PublicKey
+    config: PublicKey
+}
+
+export type CreateConstantProductConfigWithoutLockVestingParam = {
+    totalTokenSupply: number
+    percentageSupplyOnMigration: number
+    startPrice: Decimal
+    tokenBaseDecimal: number
+    tokenQuoteDecimal: number
+    swapBufferPercentage: number
+    baseFeeBps: number
+    dynamicFeeEnabled: boolean
+    activationType: ActivationType
+    collectFeeMode: CollectFeeMode
+    migrationOption: MigrationOption
+    migrationFeeOption: MigrationFeeOption
+    tokenType: TokenType
+    partnerLpPercentage: number
+    creatorLpPercentage: number
+    partnerLockedLpPercentage: number
+    creatorLockedLpPercentage: number
+    feeClaimer: PublicKey
+    leftoverReceiver: PublicKey
+    payer: PublicKey
+    quoteMint: PublicKey
+    config: PublicKey
+}
+
+export type DesignCurveParam = {
+    tokenDecimal: TokenDecimal
+    migrationQuoteThreshold: BN
+    tokenBaseSupply: BN
+    migrationBasePercent: number
+}
+
+export type DesignConstantProductCurveWithLockVestingParam = {
+    lockVestingParams: {
+        percentageSupplyVesting: number
+        frequency: number
+        numberOfPeriod: number
+        cliffUnlockEnabled: boolean
+    }
+    totalTokenSupply: number
+    percentageSupplyOnMigration: number
+    startPrice: Decimal
+    migrationPrice: Decimal
+    tokenBaseDecimal: number
+    tokenQuoteDecimal: number
+    swapBufferPercentage: number
+    baseFeeBps: number
+    dynamicFeeEnabled: boolean
+    activationType: ActivationType
+    collectFeeMode: CollectFeeMode
+    migrationOption: MigrationOption
+    migrationFeeOption: MigrationFeeOption
+    tokenType: TokenType
+    partnerLpPercentage: number
+    creatorLpPercentage: number
+    partnerLockedLpPercentage: number
+    creatorLockedLpPercentage: number
+}
+
+export type DesignConstantProductCurveWithoutLockVestingParam = {
+    totalTokenSupply: number
+    percentageSupplyOnMigration: number
+    startPrice: Decimal
+    tokenBaseDecimal: number
+    tokenQuoteDecimal: number
+    swapBufferPercentage: number
+    baseFeeBps: number
+    dynamicFeeEnabled: boolean
+    activationType: ActivationType
+    collectFeeMode: CollectFeeMode
+    migrationOption: MigrationOption
+    migrationFeeOption: MigrationFeeOption
+    tokenType: TokenType
+    partnerLpPercentage: number
+    creatorLpPercentage: number
+    partnerLockedLpPercentage: number
+    creatorLockedLpPercentage: number
+}
+
+export type DesignCurveResponse = {
+    sqrtStartPrice: BN
+    curve: LiquidityDistributionParameters[]
+}
+
+export type MigrateToDammV1Param = {
+    payer: PublicKey
+    virtualPool: PublicKey
+    dammConfig: PublicKey
+}
+
+export type MigrateToDammV2Param = {
+    payer: PublicKey
+    virtualPool: PublicKey
+    dammConfig: PublicKey
+}
+
+export type MigrateToDammV2Response = {
+    transaction: Transaction
+    firstPositionNftKeypair: Keypair
+    secondPositionNftKeypair: Keypair
+}
+
+export type ClaimTradingFeeParam = {
+    feeClaimer: PublicKey
+    pool: PublicKey
+    maxBaseAmount: BN
+    maxQuoteAmount: BN
+}
+
+export type CreateVirtualPoolMetadataParam = {
+    virtualPool: PublicKey
+    name: string
+    website: string
+    logo: string
+    creator: PublicKey
+    payer: PublicKey
+}
+
+export type CreatePartnerMetadataParam = {
+    name: string
+    website: string
+    logo: string
+    feeClaimer: PublicKey
+    payer: PublicKey
+}
+
+export type CreatePoolParam = {
+    name: string
+    symbol: string
+    uri: string
+    config: PublicKey
+    creator: PublicKey
+    baseMint: PublicKey
+    quoteMint: PublicKey
+    baseTokenType: TokenType
+    quoteTokenType: TokenType
+}
+
+export type SwapParam = {
+    owner: PublicKey
+    amountIn: BN
+    minimumAmountOut: BN
+    swapBaseForQuote: boolean
+}
+
+export type SwapQuoteParam = {
+    virtualPool: VirtualPool
+    config: PoolConfig
+    swapBaseForQuote: boolean
+    amountIn: BN
+    hasReferral: boolean
+    currentPoint: BN
+}
+
+export type DammLpTokenParam = {
+    payer: PublicKey
+    virtualPool: PublicKey
+    dammConfig: PublicKey
+    isPartner: boolean
+}
+
+export type PartnerWithdrawSurplusParam = {
+    feeClaimer: PublicKey
+    virtualPool: PublicKey
+}
+
+export type WithdrawLeftoverParam = {
+    payer: PublicKey
+    virtualPool: PublicKey
+}
+
+export type CreateLockerParam = {
+    payer: PublicKey
+    virtualPool: PublicKey
+}
+
+////////////////
+// INTERFACES //
+////////////////
+
+export interface FeeResult {
+    amount: BN
+    protocolFee: BN
+    tradingFee: BN
+    referralFee: BN
+}
+
+export interface FeeMode {
+    feesOnInput: boolean
+    feesOnBaseToken: boolean
+    hasReferral: boolean
+}
+
+export interface QuoteResult {
+    amountOut: BN
+    minimumAmountOut: BN
+    nextSqrtPrice: BN
+    fee: {
+        trading: BN
+        protocol: BN
+        referral?: BN
+    }
+    price: {
+        beforeSwap: number
+        afterSwap: number
+    }
+}
+
+export interface FeeOnAmountResult {
+    amount: BN // Amount remaining after taking trading fee
+    protocolFee: BN // Final protocol fee (after referral deduction)
+    tradingFee: BN // Portion of trading fee NOT going to protocol
+    referralFee: BN // Referral fee amount
+}
+
+export interface PrepareSwapParams {
+    inputMint: PublicKey
+    outputMint: PublicKey
+    inputTokenProgram: PublicKey
+    outputTokenProgram: PublicKey
+}
+
+export interface SwapAmount {
+    outputAmount: BN
+    nextSqrtPrice: BN
+}

package/src/utils.ts

@@ -0,0 +1,252 @@
+import { AnchorProvider, Program, Wallet } from '@coral-xyz/anchor'
+import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token'
+import {
+    PublicKey,
+    SystemProgram,
+    TransactionInstruction,
+    type Connection,
+    type GetProgramAccountsFilter,
+} from '@solana/web3.js'
+import type { DynamicBondingCurve } from './idl/dynamic-bonding-curve/idl'
+import DynamicBondingCurveIDL from './idl/dynamic-bonding-curve/idl.json'
+import type { DynamicVault } from './idl/dynamic-vault/idl'
+import DynamicVaultIDL from './idl/dynamic-vault/idl.json'
+import type { DammV1 } from './idl/damm-v1/idl'
+import DammV1IDL from './idl/damm-v1/idl.json'
+import {
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    createCloseAccountInstruction,
+    getAssociatedTokenAddressSync,
+    NATIVE_MINT,
+    TOKEN_PROGRAM_ID,
+} from '@solana/spl-token'
+import { TokenType } from './types'
+import BN from 'bn.js'
+
+export function getSecondKey(key1: PublicKey, key2: PublicKey) {
+    const buf1 = key1.toBuffer()
+    const buf2 = key2.toBuffer()
+    // Buf1 > buf2
+    if (Buffer.compare(buf1, buf2) === 1) {
+        return buf2
+    }
+    return buf1
+}
+
+export function getFirstKey(key1: PublicKey, key2: PublicKey) {
+    const buf1 = key1.toBuffer()
+    const buf2 = key2.toBuffer()
+    // Buf1 > buf2
+    if (Buffer.compare(buf1, buf2) === 1) {
+        return buf1
+    }
+    return buf2
+}
+
+/**
+ * Create a program instance
+ * @param connection - The connection to the network
+ * @returns The program instance
+ */
+export function createProgram(connection: Connection) {
+    const provider = new AnchorProvider(connection, null as unknown as Wallet, {
+        commitment: 'confirmed',
+    })
+    const program = new Program<DynamicBondingCurve>(
+        DynamicBondingCurveIDL,
+        provider
+    )
+
+    return { program }
+}
+
+/**
+ * Create a vault program instance
+ * @param connection - The connection to the network
+ * @returns The vault program instance
+ */
+export function createVaultProgram(
+    connection: Connection
+): Program<DynamicVault> {
+    const provider = new AnchorProvider(connection, null as unknown as Wallet, {
+        commitment: 'confirmed',
+    })
+
+    const program = new Program<DynamicVault>(DynamicVaultIDL, provider)
+    return program
+}
+
+/**
+ * Create a DAMM V1 program instance
+ * @param connection - The connection to the network
+ * @returns The DAMM V1 program instance
+ */
+export function createDammV1Program(connection: Connection): Program<DammV1> {
+    const provider = new AnchorProvider(connection, null as unknown as Wallet, {
+        commitment: 'confirmed',
+    })
+
+    const program = new Program<DammV1>(DammV1IDL, provider)
+    return program
+}
+
+/**
+ * Find the associated token address for a wallet and token mint
+ * @param walletAddress - The wallet address
+ * @param tokenMintAddress - The token mint address
+ * @param tokenProgramId - The token program ID
+ * @returns The associated token address
+ */
+export function findAssociatedTokenAddress(
+    walletAddress: PublicKey,
+    tokenMintAddress: PublicKey,
+    tokenProgramId: PublicKey
+): PublicKey {
+    return PublicKey.findProgramAddressSync(
+        [
+            walletAddress.toBuffer(),
+            tokenProgramId.toBuffer(),
+            tokenMintAddress.toBuffer(),
+        ],
+        ASSOCIATED_TOKEN_PROGRAM_ID
+    )[0]
+}
+
+/**
+ * Create a wrap SOL instruction
+ * @param from - The from address
+ * @param to - The to address
+ * @param amount - The amount to wrap
+ * @returns The wrap SOL instruction
+ */
+export function wrapSOLInstruction(
+    from: PublicKey,
+    to: PublicKey,
+    amount: bigint
+): TransactionInstruction[] {
+    return [
+        SystemProgram.transfer({
+            fromPubkey: from,
+            toPubkey: to,
+            lamports: amount,
+        }),
+        new TransactionInstruction({
+            keys: [
+                {
+                    pubkey: to,
+                    isSigner: false,
+                    isWritable: true,
+                },
+            ],
+            data: Buffer.from(new Uint8Array([17])),
+            programId: TOKEN_PROGRAM_ID,
+        }),
+    ]
+}
+
+/**
+ * Create an unwrap SOL instruction
+ * @param owner - The owner of the SOL
+ * @param allowOwnerOffCurve - Whether to allow the owner to be off curve
+ * @returns The unwrap SOL instruction
+ */
+export function unwrapSOLInstruction(
+    owner: PublicKey,
+    allowOwnerOffCurve = true
+): TransactionInstruction | null {
+    const wSolATAAccount = getAssociatedTokenAddressSync(
+        NATIVE_MINT,
+        owner,
+        allowOwnerOffCurve
+    )
+    if (wSolATAAccount) {
+        const closedWrappedSolInstruction = createCloseAccountInstruction(
+            wSolATAAccount,
+            owner,
+            owner,
+            [],
+            TOKEN_PROGRAM_ID
+        )
+        return closedWrappedSolInstruction
+    }
+    return null
+}
+
+/**
+ * Get the token program for a given token type
+ * @param tokenType - The token type
+ * @returns The token program
+ */
+export function getTokenProgram(tokenType: TokenType): PublicKey {
+    return tokenType === TokenType.SPL
+        ? TOKEN_PROGRAM_ID
+        : TOKEN_2022_PROGRAM_ID
+}
+
+/**
+ * Create a memcmp filter for owner-based filtering
+ * @param owner - The owner public key or string
+ * @param offset - The offset where the owner field is located in the account data
+ * @returns A GetProgramAccountsFilter array with the owner filter
+ */
+export function createProgramAccountFilter(
+    owner: PublicKey | string,
+    offset: number
+): GetProgramAccountsFilter[] {
+    const ownerKey = typeof owner === 'string' ? new PublicKey(owner) : owner
+    return [
+        {
+            memcmp: {
+                offset,
+                bytes: ownerKey.toBase58(),
+                encoding: 'base58',
+            },
+        },
+    ]
+}
+
+/**
+ * Generic account fetch helper
+ * @param accountAddress - The address of the account to fetch
+ * @param accountType - The type of account to fetch from program.account
+ * @returns The fetched account data
+ */
+export async function getAccountData<T>(
+    accountAddress: PublicKey | string,
+    accountType: keyof Program<DynamicBondingCurve>['account'],
+    program: Program<DynamicBondingCurve>
+): Promise<T> {
+    const address =
+        accountAddress instanceof PublicKey
+            ? accountAddress
+            : new PublicKey(accountAddress)
+
+    return (await program.account[accountType].fetchNullable(address)) as T
+}
+
+/**
+ * Check if a mint is the native SOL mint
+ * @param mint - The mint to check
+ * @returns Whether the mint is the native SOL mint
+ */
+export function isNativeSol(mint: PublicKey): boolean {
+    return mint.toString() === NATIVE_MINT.toString()
+}
+
+// Helper function to convert BN values to decimal strings
+export function convertBNToDecimal<T>(obj: T): T {
+    if (obj instanceof BN) {
+        return obj.toString(10) as T
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => convertBNToDecimal(item)) as T
+    }
+    if (obj && typeof obj === 'object') {
+        const result = {} as T
+        for (const key in obj) {
+            result[key] = convertBNToDecimal(obj[key])
+        }
+        return result
+    }
+    return obj
+}