@exodus/sui-api 0.1.0

package/src/vendors/client/errors.js

@@ -0,0 +1,38 @@
+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, SuiHTTPTransportError }
+// # sourceMappingURL=errors.js.map

package/src/vendors/client/http-transport.js

@@ -0,0 +1,108 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+import { JsonRpcError, SuiHTTPStatusError } from './errors.js'
+import { WebsocketClient } from './rpc-websocket-client.js'
+
+export const PACKAGE_VERSION = '1.36.1'
+export const TARGETED_RPC_VERSION = '1.55.0'
+
+/**
+ * An object defining headers to be passed to the RPC server
+ */
+
+export class SuiHTTPTransport {
+  #requestId = 0
+  #options
+  #websocketClient
+
+  constructor(options) {
+    this.#options = options
+  }
+
+  fetch(input, init) {
+    const fetchFn = this.#options.fetch ?? fetch
+
+    if (!fetchFn) {
+      throw new Error(
+        'The current environment does not support fetch, you can provide a fetch implementation in the options for SuiHTTPTransport.'
+      )
+    }
+
+    return fetchFn(input, init)
+  }
+
+  #getWebsocketClient() {
+    if (!this.#websocketClient) {
+      // eslint-disable-next-line no-undef
+      const WebSocketConstructor = this.#options.WebSocketConstructor ?? WebSocket
+      if (!WebSocketConstructor) {
+        throw new Error(
+          'The current environment does not support WebSocket, you can provide a WebSocketConstructor in the options for SuiHTTPTransport.'
+        )
+      }
+
+      this.#websocketClient = new WebsocketClient(
+        this.#options.websocket?.url ?? this.#options.url,
+        {
+          WebSocketConstructor,
+          ...this.#options.websocket,
+        }
+      )
+    }
+
+    return this.#websocketClient
+  }
+
+  async request(input) {
+    this.#requestId += 1
+
+    const res = await this.fetch(this.#options.rpc?.url ?? this.#options.url, {
+      method: 'POST',
+      signal: input.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        'Client-Sdk-Type': 'typescript',
+        'Client-Sdk-Version': PACKAGE_VERSION,
+        'Client-Target-Api-Version': TARGETED_RPC_VERSION,
+        'Client-Request-Method': input.method,
+        ...this.#options.rpc?.headers,
+      },
+      body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: this.#requestId,
+        method: input.method,
+        params: input.params,
+      }),
+    })
+
+    if (!res.ok) {
+      throw new SuiHTTPStatusError(
+        `Unexpected status code: ${res.status}`,
+        res.status,
+        res.statusText
+      )
+    }
+
+    const data = await res.json()
+
+    if ('error' in data && data.error != null) {
+      throw new JsonRpcError(data.error.message, data.error.code)
+    }
+
+    return data.result
+  }
+
+  async subscribe(input) {
+    const unsubscribe = await this.#getWebsocketClient().subscribe(input)
+
+    if (input.signal) {
+      input.signal.throwIfAborted()
+      input.signal.addEventListener('abort', () => {
+        unsubscribe()
+      })
+    }
+
+    return async () => !!(await unsubscribe())
+  }
+}

package/src/vendors/client/index.js

@@ -0,0 +1 @@
+export { SuiClient } from './client.js'

package/src/vendors/client/rpc-websocket-client.js

