@cetusprotocol/dlmm-sdk 0.0.1

package/src/modules/rewardModule.ts

@@ -0,0 +1,175 @@
+import { Transaction } from '@mysten/sui/transactions'
+import {
+  asIntN,
+  asUintN,
+  CLOCK_ADDRESS,
+  CoinAssist,
+  d,
+  getObjectFields,
+  getPackagerConfigs,
+  IModule,
+  MathUtil,
+} from '@cetusprotocol/common-sdk'
+import { CetusDlmmSDK } from '../sdk'
+import { AddRewardOption, InitRewardOption, RewardAccessOption, RewardPeriodEmission, RewardWhiteListOption } from '../types/dlmm'
+import BN from 'bn.js'
+
+export class RewardModule implements IModule<CetusDlmmSDK> {
+  protected _sdk: CetusDlmmSDK
+
+  constructor(sdk: CetusDlmmSDK) {
+    this._sdk = sdk
+  }
+
+  get sdk() {
+    return this._sdk
+  }
+
+  async getRewardPeriodEmission(
+    period_emission_handle: string,
+    curr_emission_per_second: string,
+    last_updated_time: number
+  ): Promise<RewardPeriodEmission[]> {
+    const res = await this._sdk.FullClient.getDynamicFieldsByPage(period_emission_handle)
+    const result: RewardPeriodEmission[] = []
+    const warpIds = res.data.map((item) => item.objectId)
+    if (warpIds.length > 0) {
+      const warRes = await this._sdk.FullClient.batchGetObjects(warpIds, {
+        showContent: true,
+      })
+
+      warRes.forEach((item) => {
+        const fields = getObjectFields(item)
+        const emission_rate = MathUtil.u128ToI128(new BN(fields.value.fields.value.fields.bits)).toString()
+        const time = fields.name
+        const visualizedTime = new Date(Number(time) * 1000).toLocaleString()
+        const emissions_per = MathUtil.fromX64(new BN(emission_rate)).toString()
+        const rewardPeriodEmission: RewardPeriodEmission = {
+          emissions_per_second: '0',
+          emissions_per_day: '0',
+          emissions_per,
+          time,
+          visualized_time: visualizedTime,
+        }
+        result.push(rewardPeriodEmission)
+      })
+    }
+    const sortedList = result.sort((a, b) => Number(a.time) - Number(b.time))
+    const newNodeList: RewardPeriodEmission[] = []
+
+    newNodeList.push({
+      emissions_per_second: curr_emission_per_second,
+      emissions_per_day: d(curr_emission_per_second)
+        .mul(60 * 60 * 24)
+        .toString(),
+      emissions_per: '0',
+      time: last_updated_time.toString(),
+      visualized_time: new Date(last_updated_time * 1000).toLocaleString(),
+    })
+
+    let last_emission_rate = curr_emission_per_second
+    for (let i = 0; i < sortedList.length; i++) {
+      const item = sortedList[i]
+      if (d(item.time).lte(last_updated_time)) {
+        continue
+      }
+      last_emission_rate = d(last_emission_rate).add(d(item.emissions_per)).toString()
+      const emissions_per_day = d(last_emission_rate)
+        .mul(60 * 60 * 24)
+        .toString()
+      if (d(last_emission_rate).lt(0)) {
+        item.emissions_per_second = '0'
+        item.emissions_per_day = '0'
+      } else {
+        item.emissions_per_second = last_emission_rate
+        item.emissions_per_day = emissions_per_day
+      }
+      newNodeList.push(item)
+    }
+
+    return newNodeList
+  }
+
+  /**
+   * Add reward to a pool
+   * @param options - The options for adding reward
+   * @returns The transaction for adding reward
+   */
+  addRewardPayload(option: AddRewardOption, tx?: Transaction): Transaction {
+    tx = tx || new Transaction()
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    const { pool_id, reward_coin_type, reward_amount, start_time_seconds, end_time_seconds, coin_type_a, coin_type_b } = option
+    const reward_coin = CoinAssist.buildCoinWithBalance(BigInt(reward_amount), reward_coin_type, tx)
+
+    // const start_time_vec = tx.makeMoveVec({
+    //   elements: start_time_seconds ? [tx.pure.u64(start_time_seconds)] : [],
+    //   type: 'u64',
+    // })
+    tx.pure.option('u64', start_time_seconds)
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::add_reward`,
+      arguments: [
+        tx.object(pool_id),
+        reward_coin,
+        tx.pure.u64(reward_amount),
+        tx.pure.option('u64', start_time_seconds),
+        tx.pure.u64(end_time_seconds),
+        tx.object(global_config_id),
+        tx.object(versioned_id),
+        tx.object(CLOCK_ADDRESS),
+      ],
+      typeArguments: [coin_type_a, coin_type_b, reward_coin_type],
+    })
+
+    return tx
+  }
+
+  /**
+   * Initialize reward for a pool
+   * @param option - The option for initializing reward
+   * @param tx - The transaction to add the reward to
+   * @returns The transaction for initializing reward
+   */
+  initRewardPayload(option: InitRewardOption, tx?: Transaction): Transaction {
+    tx = tx || new Transaction()
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    const { pool_id, reward_coin_types, coin_type_a, coin_type_b } = option
+
+    reward_coin_types.forEach((reward_coin_type) => {
+      tx.moveCall({
+        target: `${dlmm_pool.published_at}::pool::initialize_reward`,
+        arguments: [tx.object(pool_id), tx.object(global_config_id), tx.object(versioned_id), tx.object(CLOCK_ADDRESS)],
+        typeArguments: [coin_type_a, coin_type_b, reward_coin_type],
+      })
+    })
+
+    return tx
+  }
+
+  /**
+   * Build the payload for making reward public or private
+   * @param option - The option for making reward public or private
+   * @param tx - The transaction to make the reward public or private
+   * @returns The transaction for making reward public or private
+   */
+  buildRewardAccessPayload(option: RewardAccessOption, tx?: Transaction): Transaction {
+    tx = tx || new Transaction()
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    const { pool_id, type, coin_type_a, coin_type_b } = option
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::${type === 'to_public' ? 'make_reward_public' : 'make_reward_private'}`,
+      arguments: [tx.object(pool_id), tx.object(global_config_id), tx.object(versioned_id)],
+      typeArguments: [coin_type_a, coin_type_b],
+    })
+
+    return tx
+  }
+}

