@exodus/sui-api 1.3.1 → 1.4.1

package/src/vendors/client/client.js

@@ -1,680 +0,0 @@
-/* eslint-disable unicorn/no-await-expression-member */
-/* eslint-disable no-return-await */
-/* eslint-disable camelcase */
-import { vendorLib } from '@exodus/sui-lib'
-
-import { Experimental_BaseClient } from '../experimental/client.js'
-import { JSONRpcTransport } from '../experimental/transports/jsonRPC.js'
-import { isTransaction } from '../transactions/Transaction.js'
-import { SuiHTTPTransport } from './http-transport.js'
-
-const { fromBase58, toBase64, toHex } = vendorLib.utils
-
-const {
-  isValidSuiAddress,
-  isValidSuiObjectId,
-  isValidTransactionDigest,
-  normalizeSuiAddress,
-  normalizeSuiObjectId,
-} = vendorLib.utils
-
-const SUI_CLIENT_BRAND = Symbol.for('@mysten/SuiClient')
-
-class SuiClient extends Experimental_BaseClient {
-  /**
-   * Establish a connection to a Sui RPC endpoint
-   *
-   * @param options configuration options for the API Client
-   */
-  constructor(options) {
-    super({ network: options.network ?? 'unknown' })
-    this.jsonRpc = this
-    this.transport = options.transport ?? new SuiHTTPTransport({ url: options.url })
-    this.core = new JSONRpcTransport({
-      jsonRpcClient: this,
-    })
-  }
-
-  get [SUI_CLIENT_BRAND]() {
-    return true
-  }
-
-  async getRpcApiVersion({ signal } = Object.create(null)) {
-    const resp = await this.transport.request({
-      method: 'rpc.discover',
-      params: [],
-      signal,
-    })
-    return resp.info.version
-  }
-
-  /**
-   * Get all Coin<`coin_type`> objects owned by an address.
-   */
-  async getCoins({ coinType, owner, cursor, limit, signal }) {
-    if (!owner || !isValidSuiAddress(normalizeSuiAddress(owner))) {
-      throw new Error('Invalid Sui address')
-    }
-
-    return await this.transport.request({
-      method: 'suix_getCoins',
-      params: [owner, coinType, cursor, limit],
-      signal,
-    })
-  }
-
-  /**
-   * Get all Coin objects owned by an address.
-   */
-  async getAllCoins(input) {
-    if (!input.owner || !isValidSuiAddress(normalizeSuiAddress(input.owner))) {
-      throw new Error('Invalid Sui address')
-    }
-
-    return await this.transport.request({
-      method: 'suix_getAllCoins',
-      params: [input.owner, input.cursor, input.limit],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Get the total coin balance for one coin type, owned by the address owner.
-   */
-  async getBalance({ owner, coinType, signal }) {
-    if (!owner || !isValidSuiAddress(normalizeSuiAddress(owner))) {
-      throw new Error('Invalid Sui address')
-    }
-
-    return await this.transport.request({
-      method: 'suix_getBalance',
-      params: [owner, coinType],
-      signal,
-    })
-  }
-
-  /**
-   * Get the total coin balance for all coin types, owned by the address owner.
-   */
-  async getAllBalances(input) {
-    if (!input.owner || !isValidSuiAddress(normalizeSuiAddress(input.owner))) {
-      throw new Error('Invalid Sui address')
-    }
-
-    return await this.transport.request({
-      method: 'suix_getAllBalances',
-      params: [input.owner],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Fetch CoinMetadata for a given coin type
-   */
-  async getCoinMetadata({ coinType, signal }) {
-    return await this.transport.request({
-      method: 'suix_getCoinMetadata',
-      params: [coinType],
-      signal,
-    })
-  }
-
-  /**
-   *  Fetch total supply for a coin
-   */
-  async getTotalSupply({ coinType, signal }) {
-    return await this.transport.request({
-      method: 'suix_getTotalSupply',
-      params: [coinType],
-      signal,
-    })
-  }
-
-  /**
-   * Invoke any RPC method
-   * @param method the method to be invoked
-   * @param args the arguments to be passed to the RPC request
-   */
-  async call(method, params, { signal } = Object.create(null)) {
-    return await this.transport.request({ method, params, signal })
-  }
-
-  /**
-   * Get Move function argument types like read, write and full access
-   */
-  async getMoveFunctionArgTypes({ package: pkg, module, function: fn, signal }) {
-    return await this.transport.request({
-      method: 'sui_getMoveFunctionArgTypes',
-      params: [pkg, module, fn],
-      signal,
-    })
-  }
-
-  /**
-   * Get a map from module name to
-   * structured representations of Move modules
-   */
-  async getNormalizedMoveModulesByPackage({ package: pkg, signal }) {
-    return await this.transport.request({
-      method: 'sui_getNormalizedMoveModulesByPackage',
-      params: [pkg],
-      signal,
-    })
-  }
-
-  /**
-   * Get a structured representation of Move module
-   */
-  async getNormalizedMoveModule({ package: pkg, module, signal }) {
-    return await this.transport.request({
-      method: 'sui_getNormalizedMoveModule',
-      params: [pkg, module],
-      signal,
-    })
-  }
-
-  /**
-   * Get a structured representation of Move function
-   */
-  async getNormalizedMoveFunction({ package: pkg, module, function: fn, signal }) {
-    return await this.transport.request({
-      method: 'sui_getNormalizedMoveFunction',
-      params: [pkg, module, fn],
-      signal,
-    })
-  }
-
-  /**
-   * Get a structured representation of Move struct
-   */
-  async getNormalizedMoveStruct({ package: pkg, module, struct, signal }) {
-    return await this.transport.request({
-      method: 'sui_getNormalizedMoveStruct',
-      params: [pkg, module, struct],
-      signal,
-    })
-  }
-
-  /**
-   * Get all objects owned by an address
-   */
-  async getOwnedObjects(input) {
-    if (!input.owner || !isValidSuiAddress(normalizeSuiAddress(input.owner))) {
-      throw new Error('Invalid Sui address')
-    }
-
-    const filter = input.filter
-      ? {
-          ...input.filter,
-        }
-      : void 0
-    return await this.transport.request({
-      method: 'suix_getOwnedObjects',
-      params: [
-        input.owner,
-        {
-          filter,
-          options: input.options,
-        },
-        input.cursor,
-        input.limit,
-      ],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Get details about an object
-   */
-  async getObject(input) {
-    if (!input.id || !isValidSuiObjectId(normalizeSuiObjectId(input.id))) {
-      throw new Error('Invalid Sui Object id')
-    }
-
-    return await this.transport.request({
-      method: 'sui_getObject',
-      params: [input.id, input.options],
-      signal: input.signal,
-    })
-  }
-
-  async tryGetPastObject(input) {
-    return await this.transport.request({
-      method: 'sui_tryGetPastObject',
-      params: [input.id, input.version, input.options],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Batch get details about a list of objects. If any of the object ids are duplicates the call will fail
-   */
-  async multiGetObjects(input) {
-    input.ids.forEach((id) => {
-      if (!id || !isValidSuiObjectId(normalizeSuiObjectId(id))) {
-        throw new Error(`Invalid Sui Object id ${id}`)
-      }
-    })
-    const hasDuplicates = input.ids.length !== new Set(input.ids).size
-    if (hasDuplicates) {
-      throw new Error(`Duplicate object ids in batch call ${input.ids}`)
-    }
-
-    return await this.transport.request({
-      method: 'sui_multiGetObjects',
-      params: [input.ids, input.options],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Get transaction blocks for a given query criteria
-   */
-  async queryTransactionBlocks({ filter, options, cursor, limit, order, signal }) {
-    return await this.transport.request({
-      method: 'suix_queryTransactionBlocks',
-      params: [
-        {
-          filter,
-          options,
-        },
-        cursor,
-        limit,
-        (order || 'descending') === 'descending',
-      ],
-      signal,
-    })
-  }
-
-  async getTransactionBlock(input) {
-    if (!isValidTransactionDigest(input.digest)) {
-      throw new Error('Invalid Transaction digest')
-    }
-
-    return await this.transport.request({
-      method: 'sui_getTransactionBlock',
-      params: [input.digest, input.options],
-      signal: input.signal,
-    })
-  }
-
-  async multiGetTransactionBlocks(input) {
-    input.digests.forEach((d) => {
-      if (!isValidTransactionDigest(d)) {
-        throw new Error(`Invalid Transaction digest ${d}`)
-      }
-    })
-    const hasDuplicates = input.digests.length !== new Set(input.digests).size
-    if (hasDuplicates) {
-      throw new Error(`Duplicate digests in batch call ${input.digests}`)
-    }
-
-    return await this.transport.request({
-      method: 'sui_multiGetTransactionBlocks',
-      params: [input.digests, input.options],
-      signal: input.signal,
-    })
-  }
-
-  async executeTransactionBlock({ transactionBlock, signature, options, requestType, signal }) {
-    const result = await this.transport.request({
-      method: 'sui_executeTransactionBlock',
-      params: [
-        typeof transactionBlock === 'string' ? transactionBlock : toBase64(transactionBlock),
-        Array.isArray(signature) ? signature : [signature],
-        options,
-      ],
-      signal,
-    })
-    if (requestType === 'WaitForLocalExecution') {
-      try {
-        await this.waitForTransaction({
-          digest: result.digest,
-        })
-      } catch {}
-    }
-
-    return result
-  }
-
-  async signAndExecuteTransaction({ transaction, signer, ...input }) {
-    let transactionBytes
-    if (transaction instanceof Uint8Array) {
-      transactionBytes = transaction
-    } else {
-      transaction.setSenderIfNotSet(signer.toSuiAddress())
-      transactionBytes = await transaction.build({ client: this })
-    }
-
-    const { signature, bytes } = await signer.signTransaction(transactionBytes)
-    return this.executeTransactionBlock({
-      transactionBlock: bytes,
-      signature,
-      ...input,
-    })
-  }
-
-  /**
-   * Get total number of transactions
-   */
-  async getTotalTransactionBlocks({ signal } = Object.create(null)) {
-    const resp = await this.transport.request({
-      method: 'sui_getTotalTransactionBlocks',
-      params: [],
-      signal,
-    })
-    return BigInt(resp)
-  }
-
-  /**
-   * Getting the reference gas price for the network
-   */
-  async getReferenceGasPrice({ signal } = Object.create(null)) {
-    const resp = await this.transport.request({
-      method: 'suix_getReferenceGasPrice',
-      params: [],
-      signal,
-    })
-    return BigInt(resp)
-  }
-
-  /**
-   * Return the delegated stakes for an address
-   */
-  async getStakes(input) {
-    if (!input.owner || !isValidSuiAddress(normalizeSuiAddress(input.owner))) {
-      throw new Error('Invalid Sui address')
-    }
-
-    return await this.transport.request({
-      method: 'suix_getStakes',
-      params: [input.owner],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Return the delegated stakes queried by id.
-   */
-  async getStakesByIds(input) {
-    input.stakedSuiIds.forEach((id) => {
-      if (!id || !isValidSuiObjectId(normalizeSuiObjectId(id))) {
-        throw new Error(`Invalid Sui Stake id ${id}`)
-      }
-    })
-    return await this.transport.request({
-      method: 'suix_getStakesByIds',
-      params: [input.stakedSuiIds],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Return the latest system state content.
-   */
-  async getLatestSuiSystemState({ signal } = Object.create(null)) {
-    return await this.transport.request({
-      method: 'suix_getLatestSuiSystemState',
-      params: [],
-      signal,
-    })
-  }
-
-  /**
-   * Get events for a given query criteria
-   */
-  async queryEvents({ query, cursor, limit, order, signal }) {
-    return await this.transport.request({
-      method: 'suix_queryEvents',
-      params: [query, cursor, limit, (order || 'descending') === 'descending'],
-      signal,
-    })
-  }
-
-  /**
-   * Runs the transaction block in dev-inspect mode. Which allows for nearly any
-   * transaction (or Move call) with any arguments. Detailed results are
-   * provided, including both the transaction effects and any return values.
-   */
-  async devInspectTransactionBlock(input) {
-    let devInspectTxBytes
-    if (isTransaction(input.transactionBlock)) {
-      input.transactionBlock.setSenderIfNotSet(input.sender)
-      devInspectTxBytes = toBase64(
-        await input.transactionBlock.build({
-          client: this,
-          onlyTransactionKind: true,
-        })
-      )
-    } else if (typeof input.transactionBlock === 'string') {
-      devInspectTxBytes = input.transactionBlock
-    } else if (input.transactionBlock instanceof Uint8Array) {
-      devInspectTxBytes = toBase64(input.transactionBlock)
-    } else {
-      throw new TypeError('Unknown transaction block format.')
-    }
-
-    input.signal?.throwIfAborted()
-    return await this.transport.request({
-      method: 'sui_devInspectTransactionBlock',
-      params: [input.sender, devInspectTxBytes, input.gasPrice?.toString(), input.epoch],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Dry run a transaction block and return the result.
-   */
-  async dryRunTransactionBlock(input) {
-    return await this.transport.request({
-      method: 'sui_dryRunTransactionBlock',
-      params: [
-        typeof input.transactionBlock === 'string'
-          ? input.transactionBlock
-          : toBase64(input.transactionBlock),
-      ],
-    })
-  }
-
-  /**
-   * Return the list of dynamic field objects owned by an object
-   */
-  async getDynamicFields(input) {
-    if (!input.parentId || !isValidSuiObjectId(normalizeSuiObjectId(input.parentId))) {
-      throw new Error('Invalid Sui Object id')
-    }
-
-    return await this.transport.request({
-      method: 'suix_getDynamicFields',
-      params: [input.parentId, input.cursor, input.limit],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Return the dynamic field object information for a specified object
-   */
-  async getDynamicFieldObject(input) {
-    return await this.transport.request({
-      method: 'suix_getDynamicFieldObject',
-      params: [input.parentId, input.name],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Get the sequence number of the latest checkpoint that has been executed
-   */
-  async getLatestCheckpointSequenceNumber({ signal } = Object.create(null)) {
-    const resp = await this.transport.request({
-      method: 'sui_getLatestCheckpointSequenceNumber',
-      params: [],
-      signal,
-    })
-    return String(resp)
-  }
-
-  /**
-   * Returns information about a given checkpoint
-   */
-  async getCheckpoint(input) {
-    return await this.transport.request({
-      method: 'sui_getCheckpoint',
-      params: [input.id],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Returns historical checkpoints paginated
-   */
-  async getCheckpoints(input) {
-    return await this.transport.request({
-      method: 'sui_getCheckpoints',
-      params: [input.cursor, input?.limit, input.descendingOrder],
-      signal: input.signal,
-    })
-  }
-
-  /**
-   * Return the committee information for the asked epoch
-   */
-  async getCommitteeInfo(input) {
-    return await this.transport.request({
-      method: 'suix_getCommitteeInfo',
-      params: [input?.epoch],
-      signal: input?.signal,
-    })
-  }
-
-  async getNetworkMetrics({ signal } = Object.create(null)) {
-    return await this.transport.request({
-      method: 'suix_getNetworkMetrics',
-      params: [],
-      signal,
-    })
-  }
-
-  async getAddressMetrics({ signal } = Object.create(null)) {
-    return await this.transport.request({
-      method: 'suix_getLatestAddressMetrics',
-      params: [],
-      signal,
-    })
-  }
-
-  async getEpochMetrics(input) {
-    return await this.transport.request({
-      method: 'suix_getEpochMetrics',
-      params: [input?.cursor, input?.limit, input?.descendingOrder],
-      signal: input?.signal,
-    })
-  }
-
-  async getAllEpochAddressMetrics(input) {
-    return await this.transport.request({
-      method: 'suix_getAllEpochAddressMetrics',
-      params: [input?.descendingOrder],
-      signal: input?.signal,
-    })
-  }
-
-  /**
-   * Return the committee information for the asked epoch
-   */
-  async getEpochs(input) {
-    return await this.transport.request({
-      method: 'suix_getEpochs',
-      params: [input?.cursor, input?.limit, input?.descendingOrder],
-      signal: input?.signal,
-    })
-  }
-
-  /**
-   * Returns list of top move calls by usage
-   */
-  async getMoveCallMetrics({ signal } = Object.create(null)) {
-    return await this.transport.request({
-      method: 'suix_getMoveCallMetrics',
-      params: [],
-      signal,
-    })
-  }
-
-  /**
-   * Return the committee information for the asked epoch
-   */
-  async getCurrentEpoch({ signal } = Object.create(null)) {
-    return await this.transport.request({
-      method: 'suix_getCurrentEpoch',
-      params: [],
-      signal,
-    })
-  }
-
-  /**
-   * Return the Validators APYs
-   */
-  async getValidatorsApy({ signal } = Object.create(null)) {
-    return await this.transport.request({
-      method: 'suix_getValidatorsApy',
-      params: [],
-      signal,
-    })
-  }
-
-  // TODO: Migrate this to `sui_getChainIdentifier` once it is widely available.
-  async getChainIdentifier({ signal } = Object.create(null)) {
-    const checkpoint = await this.getCheckpoint({ id: '0', signal })
-    const bytes = fromBase58(checkpoint.digest)
-    return toHex(bytes.slice(0, 4))
-  }
-
-  async getProtocolConfig(input) {
-    return await this.transport.request({
-      method: 'sui_getProtocolConfig',
-      params: [input?.version],
-      signal: input?.signal,
-    })
-  }
-
-  /**
-   * Wait for a transaction block result to be available over the API.
-   * This can be used in conjunction with `executeTransactionBlock` to wait for the transaction to
-   * be available via the API.
-   * This currently polls the `getTransactionBlock` API to check for the transaction.
-   */
-  async waitForTransaction({ signal, timeout = 60 * 1e3, pollInterval = 2 * 1e3, ...input }) {
-    const timeoutSignal = AbortSignal.timeout(timeout)
-    // eslint-disable-next-line promise/param-names
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutSignal.addEventListener('abort', () => reject(timeoutSignal.reason))
-    })
-    timeoutPromise.catch(() => {})
-    while (!timeoutSignal.aborted) {
-      signal?.throwIfAborted()
-      try {
-        return await this.getTransactionBlock(input)
-      } catch {
-        await Promise.race([
-          new Promise((resolve) => setTimeout(resolve, pollInterval)),
-          timeoutPromise,
-        ])
-      }
-    }
-
-    timeoutSignal.throwIfAborted()
-    throw new Error('Unexpected error while waiting for transaction block.')
-  }
-
-  experimental_asClientExtension() {
-    return {
-      name: 'jsonRPC',
-      register: () => {
-        return this
-      },
-    }
-  }
-}
-export { SuiClient }
-// # sourceMappingURL=client.js.map

package/src/vendors/client/errors.js

@@ -1,38 +0,0 @@
-const CODE_TO_ERROR_TYPE = {
-  '-32700': 'ParseError',
-  '-32701': 'OversizedRequest',
-  '-32702': 'OversizedResponse',
-  '-32600': 'InvalidRequest',
-  '-32601': 'MethodNotFound',
-  '-32602': 'InvalidParams',
-  '-32603': 'InternalError',
-  '-32604': 'ServerBusy',
-  '-32000': 'CallExecutionFailed',
-  '-32001': 'UnknownError',
-  '-32003': 'SubscriptionClosed',
-  '-32004': 'SubscriptionClosedWithError',
-  '-32005': 'BatchesNotSupported',
-  '-32006': 'TooManySubscriptions',
-  '-32050': 'TransientError',
-  '-32002': 'TransactionExecutionClientError',
-}
-
-class SuiHTTPTransportError extends Error {}
-
-class JsonRpcError extends SuiHTTPTransportError {
-  constructor(message, code) {
-    super(message)
-    this.code = code
-    this.type = CODE_TO_ERROR_TYPE[code] ?? 'ServerError'
-  }
-}
-
-class SuiHTTPStatusError extends SuiHTTPTransportError {
-  constructor(message, status, statusText) {
-    super(message)
-    this.status = status
-    this.statusText = statusText
-  }
-}
-export { JsonRpcError, SuiHTTPStatusError }
-// # sourceMappingURL=errors.js.map