@exodus/sui-api 0.1.0

package/src/sui-no-history-monitor.js

@@ -0,0 +1,277 @@
+import { BaseMonitor } from '@exodus/asset-lib'
+import { SynchronizedTime } from '@exodus/basic-utils'
+import { Address, UtxoCollection } from '@exodus/models'
+import { coinTypes, RPC_URL } from '@exodus/sui-lib'
+import lodash from 'lodash'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { transformTransactions } from './transform-tx.js'
+
+const { isEmpty, unionBy, zipObject } = lodash
+
+export const UNCONFIRMED_TX_LIMIT = ms('5m')
+
+export class SuiNoHistoryMonitor extends BaseMonitor {
+  #serverApi
+
+  constructor({ asset, serverApi, interval = ms('15s'), assetClientInterface, runner, logger }) {
+    super({
+      asset,
+      interval,
+      assetClientInterface,
+      logger,
+      runner,
+    })
+    assert(serverApi, 'Sui Node API Client is required!')
+
+    this.#serverApi = serverApi
+    this.assets = Object.create(null)
+  }
+
+  // public methods
+
+  setServer(remoteConfig) {
+    this.#serverApi.setServer({
+      rpcUrl: remoteConfig?.rpcUrl || RPC_URL,
+    })
+  }
+
+  async tick({ refresh, walletAccount }) {
+    const assetName = this.asset.name
+    this.assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
+
+    const ourWalletAddress = await this.aci.getReceiveAddress({ assetName, walletAccount })
+
+    const { utxos, tokenUtxos, unknownAssetIds } = await this.#getNewAccountState({
+      address: ourWalletAddress,
+    })
+
+    if (unknownAssetIds.length > 0) {
+      this.emit('unknown-tokens', unknownAssetIds)
+    }
+
+    let batch = this.aci.createOperationsBatch()
+
+    batch = await this.aci.updateAccountStateBatch({
+      assetName,
+      walletAccount,
+      newData: {
+        utxos,
+        tokenUtxos,
+      },
+      batch,
+    })
+
+    const { txsToRemoveByAsset, txLogItemsByAsset } = await this.#resolvePendingTransactions({
+      assets: this.assets,
+      walletAccount,
+      ourWalletAddress,
+      refresh,
+    })
+
+    for (const [assetName, txsToRemove] of Object.entries(txsToRemoveByAsset)) {
+      batch = await this.aci.removeTxLogBatch({ assetName, walletAccount, txs: txsToRemove, batch })
+    }
+
+    for (const [assetName, txLogItems] of Object.entries(txLogItemsByAsset)) {
+      batch = await this.aci.updateTxLogAndNotifyBatch({
+        assetName,
+        walletAccount,
+        txs: txLogItems,
+        batch,
+        refresh,
+      })
+    }
+
+    await this.aci.executeOperationsBatch(batch)
+  }
+
+  #checkPendingTransactions = ({ pendingTransactions, pendingTxsFromNode }) => {
+    const txsToUpdate = []
+    const txsToRemove = []
+    const now = SynchronizedTime.now()
+
+    if (isEmpty(pendingTransactions)) {
+      return {
+        txsToUpdate,
+        txsToRemove,
+      }
+    }
+
+    for (const tx of pendingTransactions) {
+      const txFromNode = pendingTxsFromNode[tx.txId]
+      if (txFromNode) {
+        if (txFromNode.error === false) {
+          txsToUpdate.push({ ...tx, error: false, confirmations: 1 })
+        } else if (txFromNode.error === true) {
+          txsToUpdate.push({ ...tx, confirmations: 1 })
+        }
+      } else {
+        if (now - tx.date.getTime() > UNCONFIRMED_TX_LIMIT) {
+          txsToRemove.push(tx)
+        }
+      }
+    }
+
+    return {
+      txsToUpdate,
+      txsToRemove,
+    }
+  }
+
+  #getTransactionsFromNode = async ({ digests, ourWalletAddress, asset }) => {
+    if (digests.length === 0) return []
+
+    const transactions = await this.#serverApi.getTransactions({
+      txIds: digests,
+    })
+
+    const parsedTxs = transformTransactions({
+      transactionResults: transactions,
+      address: ourWalletAddress,
+      feeAsset: asset.feeAsset,
+      asset,
+    })
+
+    const txIds = parsedTxs.map(({ txId }) => txId)
+
+    return zipObject(txIds, parsedTxs)
+  }
+
+  #resolvePendingTransactions = async ({ assets, walletAccount, ourWalletAddress }) => {
+    const txsToRemoveByAsset = Object.create(null)
+    const txLogItemsByAsset = Object.create(null)
+
+    for (const [assetName, asset] of Object.entries(assets)) {
+      const { pendingTransactions } = await this.#getPendingTransactionsByAsset({
+        assetName,
+        walletAccount,
+      })
+
+      if (pendingTransactions.length === 0) continue
+
+      const pendingTxsFromNode = await this.#getTransactionsFromNode({
+        digests: pendingTransactions.map((tx) => tx.txId),
+        asset,
+        ourWalletAddress,
+      })
+
+      const { txsToUpdate: logItems, txsToRemove } = await this.#checkPendingTransactions({
+        pendingTransactions,
+        pendingTxsFromNode,
+      })
+
+      if (txsToRemove.length > 0) {
+        txsToRemoveByAsset[assetName] = txsToRemove
+      }
+
+      if (logItems.length > 0) {
+        txLogItemsByAsset[assetName] = logItems
+      }
+    }
+
+    return { txsToRemoveByAsset, txLogItemsByAsset }
+  }
+
+  #getPendingTransactionsByAsset = async ({ assetName, walletAccount }) => {
+    const { stale, unconfirmed } = await this.#deriveTransactionsToCheck({
+      assetName,
+      walletAccount,
+    })
+
+    const pendingTransactions = unionBy(Object.values(stale), Object.values(unconfirmed), 'tx.txId')
+
+    return { pendingTransactions }
+  }
+
+  #deriveTransactionsToCheck = async ({ assetName, walletAccount }) => {
+    const txLog = await this.aci.getTxLog({ assetName, walletAccount })
+    const { stale, unconfirmed } = this.getUnconfirmed({
+      txSet: txLog,
+      staleTxAge: UNCONFIRMED_TX_LIMIT,
+    })
+
+    return {
+      stale: stale.map((tx) => txLog.get(tx.txId)).filter(Boolean),
+      unconfirmed: unconfirmed.map((txId) => txLog.get(txId)).filter(Boolean),
+    }
+  }
+
+  #getNewAccountState = async ({ address }) => {
+    const allCoins = await this.#serverApi.getAllCoins({
+      owner: address,
+    })
+
+    const groupedCoins = allCoins.reduce((acc, coin) => {
+      if (!acc[coin.coinType]) {
+        acc[coin.coinType] = []
+      }
+
+      acc[coin.coinType].push(coin)
+      return acc
+    }, Object.create(null))
+
+    const tokenUtxos = Object.create(null)
+    let baseUtxos = UtxoCollection.createEmpty({
+      currency: this.asset.currency,
+    })
+
+    const unknownAssetIds = new Set(
+      Object.keys(groupedCoins).filter((coinType) => coinType !== coinTypes.Base)
+    )
+
+    for (const [assetName, asset] of Object.entries(this.assets)) {
+      const isBaseAsset = asset.baseAssetName === asset.name
+      if (isBaseAsset) {
+        baseUtxos = this.#formatUtxos({
+          address,
+          coinType: coinTypes.Base,
+          coins: groupedCoins[coinTypes.Base] || [],
+          asset,
+        })
+        continue
+      }
+
+      if (!unknownAssetIds.delete(asset.assetId)) continue
+
+      tokenUtxos[assetName] = this.#formatUtxos({
+        address,
+        coinType: asset.assetId,
+        coins: groupedCoins[asset.assetId] || [],
+        asset,
+      })
+    }
+
+    return {
+      utxos: baseUtxos,
+      tokenUtxos,
+      unknownAssetIds: [...unknownAssetIds],
+    }
+  }
+
+  #formatUtxos = ({ coinType, coins, asset, address }) => {
+    if (coins.length === 0) {
+      return UtxoCollection.createEmpty({
+        currency: asset.currency,
+      })
+    }
+
+    const utxoItems = coins.map((coin) => {
+      return {
+        address: Address.create(address, { path: 'm/0/0' }),
+        txId: coin.previousTransaction,
+        digest: coin.digest,
+        coinObjectId: coin.coinObjectId,
+        version: coin.version,
+        coinType,
+        confirmations: 1,
+        value: asset.currency.baseUnit(coin.balance),
+      }
+    })
+
+    return UtxoCollection.fromArray(utxoItems, { currency: asset.currency })
+  }
+}
+
+export const createSuiNoHistoryMonitor = (args) => new SuiNoHistoryMonitor(args)

