@exodus/sui-api 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.4.0](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.3.1...@exodus/sui-api@1.4.0) (2026-10-22)
+
+
+### Bug Fixes
+
+* **sui-api:** migrate node calls from json-rpc to graphql ([#9043](https://github.com/ExodusMovement/assets/issues/9043)) ([d228aba](https://github.com/ExodusMovement/assets/commit/d228abaa1cfa991ff03d429b9c1a49ffd825065b))
+
+
+
+## [1.3.1](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.3.0...@exodus/sui-api@1.3.1) (2026-10-09)
+
+
+### Bug Fixes
+
+* migrate to @exodus/basic-utils 5 ([#8894](https://github.com/ExodusMovement/assets/issues/8894)) ([ed125f3](https://github.com/ExodusMovement/assets/commit/ed125f3257785c92a3b8f8239a2e9eefe5dc6772))
+
+
+
 ## [1.3.0](https://github.com/ExodusMovement/assets/compare/@exodus/sui-api@1.2.3...@exodus/sui-api@1.3.0) (2026-10-05)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/sui-api",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Transaction monitors, RPC with the blockchain node, and other networking code for Sui",
   "type": "module",
   "main": "src/index.js",
@@ -22,21 +22,17 @@
   },
   "dependencies": {
     "@exodus/asset-lib": "^5.0.0",
-    "@exodus/assets": "^11.1.2",
-    "@exodus/basic-utils": "^3.1.0",
+    "@exodus/basic-utils": "^5.1.0",
     "@exodus/crypto": "^1.0.0-rc.26",
     "@exodus/currency": "^6.0.1",
     "@exodus/models": "^13.0.0",
     "@exodus/sui-lib": "^1.3.0",
     "@exodus/sui-meta": "^1.2.0",
-    "bn.js": "^5.2.1",
     "lodash": "^4.17.21",
     "minimalistic-assert": "^1.0.1",
-    "ms": "^2.1.3",
-    "url-join": "^4.0.0"
+    "ms": "^2.1.3"
   },
   "devDependencies": {
-    "@exodus/asset": "^2.3.0",
     "@exodus/assets-testing": "^1.0.0"
   },
   "homepage": "https://github.com/ExodusMovement/assets/tree/master/sui/sui-api",
@@ -47,5 +43,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "cde4077e979a0c4715777b654912fc29353849a9"
+  "gitHead": "f210c7a3aa55561320c43aa8d8d5804b49f390d0"
 }

package/src/api.js

@@ -1,215 +1,465 @@
-import { RPC_URL } from '@exodus/sui-lib'
-import assert from 'minimalistic-assert'
-
-import { SuiClient } from './vendors/client/index.js'
-
-const getTextFromResponse = async (response) => {
-  try {
-    const responseBody = await response.text()
-    return responseBody.slice(0, 100)
-  } catch {
-    return ''
-  }
-}
-
-const fetchJson = async (url, fetchOptions) => {
-  const response = await fetch(url, fetchOptions)
-
-  if (!response.ok) {
-    throw new Error(
-      `${url} returned ${response.status}: ${
-        response.statusText || 'Unknown Status Text'
-      }. Body: ${await getTextFromResponse(response)}`
-    )
-  }
-
-  return response.json()
-}
+import { SynchronizedTime } from '@exodus/basic-utils'
+import { coinTypes, RPC_URL, vendorLib } from '@exodus/sui-lib'
+import lodash from 'lodash'
+
+import { SuiBroadcastError } from './broadcast-error.js'
+import {
+  GraphQLClient,
+  GraphQLTimeoutError,
+  GraphQLTransportError,
+} from './graphql/graphql-client.js'
+import {
+  getMoveCalls,
+  toCoin,
+  toJsonRpcTypeTag,
+  toMoveFunctionKey,
+  toObjectRef,
+  toSimulationEffects,
+  toTransactionBlockResponse,
+} from './graphql/json-rpc-shapes.js'
+import {
+  ACTIVE_VALIDATOR_POOLS,
+  ALL_BALANCES,
+  BALANCE,
+  EXCHANGE_RATES,
+  EXECUTE_TRANSACTION,
+  INACTIVE_VALIDATOR_WRAPPER,
+  LATEST_EPOCH,
+  MOVE_FUNCTION_PARAMETERS,
+  MULTI_GET_OBJECTS,
+  MULTI_GET_TRANSACTIONS,
+  OWNED_OBJECTS,
+  SIMULATE_TRANSACTION,
+  VERSIONED_VALIDATOR,
+} from './graphql/queries.js'
+import { STAKED_SUI_TYPE } from './staking/constants.js'
+import {
+  findRecordedRate,
+  getLatestRateEpoch,
+  getRateLookupEpochs,
+  toDelegatedStakes,
+} from './staking/delegated-stakes.js'
+import { TransactionDataBuilder } from './vendors/transactions/TransactionData.js'
+
+const { bcs } = vendorLib
+const { fromBase64, fromHex, toBase64 } = vendorLib.utils
+const { chunk } = lodash
+
+const COIN_TYPE = '0x2::coin::Coin'
+const MAX_DIGESTS_PER_QUERY = 50
+const MAX_KEYS_PER_QUERY = 50
+const DEV_INSPECT_GAS_BUDGET = '50000000000'
+const EXECUTE_TIMEOUT_MS = 60_000
 
 export class SuiApi {
+  #moveFunctionParameters
+  #epoch
+  #activePools
+  #inactivePools
+  #exchangeRates
+
   constructor({ rpcUrl }) {
     this.setServer({ rpcUrl })
   }
 
   setServer({ rpcUrl = RPC_URL }) {
+    this.#moveFunctionParameters = new Map()
+    this.#epoch = null
+    this.#activePools = null
+    this.#inactivePools = new Map()
+    this.#exchangeRates = new Map()
     this.rpcUrl = encodeURI(rpcUrl)
-    this.client = new SuiClient({
-      url: rpcUrl,
-    })
+    const separator = this.rpcUrl.endsWith('/') ? '' : '/'
+    this.graphql = new GraphQLClient({ url: `${this.rpcUrl}${separator}graphql` })
   }
 
-  handleJsonRPCResponse(response) {
-    const result = response?.result
-    const error = response?.error
-    if (error || result === undefined) {
-      const message = error?.message || error?.code || 'no result'
-      throw new Error(`Bad rpc response: ${message}`)
-    }
-
-    return result
+  async #query(query, variables, options) {
+    return this.graphql.query({ query, variables, ...options })
   }
 
-  async request({ baseApiPath, path = '', method, body, headers = Object.create(null) }) {
-    assert(typeof baseApiPath === 'string', 'expected string baseApiPath')
+  async #paginate({ query, variables, getConnection }) {
+    const nodes = []
+    let cursor = null
+    while (true) {
+      const connection = getConnection(await this.#query(query, { ...variables, cursor }))
+      if (!connection) return nodes
+      nodes.push(...connection.nodes)
+      if (!connection.pageInfo.hasNextPage) return nodes
+      cursor = connection.pageInfo.endCursor
+    }
+  }
 
-    const url = new URL(`${baseApiPath}${path}`)
-    const fetchOptions = {
-      method,
-      headers: { ...this.getDefaultHeaders(), ...headers },
+  async #findMoveFunctionParameters({ package: pkg, module, function: fn }) {
+    const key = toMoveFunctionKey({ package: pkg, module, function: fn })
+    if (!this.#moveFunctionParameters.has(key)) {
+      const request = this.#query(MOVE_FUNCTION_PARAMETERS, {
+        package: pkg,
+        module,
+        function: fn,
+      }).then((data) => {
+        const parameters = data.package?.module?.function?.parameters
+        if (!parameters) {
+          this.#moveFunctionParameters.delete(key)
+          return null
+        }
+
+        return parameters.map(({ signature }) => ({
+          ref: signature.ref ?? null,
+          body: signature.body,
+        }))
+      })
+      this.#moveFunctionParameters.set(key, request)
+      request.catch(() => this.#moveFunctionParameters.delete(key))
     }
 
-    if (body) fetchOptions.body = JSON.stringify(body)
-    const response = await fetchJson(url, fetchOptions)
-    return this.handleJsonRPCResponse(response)
+    return this.#moveFunctionParameters.get(key)
   }
 
-  getDefaultHeaders() {
-    return {
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
+  async getMoveFunctionParameters(moveFunction) {
+    const parameters = await this.#findMoveFunctionParameters(moveFunction)
+    if (!parameters) {
+      throw new Error(`Cannot find sui move function ${toMoveFunctionKey(moveFunction)}`)
     }
+
+    return parameters
   }
 
-  // Transactions
+  async #getMoveFunctionParametersByKey({ transactionJsons, tolerateLookupErrors }) {
+    const moveCalls = lodash.uniqBy(transactionJsons.flatMap(getMoveCalls), toMoveFunctionKey)
+    const entries = await Promise.all(
+      moveCalls.map(async (moveCall) => {
+        const lookup = this.#findMoveFunctionParameters(moveCall)
+        return [
+          toMoveFunctionKey(moveCall),
+          await (tolerateLookupErrors ? lookup.catch(() => null) : lookup),
+        ]
+      })
+    )
+    return new Map(entries.filter(([, parameters]) => parameters))
+  }
 
-  async getTransactionByHash({ hash }) {
-    return this.request({
-      baseApiPath: this.rpcUrl,
-      method: 'POST',
-      body: {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'sui_getTransactionBlock',
-        params: [
-          hash,
-          {
-            showInput: true,
-            showRawInput: false,
-            showEffects: true,
-            showEvents: false,
-            showObjectChanges: true,
-            showBalanceChanges: true,
-            showRawEffects: false,
-          },
-        ],
-      },
+  async #toTransactionBlockResponses(transactions, { tolerateLookupErrors = false } = {}) {
+    const moveFunctionParameters = await this.#getMoveFunctionParametersByKey({
+      transactionJsons: transactions.map(({ transactionJson }) => transactionJson),
+      tolerateLookupErrors,
     })
+    return transactions.map((transaction) =>
+      toTransactionBlockResponse({ ...transaction, moveFunctionParameters })
+    )
+  }
+
+  async getTransactionByHash({ hash }) {
+    const [transaction] = await this.getTransactions({ txIds: [hash] })
+    if (!transaction) throw new Error(`Sui transaction ${hash} not found`)
+    return transaction
+  }
+
+  async getTransactions({ txIds }) {
+    const results = await Promise.all(
+      chunk(txIds, MAX_DIGESTS_PER_QUERY).map((digests) =>
+        this.#query(MULTI_GET_TRANSACTIONS, { digests })
+      )
+    )
+    const transactions = results
+      .flatMap((data) => data.multiGetTransactions)
+      .filter((transaction) => transaction?.effects)
+    return this.#toTransactionBlockResponses(transactions)
   }
 
   async getAccountBalance({ address }) {
-    return this.request({
-      baseApiPath: this.rpcUrl,
-      method: 'POST',
-      body: {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'suix_getBalance',
-        params: [address],
-      },
-    })
+    const data = await this.#query(BALANCE, { owner: address, coinType: coinTypes.Base })
+    const balance = data.address?.balance
+    return {
+      coinType: coinTypes.Base,
+      totalBalance: balance?.totalBalance ?? '0',
+    }
   }
 
   async getAccountAllBalances({ address }) {
-    return this.request({
-      baseApiPath: this.rpcUrl,
-      method: 'POST',
-      body: {
-        jsonrpc: '2.0',
-        id: 1,
-        method: 'suix_getAllBalances',
-        params: [address],
-      },
+    const balances = await this.#paginate({
+      query: ALL_BALANCES,
+      variables: { owner: address },
+      getConnection: (data) => data.address?.balances,
     })
+    return balances.map(({ coinType, totalBalance }) => ({
+      coinType: toJsonRpcTypeTag(coinType.repr),
+      totalBalance,
+    }))
   }
 
-  async getTransactions({ txIds }) {
-    return this.client.multiGetTransactionBlocks({
-      digests: txIds,
-      options: {
-        showEffects: true,
-        showObjectChanges: true,
-        showBalanceChanges: true,
-        showInput: true,
-      },
+  async #getOwnedObjects({ owner, type }) {
+    return this.#paginate({
+      query: OWNED_OBJECTS,
+      variables: { owner, type },
+      getConnection: (data) => data.address?.objects,
     })
   }
 
   async getAllCoins({ owner }) {
-    const requestByCursor = async ({ cursor }) => {
-      return this.client.getAllCoins({
-        owner,
-        cursor,
-        limit: 100,
-      })
-    }
+    const objects = await this.#getOwnedObjects({ owner, type: COIN_TYPE })
+    return objects.map(toCoin)
+  }
 
-    const coins = []
-    let cursor = null
+  async getCoins({ owner, coinType }) {
+    const objects = await this.#getOwnedObjects({ owner, type: `${COIN_TYPE}<${coinType}>` })
+    return objects.map(toCoin)
+  }
 
-    while (true) {
-      const response = await requestByCursor({ cursor })
-      coins.push(...response.data)
-      if (!response.nextCursor || !response.hasNextPage) {
-        break
-      }
+  async getObjectRefs({ ids }) {
+    const data = await this.#query(MULTI_GET_OBJECTS, { keys: ids.map((address) => ({ address })) })
+    return data.multiGetObjects.map((object) => object && toObjectRef(object))
+  }
+
+  async #getEpoch() {
+    const cached = this.#epoch
+    if (cached && SynchronizedTime.now() < cached.startMs + cached.durationMs) return cached
 
-      cursor = response.nextCursor
+    const { epoch } = await this.#query(LATEST_EPOCH)
+    this.#epoch = {
+      epochId: Number(epoch.epochId),
+      referenceGasPrice: String(epoch.referenceGasPrice),
+      startMs: Number(epoch.systemState.startMs.json),
+      durationMs: Number(epoch.systemState.durationMs.json),
     }
+    return this.#epoch
+  }
 
-    return coins
+  async getReferenceGasPrice() {
+    const { referenceGasPrice } = await this.#getEpoch()
+    return referenceGasPrice
   }
 
-  async getCoins({ owner, coinType }) {
-    const requestByCursor = async ({ cursor }) => {
-      return this.client.getCoins({
-        owner,
-        coinType,
-        cursor,
-        limit: 100,
-      })
+  async getLatestSuiSystemState() {
+    const { epochId, startMs, durationMs, referenceGasPrice } = await this.#getEpoch()
+    return {
+      epoch: String(epochId),
+      epochStartTimestampMs: String(startMs),
+      epochDurationMs: String(durationMs),
+      referenceGasPrice,
     }
+  }
+
+  async #getActivePools() {
+    const { epochId } = await this.#getEpoch()
+    if (this.#activePools?.epoch !== epochId) this.#activePools = await this.#fetchActivePools()
+    return this.#activePools
+  }
 
-    const coins = []
+  async #fetchActivePools() {
+    const pools = []
     let cursor = null
+    let epoch
+    let inactivePoolsId
     while (true) {
-      const response = await requestByCursor({ cursor })
-      coins.push(...response.data)
-      if (!response.nextCursor || !response.hasNextPage) {
-        break
-      }
+      const data = await this.#query(ACTIVE_VALIDATOR_POOLS, { cursor })
+      const { validatorSet } = data.epoch
+      epoch = data.epoch.epochId
+      inactivePoolsId = validatorSet.inactivePoolsId.extract.json
+      const { nodes, pageInfo } = validatorSet.activeValidators
+      pools.push(...nodes.map(({ contents }) => contents))
+      if (!pageInfo.hasNextPage) break
+      cursor = pageInfo.endCursor
+    }
+
+    return { epoch: Number(epoch), inactivePoolsId, pools }
+  }
 
-      cursor = response.nextCursor
+  async #getInactivePool({ inactivePoolsId, poolId }) {
+    if (!this.#inactivePools.has(poolId)) {
+      const contents = await this.#fetchInactivePool({ inactivePoolsId, poolId })
+      if (!contents) return
+      this.#inactivePools.set(poolId, contents)
     }
 
-    return coins
+    return this.#inactivePools.get(poolId)
   }
 
-  async getStakes({ owner }) {
-    return this.client.getStakes({ owner })
+  async #fetchInactivePool({ inactivePoolsId, poolId }) {
+    const wrapperData = await this.#query(INACTIVE_VALIDATOR_WRAPPER, {
+      table: inactivePoolsId,
+      poolId: toBase64(fromHex(poolId)),
+    })
+    const versioned = wrapperData.address?.dynamicField?.value?.json?.inner
+    if (!versioned) return
+
+    const validatorData = await this.#query(VERSIONED_VALIDATOR, {
+      versioned: versioned.id,
+      version: `${versioned.version}u64`,
+    })
+    return validatorData.address?.dynamicField?.value
   }
 
