@zofai/zo-sdk 0.1.92

package/src/interfaces/zlp.ts

@@ -0,0 +1,244 @@
+/**
+ * ZLP-specific interfaces and types
+ * Extends base interfaces with ZLP-specific implementations
+ */
+
+import type { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions'
+
+import type {
+  IBaseAPI,
+  IBaseCredential,
+  IBaseDataAPI,
+  IBaseFundingFeeModel,
+  IBaseHistory,
+  IBaseMarketInfo,
+  IBaseMarketValuationInfo,
+  IBaseOrderCapInfo,
+  IBaseOrderInfo,
+  IBasePositionCapInfo,
+  IBasePositionConfig,
+  IBasePositionInfo,
+  IBaseRebaseFeeModel,
+  IBaseReservingFeeModel,
+  IBaseStakePool,
+  IBaseSymbolInfo,
+  IBaseVaultInfo,
+} from './base'
+
+// ZLP-specific interfaces
+export interface IZLPMarketValuationInfo extends IBaseMarketValuationInfo { }
+
+export interface IZLPVaultInfo extends IBaseVaultInfo { }
+
+export interface IZLPReservingFeeModel extends IBaseReservingFeeModel { }
+
+export interface IZLPFundingFeeModel extends IBaseFundingFeeModel { }
+
+export interface IZLPRebaseFeeModel extends IBaseRebaseFeeModel { }
+
+export interface IZLPSymbolInfo extends IBaseSymbolInfo { }
+
+export interface IZLPMarketInfo extends IBaseMarketInfo {
+  // ZLP-specific market info fields can be added here
+}
+
+export interface IZLPPositionInfo extends IBasePositionInfo {
+  // ZLP-specific position fields can be added here
+}
+
+export interface IZLPPositionConfig extends IBasePositionConfig { }
+
+export interface IZLPPositionCapInfo extends IBasePositionCapInfo { }
+
+export interface IZLPOrderInfo extends IBaseOrderInfo { }
+
+export interface IZLPOrderCapInfo extends IBaseOrderCapInfo { }
+
+export interface IZLPHistory extends IBaseHistory {
+  // ZLP-specific history fields can be added here
+}
+
+export interface IZLPStakePool extends IBaseStakePool {
+  // ZLP-specific stake pool fields can be added here
+  rewardRate: bigint
+}
+
+export interface IZLPCredential extends IBaseCredential {
+  // ZLP-specific credential fields can be added here
+}
+
+// ZLP Symbol Config interfaces
+export interface IZLPPositionInstantExitFeeConfig {
+  instant_exit_tier_1_duration_threshold: number
+  instant_exit_tier_1_fee_bps: number
+  instant_exit_tier_1_fee_enabled: boolean
+  instant_exit_tier_2_duration_threshold: number
+  instant_exit_tier_2_fee_bps: number
+  instant_exit_tier_2_fee_enabled: boolean
+  instant_exit_tier_3_duration_threshold: number
+  instant_exit_tier_3_fee_bps: number
+  instant_exit_tier_3_fee_enabled: boolean
+}
+
+export interface IZLPSymbolConfig {
+  id: string
+  max_opening_size: number
+  max_opening_size_enabled: boolean
+  max_opening_size_per_position: number
+  max_opening_size_per_position_enabled: boolean
+  instant_exit_fee_config: IZLPPositionInstantExitFeeConfig
+}
+
+export interface IZLPOiFundingModel {
+  id: string
+  multiplier: number
+  exponent: number
+  max: number
+}
+export interface IZLPOiFundingState {
+  id: string
+  enabled: boolean
+  last_update: number
+  model: IZLPOiFundingModel
+}
+
+/**
+ * Price impact configuration for a trading symbol.
+ * Used to compute dynamic spreads based on OI skew.
+ */
+export interface IZLPPriceImpactConfig {
+  id: string
+  /** Whether price impact is enabled for this symbol */
+  enabled: boolean
+  /** Base spread applied to all trades (as a rate, e.g., 0.001 = 0.1%) */
+  baseSpreadRate: number
+  /** Maximum additional dynamic spread based on OI skew */
+  maxDynamicSpreadRate: number
+  /** Cap for total spread (base + dynamic) */
+  maxTotalSpreadRate: number
+  /** Exponent for spread curve (1.0=linear, 2.0=quadratic, 3.0=cubic) */
+  impactExponent: number
+  /** Maximum OI for long side used in skew calculation */
+  maxOiLong: number
+  /** Maximum OI for short side used in skew calculation */
+  maxOiShort: number
+  /** Reference position size for size scaling. If zero, size scaling is disabled. */
+  referenceSize: number
+}
+
+// ZLP-specific data API interface
+export interface IZLPDataAPI extends IBaseDataAPI {
+  getSymbolConfig: (indexToken: string, long: boolean) => Promise<IZLPSymbolConfig | null>
+  getPriceImpactConfig: (indexToken: string) => Promise<IZLPPriceImpactConfig | null>
+}
+
+// ZLP-specific API interface
+export interface IZLPAPI extends IBaseAPI {
+  adminIssueLootbox: (
+    coin: string,
+    tiers: number[],
+    beneficiaries: string[],
+    amounts: number[],
+    tx: Transaction,
+  ) => void
+
+  depositToPrizePool: (
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+  ) => Transaction
+
+  withdrawFromPricePool: (
+    coin: string,
+    amount: number
+  ) => Transaction
+
+  openLootbox: (
+    coin: string,
+    lootbox: string
+  ) => Transaction
+
+  adminIssueLootboxV2: (
+    coin: string,
+    tiers: number[],
+    beneficiaries: string[],
+    amounts: number[],
+    titles: string[],
+    descriptions: string[],
+    tx: Transaction,
+  ) => void
+
+  openLootboxV2: (
+    coin: string,
+    lootbox: string
+  ) => Transaction
+
+  adminIssueVestingLootboxV2: (
+    coin: string,
+    beneficiaries: string[],
+    unlockedAmounts: number[],
+    lockedAmounts: number[],
+    lockDurationsMs: number[],
+    tx: Transaction,
+  ) => void
+
+  claimUnlockedV2: (
+    coin: string,
+    vestingLootbox: string,
+  ) => Transaction
+
+  claimVestedV2: (
+    coin: string,
+    vestingLootbox: string,
+  ) => Transaction
+
+  destroyVestingLootboxV2: (
+    coin: string,
+    vestingLootbox: string,
+  ) => Transaction
+
+  depositPtb: (
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut?: number,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ) => Promise<TransactionObjectArgument>
+
+  stakeCoinObject: (
+    coinObject: TransactionObjectArgument,
+    pool: string,
+    tx?: Transaction,
+  ) => Transaction
+
+  withdrawLpCoinObject: (
+    coin: string,
+    lpCoinObject: TransactionObjectArgument,
+    minAmountOut: number,
+    tx?: Transaction,
+  ) => Promise<Transaction>
+
+  withdrawFromVaultPtb: (
+    pool: string,
+    credential: string,
+    withdrawAmount: bigint,
+    tx: Transaction,
+  ) => TransactionObjectArgument
+
+  claimRewardsPtb: (
+    pool: string,
+    credential: string,
+    tx: Transaction,
+  ) => TransactionObjectArgument
+
+  unstakeToCoins: (
+    credentials: IZLPCredential[],
+    amount: bigint,
+    pool: string,
+    tx: Transaction,
+  ) => TransactionObjectArgument[]
+}

package/src/oracle.ts

@@ -0,0 +1,153 @@
+import type { SuiClient } from '@mysten/sui/client'
+import { Transaction } from '@mysten/sui/transactions'
+import type { PriceFeed } from '@pythnetwork/pyth-sui-js'
+import { SuiPriceServiceConnection, SuiPythClient } from '@pythnetwork/pyth-sui-js'
+
+import type { IConsts, Network } from './consts'
+import { getConsts, getPriceIdToPythFeeder, getPythFeederToId, getPythFeederToPriceId, getSharedConfig, LPToken } from './consts'
+import { createJsonRpcProvider } from './utils'
+
+export class OracleAPI {
+  network: Network
+  consts: IConsts
+  sharedConfig: IConsts
+  connectionURL: string
+  PythFeederToPriceId: Record<string, string>
+  PythFeederToId: Record<string, string>
+  provider: SuiClient
+  client: SuiPythClient
+
+  private priceCache: Record<string, PriceFeed> = {}
+
+  constructor(
+    network: Network,
+    provider: SuiClient | null,
+    // todo 需要从配置文件中获取
+    connectionURL: string,
+    lpToken: LPToken = LPToken.ZLP,
+  ) {
+    this.network = network
+    this.consts = getConsts(network, lpToken)
+    this.sharedConfig = getSharedConfig(network)
+    this.connectionURL = connectionURL
+    this.PythFeederToPriceId = getPythFeederToPriceId(network)
+    this.PythFeederToId = getPythFeederToId(network)
+    this.provider = provider || createJsonRpcProvider(network)
+    this.client = new SuiPythClient(this.provider, this.consts.pythFeeder.state, this.consts.pythFeeder.wormhole.state)
+  }
+
+  validateCache() {
+    const now = Date.now() / 1000
+    for (const key in this.priceCache) {
+      if (now - (this.priceCache[key].getPriceUnchecked().publishTime || 0) > 7) {
+        delete this.priceCache[key]
+      }
+    }
+  }
+
+  async getOraclePrice(tokenId: string): Promise<PriceFeed> {
+    this.validateCache()
+    if (this.priceCache[tokenId]) {
+      return this.priceCache[tokenId]
+    }
+    const res = await this.getOraclePrices([tokenId])
+    if (!res || !res[0]) {
+      throw new Error(`Unknown token: ${tokenId}`)
+    }
+    this.priceCache[tokenId] = res[0]
+    return res[0]
+  }
+
+  async getOraclePrices(tokens: string[]): Promise<PriceFeed[]> {
+    const connection = new SuiPriceServiceConnection(this.connectionURL, {
+      priceFeedRequestConfig: {
+        binary: true,
+      },
+    })
+    const pythObjectIds = tokens.map(token => this.consts.pythFeeder.feeder[token])
+    const priceFeedIds = pythObjectIds.map(pythObjectId => `0x${this.PythFeederToPriceId[pythObjectId]}`)
+    const price = await connection.getLatestPriceFeeds(priceFeedIds)
+    return price || []
+  }
+
+  // memory leak
+  async subOraclePrices(tokens: string[], callback: (price: PriceFeed) => void): Promise<() => void> {
+    const connection = new SuiPriceServiceConnection(this.connectionURL, {
+      priceFeedRequestConfig: {
+        binary: true,
+      },
+    })
+    const pythObjectIds = tokens.map(token => this.consts.pythFeeder.feeder[token])
+    const priceFeedIds = pythObjectIds.map(pythObjectId => `0x${this.PythFeederToPriceId[pythObjectId]}`)
+    await connection.subscribePriceFeedUpdates(priceFeedIds, (price: any) => {
+      price.id = this.PythFeederToId[getPriceIdToPythFeeder(this.network)[price.id]]
+      this.priceCache[price.id] = price
+      callback(price)
+    })
+
+    return () => {
+      connection.unsubscribePriceFeedUpdates(priceFeedIds)
+    }
+  }
+
+  async initOracleTxb(
+    tokens: string[],
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObject?: any,
+  ) {
+    let tx_ = tx
+    if (!tx_) {
+      tx_ = new Transaction()
+    }
+    // Remove redundant tokens first
+    const uniqueTokens = Array.from(new Set(tokens))
+
+    const connection = new SuiPriceServiceConnection(this.connectionURL, {
+      priceFeedRequestConfig: {
+        binary: true,
+      },
+    })
+    let pythObjectIds = uniqueTokens.map(token => this.consts.pythFeeder.feeder[token])
+    // remove dupe object ids. If any of the object ids are duplicates the call will fail
+    pythObjectIds = [...new Set(pythObjectIds)].filter(Boolean)
+    const needUpdateObjectIds = (await this.provider.multiGetObjects({
+      ids: pythObjectIds,
+      options: {
+        showContent: true,
+      },
+    })).map(pythObject => [
+      Number.parseInt((pythObject.data?.content as any).fields.price_info.fields.arrival_time || 0, 10) - Date.now() / 1000,
+      pythObject.data?.objectId,
+    ]).filter((x: any) => Math.abs(x[0]) >= 0).map(x => x[1] as string)
+
+    if (needUpdateObjectIds.length === 0) {
+      return tx_
+    }
+
+    const priceFeedIds = needUpdateObjectIds
+      .map(pythObjectId => this.PythFeederToPriceId[pythObjectId])
+      .filter(Boolean)
+      .map(x => `0x${x}`)
+
+    const priceUpdateData = await connection.getPriceFeedsUpdateData(priceFeedIds)
+
+    if (sponsoredTx) {
+      const baseUpdateFee = await this.getBaseUpdateFee()
+      const pythUpdateCoins = tx_.splitCoins(
+        suiCoinObject,
+        priceFeedIds.map(() => tx_.pure.u64(baseUpdateFee)),
+      )
+      await this.client.updatePriceFeedsWithCoins(tx_, priceUpdateData, priceFeedIds, pythUpdateCoins)
+    }
+    else {
+      await this.client.updatePriceFeeds(tx_, priceUpdateData, priceFeedIds)
+    }
+
+    return tx_
+  }
+
+  async getBaseUpdateFee(): Promise<number> {
+    return await this.client.getBaseUpdateFee()
+  }
+}

package/src/utils.ts

@@ -0,0 +1,168 @@
+import { SuiClient, SuiHTTPTransport } from '@mysten/sui/client'
+
+import type { IConsts } from './consts'
+import { Network } from './consts'
+
+export function createJsonRpcProvider(network: Network) {
+  let url = ''
+  switch (network) {
+    case Network.DEVNET: {
+      url = 'https://explorer-rpc.devnet.sui.io/'
+      break
+    }
+    case Network.TESTNET: {
+      url = 'https://sui-testnet.blockvision.org/v1/2sXCJEJNOCdIJhLaDtyhKzqwn6k'
+      break
+    }
+    case Network.MAINNET: {
+      url = 'https://rpc-mainnet.suiscan.xyz'
+      break
+    }
+    default: {
+      url = 'https://explorer-rpc.devnet.sui.io/'
+    }
+  }
+
+  return new SuiClient({
+    transport: new SuiHTTPTransport({ url }),
+  })
+}
+
+export function decimalToObject(decimal: { value: string }) {
+  return Number(BigInt(decimal.value)) / 1e18
+}
+
+export function rateToObject(rate: { value: string }) {
+  return Number(BigInt(rate.value)) / 1e18
+}
+
+interface SRate {
+  fields: {
+    is_positive: boolean
+    value: {
+      fields: {
+        value: string | number
+      }
+    }
+  }
+}
+
+export function sRateToObject(sRate: SRate) {
+  const sign = sRate.fields.is_positive ? 1 : -1
+  return Number(BigInt(sRate.fields.value.fields.value)) / 1e18 * sign
+}
+
+interface SuiDecimal {
+  fields: {
+    is_positive: boolean
+    value: {
+      fields: {
+        value: string
+      }
+    }
+  }
+}
+
+export function sDecimalToObject(sDecimal: SuiDecimal) {
+  const sign = sDecimal.fields.is_positive ? 1 : -1
+  return Number(BigInt(sDecimal.fields.value.fields.value)) / 1e18 * sign
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function parseValue(field: any): number {
+  if (field.type && field.type.endsWith('::decimal::Decimal')) {
+    return decimalToObject({ value: field.fields.value })
+  }
+  else if (field.type && field.type.endsWith('::rate::Rate')) {
+    return rateToObject({ value: field.fields.value })
+  }
+  else if (field.type && field.type.endsWith('::srate::SRate')) {
+    return sRateToObject(field)
+  }
+  else if (field.type && field.type.endsWith('::sdecimal::SDecimal')) {
+    return sDecimalToObject(field)
+  }
+  return Number.parseInt(field, 10)
+}
+
+export type ReversedKeyValue<T extends object> = {
+  [K in keyof T]: T[K] extends keyof T
+    ? keyof T
+    : T[K] extends keyof T | infer V
+      ? V
+      : never;
+}
+
+export function reverseKeyValue<T extends object>(obj: T): ReversedKeyValue<T> {
+  const reversed: any = {}
+
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      const value = obj[key]
+      reversed[value] = key
+    }
+  }
+
+  return reversed
+}
+
+export function parseSymbolKey(input: string): string[] {
+  // This regex will match uppercase letters and numeric letters
+  const regex = /[A-Z0-9]/
+  let result: string[] = []
+  let wordStart = 0
+
+  for (let i = 1; i < input.length; i += 1) {
+    if (regex.test(input[i])) {
+      // Found an uppercase letter, so we split the string here
+      result.push(input.slice(wordStart, i))
+      wordStart = i
+    }
+  }
+
+  // Add the last word to the result array
+  result.push(input.slice(wordStart))
+
+  // Convert the words to lowercase, handle words ending with '_'
+  result = result.map(word => word.endsWith('_') ? word.slice(0, -1).toLowerCase() : word.toLowerCase())
+
+  return result
+}
+
+export function upperFirstCharacter(word: string): string {
+  return word.charAt(0).toUpperCase() + word.slice(1)
+}
+
+function isLetter(char: string): boolean {
+  return /^[a-z]$/i.test(char)
+}
+
+export function joinSymbol(direction: string, token: string): string {
+  const firstChar = token.charAt(0)
+  return `${direction}${isLetter(firstChar) ? upperFirstCharacter(token) : `_${token}`}`
+}
+
+export function suiSymbolToSymbol(symbol: string, consts: IConsts): string {
+  if (symbol === '0x2::sui::SUI') {
+    return 'sui'
+  }
+  const ret: Record<string, string> = {}
+  for (const key of Object.keys(consts.coins)) {
+    ret[consts.coins[key].module] = key
+  }
+  return ret[symbol]
+}
+
+export function base64ToUint8Array(base64: string) {
+  // Decode Base64 to binary
+  const binary = atob(base64)
+
+  // Create a Uint8Array from the binary data
+  const uint8Array = new Uint8Array(binary.length)
+  // Populate the Uint8Array with the binary data
+  for (let i = 0; i < binary.length; i += 1) {
+    uint8Array[i] = binary.codePointAt(i)!
+  }
+
+  return uint8Array
+}