@@ -0,0 +1,178 @@
+import { JsonRpcError } from './errors.js'
+
+function getWebsocketUrl(httpUrl) {
+  const url = new URL(httpUrl)
+  url.protocol = url.protocol.replace('http', 'ws')
+  return url.toString()
+}
+
+export const DEFAULT_CLIENT_OPTIONS = {
+  // We fudge the typing because we also check for undefined in the constructor:
+  // eslint-disable-next-line no-undef
+  WebSocketConstructor: typeof WebSocket === 'undefined' ? undefined : WebSocket, // eslint-disable-line @typescript-eslint/no-unsafe-assignment
+  callTimeout: 30_000,
+  reconnectTimeout: 3000,
+  maxReconnects: 5,
+}
+
+export class WebsocketClient {
+  endpoint
+  options
+  #requestId = 0
+  #disconnects = 0
+  #webSocket = null
+  #connectionPromise = null
+  #subscriptions = new Set()
+  #pendingRequests = new Map()
+
+  constructor(endpoint, options = Object.create(null)) {
+    this.endpoint = endpoint
+    this.options = { ...DEFAULT_CLIENT_OPTIONS, ...options }
+
+    if (!this.options.WebSocketConstructor) {
+      throw new Error('Missing WebSocket constructor')
+    }
+
+    if (this.endpoint.startsWith('http')) {
+      this.endpoint = getWebsocketUrl(this.endpoint)
+    }
+  }
+
+  async makeRequest(method, params, signal) {
+    const webSocket = await this.#setupWebSocket()
+
+    return new Promise((resolve, reject) => {
+      this.#requestId += 1
+      this.#pendingRequests.set(this.#requestId, {
+        resolve,
+        reject,
+        timeout: setTimeout(() => {
+          this.#pendingRequests.delete(this.#requestId)
+          reject(new Error(`Request timeout: ${method}`))
+        }, this.options.callTimeout),
+      })
+
+      signal?.addEventListener('abort', () => {
+        this.#pendingRequests.delete(this.#requestId)
+        reject(signal.reason)
+      })
+
+      webSocket.send(JSON.stringify({ jsonrpc: '2.0', id: this.#requestId, method, params }))
+    }).then(({ error, result }) => {
+      if (error) {
+        throw new JsonRpcError(error.message, error.code)
+      }
+
+      return result
+    })
+  }
+
+  #setupWebSocket() {
+    if (this.#connectionPromise) {
+      return this.#connectionPromise
+    }
+
+    this.#connectionPromise = new Promise((resolve) => {
+      this.#webSocket?.close()
+      this.#webSocket = new this.options.WebSocketConstructor(this.endpoint)
+
+      this.#webSocket.addEventListener('open', () => {
+        this.#disconnects = 0
+        resolve(this.#webSocket)
+      })
+
+      this.#webSocket.addEventListener('close', () => {
+        this.#disconnects++
+        if (this.#disconnects <= this.options.maxReconnects) {
+          setTimeout(() => {
+            this.#reconnect()
+          }, this.options.reconnectTimeout)
+        }
+      })
+
+      this.#webSocket.addEventListener('message', ({ data }) => {
+        let json
+        try {
+          json = JSON.parse(data)
+        } catch (error) {
+          console.error(new Error(`Failed to parse RPC message: ${data}`, { cause: error }))
+          return
+        }
+
+        if ('id' in json && json.id != null && this.#pendingRequests.has(json.id)) {
+          const { resolve, timeout } = this.#pendingRequests.get(json.id)
+
+          clearTimeout(timeout)
+          resolve(json)
+        } else if ('params' in json) {
+          const { params } = json
+          this.#subscriptions.forEach((subscription) => {
+            if (
+              subscription.subscriptionId === params.subscription &&
+              params.subscription === subscription.subscriptionId
+            ) {
+              subscription.onMessage(params.result)
+            }
+          })
+        }
+      })
+    })
+
+    return this.#connectionPromise
+  }
+
+  async #reconnect() {
+    this.#webSocket?.close()
+    this.#connectionPromise = null
+
+    return Promise.allSettled(
+      [...this.#subscriptions].map((subscription) => subscription.subscribe(this))
+    )
+  }
+
+  async subscribe(input) {
+    const subscription = new RpcSubscription(input)
+    this.#subscriptions.add(subscription)
+    await subscription.subscribe(this)
+    return () => subscription.unsubscribe(this)
+  }
+}
+
+class RpcSubscription {
+  subscriptionId = null
+  input
+  subscribed = false
+
+  constructor(input) {
+    this.input = input
+  }
+
+  onMessage(message) {
+    if (this.subscribed) {
+      this.input.onMessage(message)
+    }
+  }
+
+  async unsubscribe(client) {
+    const { subscriptionId } = this
+    this.subscribed = false
+    if (subscriptionId == null) return false
+    this.subscriptionId = null
+
+    return client.makeRequest(this.input.unsubscribe, [subscriptionId])
+  }
+
+  async subscribe(client) {
+    this.subscriptionId = null
+    this.subscribed = true
+    const newSubscriptionId = await client.makeRequest(
+      this.input.method,
+      this.input.params,
+      this.input.signal
+    )
+
+    if (this.subscribed) {
+      this.subscriptionId = newSubscriptionId
+    }
+  }
+}

package/src/vendors/experimental/cache.js

