@exodus/sui-api 0.1.0

package/src/vendors/transactions/Commands.js

@@ -0,0 +1,108 @@
+/* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
+import { vendorLib } from '@exodus/sui-lib'
+
+import { parse } from '../valibot.js'
+import { Argument } from './data/internal.js'
+
+const { toBase64, normalizeSuiObjectId } = vendorLib.utils
+
+var UpgradePolicy = /* @__PURE__ */ ((UpgradePolicy2) => {
+  UpgradePolicy2[(UpgradePolicy2['COMPATIBLE'] = 0)] = 'COMPATIBLE'
+  UpgradePolicy2[(UpgradePolicy2['ADDITIVE'] = 128)] = 'ADDITIVE'
+  UpgradePolicy2[(UpgradePolicy2['DEP_ONLY'] = 192)] = 'DEP_ONLY'
+  return UpgradePolicy2
+})(Object.create(null))
+const Commands = {
+  MoveCall(input) {
+    const [pkg, mod = '', fn = ''] =
+      'target' in input ? input.target.split('::') : [input.package, input.module, input.function]
+    return {
+      $kind: 'MoveCall',
+      MoveCall: {
+        package: pkg,
+        module: mod,
+        function: fn,
+        typeArguments: input.typeArguments ?? [],
+        arguments: input.arguments ?? [],
+      },
+    }
+  },
+  TransferObjects(objects, address) {
+    return {
+      $kind: 'TransferObjects',
+      TransferObjects: {
+        objects: objects.map((o) => parse(Argument, o)),
+        address: parse(Argument, address),
+      },
+    }
+  },
+  SplitCoins(coin, amounts) {
+    return {
+      $kind: 'SplitCoins',
+      SplitCoins: {
+        coin: parse(Argument, coin),
+        amounts: amounts.map((o) => parse(Argument, o)),
+      },
+    }
+  },
+  MergeCoins(destination, sources) {
+    return {
+      $kind: 'MergeCoins',
+      MergeCoins: {
+        destination: parse(Argument, destination),
+        sources: sources.map((o) => parse(Argument, o)),
+      },
+    }
+  },
+  Publish({ modules, dependencies }) {
+    return {
+      $kind: 'Publish',
+      Publish: {
+        modules: modules.map((module) =>
+          typeof module === 'string' ? module : toBase64(new Uint8Array(module))
+        ),
+        dependencies: dependencies.map((dep) => normalizeSuiObjectId(dep)),
+      },
+    }
+  },
+  Upgrade({ modules, dependencies, package: packageId, ticket }) {
+    return {
+      $kind: 'Upgrade',
+      Upgrade: {
+        modules: modules.map((module) =>
+          typeof module === 'string' ? module : toBase64(new Uint8Array(module))
+        ),
+        dependencies: dependencies.map((dep) => normalizeSuiObjectId(dep)),
+        package: packageId,
+        ticket: parse(Argument, ticket),
+      },
+    }
+  },
+  MakeMoveVec({ type, elements }) {
+    return {
+      $kind: 'MakeMoveVec',
+      MakeMoveVec: {
+        type: type ?? null,
+        elements: elements.map((o) => parse(Argument, o)),
+      },
+    }
+  },
+  Intent({ name, inputs = Object.create(null), data = Object.create(null) }) {
+    return {
+      $kind: '$Intent',
+      $Intent: {
+        name,
+        inputs: Object.fromEntries(
+          Object.entries(inputs).map(([key, value]) => [
+            key,
+            Array.isArray(value) ? value.map((o) => parse(Argument, o)) : parse(Argument, value),
+          ])
+        ),
+        data,
+      },
+    }
+  },
+}
+
+export { Commands, UpgradePolicy }
+// # sourceMappingURL=Commands.js.map

package/src/vendors/transactions/Inputs.js

@@ -0,0 +1,59 @@
+import { vendorLib } from '@exodus/sui-lib'
+
+const { toBase64 } = vendorLib.utils
+const { normalizeSuiAddress } = vendorLib.utils
+
+function Pure(data) {
+  return {
+    $kind: 'Pure',
+    Pure: {
+      bytes: data instanceof Uint8Array ? toBase64(data) : data.toBase64(),
+    },
+  }
+}
+
+const Inputs = {
+  Pure,
+  ObjectRef({ objectId, digest, version }) {
+    return {
+      $kind: 'Object',
+      Object: {
+        $kind: 'ImmOrOwnedObject',
+        ImmOrOwnedObject: {
+          digest,
+          version,
+          objectId: normalizeSuiAddress(objectId),
+        },
+      },
+    }
+  },
+  SharedObjectRef({ objectId, mutable, initialSharedVersion }) {
+    return {
+      $kind: 'Object',
+      Object: {
+        $kind: 'SharedObject',
+        SharedObject: {
+          mutable,
+          initialSharedVersion,
+          objectId: normalizeSuiAddress(objectId),
+        },
+      },
+    }
+  },
+  ReceivingRef({ objectId, digest, version }) {
+    return {
+      $kind: 'Object',
+      Object: {
+        $kind: 'Receiving',
+        Receiving: {
+          digest,
+          version,
+          objectId: normalizeSuiAddress(objectId),
+        },
+      },
+    }
+  },
+}
+
+export { Inputs }
+// # sourceMappingURL=Inputs.js.map

package/src/vendors/transactions/ObjectCache.js

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