@exodus/sui-api 0.1.0

package/README.md

@@ -0,0 +1,20 @@
+# @exodus/sui-api · [![npm version](https://img.shields.io/badge/npm-public-blue.svg?style=flat)](https://www.npmjs.com/package/@exodus/sui-api)
+
+The **sui-api** provides utilities for interacting with the Sui blockchain.
+It offers functionality to query transaction data, monitor network health, and broadcast transactions
+
+---
+
+## Installation
+
+Install the package via `yarn`:
+
+```bash
+yarn add @exodus/sui-api
+```
+
+## License
+
+This project is licensed under the MIT License.
+You are free to use, modify, and distribute this software under the terms of the MIT License.
+For more details, see the [LICENSE](LICENSE) file.

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@exodus/sui-api",
+  "packageManager": "yarn@4.3.1",
+  "version": "0.1.0",
+  "description": "Transaction monitors, RPC with the blockchain node, and other networking code for Sui",
+  "type": "module",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "CHANGELOG.md",
+    "package.json",
+    "README.md",
+    "!src/**/__tests__"
+  ],
+  "author": "Exodus Movement, Inc.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "run -T exodus-test --jest",
+    "lint": "run -T eslintc .",
+    "lint:fix": "yarn lint --fix"
+  },
+  "dependencies": {
+    "@exodus/asset-lib": "^5.0.0",
+    "@exodus/assets": "^11.1.2",
+    "@exodus/basic-utils": "^4.2.1",
+    "@exodus/crypto": "^1.0.0-rc.26",
+    "@exodus/currency": "^6.0.1",
+    "@exodus/models": "^12.0.1",
+    "@exodus/sui-lib": "^1.1.2",
+    "@exodus/sui-meta": "^1.1.0",
+    "bn.js": "^5.2.1",
+    "lodash": "^4.17.21",
+    "minimalistic-assert": "^1.0.1",
+    "ms": "^2.1.3",
+    "url-join": "^4.0.0"
+  },
+  "devDependencies": {
+    "@exodus/asset": "^2.0.4",
+    "@exodus/assets-testing": "^1.0.0"
+  },
+  "homepage": "https://github.com/ExodusMovement/assets/tree/master/sui/sui-api",
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asui-api"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExodusMovement/assets.git"
+  },
+  "gitHead": "c942fdd35a045680780f1dc5b096aebc5ca54c81"
+}

package/src/api.js