package/src/modules/swapModule.ts

@@ -0,0 +1,129 @@
+import { Transaction } from '@mysten/sui/transactions'
+import { CLOCK_ADDRESS, CoinAssist, d, DETAILS_KEYS, getPackagerConfigs, IModule } from '@cetusprotocol/common-sdk'
+import { DlmmErrorCode, handleError } from '../errors/errors'
+import { CetusDlmmSDK } from '../sdk'
+import { PreSwapOption, PreSwapQuote, SwapOption } from '../types/dlmm'
+import { normalizeSuiAddress } from '@mysten/sui/utils'
+import { parsedSwapQuoteData } from '../utils/parseData'
+
+export class SwapModule implements IModule<CetusDlmmSDK> {
+  protected _sdk: CetusDlmmSDK
+
+  constructor(sdk: CetusDlmmSDK) {
+    this._sdk = sdk
+  }
+
+  get sdk() {
+    return this._sdk
+  }
+
+  async preSwapQuote(option: PreSwapOption): Promise<PreSwapQuote> {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { pool_id, coin_type_a, coin_type_b, a2b, by_amount_in, in_amount } = option
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+    const tx = new Transaction()
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::pool::flash_swap`,
+      arguments: [
+        tx.object(pool_id),
+        tx.pure.bool(a2b),
+        tx.pure.bool(by_amount_in),
+        tx.pure.u64(in_amount),
+        tx.object(global_config_id),
+        tx.object(versioned_id),
+        tx.object(CLOCK_ADDRESS),
+      ],
+      typeArguments: [coin_type_a, coin_type_b],
+    })
+
+    const simulateRes = await this.sdk.FullClient.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: normalizeSuiAddress('0x0'),
+    })
+
+    if (simulateRes.error != null) {
+      return handleError(DlmmErrorCode.FetchError, new Error(simulateRes.error), {
+        [DETAILS_KEYS.METHOD_NAME]: 'fetchSwapQuote',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+
+    const quoteInfo = parsedSwapQuoteData(simulateRes, a2b)
+    if (quoteInfo == null) {
+      return handleError(DlmmErrorCode.FetchError, new Error('No quote info'), {
+        [DETAILS_KEYS.METHOD_NAME]: 'preSwapQuote',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+    quoteInfo.a2b = a2b
+    return quoteInfo
+  }
+
+  swapPayload(option: SwapOption): Transaction {
+    const { dlmm_pool, dlmm_router } = this._sdk.sdkOptions
+    const { quote_obj, coin_type_a, coin_type_b, by_amount_in, slippage, partner } = option
+    const { pool_id, in_amount, out_amount, a2b } = quote_obj
+
+    const tx = new Transaction()
+
+    const in_amount_limit = by_amount_in
+      ? in_amount
+      : d(in_amount)
+          .mul(1 + slippage)
+          .toFixed(0)
+
+    const out_amount_limit = by_amount_in
+      ? d(out_amount)
+          .mul(1 - slippage)
+          .toFixed(0)
+      : out_amount
+
+    const in_coin = CoinAssist.buildCoinWithBalance(BigInt(in_amount_limit), a2b ? coin_type_a : coin_type_b, tx)
+
+    const { versioned_id, global_config_id } = getPackagerConfigs(dlmm_pool)
+
+    console.log('🚀 ~ SwapModule ~ option:', {
+      ...option,
+      in_amount_limit,
+      out_amount_limit,
+    })
+
+    if (partner) {
+      tx.moveCall({
+        target: `${dlmm_router.published_at}::swap::${a2b ? 'swap_a2b_with_partner' : 'swap_b2a_with_partner'}`,
+        arguments: [
+          tx.object(pool_id),
+          tx.object(partner),
+          in_coin,
+          tx.pure.bool(by_amount_in),
+          tx.pure.u64(BigInt(by_amount_in ? in_amount : out_amount)),
+          tx.pure.u64(BigInt(by_amount_in ? out_amount_limit : in_amount_limit)),
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+    } else {
+      tx.moveCall({
+        target: `${dlmm_router.published_at}::swap::${a2b ? 'swap_a2b' : 'swap_b2a'}`,
+        arguments: [
+          tx.object(pool_id),
+          in_coin,
+          tx.pure.bool(by_amount_in),
+          tx.pure.u64(BigInt(by_amount_in ? in_amount : out_amount)),
+          tx.pure.u64(BigInt(by_amount_in ? out_amount_limit : in_amount_limit)),
+          tx.object(global_config_id),
+          tx.object(versioned_id),
+          tx.object(CLOCK_ADDRESS),
+        ],
+        typeArguments: [coin_type_a, coin_type_b],
+      })
+    }
+
+    tx.transferObjects([in_coin], this.sdk.getSenderAddress())
+
+    return tx
+  }
+}

package/src/sdk.ts

@@ -0,0 +1,88 @@
+import type { BaseSdkOptions, Package } from '@cetusprotocol/common-sdk'
+import { SdkWrapper } from '@cetusprotocol/common-sdk'
+import type { DlmmConfigs } from './types/dlmm'
+import { dlmmMainnet } from './config/mainnet'
+import { PoolModule } from './modules/poolModule'
+import { dlmmTestnet } from './config/testnet'
+import { PositionModule } from './modules/positionModule'
+import { SwapModule } from './modules/swapModule'
+import { PartnerModule } from './modules/partnerModule'
+import { RewardModule } from './modules/rewardModule'
+import { ConfigModule } from './modules/configModule'
+
+/**
+ * Represents options and configurations for an SDK.
+ */
+export interface SdkOptions extends BaseSdkOptions {
+  dlmm_pool: Package<DlmmConfigs>
+  dlmm_router: Package
+  faucet?: Package
+}
+
+/**
+ * The entry class of CetusDcaSDK, which is almost responsible for all interactions with dca.
+ */
+export class CetusDlmmSDK extends SdkWrapper<SdkOptions> {
+  protected _pool: PoolModule
+  protected _position: PositionModule
+  protected _swap: SwapModule
+  protected _partner: PartnerModule
+  protected _reward: RewardModule
+  protected _config: ConfigModule
+
+  constructor(options: SdkOptions) {
+    super(options)
+
+    this._pool = new PoolModule(this)
+    this._position = new PositionModule(this)
+    this._swap = new SwapModule(this)
+    this._partner = new PartnerModule(this)
+    this._reward = new RewardModule(this)
+    this._config = new ConfigModule(this)
+  }
+
+  get Pool(): PoolModule {
+    return this._pool
+  }
+
+  get Position(): PositionModule {
+    return this._position
+  }
+
+  get Swap(): SwapModule {
+    return this._swap
+  }
+
+  get Partner(): PartnerModule {
+    return this._partner
+  }
+
+  get Reward(): RewardModule {
+    return this._reward
+  }
+
+  get Config(): ConfigModule {
+    return this._config
+  }
+
+  /**
+   * Static factory method to initialize the SDK
+   * @param options SDK initialization options
+   * @returns An instance of CetusBurnDK
+   */
+  static createSDK(options: BaseSdkOptions): CetusDlmmSDK {
+    const { env = 'mainnet' } = options
+    return env === 'mainnet'
+      ? CetusDlmmSDK.createCustomSDK({ ...dlmmMainnet, ...options })
+      : CetusDlmmSDK.createCustomSDK({ ...dlmmTestnet, ...options })
+  }
+
+  /**
+   * Create a custom SDK instance with the given options
+   * @param options The options for the SDK
+   * @returns An instance of CetusBurnSDK
+   */
+  static createCustomSDK<T extends BaseSdkOptions>(options: T & SdkOptions): CetusDlmmSDK {
+    return new CetusDlmmSDK(options)
+  }
+}

package/src/types/constants.ts

@@ -0,0 +1,23 @@
+export const MAX_BIN_PER_POSITION = 1000
+
+export const MIN_BIN_ID = -443636
+
+export const MAX_BIN_ID = 443636
+
+export const BASIS_POINT_MAX = 10000
+
+export const DEFAULT_MAX_WEIGHT = 2000
+
+export const DEFAULT_MIN_WEIGHT = 200
+
+export const BIN_BOUND = 443636n
+
+export const MAX_FEE_RATE = 100_000_000
+
+export const FEE_PRECISION = 1_000_000_000
+
+export const BASIS_POINT = 10000
+
+export const REWARD_PERIOD = 7 * 24 * 60 * 60
+
+export const REWARD_PERIOD_START_AT = 1747627200