zo-sdk 0.1.17 → 0.1.19

package/src/implementations/SLPDataAPI.ts

@@ -326,33 +326,47 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   public async getPositionInfoList(
     positionCapInfoList: ISLPPositionCapInfo[],
     owner: string,
+    batchSize = 10,
   ): Promise<ISLPPositionInfo[]> {
     const positionInfoList: ISLPPositionInfo[] = []
-    await Promise.all(
-      positionCapInfoList.map(async (positionCapInfo) => {
-        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
+
+    // Process in batches of 10
+    for (let i = 0; i < positionCapInfoList.length; i += batchSize) {
+      const batch = positionCapInfoList.slice(i, i + batchSize)
+
+      await Promise.all(batch.map(async (positionCapInfo) => {
+        try {
+          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'}>`,
-            value: {
-              owner,
-              id: positionCapInfo.positionCapId,
+              value: {
+                owner,
+                id: positionCapInfo.positionCapId,
+              },
             },
-          },
-        })
+          })
 
-        if (positionRaw?.data?.content) {
-          positionInfoList.push(
-            await this.parsePositionInfo(
-              positionRaw,
-              positionCapInfo.positionCapId,
-            ),
-          )
+          if (positionRaw?.data?.content) {
+            positionInfoList.push(
+              await this.parsePositionInfo(
+                positionRaw,
+                positionCapInfo.positionCapId,
+              ),
+            )
+          }
         }
-      }),
-    )
+        catch (error) {
+          // Position might have been deleted after force settlement
+          console.warn(`Failed to parse position info for position cap ID ${positionCapInfo.positionCapId}: ${error}`)
+          // Continue with next position without adding this one to the list
+        }
+      }))
+    }
 
     return positionInfoList.sort((a, b) =>
       a.openTimestamp > b.openTimestamp ? 1 : -1,
@@ -808,31 +822,47 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
   public async getOrderInfoList(
     orderCapInfoList: ISLPOrderCapInfo[],
     owner: string,
+    batchSize = 10,
   ): Promise<ISLPOrderInfo[]> {
     const orderInfoList: ISLPOrderInfo[] = []
-    await Promise.all(
-      orderCapInfoList.map(async (orderCapInfo) => {
-        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
+
+    // Process in batches of 10
+    for (let i = 0; i < orderCapInfoList.length; i += batchSize) {
+      const batch = orderCapInfoList.slice(i, i + batchSize)
+
+      await Promise.all(batch.map(async (orderCapInfo) => {
+        try {
+          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
               }>`,
-            value: {
-              owner,
-              id: orderCapInfo.orderCapId,
-              position_id: {
-                vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+              value: {
+                owner,
+                id: orderCapInfo.orderCapId,
+                position_id: {
+                  vec: orderCapInfo.positionId ? [orderCapInfo.positionId] : [],
+                },
               },
             },
-          },
-        })
-        orderInfoList.push(
-          this.parseOrderInfo(orderRaw, orderCapInfo.orderCapId),
-        )
-      }),
-    )
+          })
+          orderInfoList.push(
+            this.parseOrderInfo(orderRaw, orderCapInfo.orderCapId),
+          )
+        }
+        catch (error) {
+          // Order might have been deleted
+          console.warn(`Failed to parse order info for order cap ID ${orderCapInfo.orderCapId}: ${error}`)
+          // Continue with next order without adding this one to the list
+        }
+      }))
+    }
+
     return orderInfoList.sort((a, b) => (a.createdAt > b.createdAt ? 1 : -1))
   }
 

package/src/implementations/USDZAPI.ts

@@ -13,7 +13,6 @@ import { BaseAPI } from '../abstract'
 import type { Network } from '../consts'
 import { ALLOW_TRADE_CAN_TRADE, ALLOW_TRADE_MUST_TRADE, ALLOW_TRADE_NO_TRADE, LPToken } from '../consts'
 import type {
-  IBaseCredential,
   IBaseHistoryResponse,
   IBaseMarketInfo,
   IBaseMarketValuationInfo,
@@ -28,6 +27,7 @@ import type {
   IBaseSymbolInfo,
   IBaseVaultInfo,
   IUSDZAPI,
+  IUSDZCredential,
 } from '../interfaces'
 import { joinSymbol } from '../utils'
 import { USDZDataAPI } from './USDZDataAPI'
@@ -45,14 +45,6 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     this.dataAPI = new USDZDataAPI(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}.`)
   }
@@ -121,7 +113,7 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
 
-  public getPositionInfoList(_positionCapInfoList: IBasePositionCapInfo[], _owner: string): Promise<IBasePositionInfo[]> {
+  public getPositionInfoList(_positionCapInfoList: IBasePositionCapInfo[], _owner: string, _batchSize?: number): Promise<IBasePositionInfo[]> {
     throw new Error(`Method not implemented in ${this.constructor.name}.`)
   }
 
@@ -615,6 +607,87 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     return tx
   }
 
+  /**
+   * Deposits collateral into USDZ vault
+   */
+  public async depositPtb(
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut = 0,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ): Promise<any> {
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    // Add referral if needed
+    if (referralAddress && !(await this.dataAPI.hasReferral(sender || ''))) {
+      tx = await this.addReferral(referralAddress, tx)
+    }
+
+    // Initialize oracle transaction
+    const pythFeederKeys = Object.keys(this.consts.pythFeeder.feeder)
+
+    // Handle sponsored transaction case
+    if (sponsoredTx) {
+      const suiCoinObject = this.processCoins(tx, 'sui', suiCoinObjectsForPythUpdate || [], true)
+      tx = await this.initOracleTxb(pythFeederKeys, tx, true, suiCoinObject)
+
+      // Process deposit coins
+      const depositObject = coin === 'sui'
+        ? tx.splitCoins(suiCoinObject, [tx.pure.u64(amount)])[0]
+        : tx.splitCoins(this.processCoins(tx, coin, coinObjects, true), [tx.pure.u64(amount)])[0]
+
+      const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+
+      const [mintedCoin] = tx.moveCall({
+        target: `${this.consts.zoCore.upgradedPackage}::market::deposit_ptb`,
+        typeArguments: [`${this.consts.zoCore.package}::usdz::USDZ`, this.consts.coins[coin].module],
+        arguments: [
+          tx.object(this.consts.zoCore.market),
+          tx.object(this.consts.zoCore.rebaseFeeModel),
+          depositObject,
+          tx.pure.u64(minAmountOut),
+          vaultsValuation,
+          symbolsValuation,
+        ],
+      })
+      return mintedCoin
+    }
+
+    // Handle non-sponsored transaction case
+    tx = await this.initOracleTxb(pythFeederKeys, tx)
+    const depositObject = tx.splitCoins(
+      this.processCoins(tx, coin, coinObjects, false),
+      [tx.pure.u64(amount)],
+    )[0]
+
+    const { vaultsValuation, symbolsValuation } = this.dataAPI.valuate(tx)
+
+    const [mintedCoin] = tx.moveCall({
+      target: `${this.consts.zoCore.upgradedPackage}::market::deposit_ptb`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::usdz::USDZ`,
+        this.consts.coins[coin].module,
+      ],
+      arguments: [
+        tx.object(this.consts.zoCore.market),
+        tx.object(this.consts.zoCore.rebaseFeeModel),
+        depositObject,
+        tx.pure.u64(minAmountOut),
+        vaultsValuation,
+        symbolsValuation,
+      ],
+    })
+
+    return mintedCoin
+  }
+
   /**
    * Withdraws collateral from USDZ vault
    */
@@ -660,6 +733,122 @@ export class USDZAPI extends BaseAPI implements IUSDZAPI {
     return tx
   }
 
+  /**
+   * Stakes USDZ tokens in ZO staking pools
+   */
+  public stake(
+    lpCoinObjects: string[],
+    amount: bigint,
+    pool: string,
+    tx?: Transaction,
+  ): Transaction {
+    if (!this.consts.zoStaking) {
+      throw new Error('ZO staking configuration not found')
+    }
+
+    if (!tx) {
+      tx = new Transaction()
+    }
+
+    const coinObject = this.processCoins(tx, 'usdz', lpCoinObjects)
+    const [depositObject] = tx.splitCoins(coinObject, [tx.pure.u64(amount)])
+
+    tx.moveCall({
+      target: `${this.consts.zoStaking.package}::pool::deposit`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::usdz::USDZ`,
+        `${this.consts.coins.sui.module}`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        depositObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Stakes USDZ tokens using coin object only (PTB)
+   */
+  public stakeCoinObject(
+    coinObject: any,
+    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`,
+      typeArguments: [
+        `${this.consts.zoCore.package}::usdz::USDZ`,
+        `${this.consts.coins.sui.module}`,
+      ],
+      arguments: [
+        tx.object(pool),
+        tx.object(SUI_CLOCK_OBJECT_ID),
+        coinObject,
+      ],
+    })
+    return tx
+  }
+
+  /**
+   * Unstakes USDZ tokens from ZO staking pools
+   */
+  public unstake(
+    credentials: IUSDZCredential[],
+    amount: bigint,
+    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()
+    }
+    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.consts.zoStaking.package}::pool::withdraw`,
+        typeArguments: [
+          `${this.consts.zoCore.package}::usdz::USDZ`,
+          `${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.consts.zoStaking.package}::pool::clear_empty_credential`,
+          typeArguments: [
+            `${this.consts.zoCore.package}::usdz::USDZ`,
+          `${this.consts.coins.sui.module}`,
+          ],
+          arguments: [tx.object(credential.id)],
+        })
+      }
+    }
+    return tx
+  }
+
   public async swap(
     fromToken: string,
     toToken: string,

package/src/implementations/USDZDataAPI.ts

@@ -14,7 +14,7 @@ import { LPToken, SECONDS_PER_EIGHT_HOUR, USDZ_TOKEN_DECIMALS } from '../consts'
 import type {
   IBaseHistoryResponse,
   IBaseStaked,
-  IBaseStakePool,
+  IUSDZCredential,
   IUSDZDataAPI,
   IUSDZFundingFeeModel,
   IUSDZMarketInfo,
@@ -26,6 +26,7 @@ import type {
   IUSDZPositionInfo,
   IUSDZRebaseFeeModel,
   IUSDZReservingFeeModel,
+  IUSDZStakePool,
   IUSDZSymbolConfig,
   IUSDZSymbolInfo,
   IUSDZVaultInfo,
@@ -42,12 +43,63 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     super(network, provider, apiEndpoint, connectionURL, LPToken.USDZ)
   }
 
-  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) =>
+      USDZDataAPI.parseCredential(item, pool),
+    )
+    return {
+      credentials,
+      amount: credentials.reduce(
+        (acc: bigint, cur: IUSDZCredential) => acc + cur.amount,
+        BigInt(0),
+      ),
+      claimable: credentials.reduce(
+        (acc: bigint, cur: IUSDZCredential) => acc + cur.claimable,
+        BigInt(0),
+      ),
+    }
   }
 
-  public getStakePool(): Promise<IBaseStakePool> {
-    throw new Error(`${this.constructor.name}: Method not implemented.`)
+  public async getStakePool(): Promise<IUSDZStakePool> {
+    const raw = await this.provider.getObject({
+      id: this.consts.zoStaking.pools[0],
+      options: {
+        showContent: true,
+      },
+    })
+    return USDZDataAPI.parseStakePool(raw)
   }
 
   /**
@@ -877,4 +929,57 @@ export class USDZDataAPI extends BaseDataAPI implements IUSDZDataAPI {
     return vaultInfo.unrealisedReservingFeeAmount
       + (vaultInfo.reservedAmount * reservingFeeModel.multiplier * periods) / 1e18
   }
+
+  private static parseCredential(raw: any, pool: IUSDZStakePool): IUSDZCredential {
+    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): IUSDZStakePool {
+    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),
+    }
+    USDZDataAPI.refreshPool(pool, Math.floor(Date.now() / 1000))
+    return pool
+  }
+
+  private static refreshPool(pool: IUSDZStakePool, 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

@@ -238,9 +238,9 @@ export interface IBaseDataAPI {
 
   // User data methods
   getPositionCapInfoList: (owner: string) => Promise<IBasePositionCapInfo[]>
-  getPositionInfoList: (positionCapInfoList: IBasePositionCapInfo[], owner: string) => Promise<IBasePositionInfo[]>
+  getPositionInfoList: (positionCapInfoList: IBasePositionCapInfo[], owner: string, batchSize?: number) => Promise<IBasePositionInfo[]>
   getOrderCapInfoList: (owner: string) => Promise<IBaseOrderCapInfo[]>
-  getOrderInfoList: (orderCapInfoList: IBaseOrderCapInfo[], owner: string) => Promise<IBaseOrderInfo[]>
+  getOrderInfoList: (orderCapInfoList: IBaseOrderCapInfo[], owner: string, batchSize?: number) => Promise<IBaseOrderInfo[]>
   getHistory: (trader: string, page: number, limit: number, orderType?: string, symbol?: string) => Promise<IBaseHistoryResponse>
 
   // Staking methods

package/src/interfaces/usdz.ts

@@ -3,6 +3,8 @@
  * Extends base interfaces with USDZ-specific implementations
  */
 
+import type { Transaction } from '@mysten/sui/transactions'
+
 import type {
   IBaseAPI,
   IBaseCredential,
@@ -58,6 +60,7 @@ export interface IUSDZHistory extends IBaseHistory {
 
 export interface IUSDZStakePool extends IBaseStakePool {
   // USDZ-specific stake pool fields can be added here
+  rewardRate: bigint
 }
 
 export interface IUSDZCredential extends IBaseCredential {
@@ -92,4 +95,21 @@ export interface IUSDZDataAPI extends IBaseDataAPI {
 }
 
 // USDZ-specific API interface
-export interface IUSDZAPI extends IBaseAPI { }
+export interface IUSDZAPI extends IBaseAPI {
+  depositPtb: (
+    coin: string,
+    coinObjects: string[],
+    amount: number,
+    minAmountOut?: number,
+    referralAddress?: string,
+    sender?: string,
+    tx?: Transaction,
+    sponsoredTx?: boolean,
+    suiCoinObjectsForPythUpdate?: string[],
+  ) => Promise<any>
+  stakeCoinObject: (
+    coinObject: any,
+    pool: string,
+    tx?: Transaction,
+  ) => any
+}