@exodus/sui-api 1.0.0 → 1.0.2

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

@@ -1,178 +0,0 @@
-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/errors.js

@@ -1,32 +0,0 @@
-/* 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

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

package/src/vendors/experimental/transports/utils.js

@@ -1,90 +0,0 @@
-import { vendorLib } from '@exodus/sui-lib'
-
-import { TransactionDataBuilder } from '../../transactions/TransactionData.js'
-
-const { bcs } = vendorLib
-
-function parseTransactionBcs(bytes) {
-  return {
-    ...TransactionDataBuilder.fromBytes(bytes).snapshot(),
-    bcs: bytes,
-  }
-}
-
-function parseTransactionEffectsBcs(effects) {
-  const parsed = bcs.TransactionEffects.parse(effects)
-  switch (parsed.$kind) {
-    case 'V1':
-      return parseTransactionEffectsV1({ bytes: effects, effects: parsed.V1 })
-    case 'V2':
-      return parseTransactionEffectsV2({ bytes: effects, effects: parsed.V2 })
-    default:
-      throw new Error(`Unknown transaction effects version: ${parsed.$kind}`)
-  }
-}
-
-function parseTransactionEffectsV1(_) {
-  throw new Error('V1 effects are not supported yet')
-}
-
-function parseTransactionEffectsV2({ bytes, effects }) {
-  const changedObjects = effects.changedObjects.map(([id, change]) => {
-    return {
-      id,
-      inputState: change.inputState.$kind === 'Exist' ? 'Exists' : 'DoesNotExist',
-      inputVersion: change.inputState.Exist?.[0][0] ?? null,
-      inputDigest: change.inputState.Exist?.[0][1] ?? null,
-      inputOwner: change.inputState.Exist?.[1] ?? null,
-      outputState:
-        change.outputState.$kind === 'NotExist' ? 'DoesNotExist' : change.outputState.$kind,
-      outputVersion:
-        change.outputState.$kind === 'PackageWrite'
-          ? change.outputState.PackageWrite?.[0]
-          : change.outputState.ObjectWrite
-            ? effects.lamportVersion
-            : null,
-      outputDigest:
-        change.outputState.$kind === 'PackageWrite'
-          ? change.outputState.PackageWrite?.[1]
-          : change.outputState.ObjectWrite?.[0] ?? null,
-      outputOwner: change.outputState.ObjectWrite ? change.outputState.ObjectWrite[1] : null,
-      idOperation: change.idOperation.$kind,
-    }
-  })
-  return {
-    bcs: bytes,
-    digest: effects.transactionDigest,
-    version: 2,
-    status:
-      effects.status.$kind === 'Success'
-        ? {
-            success: true,
-            error: null,
-          }
-        : {
-            success: false,
-            // TODO: add command
-            error: effects.status.Failed.error.$kind,
-          },
-    gasUsed: effects.gasUsed,
-    transactionDigest: effects.transactionDigest,
-    gasObject:
-      effects.gasObjectIndex === null ? null : changedObjects[effects.gasObjectIndex] ?? null,
-    eventsDigest: effects.eventsDigest,
-    dependencies: effects.dependencies,
-    lamportVersion: effects.lamportVersion,
-    changedObjects,
-    unchangedSharedObjects: effects.unchangedSharedObjects.map(([objectId, object]) => {
-      return {
-        kind: object.$kind,
-        objectId,
-        version: object.$kind === 'ReadOnlyRoot' ? object.ReadOnlyRoot[0] : object[object.$kind],
-        digest: object.$kind === 'ReadOnlyRoot' ? object.ReadOnlyRoot[1] : null,
-      }
-    }),
-    auxiliaryDataDigest: effects.auxDataDigest,
-  }
-}
-
-export { parseTransactionBcs, parseTransactionEffectsBcs }
-// # sourceMappingURL=utils.js.map

package/src/vendors/transactions/Arguments.js

@@ -1,22 +0,0 @@
-import { createObjectMethods } from './object.js'
-import { createPure } from './pure.js'
-
-const Arguments = {
-  pure: createPure((value) => (tx) => tx.pure(value)),
-  object: createObjectMethods((value) => (tx) => tx.object(value)),
-  sharedObjectRef:
-    (...args) =>
-    (tx) =>
-      tx.sharedObjectRef(...args),
-  objectRef:
-    (...args) =>
-    (tx) =>
-      tx.objectRef(...args),
-  receivingRef:
-    (...args) =>
-    (tx) =>
-      tx.receivingRef(...args),
-}
-
-export { Arguments }
-// # sourceMappingURL=Arguments.js.map

package/src/vendors/transactions/ObjectCache.js

@@ -1,272 +0,0 @@
-/* eslint-disable no-sequences */
-import { vendorLib } from '@exodus/sui-lib'
-
-const { normalizeSuiAddress } = vendorLib.utils
-
-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 _caches, _cache, _onEffects
-
-class AsyncCache {
-  async getObject(id) {
-    const [owned, shared] = await Promise.all([
-      this.get('OwnedObject', id),
-      this.get('SharedOrImmutableObject', id),
-    ])
-    return owned ?? shared ?? null
-  }
-
-  async getObjects(ids) {
-    return Promise.all(ids.map((id) => this.getObject(id)))
-  }
-
-  async addObject(object) {
-    if (object.owner) {
-      await this.set('OwnedObject', object.objectId, object)
-    } else {
-      await this.set('SharedOrImmutableObject', object.objectId, object)
-    }
-
-    return object
-  }
-
-  async addObjects(objects) {
-    await Promise.all(objects.map(async (object) => this.addObject(object)))
-  }
-
-  async deleteObject(id) {
-    await Promise.all([this.delete('OwnedObject', id), this.delete('SharedOrImmutableObject', id)])
-  }
-
-  async deleteObjects(ids) {
-    await Promise.all(ids.map((id) => this.deleteObject(id)))
-  }
-
-  async getMoveFunctionDefinition(ref) {
-    const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`
-    return this.get('MoveFunction', functionName)
-  }
-
-  async addMoveFunctionDefinition(functionEntry) {
-    const pkg = normalizeSuiAddress(functionEntry.package)
-    const functionName = `${pkg}::${functionEntry.module}::${functionEntry.function}`
-    const entry = {
-      ...functionEntry,
-      package: pkg,
-    }
-    await this.set('MoveFunction', functionName, entry)
-    return entry
-  }
-
-  async deleteMoveFunctionDefinition(ref) {
-    const functionName = `${normalizeSuiAddress(ref.package)}::${ref.module}::${ref.function}`
-    await this.delete('MoveFunction', functionName)
-  }
-
-  async getCustom(key) {
-    return this.get('Custom', key)
-  }
-
-  async setCustom(key, value) {
-    return this.set('Custom', key, value)
-  }
-
-  async deleteCustom(key) {
-    return this.delete('Custom', key)
-  }
-}
-
-class InMemoryCache extends AsyncCache {
-  constructor() {
-    super(...arguments)
-    __privateAdd(this, _caches, {
-      OwnedObject: /* @__PURE__ */ new Map(),
-      SharedOrImmutableObject: /* @__PURE__ */ new Map(),
-      MoveFunction: /* @__PURE__ */ new Map(),
-      Custom: /* @__PURE__ */ new Map(),
-    })
-  }
-
-  async get(type, key) {
-    return __privateGet(this, _caches)[type].get(key) ?? null
-  }
-
-  async set(type, key, value) {
-    __privateGet(this, _caches)[type].set(key, value)
-  }
-
-  async delete(type, key) {
-    __privateGet(this, _caches)[type].delete(key)
-  }
-
-  async clear(type) {
-    if (type) {
-      __privateGet(this, _caches)[type].clear()
-    } else {
-      for (const cache of Object.values(__privateGet(this, _caches))) {
-        cache.clear()
-      }
-    }
-  }
-}
-_caches = new WeakMap()
-
-class ObjectCache {
-  constructor({ cache = new InMemoryCache(), onEffects }) {
-    __privateAdd(this, _cache)
-    __privateAdd(this, _onEffects)
-    __privateSet(this, _cache, cache)
-    __privateSet(this, _onEffects, onEffects)
-  }
-
-  asPlugin() {
-    return async (transactionData, _options, next) => {
-      const unresolvedObjects = transactionData.inputs
-        .filter((input) => input.UnresolvedObject)
-        .map((input) => input.UnresolvedObject.objectId)
-      // eslint-disable-next-line unicorn/no-await-expression-member
-      const cached = (await __privateGet(this, _cache).getObjects(unresolvedObjects)).filter(
-        (obj) => obj !== null
-      )
-      const byId = new Map(cached.map((obj) => [obj.objectId, obj]))
-      for (const input of transactionData.inputs) {
-        if (!input.UnresolvedObject) {
-          continue
-        }
-
-        const cached2 = byId.get(input.UnresolvedObject.objectId)
-        if (!cached2) {
-          continue
-        }
-
-        if (cached2.initialSharedVersion && !input.UnresolvedObject.initialSharedVersion) {
-          input.UnresolvedObject.initialSharedVersion = cached2.initialSharedVersion
-        } else {
-          if (cached2.version && !input.UnresolvedObject.version) {
-            input.UnresolvedObject.version = cached2.version
-          }
-
-          if (cached2.digest && !input.UnresolvedObject.digest) {
-            input.UnresolvedObject.digest = cached2.digest
-          }
-        }
-      }
-
-      await Promise.all(
-        transactionData.commands.map(async (commands) => {
-          if (commands.MoveCall) {
-            const def = await this.getMoveFunctionDefinition({
-              package: commands.MoveCall.package,
-              module: commands.MoveCall.module,
-              function: commands.MoveCall.function,
-            })
-            if (def) {
-              // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
-              commands.MoveCall._argumentTypes = def.parameters
-            }
-          }
-        })
-      )
-      await next()
-      await Promise.all(
-        transactionData.commands.map(async (commands) => {
-          if (commands.MoveCall?._argumentTypes) {
-            await __privateGet(this, _cache).addMoveFunctionDefinition({
-              package: commands.MoveCall.package,
-              module: commands.MoveCall.module,
-              function: commands.MoveCall.function,
-              parameters: commands.MoveCall._argumentTypes,
-            })
-          }
-        })
-      )
-    }
-  }
-
-  async clear() {
-    await __privateGet(this, _cache).clear()
-  }
-
-  async getMoveFunctionDefinition(ref) {
-    return __privateGet(this, _cache).getMoveFunctionDefinition(ref)
-  }
-
-  async getObjects(ids) {
-    return __privateGet(this, _cache).getObjects(ids)
-  }
-
-  async deleteObjects(ids) {
-    return __privateGet(this, _cache).deleteObjects(ids)
-  }
-
-  async clearOwnedObjects() {
-    await __privateGet(this, _cache).clear('OwnedObject')
-  }
-
-  async clearCustom() {
-    await __privateGet(this, _cache).clear('Custom')
-  }
-
-  async getCustom(key) {
-    return __privateGet(this, _cache).getCustom(key)
-  }
-
-  async setCustom(key, value) {
-    return __privateGet(this, _cache).setCustom(key, value)
-  }
-
-  async deleteCustom(key) {
-    return __privateGet(this, _cache).deleteCustom(key)
-  }
-
-  async applyEffects(effects) {
-    var _a
-    if (!effects.V2) {
-      throw new Error(`Unsupported transaction effects version ${effects.$kind}`)
-    }
-
-    const { lamportVersion, changedObjects } = effects.V2
-    const deletedIds = []
-    const addedObjects = []
-    changedObjects.forEach(([id, change]) => {
-      if (change.outputState.NotExist) {
-        deletedIds.push(id)
-      } else if (change.outputState.ObjectWrite) {
-        const [digest, owner] = change.outputState.ObjectWrite
-        addedObjects.push({
-          objectId: id,
-          digest,
-          version: lamportVersion,
-          owner: owner.AddressOwner ?? owner.ObjectOwner ?? null,
-          initialSharedVersion: owner.Shared?.initialSharedVersion ?? null,
-        })
-      }
-    })
-    await Promise.all([
-      __privateGet(this, _cache).addObjects(addedObjects),
-      __privateGet(this, _cache).deleteObjects(deletedIds),
-      (_a = __privateGet(this, _onEffects)) == null ? void 0 : _a.call(this, effects),
-    ])
-  }
-}
-_cache = new WeakMap()
-_onEffects = new WeakMap()
-export { AsyncCache, InMemoryCache, ObjectCache }
-// # sourceMappingURL=ObjectCache.js.map