@exodus/sui-api 1.3.1 → 1.4.1

package/src/balances.js

@@ -1,29 +1,29 @@
 import { getStakingBalances } from './staking/staking-balances.js'
 
+const getAddressBalance = ({ asset, accountState }) =>
+  asset.currency.baseUnit(accountState.addressBalances[asset.name] ?? 0)
+
 export const getBalances = ({ asset, accountState }) => {
   const isBaseAsset = asset.name === asset.baseAssetName
+  const addressBalance = getAddressBalance({ asset, accountState })
 
   if (isBaseAsset) {
     const spendable = accountState.utxos.value
     const stakingBalances = getStakingBalances({ asset, stakingInfo: accountState.stakingInfo })
     const { staking, staked, unstaked } = stakingBalances
     return {
-      total: spendable.add(staking).add(staked).add(unstaked),
+      total: spendable.add(addressBalance).add(staking).add(staked).add(unstaked),
       spendable,
       stakeable: spendable,
+      unspendable: addressBalance,
       ...stakingBalances,
     }
   }
 
-  if (accountState.tokenUtxos[asset.name]) {
-    return {
-      total: accountState.tokenUtxos[asset.name].value,
-      spendable: accountState.tokenUtxos[asset.name].value,
-    }
-  }
-
+  const spendable = accountState.tokenUtxos[asset.name]?.value ?? asset.currency.ZERO
   return {
-    total: asset.currency.ZERO,
-    spendable: asset.currency.ZERO,
+    total: spendable.add(addressBalance),
+    spendable,
+    unspendable: addressBalance,
   }
 }

package/src/basic-account-state.js

@@ -8,6 +8,7 @@ export const createBasicAccountState = () => {
     static defaults = {
       utxos: UtxoCollection.createEmpty({ currency: asset.currency }),
       tokenUtxos: Object.create(null),
+      addressBalances: Object.create(null),
       stakingInfo: EMPTY_STAKING_INFO,
     }
   }

package/src/broadcast-error.js

@@ -0,0 +1,8 @@
+export class SuiBroadcastError extends Error {
+  constructor({ message, digest, outcome, cause }) {
+    super(`${message} (tx ${digest})`, { cause })
+    this.name = 'SuiBroadcastError'
+    this.digest = digest
+    this.outcome = outcome
+  }
+}

package/src/create-unsigned-tx.js

@@ -28,7 +28,7 @@ export const createUnsignedTxFactory = ({ assetClientInterface, serverApi }) =>
       txb.setSender(senderAddress)
 
       return {
-        txData: await txb.build({ client: serverApi.client, ...buildOptions }),
+        txData: await serverApi.buildTransaction({ transaction: txb, ...buildOptions }),
         txMeta: Object.create(null),
       }
     }
@@ -53,7 +53,7 @@ export const createUnsignedTxFactory = ({ assetClientInterface, serverApi }) =>
     txb.setSender(senderAddress)
 
     return {
-      txData: await txb.build({ client: serverApi.client, ...buildOptions }),
+      txData: await serverApi.buildTransaction({ transaction: txb, ...buildOptions }),
       txMeta: Object.create(null),
     }
   }

package/src/get-fee-async.js

@@ -27,7 +27,7 @@ export const getFeeAsyncFactory = ({ assetClientInterface, serverApi, createUnsi
       },
     })
 