@@ -0,0 +1,198 @@
+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()
+}
+
+export class SuiApi {
+  constructor({ rpcUrl }) {
+    this.setServer({ rpcUrl })
+  }
+
+  setServer({ rpcUrl = RPC_URL }) {
+    this.rpcUrl = encodeURI(rpcUrl)
+    this.client = new SuiClient({
+      url: rpcUrl,
+    })
+  }
+
+  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 request({ baseApiPath, path = '', method, body, headers = Object.create(null) }) {
+    assert(typeof baseApiPath === 'string', 'expected string baseApiPath')
+
+    const url = new URL(`${baseApiPath}${path}`)
+    const fetchOptions = {
+      method,
+      headers: { ...this.getDefaultHeaders(), ...headers },
+    }
+
+    if (body) fetchOptions.body = JSON.stringify(body)
+    const response = await fetchJson(url, fetchOptions)
+    return this.handleJsonRPCResponse(response)
+  }
+
+  getDefaultHeaders() {
+    return {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    }
+  }
+
+  // Transactions
+
+  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 getAccountBalance({ address }) {
+    return this.request({
+      baseApiPath: this.rpcUrl,
+      method: 'POST',
+      body: {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'suix_getBalance',
+        params: [address],
+      },
+    })
+  }
+
+  async getAccountAllBalances({ address }) {
+    return this.request({
+      baseApiPath: this.rpcUrl,
+      method: 'POST',
+      body: {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'suix_getAllBalances',
+        params: [address],
+      },
+    })
+  }
+
+  async getTransactions({ txIds }) {
+    return this.client.multiGetTransactionBlocks({
+      digests: txIds,
+      options: {
+        showEffects: true,
+        showObjectChanges: true,
+        showBalanceChanges: true,
+        showInput: true,
+      },
+    })
+  }
+
+  async getAllCoins({ owner }) {
+    const requestByCursor = async ({ cursor }) => {
+      return this.client.getAllCoins({
+        owner,
+        cursor,
+        limit: 100,
+      })
+    }
+
+    const coins = []
+    let cursor = null
+
+    while (true) {
+      const response = await requestByCursor({ cursor })
+      coins.push(...response.data)
+      if (!response.nextCursor || !response.hasNextPage) {
+        break
+      }
+
+      cursor = response.nextCursor
+    }
+
+    return coins
+  }
+
+  async getCoins({ owner, coinType }) {
+    const requestByCursor = async ({ cursor }) => {
+      return this.client.getCoins({
+        owner,
+        coinType,
+        cursor,
+        limit: 100,
+      })
+    }
+
+    const coins = []
+    let cursor = null
+    while (true) {
+      const response = await requestByCursor({ cursor })
+      coins.push(...response.data)
+      if (!response.nextCursor || !response.hasNextPage) {
+        break
+      }
+
+      cursor = response.nextCursor
+    }
+
+    return coins
+  }
+
+  async broadcastTx(plainTx) {
+    return this.client.executeTransactionBlock({
+      transactionBlock: plainTx.bytes,
+      signature: plainTx.signature,
+      options: {
+        showEffects: true,
+        showObjectChanges: true,
+        showBalanceChanges: true,
+      },
+    })
+  }
+}

package/src/balances.js

@@ -0,0 +1,22 @@
+export const getBalances = ({ asset, accountState }) => {
+  const isBaseAsset = asset.name === asset.baseAssetName
+
+  if (isBaseAsset) {
+    return {
+      total: accountState.utxos.value,
+      spendable: accountState.utxos.value,
+    }
+  }
+
+  if (accountState.tokenUtxos[asset.name]) {
+    return {
+      total: accountState.tokenUtxos[asset.name].value,
+      spendable: accountState.tokenUtxos[asset.name].value,
+    }
+  }
+
+  return {
+    total: asset.currency.ZERO,
+    spendable: asset.currency.ZERO,
+  }
+}

package/src/basic-account-state.js

@@ -0,0 +1,11 @@
+import { AccountState, UtxoCollection } from '@exodus/models'
+import { asset } from '@exodus/sui-meta'
+
+export const createBasicAccountState = () => {
+  return class SuiAccountState extends AccountState {
+    static defaults = {
+      utxos: UtxoCollection.createEmpty({ currency: asset.currency }),
+      tokenUtxos: Object.create(null),
+    }
+  }
+}

package/src/create-unsigned-tx.js

@@ -0,0 +1,60 @@
+import { UtxoCollection } from '@exodus/models'
+import assert from 'minimalistic-assert'
+
+import { Transaction } from './vendors/transactions/index.js'
+
+export const createUnsignedTxFactory = ({ assetClientInterface, serverApi }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  return async ({
+    asset,
+    senderAddress,
+    recipientAddress,
+    amount,
+    gasBudget,
+    walletAccount,
+    buildOptions = Object.create(null),
+  }) => {
+    const accountState = await assetClientInterface.getAccountState({
+      assetName: asset.baseAssetName,
+      walletAccount,
+    })
+
+    const txb = new Transaction()
+
+    txb.setGasBudget(BigInt(gasBudget))
+
+    if (asset.name === asset.baseAssetName) {
+      txb.transferObjects([txb.splitCoins(txb.gas, [amount])], txb.pure.address(recipientAddress))
+      txb.setSender(senderAddress)
+
+      return {
+        txData: await txb.build({ client: serverApi.client, ...buildOptions }),
+        txMeta: Object.create(null),
+      }
+    }
+
+    const usedCoins = (
+      accountState.tokenUtxos[asset.name] ||
+      UtxoCollection.createEmpty({ currency: asset.currency })
+    ).toArray()
+
+    usedCoins.reverse()
+
+    const coinObjectIds = usedCoins.map((coin) => coin.coinObjectId)
+
+    const [inputCoin, ...rest] = coinObjectIds
+    if (rest.length > 0) {
+      txb.mergeCoins(inputCoin, rest)
+    }
+
+    const [coin] = txb.splitCoins(inputCoin, [amount])
+
+    txb.transferObjects([coin], txb.pure.address(recipientAddress))
+    txb.setSender(senderAddress)
+
+    return {
+      txData: await txb.build({ client: serverApi.client, ...buildOptions }),
+      txMeta: Object.create(null),
+    }
+  }
+}

