@zofai/zo-sdk 0.1.100 → 0.2.1

package/src/implementations/SLPDataAPI.ts

@@ -184,7 +184,7 @@ export class SLPDataAPI extends BaseDataAPI implements ISLPDataAPI {
       const [direction, token] = parseSymbolKey(key)
       const symbol = this.consts.sudoCore.symbols[key]
       tx.moveCall({
-        target: `${this.consts.sudoCore.upgradedPackage}::market::valuate_symbol_v1_1`,
+        target: `${this.consts.sudoCore.upgradedPackage}::market::valuate_symbol_v2`,
         typeArguments: [
           `${this.consts.sudoCore.package}::slp::SLP`,
           this.consts.coins[token].module,

package/src/implementations/ZLPDataAPI.ts

@@ -1209,7 +1209,24 @@ export class ZLPDataAPI extends BaseDataAPI implements IZLPDataAPI {
     // OI context for funding: fetch state and paired side size when enabled
     const oiState = await this.getSymbolOiFundingState(positionInfo.indexToken)
     const pairedSymbol = await this.getSymbolInfo(positionInfo.indexToken, !positionInfo.long)
-    positionInfo.fundingFeeValue = ZLPDataAPI.calculatePositionFundingFee(positionInfo, await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long), (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel, (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(), (await this.getMarketInfo()).lpSupplyWithDecimals, Date.now() / 1000, oiState && oiState.enabled ? oiState : undefined, pairedSymbol.openingSize)
+    const computedFundingFeeValue = ZLPDataAPI.calculatePositionFundingFee(
+      positionInfo,
+      await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long),
+      (await this.getSymbolInfo(positionInfo.indexToken, positionInfo.long)).fundingFeeModel,
+      (await this.getOraclePrice(positionInfo.indexToken)).getPriceUnchecked().getPriceAsNumberUnchecked(),
+      (await this.getMarketInfo()).lpSupplyWithDecimals,
+      Date.now() / 1000,
+      oiState && oiState.enabled ? oiState : undefined,
+      pairedSymbol.openingSize,
+    )
+    // Don't clobber a valid on-chain value with a transient 0/NaN from missing pricing/OI context.
+    const existing = positionInfo.fundingFeeValue
+    const computedIsFinite = Number.isFinite(computedFundingFeeValue)
+    const computedIsZeroish = computedIsFinite && Math.abs(computedFundingFeeValue) < 1e-12
+    const existingIsNonZeroish = Number.isFinite(existing) && Math.abs(existing) >= 1e-12
+    if (computedIsFinite && !(computedIsZeroish && existingIsNonZeroish)) {
+      positionInfo.fundingFeeValue = computedFundingFeeValue
+    }
 
     return positionInfo
   }

package/src/utils.ts

@@ -70,19 +70,72 @@ export function sDecimalToObject(sDecimal: SuiDecimal) {
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function parseValue(field: any): number {
-  if (field.type && field.type.endsWith('::decimal::Decimal')) {
-    return decimalToObject({ value: field.fields.value })
+  if (field === null || field === undefined) {
+    return 0
   }
-  else if (field.type && field.type.endsWith('::rate::Rate')) {
-    return rateToObject({ value: field.fields.value })
+  if (typeof field === 'number') {
+    return field
   }
-  else if (field.type && field.type.endsWith('::srate::SRate')) {
-    return sRateToObject(field)
+  if (typeof field === 'bigint') {
+    return Number(field)
   }
-  else if (field.type && field.type.endsWith('::sdecimal::SDecimal')) {
-    return sDecimalToObject(field)
+  if (typeof field === 'string') {
+    const n = Number.parseInt(field, 10)
+    return Number.isFinite(n) ? n : 0
   }
-  return Number.parseInt(field, 10)
+  // Some Move values arrive as nested { fields: { value: ... } } wrappers (and/or Option-like wrappers).
+  if (typeof field === 'object') {
+    // Prefer typed parsing when available.
+    if (field.type && field.type.endsWith('::decimal::Decimal')) {
+      return decimalToObject({ value: field.fields.value })
+    }
+    else if (field.type && field.type.endsWith('::rate::Rate')) {
+      return rateToObject({ value: field.fields.value })
+    }
+    else if (field.type && field.type.endsWith('::srate::SRate')) {
+      return sRateToObject(field)
+    }
+    else if (field.type && field.type.endsWith('::sdecimal::SDecimal')) {
+      return sDecimalToObject(field)
+    }
+
+    // Unwrap common wrapper patterns.
+    // - Option<T>: { fields: { some: T } } or { fields: { value: T } } (varies by serializer)
+    // - Inner wrappers: { fields: { value: <primitive or struct> } }
+    const unwrapKeys = ['some', 'value', 'inner']
+    let cur: any = field
+    for (let i = 0; i < 6; i += 1) {
+      const f = cur?.fields
+      if (!f || typeof f !== 'object')
+        break
+      const nextKey = unwrapKeys.find(k => f[k] !== undefined)
+      if (!nextKey)
+        break
+      cur = f[nextKey]
+      if (cur === null || cur === undefined)
+        return 0
+      if (typeof cur === 'string') {
+        const n = Number.parseInt(cur, 10)
+        return Number.isFinite(n) ? n : 0
+      }
+      if (typeof cur === 'number')
+        return cur
+      if (typeof cur === 'bigint')
+        return Number(cur)
+      // If we hit a typed struct, recurse once to apply typed parsing.
+      if (typeof cur === 'object' && cur.type)
+        return parseValue(cur)
+    }
+
+    const maybeStr = (field as any)?.fields?.value
+    if (typeof maybeStr === 'string') {
+      const n = Number.parseInt(maybeStr, 10)
+      return Number.isFinite(n) ? n : 0
+    }
+  }
+
+  const n = Number.parseInt(String(field), 10)
+  return Number.isFinite(n) ? n : 0
 }
 
 export type ReversedKeyValue<T extends object> = {