-    const simulation = await serverApi.client.devInspectTransactionBlock({
+    const simulation = await serverApi.devInspectTransaction({
       sender: senderAddress,
       transactionBlock: txData,
     })

package/src/graphql/graphql-client.js

@@ -0,0 +1,82 @@
+import ms from 'ms'
+
+const MAX_ERROR_BODY_LENGTH = 100
+const DEFAULT_TIMEOUT_MS = ms('30s')
+
+export class GraphQLTimeoutError extends Error {
+  constructor({ url, timeoutMs }) {
+    super(`${url} timed out after ${timeoutMs}ms`)
+    this.name = 'GraphQLTimeoutError'
+  }
+}
+
+export class GraphQLTransportError extends Error {
+  constructor(message, { cause } = Object.create(null)) {
+    super(message, { cause })
+    this.name = 'GraphQLTransportError'
+  }
+}
+
+const SERVER_ERROR_STATUS = 500
+
+const readErrorBody = async (response) => {
+  try {
+    const text = await response.text()
+    return text.slice(0, MAX_ERROR_BODY_LENGTH)
+  } catch {
+    return ''
+  }
+}
+
+export class GraphQLClient {
+  #url
+  #timeoutMs
+
+  constructor({ url, timeoutMs = DEFAULT_TIMEOUT_MS }) {
+    this.#url = url
+    this.#timeoutMs = timeoutMs
+  }
+
+  async #post({ query, variables, timeoutMs }) {
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), timeoutMs)
+    try {
+      const response = await fetch(this.#url, {
+        method: 'POST',
+        headers: { Accept: 'application/json', 'Content-Type': 'application/json' },
+        body: JSON.stringify({ query, variables }),
+        signal: controller.signal,
+      }).catch((error) => {
+        if (controller.signal.aborted) throw error
+        throw new GraphQLTransportError(`${this.#url} request failed: ${error.message}`, {
+          cause: error,
+        })
+      })
+
+      if (!response.ok) {
+        const message = `${this.#url} returned ${response.status}: ${
+          response.statusText || 'Unknown Status Text'
+        }. Body: ${await readErrorBody(response)}`
+        if (response.status >= SERVER_ERROR_STATUS) throw new GraphQLTransportError(message)
+        throw new Error(message)
+      }
+
+      return await response.json()
+    } catch (error) {
+      if (controller.signal.aborted) throw new GraphQLTimeoutError({ url: this.#url, timeoutMs })
+      throw error
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  async query({ query, variables = Object.create(null), timeoutMs = this.#timeoutMs }) {
+    const { data, errors } = await this.#post({ query, variables, timeoutMs })
+    if (errors?.length > 0) {
+      throw new Error(`Bad graphql response: ${errors.map(({ message }) => message).join('; ')}`)
+    }
+
+    if (!data) throw new Error('Bad graphql response: no data')
+    return data
+  }
+}

package/src/graphql/json-rpc-shapes.js

@@ -0,0 +1,342 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+import { getPureBcsSchema } from '../vendors/transactions/serializer.js'
+
+const { fromBase64, normalizeSuiAddress } = vendorLib.utils
+
+const SPECIAL_ADDRESS_REGEX = /0x0{63}([\dA-Fa-f])(?![\dA-Fa-f])/g
+const NO_GAS_OBJECT_ID = `0x${'0'.repeat(64)}`
+
+export const toJsonRpcTypeTag = (typeTag) =>
+  typeTag.replaceAll(SPECIAL_ADDRESS_REGEX, '0x$1').replaceAll(/,\s*/g, ', ')
+
+export const toMoveFunctionKey = ({ package: pkg, module, function: fn }) =>
+  `${normalizeSuiAddress(pkg)}::${module}::${fn}`
+
+const toOwner = (owner) => {
+  switch (owner?.kind) {
+    case 'ADDRESS':
+      return { AddressOwner: owner.address }
+    case 'OBJECT':
+      return { ObjectOwner: owner.address }
+    case 'SHARED':
+      return { Shared: { initial_shared_version: Number(owner.version) } }
+    case 'IMMUTABLE':
+      return 'Immutable'
+    case 'CONSENSUS_ADDRESS':
+      return {
+        ConsensusAddressOwner: { owner: owner.address, start_version: Number(owner.version) },
+      }
+    default:
+      return { Unknown: owner?.kind ?? null }
+  }
+}
+
+const toArgument = (argument) => {
+  switch (argument?.kind) {
+    case 'GAS':
+      return 'GasCoin'
+    case 'INPUT':
+      return { Input: argument.input }
+    case 'RESULT':
+      return argument.subresult === undefined
+        ? { Result: argument.result }
+        : { NestedResult: [argument.result, argument.subresult] }
+    default:
+      return { Unknown: argument?.kind ?? null }
+  }
+}
+
+const toCommand = (command) => {
+  if (command.moveCall) {
+    const { package: pkg, module, function: fn, typeArguments, arguments: args } = command.moveCall
+    return {
+      MoveCall: {
+        package: pkg,
+        module,
+        function: fn,
+        ...(typeArguments?.length > 0 && { type_arguments: typeArguments.map(toJsonRpcTypeTag) }),
+        arguments: (args ?? []).map(toArgument),
+      },
+    }
+  }
+
+  if (command.splitCoins) {
+    const { coin, amounts = [] } = command.splitCoins
+    return { SplitCoins: [toArgument(coin), amounts.map(toArgument)] }
+  }
+
+  if (command.transferObjects) {
+    const { objects = [], address } = command.transferObjects
+    return { TransferObjects: [objects.map(toArgument), toArgument(address)] }
+  }
+
+  if (command.mergeCoins) {
+    const { coin, coinsToMerge = [] } = command.mergeCoins
+    return { MergeCoins: [toArgument(coin), coinsToMerge.map(toArgument)] }
+  }
+
+  if (command.makeMoveVector) {
+    const { elementType, elements = [] } = command.makeMoveVector
+    return {
+      MakeMoveVec: [elementType ? toJsonRpcTypeTag(elementType) : null, elements.map(toArgument)],
+    }
+  }
+
+  if (command.publish) {
+    return { Publish: command.publish.dependencies ?? [] }
+  }
+
+  if (command.upgrade) {
+    const { dependencies, package: pkg, ticket } = command.upgrade
+    return { Upgrade: [dependencies ?? [], pkg, toArgument(ticket)] }
+  }
+
+  return { Unknown: Object.keys(command) }
+}
+
+const getInputTypes = ({ commands, moveFunctionParameters }) => {
+  const types = new Map()
+  const setType = (argument, type) => {
+    if (argument?.kind === 'INPUT' && !types.has(argument.input)) types.set(argument.input, type)
+  }
+
+  for (const command of commands) {
+    if (command.splitCoins) {
+      ;(command.splitCoins.amounts ?? []).forEach((amount) => setType(amount, 'u64'))
+    }
+
+    if (command.transferObjects) setType(command.transferObjects.address, 'address')
+    if (command.moveCall) {
+      const parameters = moveFunctionParameters.get(toMoveFunctionKey(command.moveCall)) ?? []
+      command.moveCall.arguments?.forEach((argument, index) =>
+        setType(argument, parameters[index]?.body)
+      )
+    }
+  }
+
+  return types
+}
+
+const toRawPureInput = (bytes) => ({ type: 'pure', valueType: null, value: [...bytes] })
+
+const toPureInput = ({ bytes, type }) => {
+  if (typeof type !== 'string') return toRawPureInput(bytes)
+
+  try {
+    return { type: 'pure', valueType: type, value: getPureBcsSchema(type).parse(bytes) }
+  } catch {
+    return toRawPureInput(bytes)
+  }
+}
+
+const toInput = ({ input, type }) => {
+  switch (input.kind) {
+    case 'PURE':
+      return toPureInput({ bytes: fromBase64(input.pure), type })
+    case 'IMMUTABLE_OR_OWNED':
+      return {
+        type: 'object',
+        objectType: 'immOrOwnedObject',
+        objectId: input.objectId,
+        version: input.version,
+        digest: input.digest,
+      }
+    case 'SHARED':
+      return {
+        type: 'object',
+        objectType: 'sharedObject',
+        objectId: input.objectId,
+        initialSharedVersion: input.version,
+        mutable: input.mutable,
+      }
+    case 'RECEIVING':
+      return {
+        type: 'object',
+        objectType: 'receiving',
+        objectId: input.objectId,
+        version: input.version,
+        digest: input.digest,
+      }
+    default:
+      return { type: 'unknown', kind: input.kind }
+  }
+}
+
+const toTransactionKind = ({ kind, moveFunctionParameters }) => {
+  if (kind.kind !== 'PROGRAMMABLE_TRANSACTION') return { kind: kind.kind }
+
+  const { inputs = [], commands = [] } = kind.programmableTransaction
+  const inputTypes = getInputTypes({ commands, moveFunctionParameters })
+  return {
+    kind: 'ProgrammableTransaction',
+    inputs: inputs.map((input, index) => toInput({ input, type: inputTypes.get(index) })),
+    transactions: commands.map(toCommand),
+  }
+}
+
+export const getMoveCalls = (transactionJson) =>
+  (transactionJson?.kind?.programmableTransaction?.commands ?? [])
+    .map((command) => command.moveCall)
+    .filter(Boolean)
+
+const toTransactionData = ({ transactionJson, moveFunctionParameters }) => {
+  const { sender, gasPayment, kind } = transactionJson
+  return {
+    messageVersion: 'v1',
+    transaction: toTransactionKind({ kind, moveFunctionParameters }),
+    sender,
+    gasData: {
+      payment: (gasPayment.objects ?? []).map(({ objectId, version, digest }) => ({
+        objectId,
+        version: Number(version),
+        digest,
+      })),
+      owner: gasPayment.owner,
+      price: gasPayment.price,
+      budget: gasPayment.budget,
+    },
+  }
+}
+
+const toStatus = ({ success, error }) =>
+  success
+    ? { status: 'success' }
+    : { status: 'failure', error: error?.description ?? error?.kind ?? 'unknown' }
+
+const toGasObject = (gasObject) => {
+  if (!gasObject) {
+    return {
+      owner: { AddressOwner: NO_GAS_OBJECT_ID },
+      reference: {
+        objectId: NO_GAS_OBJECT_ID,
+        version: 0,
+        digest: '11111111111111111111111111111111',
+      },
+    }
+  }
+
+  return {
+    owner: toOwner(gasObject.outputOwner),
+    reference: {
+      objectId: gasObject.objectId,
+      version: Number(gasObject.outputVersion),
+      digest: gasObject.outputDigest,
+    },
+  }
+}
+
+const toEffects = (effectsJson) => ({
+  messageVersion: 'v1',
+  status: toStatus(effectsJson.status),
+  executedEpoch: effectsJson.epoch,
+  gasUsed: effectsJson.gasUsed,
+  transactionDigest: effectsJson.transactionDigest,
+  gasObject: toGasObject(effectsJson.gasObject),
+  dependencies: effectsJson.dependencies ?? [],
+})
+
+const toObjectChange = ({ change, sender, lamportVersion }) => {
+  const { objectId, inputState, outputState, idOperation } = change
+  const objectType = change.objectType && toJsonRpcTypeTag(change.objectType)
+  const inputExists = inputState === 'INPUT_OBJECT_STATE_EXISTS'
+
+  if (outputState === 'OUTPUT_OBJECT_STATE_ACCUMULATOR_WRITE') return
+
+  if (outputState === 'OUTPUT_OBJECT_STATE_PACKAGE_WRITE') {
+    return {
+      type: 'published',
+      packageId: objectId,
+      version: change.outputVersion,
+      digest: change.outputDigest,
+    }
+  }
+
+  if (
+    idOperation === 'DELETED' ||
+    (inputExists && outputState !== 'OUTPUT_OBJECT_STATE_OBJECT_WRITE')
+  ) {
+    return {
+      type: idOperation === 'DELETED' ? 'deleted' : 'wrapped',
+      sender,
+      objectType,
+      objectId,
+      version: lamportVersion,
+    }
+  }
+
+  const written = {
+    sender,
+    owner: toOwner(change.outputOwner),
+    objectType,
+    objectId,
+    version: change.outputVersion,
+    ...(inputExists && { previousVersion: change.inputVersion }),
+    digest: change.outputDigest,
+  }
+
+  return { type: inputExists ? 'mutated' : 'created', ...written }
+}
+
+const toObjectChanges = ({ effectsJson, sender }) =>
+  (effectsJson.changedObjects ?? [])
+    .map((change) => toObjectChange({ change, sender, lamportVersion: effectsJson.lamportVersion }))
+    .filter(Boolean)
+
+const toBalanceChanges = (balanceChangesJson) =>
+  (balanceChangesJson ?? []).map(({ address, coinType, amount }) => ({
+    owner: { AddressOwner: address },
+    coinType: toJsonRpcTypeTag(coinType),
+    amount,
+  }))
+
+export const toTransactionBlockResponse = ({
+  digest,
+  transactionJson,
+  effects,
+  moveFunctionParameters,
+}) => {
+  const { effectsJson, balanceChangesJson, timestamp, checkpoint } = effects
+  return {
+    digest,
+    transaction: { data: toTransactionData({ transactionJson, moveFunctionParameters }) },
+    effects: toEffects(effectsJson),
+    objectChanges: toObjectChanges({ effectsJson, sender: transactionJson.sender }),
+    balanceChanges: toBalanceChanges(balanceChangesJson),
+    ...(timestamp && { timestampMs: String(Date.parse(timestamp)) }),
+    ...(checkpoint && { checkpoint: String(checkpoint.sequenceNumber) }),
+  }
+}
+
+export const toCoin = (node) => {
+  const coinObjectType = toJsonRpcTypeTag(node.contents.type.repr)
+  const [, coinType] = coinObjectType.match(/^0x2::coin::Coin<(.+)>$/) ?? []
+  if (!coinType) throw new Error(`Unexpected sui coin type ${coinObjectType}`)
+
+  return {
+    coinType,
+    coinObjectId: node.address,
+    version: String(node.version),
+    digest: node.digest,
+    balance: node.contents.json.balance,
+    previousTransaction: node.previousTransaction?.digest,
+  }
+}
+
+const getInitialSharedVersion = (owner) => {
+  if (owner?.__typename === 'Shared') return String(owner.initialSharedVersion)
+  if (owner?.__typename === 'ConsensusAddressOwner') return String(owner.startVersion)
+  return null
+}
+
+export const toObjectRef = (object) => ({
+  objectId: object.address,
+  digest: object.digest,
+  version: String(object.version),
+  initialSharedVersion: getInitialSharedVersion(object.owner),
+})
+
+export const toSimulationEffects = (effectsJson) => ({
+  status: toStatus(effectsJson.status),
+  gasUsed: effectsJson.gasUsed,
+})

package/src/graphql/queries.js

@@ -0,0 +1,166 @@
+const TRANSACTION_EFFECTS_FIELDS = `
+  digest
+  timestamp
+  checkpoint { sequenceNumber }
+  effectsJson
+  balanceChangesJson
+`
+
+export const MULTI_GET_TRANSACTIONS = `
+  query ($digests: [String!]!) {
+    multiGetTransactions(keys: $digests) {
+      digest
+      transactionJson
+      effects { ${TRANSACTION_EFFECTS_FIELDS} }
+    }
+  }
+`
+
+export const EXECUTE_TRANSACTION = `
+  mutation ($transactionDataBcs: Base64!, $signatures: [Base64!]!) {
+    executeTransaction(transactionDataBcs: $transactionDataBcs, signatures: $signatures) {
+      effects {
+        ${TRANSACTION_EFFECTS_FIELDS}
+        transaction { digest transactionJson }
+      }
+    }
+  }
+`
+
+export const SIMULATE_TRANSACTION = `
+  query ($transaction: JSON!, $checksEnabled: Boolean) {
+    simulateTransaction(transaction: $transaction, checksEnabled: $checksEnabled) {
+      effects { effectsJson }
+    }
+  }
+`
+
+export const OWNED_OBJECTS = `
+  query ($owner: SuiAddress!, $type: String!, $cursor: String) {
+    address(address: $owner) {
+      objects(first: 50, after: $cursor, filter: { type: $type }) {
+        pageInfo { hasNextPage endCursor }
+        nodes {
+          address
+          version
+          digest
+          previousTransaction { digest }
+          contents { type { repr } json }
+        }
+      }
+    }
+  }
+`
+
+export const BALANCE = `
+  query ($owner: SuiAddress!, $coinType: String!) {
+    address(address: $owner) {
+      balance(coinType: $coinType) { coinType { repr } totalBalance }
+    }
+  }
+`
+
+export const ALL_BALANCES = `
+  query ($owner: SuiAddress!, $cursor: String) {
+    address(address: $owner) {
+      balances(first: 50, after: $cursor) {
+        pageInfo { hasNextPage endCursor }
+        nodes { coinType { repr } totalBalance addressBalance }
+      }
+    }
+  }
+`
+
+export const MULTI_GET_OBJECTS = `
+  query ($keys: [ObjectKey!]!) {
+    multiGetObjects(keys: $keys) {
+      address
+      version
+      digest
+      owner {
+        __typename
+        ... on Shared { initialSharedVersion }
+        ... on ConsensusAddressOwner { startVersion }
+      }
+    }
+  }
+`
+
+export const MOVE_FUNCTION_PARAMETERS = `
+  query ($package: SuiAddress!, $module: String!, $function: String!) {
+    package(address: $package) {
+      module(name: $module) {
+        function(name: $function) { parameters { signature } }
+      }
+    }
+  }
+`
+
+export const LATEST_EPOCH = `
+  query {
+    epoch {
+      epochId
+      referenceGasPrice
+      systemState {
+        startMs: extract(path: "epoch_start_timestamp_ms") { json }
+        durationMs: extract(path: "parameters.epoch_duration_ms") { json }
+      }
+    }
+  }
+`
+
+export const ACTIVE_VALIDATOR_POOLS = `
+  query ($cursor: String) {
+    epoch {
+      epochId
+      validatorSet {
+        inactivePoolsId: contents { extract(path: "inactive_validators.id") { json } }
+        activeValidators(first: 50, after: $cursor) {
+          pageInfo { hasNextPage endCursor }
+          nodes {
+            contents {
+              validatorAddress: extract(path: "metadata.sui_address") { json }
+              stakingPool: extract(path: "staking_pool") { json }
+            }
+          }
+        }
+      }
+    }
+  }
+`
+
+export const INACTIVE_VALIDATOR_WRAPPER = `
+  query ($table: SuiAddress!, $poolId: Base64!) {
+    address(address: $table) {
+      dynamicField(name: { type: "0x2::object::ID", bcs: $poolId }) {
+        value { ... on MoveValue { json } }
+      }
+    }
+  }
+`
+
+export const VERSIONED_VALIDATOR = `
+  query ($versioned: SuiAddress!, $version: String!) {
+    address(address: $versioned) {
+      dynamicField(name: { literal: $version }) {
+        value {
+          ... on MoveValue {
+            validatorAddress: extract(path: "metadata.sui_address") { json }
+            stakingPool: extract(path: "staking_pool") { json }
+          }
+        }
+      }
+    }
+  }
+`
+
+export const EXCHANGE_RATES = `
+  query ($table: SuiAddress!, $keys: [DynamicFieldName!]!) {
+    address(address: $table) {
+      multiGetDynamicFields(keys: $keys) {
+        name { json }
+        value { ... on MoveValue { json } }
+      }
+    }
+  }
+`

package/src/index.js

@@ -1,4 +1,5 @@
 export { SuiApi } from './api.js'
+export { SuiBroadcastError } from './broadcast-error.js'
 
 export { getFeeFactory } from './get-fee.js'
 export { createBasicAccountState } from './basic-account-state.js'