package/src/transform-tx.js

@@ -0,0 +1,100 @@
+const parseTransaction = ({ transaction, asset }) => {
+  const { data } = transaction
+  const {
+    sender,
+    transaction: { inputs },
+  } = data
+
+  const recipient = inputs.find(
+    (input) => input.type === 'pure' && input.valueType === 'address'
+  )?.value
+
+  const amount = inputs.find((input) => input.type === 'pure' && input.valueType === 'u64')?.value
+
+  return {
+    from: sender,
+    to: recipient,
+    coinAmount: amount ? asset.currency.baseUnit(amount) : asset.currency.ZERO,
+  }
+}
+
+export const getGasBudget = ({ gasUsed, feeAsset }) => {
+  // gas_budget >= max{computation_fees,total_gas_fees}
+
+  const { currency } = feeAsset
+
+  const totalFee = getFeeAmount({ gasUsed, feeAsset })
+
+  const computationAndStorageFee = currency
+    .baseUnit(gasUsed.computationCost)
+    .add(currency.baseUnit(gasUsed.storageCost))
+
+  if (computationAndStorageFee.gt(totalFee)) {
+    return computationAndStorageFee
+  }
+
+  return totalFee
+}
+
+export const getFeeAmount = ({ gasUsed, feeAsset }) => {
+  const { currency } = feeAsset
+  return currency
+    .baseUnit(gasUsed.computationCost)
+    .add(currency.baseUnit(gasUsed.storageCost))
+    .sub(currency.baseUnit(gasUsed.storageRebate))
+    .clampLowerZero()
+}
+
+const parseConfirmations = ({ effects }) => {
+  const { status, gasObject } = effects
+
+  if (!status?.status || !gasObject?.reference?.version) {
+    return {
+      confirmations: 0,
+      error: 0,
+    }
+  }
+
+  return {
+    confirmations: 1,
+    error: status.status === 'failure' ? status.error : false,
+  }
+}
+
+export function transformTransactions({ transactionResults, address, feeAsset, asset }) {
+  if (transactionResults.length === 0) return []
+  return transactionResults.map((transactionResult) => {
+    const { effects, transaction, timestampMs } = transactionResult
+    const { gasUsed } = effects
+
+    const { from, to, coinAmount } = parseTransaction({ transaction, asset })
+    const { confirmations, error } = parseConfirmations({ effects })
+    const wasSend = from === address
+    const args = Object.create(null)
+
+    if (wasSend) {
+      args.to = to
+      args.feeAmount = getFeeAmount({ gasUsed, feeAsset })
+      args.feeCoinName = feeAsset.name
+      args.coinAmount = coinAmount.negate()
+    } else {
+      args.from = [from]
+      args.coinAmount = coinAmount
+    }
+
+    return {
+      txId: transactionResult.digest,
+      date: new Date(parseInt(timestampMs, 10)),
+      selfSend: wasSend && from === to,
+      confirmations,
+      error,
+      data: Object.create(null),
+      currencies: {
+        [asset.name]: asset.currency,
+        [feeAsset.name]: feeAsset.currency,
+      },
+      coinName: asset.name,
+      ...args,
+    }
+  })
+}

