zo-sdk 0.1.24 → 0.1.26

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,65 @@ 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.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 +895,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 +1254,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 && pool.rewardRate) {
+      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 +1306,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',
           },
         },
@@ -93,8 +93,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

@@ -93,8 +93,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,
       },

package/src/implementations/ZLPAPI.ts

@@ -28,6 +28,7 @@ import type {
   IBaseSymbolInfo,
   IBaseVaultInfo,
   IZLPAPI,
+  IZLPCredential,
 } from '../interfaces'
 import { joinSymbol } from '../utils'
 import { ZLPDataAPI } from './ZLPDataAPI'
@@ -45,14 +46,6 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     this.dataAPI = new ZLPDataAPI(network, provider, apiEndpoint, connectionURL)
   }
 
-  public stake(_lpCoinObjects: string[], _amount: bigint, _pool: string, _tx?: Transaction): Transaction {
-    throw new Error(`Method not implemented in ${this.constructor.name}.`)
-  }
-
-  public unstake(_credentials: IBaseCredential[], _amount: bigint, _pool: string, _tx?: Transaction): Transaction {
-    throw new Error(`Method not implemented in ${this.constructor.name}.`)
-  }
-
   public claimTokenFromSCard(_token: string, _coinObjects: string[], _kioskClient: KioskClient, _kioskCap: KioskOwnerCap, _scard: string): Transaction {
     throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
@@ -275,6 +268,110 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     return tx
   }
 
+  /**
+   * Stakes ZLP tokens in ZO staking pools
+   */
+  public stake(
+    lpCoinObjects: string[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    const coinObject = this.processCoins(tx, 'zlp', lpCoinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        `${this.consts.coins.sui.module}`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Stakes ZLP tokens using coin object only (PTB)
+   */
+  public stakeCoinObject(
+    coinObject: any,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    tx.moveCall({
+      target: `${this.sharedConfig.zoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::zlp::ZLP`,
+        `${this.consts.coins.sui.module}`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        coinObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Unstakes ZLP tokens from ZO staking pools
+   */
+  public unstake(
+    credentials: IZLPCredential[],
+    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.zoCore.package}::zlp::ZLP`,
+          `${this.consts.coins.sui.module}`,
+        ],
+        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.zoCore.package}::zlp::ZLP`,
+            `${this.consts.coins.sui.module}`,
+          ],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+    return tx
+  }
+
   public async swap(
     fromToken: string,
     toToken: string,
@@ -1298,15 +1395,15 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     }
     for (const [i, beneficiary] of beneficiaries.entries()) {
       tx.moveCall({
-        target: `${this.consts.zoLootbox.package}::lootbox::admin_issue_lootbox`,
+        target: `${this.sharedConfig.zoLootbox.package}::lootbox::admin_issue_lootbox`,
         typeArguments: [module],
         arguments: [
-          tx.object(this.consts.zoLootbox.adminCap),
+          tx.object(this.sharedConfig.zoLootbox.adminCap),
           tx.pure.u8(tiers[i]),
           tx.pure.address(beneficiary),
           tx.pure.u64(amounts[i]),
           tx.pure.bool(amounts[i] > 0),
-          tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
+          tx.object(`${this.sharedConfig.zoLootbox.lootboxSettings}`),
         ],
       })
     }
@@ -1327,11 +1424,11 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     }
 
     tx.moveCall({
-      target: `${this.consts.zoLootbox.package}::lootbox::deposit`,
+      target: `${this.sharedConfig.zoLootbox.package}::lootbox::deposit`,
       typeArguments: [module],
       arguments: [
-        tx.object(this.consts.zoLootbox.adminCap),
-        tx.object(this.consts.zoLootbox.lootboxTreasury),
+        tx.object(this.sharedConfig.zoLootbox.adminCap),
+        tx.object(this.sharedConfig.zoLootbox.lootboxTreasury),
         depositObject,
       ],
     })
@@ -1352,11 +1449,11 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     }
 
     tx.moveCall({
-      target: `${this.consts.zoLootbox.package}::lootbox::withdraw`,
+      target: `${this.sharedConfig.zoLootbox.package}::lootbox::withdraw`,
       typeArguments: [module],
       arguments: [
-        tx.object(this.consts.zoLootbox.adminCap),
-        tx.object(this.consts.zoLootbox.lootboxTreasury),
+        tx.object(this.sharedConfig.zoLootbox.adminCap),
+        tx.object(this.sharedConfig.zoLootbox.lootboxTreasury),
         tx.object(metadata),
         tx.pure.u64(amount),
       ],
@@ -1378,13 +1475,13 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     }
 
     tx.moveCall({
-      target: `${this.consts.zoLootbox.upgradedPackage}::lootbox::open_lootbox`,
+      target: `${this.sharedConfig.zoLootbox.upgradedPackage}::lootbox::open_lootbox`,
       typeArguments: [module],
       arguments: [
-        tx.object(`${this.consts.zoLootbox.lootboxTreasury}`),
+        tx.object(`${this.sharedConfig.zoLootbox.lootboxTreasury}`),
         tx.object(lootbox),
         tx.object(metadata),
-        tx.object(`${this.consts.zoLootbox.lootboxSettings}`),
+        tx.object(`${this.sharedConfig.zoLootbox.lootboxSettings}`),
       ],
     })
 
@@ -1408,18 +1505,18 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
 
     for (const [i, beneficiary] of beneficiaries.entries()) {
       const moveCallArgs = {
-        target: `${this.consts.zoLootboxV2.package}::lootbox::admin_issue_lootbox`,
+        target: `${this.sharedConfig.zoLootboxV2.package}::lootbox::admin_issue_lootbox`,
         typeArguments: [module],
         arguments: [
-          tx.object(this.consts.zoLootboxV2.adminCap),
-          tx.object(this.consts.zoLootboxV2.lootboxTreasury),
+          tx.object(this.sharedConfig.zoLootboxV2.adminCap),
+          tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
           tx.pure.u8(tiers[i]),
           tx.pure.address(beneficiary),
           tx.pure.u64(amounts[i]),
           tx.pure.bool(amounts[i] > 0),
           tx.pure.string(titles[i]),
           tx.pure.string(descriptions[i]),
-          tx.object(`${this.consts.zoLootboxV2.lootboxSettings}`),
+          tx.object(`${this.sharedConfig.zoLootboxV2.lootboxSettings}`),
         ],
       }
 
@@ -1441,13 +1538,13 @@ export class ZLPAPI extends BaseAPI implements IZLPAPI {
     }
 
     tx.moveCall({
-      target: `${this.consts.zoLootboxV2.package}::lootbox::open_lootbox`,
+      target: `${this.sharedConfig.zoLootboxV2.package}::lootbox::open_lootbox`,
       typeArguments: [module],
       arguments: [
-        tx.object(this.consts.zoLootboxV2.lootboxTreasury),
+        tx.object(this.sharedConfig.zoLootboxV2.lootboxTreasury),
         tx.object(lootbox),
         tx.object(metadata),
-        tx.object(this.consts.zoLootboxV2.lootboxSettings),
+        tx.object(this.sharedConfig.zoLootboxV2.lootboxSettings),
       ],
     })