-  async getLatestSuiSystemState() {
-    return this.client.getLatestSuiSystemState()
+  async #getExchangeRates({ table, epochs, currentEpoch }) {
+    const cached = this.#exchangeRates.get(table) ?? new Map()
+    this.#exchangeRates.set(table, cached)
+    const missing = epochs.filter((epoch) => !cached.has(epoch))
+    const fetched = await this.#fetchExchangeRates({ table, epochs: missing })
+    for (const epoch of missing) {
+      const rate = fetched.get(epoch)
+      if (rate || epoch < currentEpoch - 1) cached.set(epoch, rate ?? null)
+    }
+
+    return new Map(
+      epochs.filter((epoch) => cached.get(epoch)).map((epoch) => [epoch, cached.get(epoch)])
+    )
+  }
+
+  async #fetchExchangeRates({ table, epochs }) {
+    const results = await Promise.all(
+      chunk(epochs, MAX_KEYS_PER_QUERY).map((epochChunk) =>
+        this.#query(EXCHANGE_RATES, {
+          table,
+          keys: epochChunk.map((epoch) => ({ literal: `${epoch}u64` })),
+        })
+      )
+    )
+    const fields = results.flatMap((data) => data.address?.multiGetDynamicFields ?? [])
+    return new Map(fields.filter(Boolean).map(({ name, value }) => [Number(name.json), value.json]))
+  }
+
+  async #toPool({ contents, stakedSuis, epoch }) {
+    const stakingPool = contents.stakingPool.json
+    const deactivationEpoch =
+      stakingPool.deactivation_epoch === null ? null : Number(stakingPool.deactivation_epoch)
+    const latestEpoch = getLatestRateEpoch({ pool: { deactivationEpoch }, epoch })
+    const activationEpochs = lodash.uniq(
+      stakedSuis
+        .filter((stakedSui) => stakedSui.pool_id === stakingPool.id)
+        .map((stakedSui) => Number(stakedSui.stake_activation_epoch))
+        .filter((activationEpoch) => activationEpoch <= epoch)
+    )
+    const recordedRates = await this.#getExchangeRates({
+      table: stakingPool.exchange_rates.id,
+      epochs: getRateLookupEpochs([latestEpoch, ...activationEpochs]),
+      currentEpoch: epoch,
+    })
+
+    return {
+      validatorAddress: contents.validatorAddress.json,
+      deactivationEpoch,
+      rates: new Map(
+        activationEpochs.map((activationEpoch) => [
+          activationEpoch,
+          findRecordedRate({ rates: recordedRates, epoch: activationEpoch }),
+        ])
+      ),
+      currentRate: findRecordedRate({ rates: recordedRates, epoch: latestEpoch }),
+    }
+  }
+
+  async getStakes({ owner }) {
+    const objects = await this.#getOwnedObjects({ owner, type: STAKED_SUI_TYPE })
+    if (objects.length === 0) return []
+
+    const stakedSuis = objects.map(({ contents }) => contents.json)
+    const { epoch, inactivePoolsId, pools } = await this.#getActivePools()
+    const poolIds = new Set(stakedSuis.map((stakedSui) => stakedSui.pool_id))
+    const contentsByPoolId = new Map(
+      pools
+        .filter(({ stakingPool }) => poolIds.has(stakingPool.json.id))
+        .map((contents) => [contents.stakingPool.json.id, contents])
+    )
+
+    const inactivePools = await Promise.all(
+      [...poolIds]
+        .filter((poolId) => !contentsByPoolId.has(poolId))
+        .map(async (poolId) => [poolId, await this.#getInactivePool({ inactivePoolsId, poolId })])
+    )
+    for (const [poolId, contents] of inactivePools) {
+      if (contents) contentsByPoolId.set(poolId, contents)
+    }
+
+    const entries = await Promise.all(
+      [...contentsByPoolId].map(async ([poolId, contents]) => [
+        poolId,
+        await this.#toPool({ contents, stakedSuis, epoch }),
+      ])
+    )
+
+    return toDelegatedStakes({ stakedSuis, poolsById: new Map(entries), epoch })
   }
 
   async buildTransaction({ transaction, onlyTransactionKind = false }) {
-    return transaction.build({ client: this.client, onlyTransactionKind })
+    return transaction.build({ client: this, onlyTransactionKind })
+  }
+
+  async #simulate({ transactionDataBcs, checksEnabled }) {
+    const data = await this.#query(SIMULATE_TRANSACTION, {
+      transaction: { bcs: { value: transactionDataBcs } },
+      checksEnabled,
+    })
+    const effectsJson = data.simulateTransaction.effects?.effectsJson
+    if (!effectsJson) throw new Error('Bad sui simulation response: no effects')
+    return { effects: toSimulationEffects(effectsJson) }
+  }
+
+  async dryRunTransaction({ transactionBlock }) {
+    return this.#simulate({ transactionDataBcs: toBase64(transactionBlock), checksEnabled: true })
   }
 
   async devInspectTransaction({ sender, transactionBlock }) {
-    return this.client.devInspectTransactionBlock({ sender, transactionBlock })
+    const transactionDataBcs = bcs.TransactionData.serialize({
+      V1: {
+        kind: bcs.TransactionKind.parse(transactionBlock),
+        sender,
+        gasData: {
+          payment: [],
+          owner: sender,
+          price: await this.getReferenceGasPrice(),
+          budget: DEV_INSPECT_GAS_BUDGET,
+        },
+        expiration: { None: true },
+      },
+    }).toBase64()
+    return this.#simulate({ transactionDataBcs, checksEnabled: false })
+  }
+
+  async #execute({ plainTx, digest }) {
+    try {
+      const data = await this.#query(
+        EXECUTE_TRANSACTION,
+        { transactionDataBcs: plainTx.bytes, signatures: [plainTx.signature] },
+        { timeoutMs: EXECUTE_TIMEOUT_MS }
+      )
+      return data.executeTransaction.effects
+    } catch (error) {
+      if (!(error instanceof GraphQLTimeoutError || error instanceof GraphQLTransportError)) {
+        throw error
+      }
+
+      throw new SuiBroadcastError({
+        message: 'Sui execution did not complete, the transaction may still execute',
+        digest,
+        outcome: 'unknown',
+        cause: error,
+      })
+    }
   }
 
   async broadcastTx(plainTx) {
-    return this.client.executeTransactionBlock({
-      transactionBlock: plainTx.bytes,
-      signature: plainTx.signature,
-      options: {
-        showInput: true,
-        showEffects: true,
-        showObjectChanges: true,
-        showBalanceChanges: true,
-      },
-    })
+    const digest = TransactionDataBuilder.getDigestFromBytes(fromBase64(plainTx.bytes))
+    const effects = await this.#execute({ plainTx, digest })
+    if (!effects?.transaction) {
+      throw new SuiBroadcastError({
+        message: 'Bad sui execution response: no effects',
+        digest,
+        outcome: 'unknown',
+      })
+    }
+
+    try {
+      const [result] = await this.#toTransactionBlockResponses(
+        [{ digest, transactionJson: effects.transaction.transactionJson, effects }],
+        { tolerateLookupErrors: true }
+      )
+      return result
+    } catch (error) {
+      throw new SuiBroadcastError({
+        message: 'Sui transaction executed but its response could not be mapped',
+        digest,
+        outcome: 'executed',
+        cause: error,
+      })
+    }
   }
 }