package/src/tx-send.js

@@ -0,0 +1,249 @@
+import { UtxoCollection } from '@exodus/models'
+import { coinTypes, objectTypes, toCoinType } from '@exodus/sui-lib'
+import assert from 'minimalistic-assert'
+
+import { getFeeAmount } from './transform-tx.js'
+
+const deriveNewUtxos = ({ mutatedObject, balanceChange, deletedObjects, utxos, asset }) => {
+  const utxoArray = utxos.toArray()
+
+  const deletedObjectIds = new Set(deletedObjects.map(({ objectId }) => objectId))
+  const deleted = utxoArray.filter((utxo) => deletedObjectIds.has(utxo.coinObjectId))
+
+  const deletedBalance = deleted.reduce((acc, utxo) => {
+    return acc.add(utxo.value)
+  }, asset.currency.baseUnit(0))
+
+  const mutated = utxoArray.find((utxo) => utxo.coinObjectId === mutatedObject.objectId)
+
+  const newMutatedBalance = mutated.value
+    .add(deletedBalance)
+    .add(asset.currency.baseUnit(balanceChange))
+
+  const newMutated = {
+    ...mutated,
+    version: mutatedObject.version,
+    digest: mutatedObject.digest,
+    value: newMutatedBalance,
+  }
+
+  const unaffectedObjects = utxoArray.filter(
+    (utxo) =>
+      utxo.coinObjectId !== mutatedObject.objectId && !deletedObjectIds.has(utxo.coinObjectId)
+  )
+
+  return {
+    utxos: UtxoCollection.fromArray([...unaffectedObjects, newMutated], {
+      currency: asset.currency,
+    }),
+  }
+}
+
+const getObjectAndBalanceChangesByType = ({
+  objectChanges,
+  balanceChanges,
+  ownerAddress,
+  asset,
+}) => {
+  const ownerBalanceChangesByType = balanceChanges.reduce((acc, change) => {
+    const { owner, coinType, amount } = change
+    if (owner?.AddressOwner !== ownerAddress) {
+      return acc
+    }
+
+    acc[coinType] = amount
+
+    return acc
+  }, Object.create(null))
+
+  const wasBaseAssetSent = asset.name === asset.baseAssetName
+
+  const ownerObjectChangesByType = objectChanges.reduce((acc, change) => {
+    const { owner, objectType, type } = change
+
+    if (!acc[objectType]) {
+      acc[objectType] = {
+        created: [],
+        mutated: [],
+        deleted: [],
+      }
+    }
+
+    switch (type) {
+      case 'mutated':
+        if (owner?.AddressOwner !== ownerAddress) {
+          return acc
+        }
+
+        acc[objectType].mutated.push(change)
+        break
+      case 'created':
+        if (owner?.AddressOwner !== ownerAddress) {
+          return acc
+        }
+
+        acc[objectType].created.push(change)
+        break
+      case 'deleted':
+        acc[objectType].deleted.push(change)
+        break
+    }
+
+    return acc
+  }, Object.create(null))
+
+  const baseObjectsMutated = ownerObjectChangesByType[objectTypes.Base]?.mutated
+
+  if (
+    !baseObjectsMutated ||
+    baseObjectsMutated.length !== 1 ||
+    !ownerBalanceChangesByType[coinTypes.Base]
+  ) {
+    // expect to have 1 mutated object at point because coins were merged
+    throw new Error('In-decidable state change')
+  }
+
+  if (!wasBaseAssetSent) {
+    const assetId = asset.assetId
+    const coinType = toCoinType(assetId)
+
+    const assetObjectsMutated = ownerObjectChangesByType[coinType]?.mutated
+
+    if (
+      !assetObjectsMutated ||
+      assetObjectsMutated.length !== 1 ||
+      !ownerBalanceChangesByType[assetId]
+    ) {
+      // expect to have 1 mutated object at point because coins were merged
+      throw new Error('In-decidable state change')
+    }
+  }
+
+  return {
+    ownerObjectChangesByType,
+    ownerBalanceChangesByType,
+  }
+}
+
+const updateAccountStateAfterSend = async ({
+  aci,
+  asset,
+  walletAccount,
+  ownerAddress,
+  result,
+  amount,
+  recipientAddress,
+}) => {
+  const { feeAsset, currency: assetCurrency, name: assetName } = asset
+  const { objectChanges, balanceChanges, digest, effects } = result
+  const { gasUsed } = effects
+  const wasBaseAssetSent = assetName === asset.baseAssetName
+
+  const fee = getFeeAmount({ gasUsed, feeAsset })
+
+  const accountState = await aci.getAccountState({
+    assetName: asset.baseAssetName,
+    walletAccount,
+  })
+
+  const tx = {
+    txId: digest,
+    confirmations: 0,
+    coinName: assetName,
+    coinAmount: amount.abs().negate(),
+    feeAmount: fee,
+    feeCoinName: feeAsset.name,
+    selfSend: false,
+    to: recipientAddress,
+    data: Object.create(null),
+    currencies: { [assetName]: assetCurrency, [feeAsset.name]: feeAsset.currency },
+  }
+
+  const { ownerObjectChangesByType, ownerBalanceChangesByType } = getObjectAndBalanceChangesByType({
+    objectChanges,
+    balanceChanges,
+    ownerAddress,
+    asset,
+  })
+
+  const newAccountState = Object.create(null)
+
+  const newBaseUtxos = deriveNewUtxos({
+    mutatedObject: ownerObjectChangesByType[objectTypes.Base].mutated[0],
+    balanceChange: ownerBalanceChangesByType[coinTypes.Base],
+    deletedObjects: ownerObjectChangesByType[objectTypes.Base].deleted,
+    utxos: accountState.utxos,
+    asset: asset.baseAsset,
+  })
+
+  newAccountState.utxos = newBaseUtxos.utxos
+
+  if (!wasBaseAssetSent) {
+    const coinType = toCoinType(asset.assetId)
+    const newTokenUtxos = deriveNewUtxos({
+      mutatedObject: ownerObjectChangesByType[coinType].mutated[0],
+      balanceChange: ownerBalanceChangesByType[asset.assetId],
+      deletedObjects: ownerObjectChangesByType[coinType].deleted,
+      utxos: accountState.tokenUtxos[asset.name],
+      asset,
+    })
+
+    newAccountState.tokenUtxos = { [asset.name]: newTokenUtxos.utxos }
+  }
+
+  let batch = aci.createOperationsBatch()
+
+  batch = await aci.updateAccountStateBatch({
+    assetName: asset.baseAssetName,
+    walletAccount,
+    newData: {
+      utxos: newAccountState.utxos,
+      tokenUtxos: {
+        ...accountState.tokenUtxos,
+        ...(newAccountState.tokenUtxos && newAccountState.tokenUtxos[asset.name]
+          ? { [asset.name]: newAccountState.tokenUtxos[asset.name] }
+          : Object.create(null)),
+      },
+    },
+    batch,
+  })
+
+  batch = await aci.updateTxLogAndNotifyBatch({ assetName, walletAccount, txs: [tx], batch })
+
+  await aci.executeOperationsBatch(batch)
+}
+
+export const txSendFactory = ({ assetClientInterface: aci, serverApi, createUnsignedTx }) => {
+  assert(aci, 'assetClientInterface is required')
+
+  return async ({ asset, walletAccount, address: recipientAddress, amount, gasBudget }) => {
+    const { name: assetName } = asset
+
+    const senderAddress = await aci.getReceiveAddress({ assetName, walletAccount })
+
+    const unsignedTx = await createUnsignedTx({
+      asset,
+      senderAddress,
+      recipientAddress,
+      amount: amount.toBaseString(),
+      serverApi,
+      gasBudget,
+      walletAccount,
+    })
+
+    const { plainTx } = await aci.signTransaction({ assetName, unsignedTx, walletAccount })
+
+    const result = await serverApi.broadcastTx(plainTx)
+
+    await updateAccountStateAfterSend({
+      aci,
+      asset,
+      walletAccount,
+      ownerAddress: senderAddress,
+      result,
+      amount,
+      recipientAddress,
+    })
+    return { txId: result.digest }
+  }
+}