package/src/get-fee-async.js

@@ -0,0 +1,62 @@
+import { MIN_GAS_BUDGET } from '@exodus/sui-lib'
+import assert from 'minimalistic-assert'
+
+import { getFeeAmount, getGasBudget } from './transform-tx.js'
+
+export const getFeeAsyncFactory = ({ assetClientInterface, serverApi, createUnsignedTx }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+
+  return async ({
+    asset,
+    walletAccount,
+    toAddress: recipientAddress,
+    fromAddress: senderAddress,
+    amount,
+  }) => {
+    const feeAsset = asset.feeAsset
+
+    const { txData } = await createUnsignedTx({
+      asset,
+      senderAddress,
+      walletAccount,
+      recipientAddress:
+        recipientAddress || '0x7a2ddb6af66beb0d9987c6c9010cb9053454f067e16775a8ecf19961195c3d28',
+      amount: amount.toBaseString(),
+      serverApi,
+      gasBudget: MIN_GAS_BUDGET,
+      buildOptions: {
+        onlyTransactionKind: true,
+      },
+    })
+
+    const simulation = await serverApi.client.devInspectTransactionBlock({
+      sender: senderAddress,
+      transactionBlock: txData,
+    })
+
+    const { gasUsed } = simulation.effects
+
+    assert(
+      gasUsed?.computationCost && gasUsed?.storageCost && gasUsed?.storageRebate,
+      'Invalid simulation result'
+    )
+
+    let fee = getFeeAmount({
+      feeAsset,
+      gasUsed,
+    })
+
+    const gasBudget = getGasBudget({ gasUsed, feeAsset })
+
+    if (fee.lt(asset.feeAsset.currency.baseUnit(MIN_GAS_BUDGET))) {
+      // sometimes we can receive a negative fee because of storage rebate
+      // so we use the gas budget instead
+      fee = gasBudget
+    }
+
+    return {
+      fee,
+      gasBudget: gasBudget.toNumber(),
+    }
+  }
+}

package/src/get-fee.js

@@ -0,0 +1,10 @@
+import { DEFAULT_GAS_BUDGET } from '@exodus/sui-lib'
+
+export const getFeeFactory =
+  ({ asset }) =>
+  ({ feeData, feeOpts }) => {
+    return {
+      fee: asset.feeAsset.currency.baseUnit(DEFAULT_GAS_BUDGET),
+      gasBudget: DEFAULT_GAS_BUDGET,
+    }
+  }

package/src/index.js

@@ -0,0 +1,9 @@
+export { SuiApi } from './api.js'
+
+export { getFeeFactory } from './get-fee.js'
+export { createBasicAccountState } from './basic-account-state.js'
+export { getBalances } from './balances.js'
+export { createSuiNoHistoryMonitor } from './sui-no-history-monitor.js'
+export { getFeeAsyncFactory } from './get-fee-async.js'
+export { txSendFactory } from './tx-send.js'
+export { createUnsignedTxFactory } from './create-unsigned-tx.js'