@cetusprotocol/dlmm-sdk 0.0.1

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@cetusprotocol/dlmm-sdk",
+  "version": "0.0.1",
+  "description": "SDK for cetus dlmm",
+  "typings": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint src/*.ts src/**/*.ts",
+    "lint:fix": "eslint src/*.ts src/**/*.ts --fix",
+    "build": "pnpm run build:tsup",
+    "build:tsup": "npm run build:clean && npm run _build:node",
+    "build:clean": "rm -rf dist",
+    "_build:node": "tsup --format cjs,esm --dts",
+    "build:doc": "npx typedoc",
+    "publish_batch:test": "npm publish --tag experimental",
+    "publish:test": "node ../../scripts/version.js burn && npm publish --tag experimental"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "keywords": [],
+  "author": "test",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@cetusprotocol/common-sdk": "workspace:*",
+    "@cetusprotocol/test-utils": "workspace:*"
+  },
+  "peerDependencies": {
+    "@cetusprotocol/common-sdk": "*",
+    "@mysten/sui": "*"
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from './mainnet'
+export * from './testnet'

package/src/config/mainnet.ts

@@ -0,0 +1,25 @@
+import type { SdkOptions } from '../sdk'
+import { FullRpcUrlMainnet } from '@cetusprotocol/common-sdk'
+// mainnet
+export const dlmmMainnet: SdkOptions = {
+  env: 'mainnet',
+  full_rpc_url: FullRpcUrlMainnet,
+  dlmm_pool: {
+    package_id: '0x8eb878ff59ecd9326697dc80f9df55ccfb050a711bb712981b1dc509f393cbdf',
+    published_at: '0xa0f34a9aa8cd17e92c87bd93957c8daeba7fd45c2dbbba73f45ff47a93526c6b',
+    version: 1,
+    config: {
+      registry_id: '0xd436e82a6ef89b0ad4a1b8bd19b0e8e1c662e4a358a8dfe8221b1833abf3685b',
+      pools_id: '0x09bb9bde6875ba06551617aec1ea7a653cda0f526ae7ce42bdc6ef4a713a3f19',
+      global_config_id: '0xbf90603a8a7488a1440ed88e1d4c8d7b1f0c4cfd827dbb1c70655acc90258cc2',
+      versioned_id: '0x8bdb4c81a2d507dbbf4a5762e64a3c39cae1fd201b47aae474eff8b31e1f384a',
+      admin_cap_id: '0xec28f827eb125c80f316a0356b84eb52b98c6157bd443095843b1a3788518655',
+      partners_id: '0x19c6643ead4b13f4066db107a8606694cff3a2d81b7f11c759da460b5ea23491',
+    },
+  },
+  dlmm_router: {
+    package_id: '0xb269f062e8f7fd2bd653a79405dea7c48cb0bf62b11e33c939637d52b1560a65',
+    published_at: '0xb269f062e8f7fd2bd653a79405dea7c48cb0bf62b11e33c939637d52b1560a65',
+    version: 1,
+  },
+}

package/src/config/testnet.ts

@@ -0,0 +1,30 @@
+import { FullRpcUrlTestnet } from '@cetusprotocol/common-sdk'
+import type { SdkOptions } from '../sdk'
+
+export const dlmmTestnet: SdkOptions = {
+  env: 'testnet',
+  full_rpc_url: FullRpcUrlTestnet,
+  dlmm_pool: {
+    package_id: '0x05a79a247dc4c0daf0c03912cc2f14ebb3d0ca925482c3c09f516b16825bfc45',
+    published_at: '0x534b3ca6b921257b33db4d0d0ac5b4f37c1eb15c22c5a55b38faba8d9f91b1c3',
+    version: 1,
+    config: {
+      registry_id: '0xcb49fbeebeb778fcae261c3a9fad8abe7e329ac0f86ef458e0bd5b587b0ad858',
+      pools_id: '0x7fc11580586ea9f0941be9973345ebf82cf5c479353b865a22e59cd720b8bf04',
+      global_config_id: '0xac39b660d54aadaaef08b17605d0c91c102797be18b00b590647321f11948c35',
+      versioned_id: '0xc1d8eae3c5e6b5322136bbe71c3d348b1061695cf199e9c4d5efd1139b294edb',
+      admin_cap_id: '0x570ce0b84182892b8af58fd74307a144aa36b330141bfa01d0f0c1978d2325a8',
+      partners_id: '0xd7833b08e9637f4431f6a69dad8f6d0f9f3b09c16387b33ac527411df0f99d12',
+    },
+  },
+  dlmm_router: {
+    package_id: '0xe2c57dabc1ab2c48d17b50e418d77312c29d1f98594bdf5bffb643b07231ac09',
+    published_at: '0x3249405dc05e570e642bc8029f8ce0800ee1e7589e8988af8acc6730fd83dbf5',
+    version: 1,
+  },
+  faucet: {
+    package_id: '0x14a71d857b34677a7d57e0feb303df1adb515a37780645ab763d42ce8d1a5e48',
+    published_at: '0x14a71d857b34677a7d57e0feb303df1adb515a37780645ab763d42ce8d1a5e48',
+    version: 1,
+  },
+}

package/src/errors/errors.ts

@@ -0,0 +1,40 @@
+import { BaseError } from '@cetusprotocol/common-sdk'
+
+export enum DlmmErrorCode {
+  FetchError = 'FetchError',
+  ParseError = 'ParseError',
+  InvalidStrategyParams = 'InvalidStrategyParams',
+  InvalidBinWidth = 'InvalidBinWidth',
+  GetObjectError = 'GetObjectError',
+  InvalidBinId = 'InvalidBinId',
+  InsufficientLiquidity = 'InsufficientLiquidity',
+  InvalidParams = 'InvalidParams',
+  InvalidCoinTypeSequence = 'InvalidCoinTypeSequence',
+  NotFound = 'NotFound',
+  AmountTooSmall = 'AmountTooSmall',
+  LiquiditySupplyIsZero = 'LiquiditySupplyIsZero',
+  InvalidDeltaLiquidity = 'InvalidDeltaLiquidity',
+}
+
+export class DlmmError extends BaseError {
+  constructor(message: string, error_code?: DlmmErrorCode, details?: Record<string, any>) {
+    super(message, error_code || 'UnknownError', details)
+  }
+
+  static isDlmmErrorCode(e: any, code: DlmmErrorCode): boolean {
+    return this.isErrorCode<DlmmError>(e, code)
+  }
+}
+
+export const handleError = (code: DlmmErrorCode, error: Error | string, details?: Record<string, any>) => {
+  const errorDetails = {
+    ...details,
+    stack: error instanceof Error ? error.stack : undefined,
+  }
+
+  if (error instanceof Error) {
+    throw new DlmmError(error.message, code, errorDetails)
+  } else {
+    throw new DlmmError(error, code, errorDetails)
+  }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+import { CetusDlmmSDK, SdkOptions } from './sdk'
+
+export * from './utils'
+export * from './types'
+export * from './modules'
+export * from './config'
+export { CetusDlmmSDK, SdkOptions }
+export default CetusDlmmSDK

package/src/modules/configModule.ts

@@ -0,0 +1,184 @@
+import { Transaction } from '@mysten/sui/transactions'
+import { CLOCK_ADDRESS, DETAILS_KEYS, fixCoinType, getObjectFields, getPackagerConfigs, IModule } from '@cetusprotocol/common-sdk'
+import { DlmmErrorCode, handleError } from '../errors/errors'
+import { CetusDlmmSDK } from '../sdk'
+import { BinStepConfig, DlmmConfigs, DlmmGlobalConfig, RewardWhiteListOption } from '../types/dlmm'
+import { log } from 'console'
+
+export class ConfigModule implements IModule<CetusDlmmSDK> {
+  protected _sdk: CetusDlmmSDK
+
+  constructor(sdk: CetusDlmmSDK) {
+    this._sdk = sdk
+  }
+
+  get sdk() {
+    return this._sdk
+  }
+
+  /**
+   * Build the payload for adding or removing reward white list
+   * @param option - The option for adding or removing reward white list
+   * @param tx - The transaction to add the reward white list to
+   * @returns The transaction for adding or removing reward white list
+   */
+  buildRewardWhiteListPayload(option: RewardWhiteListOption, tx?: Transaction): Transaction {
+    tx = tx || new Transaction()
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    const { reward_coin_types, type } = option
+
+    reward_coin_types.forEach((reward_coin_type) => {
+      tx.moveCall({
+        target: `${dlmm_pool.published_at}::config::${type === 'add' ? 'add_reward_whitelist' : 'remove_reward_whitelist'}`,
+        arguments: [tx.object(global_config_id), tx.object(versioned_id)],
+        typeArguments: [reward_coin_type],
+      })
+    })
+
+    return tx
+  }
+
+  async getBinStepConfigList(bin_steps_handle: string): Promise<BinStepConfig[]> {
+    const res = await this._sdk.FullClient.getDynamicFields({
+      parentId: bin_steps_handle,
+    })
+
+    const list: BinStepConfig[] = []
+
+    const bin_step_ids = res.data.map((item) => item.objectId)
+
+    if (bin_step_ids.length > 0) {
+      const bin_step_configs = await this._sdk.FullClient.batchGetObjects(bin_step_ids, {
+        showContent: true,
+      })
+
+      bin_step_configs.forEach((item) => {
+        const fields = getObjectFields(item)
+        const bin_step_config: BinStepConfig = {
+          ...fields.value.fields,
+        }
+        list.push(bin_step_config)
+      })
+    }
+
+    return list
+  }
+
+  /**
+   * Get the list of bin step configs
+   * @returns The list of bin step configs
+   */
+  async getDlmmGlobalConfig(): Promise<DlmmGlobalConfig> {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { global_config_id } = getPackagerConfigs(dlmm_pool)
+    try {
+      const res = await this._sdk.FullClient.getObject({
+        id: global_config_id,
+        options: { showContent: true },
+      })
+
+      const fields = getObjectFields(res)
+
+      const reward_config = fields.reward_config.fields
+
+      const white_list: string[] =
+        reward_config.reward_white_list?.fields?.contents?.map((item: any) => {
+          return fixCoinType(item.fields.key.fields.name, false) as string
+        }) || []
+
+      const globalConfig: DlmmGlobalConfig = {
+        id: fields.id.id,
+        acl: {
+          id: fields.acl.fields.permissions.fields.id.id,
+          size: fields.acl.fields.permissions.fields.size,
+        },
+        allowed_list: {
+          id: fields.allowed_list.fields.id.id,
+          size: fields.allowed_list.fields.size,
+        },
+        denied_list: {
+          id: fields.denied_list.fields.id.id,
+          size: fields.denied_list.fields.size,
+        },
+        bin_steps: {
+          id: fields.bin_steps.fields.id.id,
+          size: fields.bin_steps.fields.size,
+        },
+        reward_white_list: white_list,
+        blocked_position: {
+          id: fields.restriction.fields.blocked_position.fields.permissions.fields.id.id,
+          size: fields.restriction.fields.blocked_position.fields.permissions.fields.size,
+        },
+        blocked_user: {
+          id: fields.restriction.fields.blocked_user.fields.permissions.fields.id.id,
+          size: fields.restriction.fields.blocked_user.fields.permissions.fields.size,
+        },
+        min_reward_duration: Number(reward_config.min_reward_duration),
+        non_manager_initialize_reward_cap: Number(reward_config.non_manager_initialize_reward_cap),
+        reward_public: reward_config.reward_public,
+      }
+
+      return globalConfig
+    } catch (error) {
+      console.log('fetchGlobalConfig error: ', error)
+      return handleError(DlmmErrorCode.FetchError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getBinStepConfigs',
+        [DETAILS_KEYS.REQUEST_PARAMS]: global_config_id,
+      })
+    }
+  }
+
+  /**
+   * Fetch the configs of the dlmm SDK
+   * @returns The configs of the dlmm
+   */
+  async fetchDlmmSdkConfigs(): Promise<DlmmConfigs> {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const configs: DlmmConfigs = {
+      registry_id: '',
+      pools_id: '',
+      global_config_id: '',
+      versioned_id: '',
+      admin_cap_id: '',
+      partners_id: '',
+    }
+
+    const res = await this._sdk.FullClient.getObject({
+      id: dlmm_pool.package_id,
+      options: { showContent: true, showPreviousTransaction: true },
+    })
+    const tx_digest = res.data?.previousTransaction!
+    const txRes = await this._sdk.FullClient.getTransactionBlock({ digest: tx_digest, options: { showEvents: true } })
+    txRes.events?.forEach((event) => {
+      const type = event.type
+      const parsedJson = event.parsedJson as any
+
+      if (type.includes('versioned::InitEvent')) {
+        configs.versioned_id = parsedJson.versioned
+      }
+
+      if (type.includes('partner::InitPartnerEvent')) {
+        configs.partners_id = parsedJson.partners_id
+      }
+
+      if (type.includes('config::InitEvent')) {
+        configs.global_config_id = parsedJson.config_id
+      }
+
+      if (type.includes('admin_cap::InitEvent')) {
+        configs.admin_cap_id = parsedJson.admin_cap_id
+      }
+
+      if (type.includes('registry::RegistryEvent')) {
+        configs.registry_id = parsedJson.pools_id
+      }
+    })
+    const registerRes = await this._sdk.FullClient.getObject({ id: configs.registry_id, options: { showContent: true } })
+    const registerFields = getObjectFields(registerRes)
+    configs.pools_id = registerFields.pools.fields.id.id
+
+    return configs
+  }
+}

package/src/modules/index.ts

@@ -0,0 +1 @@
+export * from './poolModule'

package/src/modules/partnerModule.ts

@@ -0,0 +1,302 @@
+import { Transaction } from '@mysten/sui/transactions'
+import { CLOCK_ADDRESS, d, DETAILS_KEYS, fixCoinType, getObjectFields, getPackagerConfigs, IModule } from '@cetusprotocol/common-sdk'
+import { DlmmErrorCode, handleError } from '../errors/errors'
+import { parsePartner } from '../utils'
+import { CetusDlmmSDK } from '../sdk'
+import { ClaimRefFeeOption, CreatePartnerOption, Partner, UpdateRefFeeRateOption, UpdateTimeRangeOption } from '../types/dlmm'
+import { BASIS_POINT } from '../types/constants'
+
+export class PartnerModule implements IModule<CetusDlmmSDK> {
+  protected _sdk: CetusDlmmSDK
+
+  constructor(sdk: CetusDlmmSDK) {
+    this._sdk = sdk
+  }
+
+  get sdk() {
+    return this._sdk
+  }
+
+  /**
+   * Get a list of partners.
+   * @returns {Promise<Partner[]>} A promise that resolves to an array of Partner objects.
+   */
+  async getPartnerList(): Promise<Partner[]> {
+    const allPartner: Partner[] = []
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { partners_id } = getPackagerConfigs(dlmm_pool)
+    try {
+      const res = await this._sdk.FullClient.getObject({ id: partners_id, options: { showContent: true } })
+      const fields = getObjectFields(res)
+      const warpIds = fields.partners.fields.contents.map((item: any) => {
+        return item.fields.value
+      })
+
+      if (warpIds.length > 0) {
+        const res = await this._sdk.FullClient.batchGetObjects(warpIds, {
+          showContent: true,
+          showType: true,
+        })
+        res.forEach((item) => {
+          const partner = parsePartner(item)
+          allPartner.push(partner)
+        })
+      }
+    } catch (error) {
+      return handleError(DlmmErrorCode.FetchError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getPartnerList',
+        [DETAILS_KEYS.REQUEST_PARAMS]: partners_id,
+      })
+    }
+
+    return allPartner
+  }
+
+  /**
+   * Get the partner cap ID for a given owner and partner ID.
+   * @param owner - The owner of the partner.
+   * @param partner_id - The ID of the partner.
+   * @returns A promise that resolves to the partner cap ID or undefined if not found.
+   */
+  async getPartnerCapId(owner: string, partner_id: string): Promise<string> {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    try {
+      const cacheKey = `partner_cap_id_${owner}_${partner_id}`
+      const cached = this._sdk.getCache<string>(cacheKey)
+      if (cached) {
+        return cached
+      }
+      const res = await this._sdk.FullClient.getOwnedObjects({
+        owner,
+        options: {
+          showContent: true,
+          showType: true,
+        },
+        filter: {
+          StructType: `${dlmm_pool.package_id}::partner::PartnerCap`,
+        },
+      })
+      let partnerCapId = undefined
+      res.data.forEach((item) => {
+        const fields = getObjectFields(item)
+        if (fields.partner_id === partner_id) {
+          partnerCapId = fields.id.id
+          this._sdk.updateCache(cacheKey, partnerCapId)
+        }
+      })
+      if (!partnerCapId) {
+        return handleError(DlmmErrorCode.NotFound, new Error('Partner cap not found'), {
+          [DETAILS_KEYS.METHOD_NAME]: 'getPartnerCapId',
+          [DETAILS_KEYS.REQUEST_PARAMS]: {
+            owner,
+            partner_id,
+          },
+        })
+      }
+      return partnerCapId
+    } catch (error) {
+      return handleError(DlmmErrorCode.FetchError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getPartnerCapId',
+        [DETAILS_KEYS.REQUEST_PARAMS]: {
+          owner,
+          partner_id,
+        },
+      })
+    }
+  }
+
+  /**
+   * Get the balance of a partner
+   * @param partner_balance_handle - The handle of the partner balance
+   * @returns A promise that resolves to an array of { coin_type: string; balance: string } objects.
+   */
+  async getPartnerBalance(partner_balance_handle: string) {
+    try {
+      const res = await this._sdk.FullClient.getDynamicFieldsByPage(partner_balance_handle)
+
+      const balanceList: { coin_type: string; balance: string }[] = []
+
+      const warpIds = res.data.map((item) => item.objectId)
+
+      if (warpIds.length > 0) {
+        const res = await this._sdk.FullClient.batchGetObjects(warpIds, {
+          showContent: true,
+          showType: true,
+        })
+        res.forEach((item) => {
+          const fields = getObjectFields(item)
+          console.log(fields)
+          balanceList.push({
+            coin_type: fixCoinType(fields.name, false),
+            balance: fields.value,
+          })
+        })
+      }
+      return balanceList
+    } catch (error) {
+      return handleError(DlmmErrorCode.FetchError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getPartnerBalance',
+        [DETAILS_KEYS.REQUEST_PARAMS]: partner_balance_handle,
+      })
+    }
+  }
+
+  /**
+   * Get a partner by its object ID.
+   * @param {string} partner_id The object ID of the partner to get.
+   * @returns {Promise<Partner>} A promise that resolves to a Partner object.
+   */
+  async getPartner(partner_id: string): Promise<Partner> {
+    try {
+      const res = await this._sdk.FullClient.getObject({ id: partner_id, options: { showContent: true } })
+      const partner = parsePartner(res)
+      return partner
+    } catch (error) {
+      return handleError(DlmmErrorCode.FetchError, error as Error, {
+        [DETAILS_KEYS.METHOD_NAME]: 'getPartner',
+        [DETAILS_KEYS.REQUEST_PARAMS]: partner_id,
+      })
+    }
+  }
+
+  /**
+   * Update the ref fee rate of a partner
+   * @param option - The option for updating the ref fee rate
+   * @returns The transaction for updating the ref fee rate
+   */
+  updateRefFeeRatePayload(option: UpdateRefFeeRateOption, tx?: Transaction): Transaction {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { partner_id, ref_fee_rate } = option
+
+    const { global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    tx = tx || new Transaction()
+
+    const ref_fee_rate_raw = d(ref_fee_rate).mul(BASIS_POINT)
+    if (ref_fee_rate_raw.gt(BASIS_POINT)) {
+      return handleError(DlmmErrorCode.InvalidParams, new Error('ref_fee_rate is cannot be greater than 1'), {
+        [DETAILS_KEYS.METHOD_NAME]: 'updateRefFeeRatePayload',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::partner::update_ref_fee_rate`,
+      arguments: [tx.object(partner_id), tx.pure.u64(ref_fee_rate_raw.toNumber()), tx.object(global_config_id), tx.object(versioned_id)],
+      typeArguments: [],
+    })
+
+    return tx
+  }
+
+  /**
+   * Create a claim ref fee payload
+   * @param option - The option for claiming ref fee
+   * @returns The transaction for claiming ref fee
+   */
+  async claimRefFeePayload(option: ClaimRefFeeOption) {
+    const { partner_id, partner_cap_id, fee_coin_types } = option
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    const tx = new Transaction()
+
+    let partnerCapId = partner_cap_id
+    if (!partnerCapId) {
+      partnerCapId = await this.getPartnerCapId(this._sdk.getSenderAddress(), partner_id)
+    }
+
+    fee_coin_types.forEach((coin_type) => {
+      tx.moveCall({
+        target: `${dlmm_pool.published_at}::partner::claim_ref_fee`,
+        arguments: [tx.object(partner_id), tx.object(partnerCapId), tx.object(versioned_id)],
+        typeArguments: [coin_type],
+      })
+    })
+
+    return tx
+  }
+
+  updateTimeRangePayload(option: UpdateTimeRangeOption, tx?: Transaction): Transaction {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { partner_id, start_time, end_time } = option
+
+    const { global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    tx = tx || new Transaction()
+
+    const startTimeInSeconds = start_time > 1e12 ? Math.floor(start_time / 1000) : start_time
+    const endTimeInSeconds = end_time > 1e12 ? Math.floor(end_time / 1000) : end_time
+
+    if (endTimeInSeconds <= startTimeInSeconds) {
+      return handleError(DlmmErrorCode.InvalidParams, new Error('end_time must be greater than start_time'), {
+        [DETAILS_KEYS.METHOD_NAME]: 'createPartnerPayload',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::partner::update_time_range`,
+      arguments: [
+        tx.object(partner_id),
+        tx.pure.u64(startTimeInSeconds),
+        tx.pure.u64(endTimeInSeconds),
+        tx.object(global_config_id),
+        tx.object(versioned_id),
+        tx.object(CLOCK_ADDRESS),
+      ],
+      typeArguments: [],
+    })
+
+    return tx
+  }
+
+  /**
+   * Create a partner
+   * @param option - The option for creating a partner
+   * @returns The transaction for creating a partner
+   */
+  createPartnerPayload(option: CreatePartnerOption): Transaction {
+    const { dlmm_pool } = this._sdk.sdkOptions
+    const { name, ref_fee_rate, start_time, end_time, recipient } = option
+
+    const { partners_id, global_config_id, versioned_id } = getPackagerConfigs(dlmm_pool)
+
+    const tx = new Transaction()
+
+    const ref_fee_rate_raw = d(ref_fee_rate).mul(BASIS_POINT)
+    if (ref_fee_rate_raw.gt(BASIS_POINT)) {
+      return handleError(DlmmErrorCode.InvalidParams, new Error('ref_fee_rate is cannot be greater than 1'), {
+        [DETAILS_KEYS.METHOD_NAME]: 'createPartnerPayload',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+
+    const startTimeInSeconds = start_time > 1e12 ? Math.floor(start_time / 1000) : start_time
+    const endTimeInSeconds = end_time > 1e12 ? Math.floor(end_time / 1000) : end_time
+
+    if (endTimeInSeconds <= startTimeInSeconds) {
+      return handleError(DlmmErrorCode.InvalidParams, new Error('end_time must be greater than start_time'), {
+        [DETAILS_KEYS.METHOD_NAME]: 'createPartnerPayload',
+        [DETAILS_KEYS.REQUEST_PARAMS]: option,
+      })
+    }
+
+    tx.moveCall({
+      target: `${dlmm_pool.published_at}::partner::create_partner`,
+      arguments: [
+        tx.object(partners_id),
+        tx.pure.string(name),
+        tx.pure.u64(ref_fee_rate_raw.toNumber()),
+        tx.pure.u64(startTimeInSeconds),
+        tx.pure.u64(endTimeInSeconds),
+        tx.pure.address(recipient),
+        tx.object(global_config_id),
+        tx.object(versioned_id),
+      ],
+      typeArguments: [],
+    })
+
+    return tx
+  }
+}