@@ -0,0 +1,89 @@
+/* eslint-disable no-sequences */
+var __typeError = (msg) => {
+  throw new TypeError(msg)
+}
+
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError('Cannot ' + msg)
+var __privateGet = (obj, member, getter) => (
+  __accessCheck(obj, member, 'read from private field'), getter ? getter.call(obj) : member.get(obj)
+)
+var __privateAdd = (obj, member, value) =>
+  member.has(obj)
+    ? __typeError('Cannot add the same private member more than once')
+    : member instanceof WeakSet
+      ? member.add(obj)
+      : member.set(obj, value)
+var __privateSet = (obj, member, value, setter) => (
+  __accessCheck(obj, member, 'write to private field'),
+  setter ? setter.call(obj, value) : member.set(obj, value),
+  value
+)
+var _prefix, _cache
+const _ClientCache = class _ClientCache {
+  constructor({ prefix, cache } = Object.create(null)) {
+    __privateAdd(this, _prefix)
+    __privateAdd(this, _cache)
+    __privateSet(this, _prefix, prefix ?? [])
+    __privateSet(this, _cache, cache ?? /* @__PURE__ */ new Map())
+  }
+
+  read(key, load) {
+    const cacheKey = [__privateGet(this, _prefix), ...key].join(':')
+    if (__privateGet(this, _cache).has(cacheKey)) {
+      return __privateGet(this, _cache).get(cacheKey)
+    }
+
+    const result = load()
+    __privateGet(this, _cache).set(cacheKey, result)
+    if (typeof result === 'object' && result !== null && result.hasOwnProperty('then')) {
+      return Promise.resolve(result)
+        .then((v) => {
+          __privateGet(this, _cache).set(cacheKey, v)
+          return v
+        })
+        .catch((err) => {
+          __privateGet(this, _cache).delete(cacheKey)
+          throw err
+        })
+    }
+
+    return result
+  }
+
+  readSync(key, load) {
+    const cacheKey = [__privateGet(this, _prefix), ...key].join(':')
+    if (__privateGet(this, _cache).has(cacheKey)) {
+      return __privateGet(this, _cache).get(cacheKey)
+    }
+
+    const result = load()
+    __privateGet(this, _cache).set(cacheKey, result)
+    return result
+  }
+
+  clear(prefix) {
+    const prefixKey = [...__privateGet(this, _prefix), ...(prefix ?? [])].join(':')
+    if (!prefixKey) {
+      __privateGet(this, _cache).clear()
+      return
+    }
+
+    for (const key of __privateGet(this, _cache).keys()) {
+      if (key.startsWith(prefixKey)) {
+        __privateGet(this, _cache).delete(key)
+      }
+    }
+  }
+
+  scope(prefix) {
+    return new _ClientCache({
+      prefix: [...__privateGet(this, _prefix), ...(Array.isArray(prefix) ? prefix : [prefix])],
+      cache: __privateGet(this, _cache),
+    })
+  }
+}
+_prefix = new WeakMap()
+_cache = new WeakMap()
+const ClientCache = _ClientCache
+export { ClientCache }
+// # sourceMappingURL=cache.js.map

package/src/vendors/experimental/client.js

@@ -0,0 +1,27 @@
+/* eslint-disable camelcase */
+import { ClientCache } from './cache.js'
+
+class Experimental_BaseClient {
+  constructor({ network, base }) {
+    this.network = network
+    this.base = base ?? this
+    this.cache = base?.cache ?? new ClientCache()
+  }
+
+  $extend(...registrations) {
+    return Object.create(
+      this,
+      Object.fromEntries(
+        registrations.map((registration) => {
+          if ('experimental_asClientExtension' in registration) {
+            const { name, register } = registration.experimental_asClientExtension()
+            return [name, { value: register(this) }]
+          }
+
+          return [registration.name, { value: registration.register(this) }]
+        })
+      )
+    )
+  }
+}
+export { Experimental_BaseClient }

package/src/vendors/experimental/core.js

