zo-sdk 0.1.24 → 0.1.26

package/src/implementations/ZLPDataAPI.ts

@@ -15,6 +15,7 @@ import type {
   IBaseHistoryResponse,
   IBaseStaked,
   IBaseStakePool,
+  IZLPCredential,
   IZLPDataAPI,
   IZLPFundingFeeModel,
   IZLPMarketInfo,
@@ -26,6 +27,7 @@ import type {
   IZLPPositionInfo,
   IZLPRebaseFeeModel,
   IZLPReservingFeeModel,
+  IZLPStakePool,
   IZLPSymbolConfig,
   IZLPSymbolInfo,
   IZLPVaultInfo,
@@ -42,12 +44,64 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     super(network, provider, apiEndpoint, connectionURL, LPToken.ZLP)
   }
 
-  public getStaked(_owner: string): Promise<IBaseStaked> {
-    throw new Error(`${this.constructor.name}: Method not implemented.`)
+  public async getStaked(owner: string): Promise<IBaseStaked> {
+    let rawCredentialsData: any[] = []
+    let queryNextPage = true
+    let queryCursor: string | undefined | null
+
+    const limit = 50
+
+    while (queryNextPage) {
+      const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          MoveModule: {
+            package: this.consts.zoStaking.package,
+            module: 'pool',
+          },
+        },
+        options: {
+          showType: true,
+          showContent: true,
+        },
+        cursor: queryCursor,
+        limit,
+      })
+
+      queryNextPage = hasNextPage
+      queryCursor = nextCursor!
+      if (!data)
+        break
+      rawCredentialsData = [...rawCredentialsData, ...data]
+    }
+
+    const pool = await this.getStakePool()
+
+    const credentials = rawCredentialsData.map((item: any) =>
+      ZLPDataAPI.parseCredential(item, pool),
+    )
+    return {
+      credentials,
+      amount: credentials.reduce(
+        (acc: bigint, cur: IZLPCredential) => acc + cur.amount,
+        BigInt(0),
+      ),
+      claimable: credentials.reduce(
+        (acc: bigint, cur: IZLPCredential) => acc + cur.claimable,
+        BigInt(0),
+      ),
+    }
   }
 
-  public getStakePool(): Promise<IBaseStakePool> {
-    throw new Error(`${this.constructor.name}: Method not implemented.`)
+  public async getStakePool(): Promise<IZLPStakePool> {
+    const poolId = this.consts.zoStaking.pools.ZLP
+    const raw = await this.provider.getObject({
+      id: poolId,
+      options: {
+        showContent: true,
+      },
+    })
+    return ZLPDataAPI.parseStakePool(raw)
   }
 
   /**
@@ -907,4 +961,57 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     return vaultInfo.unrealisedReservingFeeAmount
       + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18
   }
+
+  private static parseCredential(raw: any, pool: IZLPStakePool): IZLPCredential {
+    const stakedAmount = BigInt(raw.data.content.fields.stake)
+    const accRewardPerShare = BigInt(
+      raw.data.content.fields.acc_reward_per_share,
+    )
+    return {
+      id: raw.data.objectId,
+      lockUntil: parseValue(raw.data.content.fields.lock_until),
+      amount: stakedAmount,
+      accRewardPerShare,
+      claimable:
+        ((pool.accRewardPerShare - accRewardPerShare) * stakedAmount)
+        / BigInt(1e18),
+    }
+  }
+
+  private static parseStakePool(raw: any): IZLPStakePool {
+    const content = raw.data.content.fields
+    const pool = {
+      id: content.id.id,
+      enabled: content.enabled,
+      lastUpdatedTime: parseValue(content.last_updated_time),
+      stakedAmount: BigInt(content.staked_amount),
+      reward: BigInt(content.reward_vault),
+      startTime: parseValue(content.start_time),
+      endTime: parseValue(content.end_time),
+      rewardRate: BigInt(content.reward_rate),
+      accRewardPerShare: BigInt(content.acc_reward_per_share),
+      lockDuration: parseValue(content.lock_duration),
+    }
+    ZLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
+    return pool
+  }
+
+  private static refreshPool(pool: IZLPStakePool, timestamp: number): void {
+    if (timestamp <= pool.lastUpdatedTime || timestamp < pool.startTime) {
+      return
+    }
+
+    const applicableEndTime = Math.max(pool.endTime, pool.lastUpdatedTime)
+
+    const calculationEndTime = Math.min(timestamp, applicableEndTime)
+
+    if (calculationEndTime > pool.lastUpdatedTime && pool.stakedAmount > BigInt(0) && pool.rewardRate > BigInt(0)) {
+      const timeDiff = BigInt(calculationEndTime - pool.lastUpdatedTime)
+      const rewardAmount = timeDiff * pool.rewardRate
+      const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount
+      pool.accRewardPerShare += rewardPerShare
+    }
+
+    pool.lastUpdatedTime = calculationEndTime
+  }
 }

package/src/interfaces/base.ts

@@ -372,7 +372,9 @@ export interface IBaseAPI {
     indexToken: string,
     amount: number,
     coinObjects: string[],
-    long: boolean
+    long: boolean,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
   ) => Promise<Transaction>
 
   redeemFromPosition: (
@@ -380,7 +382,9 @@ export interface IBaseAPI {
     collateralToken: string,
     indexToken: string,
     amount: number,
-    long: boolean
+    long: boolean,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
   ) => Promise<Transaction>
 
   cancelOrder: (

package/src/interfaces/slp.ts

@@ -56,7 +56,10 @@ export interface ISLPHistory extends IBaseHistory { }
 
 export interface ISLPStaked extends IBaseStaked { }
 
-export interface ISLPStakePool extends IBaseStakePool { }
+export interface ISLPStakePool extends IBaseStakePool {
+  // SLP-specific stake pool fields to match new staking implementation
+  rewardRate?: bigint // Optional for backward compatibility
+}
 
 export interface ISLPCredential extends IBaseCredential { }
 

package/src/interfaces/zlp.ts

@@ -60,6 +60,7 @@ export interface IZLPHistory extends IBaseHistory {
 
 export interface IZLPStakePool extends IBaseStakePool {
   // ZLP-specific stake pool fields can be added here
+  rewardRate: bigint
 }
 
 export interface IZLPCredential extends IBaseCredential {

package/src/oracle.ts

@@ -4,12 +4,13 @@ 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, LPToken } 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>
@@ -27,6 +28,7 @@ export class OracleAPI {
   ) {
     this.network = network
     this.consts = getConsts(network, lpToken)
+    this.sharedConfig = getSharedConfig(network)
     this.connectionURL = connectionURL
     this.PythFeederToPriceId = getPythFeederToPriceId(network)
     this.PythFeederToId = getPythFeederToId(network)

package/src/utils.ts

@@ -123,8 +123,8 @@ export function parseSymbolKey(input: string): string[] {
   // Add the last word to the result array
   result.push(input.slice(wordStart))
 
-  // Convert the words to lowercase
-  result = result.map(word => word.toLowerCase())
+  // Convert the words to lowercase, handle words ending with '_'
+  result = result.map(word => word.endsWith('_') ? word.slice(0, -1).toLowerCase() : word.toLowerCase())
 
   return result
 }