zo-sdk 0.1.25 → 0.1.27

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),
       ],
     })
 

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,70 @@ 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()
+
+    // 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}::zlp::ZLP, 0x2::sui::SUI>`
+      ).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 +967,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/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)