@@ -0,0 +1,105 @@
+/* eslint-disable camelcase */
+
+import { vendorLib } from '@exodus/sui-lib'
+
+import { Experimental_BaseClient } from './client.js'
+import { MvrClient } from './mvr.js'
+
+const { TypeTagSerializer } = vendorLib.bcs
+const { deriveDynamicFieldID, normalizeStructTag, parseStructTag, SUI_ADDRESS_LENGTH } =
+  vendorLib.utils
+
+const DEFAULT_MVR_URLS = {
+  mainnet: 'https://mainnet.mvr.mystenlabs.com',
+  testnet: 'https://testnet.mvr.mystenlabs.com',
+}
+
+class Experimental_CoreClient extends Experimental_BaseClient {
+  constructor(options) {
+    super(options)
+    this.core = this
+    this.mvr = new MvrClient({
+      cache: this.cache.scope('core.mvr'),
+      url: options.mvr?.url ?? DEFAULT_MVR_URLS[this.network],
+      pageSize: options.mvr?.pageSize,
+      overrides: options.mvr?.overrides,
+    })
+  }
+
+  async getObject(options) {
+    const { objectId } = options
+    const {
+      objects: [result],
+    } = await this.getObjects({ objectIds: [objectId], signal: options.signal })
+    if (result instanceof Error) {
+      throw result
+    }
+
+    return { object: result }
+  }
+
+  async getDynamicField(options) {
+    const fieldId = deriveDynamicFieldID(
+      options.parentId,
+      TypeTagSerializer.parseFromStr(options.name.type),
+      options.name.bcs
+    )
+    const {
+      objects: [fieldObject],
+    } = await this.getObjects({
+      objectIds: [fieldId],
+      signal: options.signal,
+    })
+    if (fieldObject instanceof Error) {
+      throw fieldObject
+    }
+
+    const fieldType = parseStructTag(fieldObject.type)
+    const content = await fieldObject.content
+    return {
+      dynamicField: {
+        id: fieldObject.id,
+        digest: fieldObject.digest,
+        version: fieldObject.version,
+        type: fieldObject.type,
+        name: {
+          type:
+            typeof fieldType.typeParams[0] === 'string'
+              ? fieldType.typeParams[0]
+              : normalizeStructTag(fieldType.typeParams[0]),
+          bcs: options.name.bcs,
+        },
+        value: {
+          type:
+            typeof fieldType.typeParams[1] === 'string'
+              ? fieldType.typeParams[1]
+              : normalizeStructTag(fieldType.typeParams[1]),
+          bcs: content.slice(SUI_ADDRESS_LENGTH + options.name.bcs.length),
+        },
+      },
+    }
+  }
+
+  async waitForTransaction({ signal, timeout = 60 * 1e3, ...input }) {
+    const abortSignal = signal
+      ? AbortSignal.any([AbortSignal.timeout(timeout), signal])
+      : AbortSignal.timeout(timeout)
+    // eslint-disable-next-line promise/param-names
+    const abortPromise = new Promise((_, reject) => {
+      abortSignal.addEventListener('abort', () => reject(abortSignal.reason))
+    })
+    abortPromise.catch(() => {})
+    while (true) {
+      abortSignal.throwIfAborted()
+      try {
+        return await this.getTransaction({
+          ...input,
+          signal: abortSignal,
+        })
+      } catch {
+        await Promise.race([new Promise((resolve) => setTimeout(resolve, 2e3)), abortPromise])
+      }
+    }
+  }
+}
+export { Experimental_CoreClient }

package/src/vendors/experimental/errors.js

@@ -0,0 +1,32 @@
+/* eslint-disable sonarjs/no-nested-template-literals */
+class SuiClientError extends Error {}
+
+class ObjectError extends SuiClientError {
+  constructor(code, message) {
+    super(message)
+    this.code = code
+  }
+
+  static fromResponse(response, objectId) {
+    switch (response.code) {
+      case 'notExists':
+        return new ObjectError(response.code, `Object ${response.object_id} does not exist`)
+      case 'dynamicFieldNotFound':
+        return new ObjectError(
+          response.code,
+          `Dynamic field not found for object ${response.parent_object_id}`
+        )
+      case 'deleted':
+        return new ObjectError(response.code, `Object ${response.object_id} has been deleted`)
+      case 'displayError':
+        return new ObjectError(response.code, `Display error: ${response.error}`)
+      default:
+        return new ObjectError(
+          response.code,
+          `Unknown error while loading object${objectId ? ` ${objectId}` : ''}`
+        )
+    }
+  }
+}
+export { ObjectError, SuiClientError }
+// # sourceMappingURL=errors.js.map

package/src/vendors/experimental/index.js

@@ -0,0 +1,5 @@
+/* eslint-disable camelcase */
+export { ClientCache } from './cache.js'
+export { Experimental_CoreClient } from './core.js'
+export { Experimental_BaseClient } from './client.js'
+// # sourceMappingURL=index.js.map