zo-sdk 0.1.25 → 0.1.27

package/src/implementations/SLPAPI.ts

@@ -379,6 +379,110 @@ export class SLPAPI extends BaseAPI implements ISLPAPI {
     return tx
   }
 
+  /**
+   * Stakes SLP tokens in ZO staking pools
+   */
+  public stakeV2(
+    lpCoinObjects: string[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    const coinObject = this.processCoins(tx, 'slp', lpCoinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        `${this.consts.sudoCore.package}::slp::SLP`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Stakes SLP tokens using coin object only (PTB)
+   */
+  public stakeCoinObjectV2(
+    coinObject: any,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.sudoCore.package}::slp::SLP`,
+        `${this.consts.sudoCore.package}::slp::SLP`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        coinObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Unstakes SLP tokens from ZO staking pools
+   */
+  public unstakeV2(
+    credentials: ISLPCredential[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    let unstakeAmount = amount
+    if (!tx) {
+      tx = new Transaction()
+    }
+    for (const credential of credentials) {
+      const withdrawAmount = (() => {
+        const min = (a: bigint, b: bigint) => a < b ? a : b
+        return min(unstakeAmount, credential.amount)
+      })()
+      unstakeAmount -= withdrawAmount
+      tx.moveCall({
+        target: `${this.sharedConfig.zoStaking.package}::pool::withdraw`,
+        typeArguments: [
+          `${this.consts.sudoCore.package}::slp::SLP`,
+          `${this.consts.sudoCore.package}::slp::SLP`,
+        ],
+        arguments: [
+          tx.object(pool),
+          tx.object(SUI_CLOCK_OBJECT_ID),
+          tx.object(credential.id),
+          tx.pure.u64(withdrawAmount),
+        ],
+      })
+      if (credential.amount === BigInt(0)) {
+        tx.moveCall({
+          target: `${this.sharedConfig.zoStaking.package}::pool::clear_empty_credential`,
+          typeArguments: [
+            `${this.consts.sudoCore.package}::slp::SLP`,
+            `${this.consts.sudoCore.package}::slp::SLP`,
+          ],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+    return tx
+  }
+
   /**
    * Opens a position using Sudo SDK approach
    */

package/src/implementations/SLPDataAPI.ts

@@ -339,11 +339,9 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
           const positionRaw = await this.provider.getDynamicFieldObject({
             parentId: this.consts.sudoCore.positionsParent,
             name: {
-              type: `${this.consts.sudoCore.package}::market::PositionName<${
-                positionCapInfo.symbol0
-              }, ${positionCapInfo.symbol1}, ${
-                this.consts.sudoCore.package
-              }::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
+              type: `${this.consts.sudoCore.package}::market::PositionName<${positionCapInfo.symbol0
+                }, ${positionCapInfo.symbol1}, ${this.consts.sudoCore.package
+                }::market::${positionCapInfo.long ? 'LONG' : 'SHORT'}>`,
               value: {
                 owner,
                 id: positionCapInfo.positionCapId,
@@ -463,6 +461,9 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     }
   }
 
+  /**
+   * Legacy method: Get stake pool from sudo_staking
+   */
   public async getStakePool(): Promise<ISLPStakePool> {
     const raw = await this.provider.getObject({
       id: this.consts.sudoStaking.pool,
@@ -473,6 +474,70 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     return SLPDataAPI.parseStakePool(raw)
   }
 
+  public async getStakePoolV2(): Promise<ISLPStakePool> {
+    const poolId = this.sharedConfig.zoStaking.pools.SLP
+    const raw = await this.provider.getObject({
+      id: poolId,
+      options: {
+        showContent: true,
+      },
+    })
+    return SLPDataAPI.parseStakePool(raw)
+  }
+
+  public async getStakedV2(owner: string): Promise<ISLPStaked> {
+    let rawCredentialsData: any[] = []
+    let queryNextPage = true
+    let queryCursor
+    const limit = 50
+
+    while (queryNextPage) {
+      const { data, hasNextPage, nextCursor } = await this.provider.getOwnedObjects({
+        owner,
+        filter: {
+          MoveModule: {
+            package: this.sharedConfig.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.getStakePoolV2()
+
+    const credentials = rawCredentialsData
+      .filter(
+        (item: any) =>
+          item.data.type ===
+          `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.sudoCore.package}::slp::SLP, ${this.consts.sudoCore.package}::slp::SLP>`
+      ).map((item: any) =>
+        SLPDataAPI.parseCredential(item, pool),
+      )
+    return {
+      credentials,
+      amount: credentials.reduce(
+        (acc: bigint, cur: ISLPCredential) => acc + cur.amount,
+        BigInt(0),
+      ),
+      claimable: credentials.reduce(
+        (acc: bigint, cur: ISLPCredential) => acc + cur.claimable,
+        BigInt(0),
+      ),
+    }
+  }
+
   public async fundingFeeRate(indexToken: string, long: boolean, sender?: string): Promise<number> {
     if (!sender) {
       throw new Error('Sender address is required for fundingFeeRate calculation')
@@ -835,13 +900,10 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
           const orderRaw = await this.provider.getDynamicFieldObject({
             parentId: this.consts.sudoCore.ordersParent,
             name: {
-              type: `${this.consts.sudoCore.package}::market::OrderName<${
-                orderCapInfo.symbol0
-              }, ${orderCapInfo.symbol1}, ${
-                this.consts.sudoCore.package
-              }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${
-                this.consts.coins.sui.module
-              }>`,
+              type: `${this.consts.sudoCore.package}::market::OrderName<${orderCapInfo.symbol0
+                }, ${orderCapInfo.symbol1}, ${this.consts.sudoCore.package
+                }::market::${orderCapInfo.long ? 'LONG' : 'SHORT'}, ${this.consts.coins.sui.module
+                }>`,
               value: {
                 owner,
                 id: orderCapInfo.orderCapId,
@@ -1197,21 +1259,36 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
 
   private static parseStakePool(raw: any): ISLPStakePool {
     const content = raw.data.content.fields
-    const pool = {
+
+    // Check if this is the new version with reward_vault and reward_rate
+    const isNewVersion = content.reward_vault !== undefined && content.reward_rate !== undefined
+
+    const pool: ISLPStakePool = {
       id: content.id.id,
       enabled: content.enabled,
       lastUpdatedTime: parseValue(content.last_updated_time),
       stakedAmount: BigInt(content.staked_amount),
-      reward: BigInt(content.reward),
+      // Support both old 'reward' and new 'reward_vault' field names
+      reward: BigInt(content.reward_vault || content.reward),
       startTime: parseValue(content.start_time),
       endTime: parseValue(content.end_time),
       accRewardPerShare: BigInt(content.acc_reward_per_share),
       lockDuration: parseValue(content.lock_duration),
+      // Add rewardRate if available (new version)
+      ...(isNewVersion && { rewardRate: BigInt(content.reward_rate) }),
     }
-    SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
+
+    // Use appropriate refresh method based on version
+    if (isNewVersion) {
+      SLPDataAPI.refreshPoolV2(pool, Math.floor(Date.now() / 1000))
+    } else {
+      SLPDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
+    }
+
     return pool
   }
 
+  // Legacy refresh method for backward compatibility
   private static refreshPool(pool: ISLPStakePool, timestamp: number): void {
     if (timestamp === pool.lastUpdatedTime || timestamp < pool.startTime) {
       return
@@ -1234,4 +1311,24 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
     const rewardPerShare = (rewardAmount * BigInt(1e18)) / pool.stakedAmount
     pool.accRewardPerShare += rewardPerShare
   }
+
+  // New refresh method matching SLP implementation
+  private static refreshPoolV2(pool: ISLPStakePool, 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 && 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/implementations/USDZAPI.ts

@@ -742,10 +742,6 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     pool: string,
     tx?: Transaction,
   ): Transaction {
-    if (!this.consts.zoStaking) {
-      throw new Error('ZO staking configuration not found')
-    }
-
     if (!tx) {
       tx = new Transaction()
     }
@@ -754,7 +750,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
 
     tx.moveCall({
-      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
       typeArguments: [
         `${this.consts.zoCore.package}::usdz::USDZ`,
         `${this.consts.coins.sui.module}`,
@@ -776,16 +772,12 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     pool: string,
     tx?: Transaction,
   ): Transaction {
-    if (!this.consts.zoStaking) {
-      throw new Error('ZO staking configuration not found')
-    }
-
     if (!tx) {
       tx = new Transaction()
     }
 
     tx.moveCall({
-      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
       typeArguments: [
         `${this.consts.zoCore.package}::usdz::USDZ`,
         `${this.consts.coins.sui.module}`,
@@ -808,10 +800,6 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     pool: string,
     tx?: Transaction,
   ): Transaction {
-    if (!this.consts.zoStaking) {
-      throw new Error('ZO staking configuration not found')
-    }
-
     let unstakeAmount = amount
     if (!tx) {
       tx = new Transaction()
@@ -823,7 +811,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
       })()
       unstakeAmount -= withdrawAmount
       tx.moveCall({
-        target: `${this.consts.zoStaking.package}::pool::withdraw`,
+        target: `${this.sharedConfig.zoStaking.package}::pool::withdraw`,
         typeArguments: [
           `${this.consts.zoCore.package}::usdz::USDZ`,
           `${this.consts.coins.sui.module}`,
@@ -837,10 +825,10 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
       })
       if (credential.amount === BigInt(0)) {
         tx.moveCall({
-          target: `${this.consts.zoStaking.package}::pool::clear_empty_credential`,
+          target: `${this.sharedConfig.zoStaking.package}::pool::clear_empty_credential`,
           typeArguments: [
             `${this.consts.zoCore.package}::usdz::USDZ`,
-          `${this.consts.coins.sui.module}`,
+            `${this.consts.coins.sui.module}`,
           ],
           arguments: [tx.object(credential.id)],
         })

package/src/implementations/USDZDataAPI.ts

@@ -55,7 +55,7 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
         owner,
         filter: {
           MoveModule: {
-            package: this.consts.zoStaking.package,
+            package: this.sharedConfig.zoStaking.package,
             module: 'pool',
           },
         },
@@ -76,9 +76,14 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
 
     const pool = await this.getStakePool()
 
-    const credentials = rawCredentialsData.map((item: any) =>
-      USDZDataAPI.parseCredential(item, pool),
-    )
+    const credentials = rawCredentialsData
+      .filter(
+        (item: any) =>
+          item.data.type ===
+          `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.zoCore.package}::usdz::USDZ, 0x2::sui::SUI>`
+      ).map((item: any) =>
+        USDZDataAPI.parseCredential(item, pool),
+      )
     return {
       credentials,
       amount: credentials.reduce(
@@ -93,8 +98,9 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
   }
 
   public async getStakePool(): Promise<IUSDZStakePool> {
+    const poolId = this.sharedConfig.zoStaking.pools.USDZ
     const raw = await this.provider.getObject({
-      id: this.consts.zoStaking.pools[0],
+      id: poolId,
       options: {
         showContent: true,
       },

package/src/implementations/ZBTCVCAPI.ts

@@ -742,10 +742,6 @@ export class ZBTCVCAPI extends BaseAPI implements IZBTCVCAPI {
     pool: string,
     tx?: Transaction,
   ): Transaction {
-    if (!this.consts.zoStaking) {
-      throw new Error('ZO staking configuration not found')
-    }
-
     if (!tx) {
       tx = new Transaction()
     }
@@ -754,7 +750,7 @@ export class ZBTCVCAPI extends BaseAPI implements IZBTCVCAPI {
     const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
 
     tx.moveCall({
-      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
       typeArguments: [
         `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
         `${this.consts.coins.sui.module}`,
@@ -776,16 +772,12 @@ export class ZBTCVCAPI extends BaseAPI implements IZBTCVCAPI {
     pool: string,
     tx?: Transaction,
   ): Transaction {
-    if (!this.consts.zoStaking) {
-      throw new Error('ZO staking configuration not found')
-    }
-
     if (!tx) {
       tx = new Transaction()
     }
 
     tx.moveCall({
-      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
       typeArguments: [
         `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
         `${this.consts.coins.sui.module}`,
@@ -808,10 +800,6 @@ export class ZBTCVCAPI extends BaseAPI implements IZBTCVCAPI {
     pool: string,
     tx?: Transaction,
   ): Transaction {
-    if (!this.consts.zoStaking) {
-      throw new Error('ZO staking configuration not found')
-    }
-
     let unstakeAmount = amount
     if (!tx) {
       tx = new Transaction()
@@ -823,7 +811,7 @@ export class ZBTCVCAPI extends BaseAPI implements IZBTCVCAPI {
       })()
       unstakeAmount -= withdrawAmount
       tx.moveCall({
-        target: `${this.consts.zoStaking.package}::pool::withdraw`,
+        target: `${this.sharedConfig.zoStaking.package}::pool::withdraw`,
         typeArguments: [
           `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
           `${this.consts.coins.sui.module}`,
@@ -837,10 +825,10 @@ export class ZBTCVCAPI extends BaseAPI implements IZBTCVCAPI {
       })
       if (credential.amount === BigInt(0)) {
         tx.moveCall({
-          target: `${this.consts.zoStaking.package}::pool::clear_empty_credential`,
+          target: `${this.sharedConfig.zoStaking.package}::pool::clear_empty_credential`,
           typeArguments: [
             `${this.consts.zoCore.package}::zbtcvc::ZBTCVC`,
-          `${this.consts.coins.sui.module}`,
+            `${this.consts.coins.sui.module}`,
           ],
           arguments: [tx.object(credential.id)],
         })

package/src/implementations/ZBTCVCDataAPI.ts

@@ -76,9 +76,15 @@ export class ZBTCVCDataAPI extends BaseDataAPI implements IZBTCVCDataAPI {
 
     const pool = await this.getStakePool()
 
-    const credentials = rawCredentialsData.map((item: any) =>
-      ZBTCVCDataAPI.parseCredential(item, pool),
-    )
+    // TODO: Update reward coin type once available
+    const credentials = rawCredentialsData
+      .filter(
+        (item: any) =>
+          item.data.type ===
+          `${this.sharedConfig.zoStaking.package}::pool::Credential<${this.consts.zoCore.package}::zbtcvc::ZBTCVC, 0x2::sui::SUI>`
+      ).map((item: any) =>
+        ZBTCVCDataAPI.parseCredential(item, pool),
+      )
     return {
       credentials,
       amount: credentials.reduce(
@@ -93,8 +99,9 @@ export class ZBTCVCDataAPI extends BaseDataAPI implements IZBTCVCDataAPI {
   }
 
   public async getStakePool(): Promise<IZBTCVCStakePool> {
+    const poolId = this.consts.zoStaking.pools.ZBTCVC
     const raw = await this.provider.getObject({
-      id: this.consts.zoStaking.pools[0],
+      id: poolId,
       options: {
         showContent: true,
       },