@gardenfi/swap 0.1.0 → 0.1.1

package/dist/index267.js

@@ -1,576 +1,287 @@
-import { fromBase64 as m } from "./index260.js";
-import { chunk as x } from "./index340.js";
-import { bcs as p } from "./index342.js";
-import { Transaction as C } from "./index77.js";
-import { jsonRpcClientResolveTransactionPlugin as I } from "./index343.js";
-import { TransactionDataBuilder as P } from "./index336.js";
-import { normalizeSuiAddress as k } from "./index263.js";
-import { Experimental_CoreClient as E } from "./index344.js";
-import { ObjectError as y } from "./index345.js";
-import { parseTransactionBcs as N, parseTransactionEffectsBcs as A } from "./index346.js";
-var h = (t) => {
+import { chunk as D } from "./index340.js";
+import { DataLoader as L } from "./index341.js";
+import { isValidNamedPackage as O, isValidNamedType as z } from "./index266.js";
+import { isValidSuiAddress as I, normalizeSuiAddress as U, parseStructTag as M, normalizeStructTag as G } from "./index264.js";
+import { PACKAGE_VERSION as H } from "./index257.js";
+var b = (t) => {
   throw TypeError(t);
-}, S = (t, e, r) => e.has(t) || h("Cannot " + r), i = (t, e, r) => (S(t, e, "read from private field"), r ? r.call(t) : e.get(t)), $ = (t, e, r) => e.has(t) ? h("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, r), B = (t, e, r, n) => (S(t, e, "write to private field"), e.set(t, r), r), a;
-class Q extends E {
-  constructor({
-    jsonRpcClient: e,
-    mvr: r
-  }) {
-    super({ network: e.network, base: e, mvr: r }), $(this, a), B(this, a, e);
-  }
-  async getObjects(e) {
-    const r = x(e.objectIds, 50), n = [];
-    for (const d of r) {
-      const o = await i(this, a).multiGetObjects({
-        ids: d,
-        options: {
-          showOwner: !0,
-          showType: !0,
-          showBcs: !0,
-          showPreviousTransaction: !0
-        },
-        signal: e.signal
-      });
-      for (const [u, s] of o.entries())
-        s.error ? n.push(y.fromResponse(s.error, d[u])) : n.push(v(s.data));
-    }
-    return {
-      objects: n
-    };
-  }
-  async getOwnedObjects(e) {
-    const r = await i(this, a).getOwnedObjects({
-      owner: e.address,
-      limit: e.limit,
-      cursor: e.cursor,
-      options: {
-        showOwner: !0,
-        showType: !0,
-        showBcs: !0,
-        showPreviousTransaction: !0
-      },
-      filter: e.type ? { StructType: e.type } : null,
-      signal: e.signal
-    });
-    return {
-      objects: r.data.map((n) => {
-        if (n.error)
-          throw y.fromResponse(n.error);
-        return v(n.data);
-      }),
-      hasNextPage: r.hasNextPage,
-      cursor: r.nextCursor ?? null
-    };
-  }
-  async getCoins(e) {
-    const r = await i(this, a).getCoins({
-      owner: e.address,
-      coinType: e.coinType,
-      limit: e.limit,
-      cursor: e.cursor,
-      signal: e.signal
-    });
-    return {
-      objects: r.data.map((n) => ({
-        id: n.coinObjectId,
-        version: n.version,
-        digest: n.digest,
-        balance: n.balance,
-        type: `0x2::coin::Coin<${n.coinType}>`,
-        content: Promise.resolve(
-          _.serialize({
-            id: n.coinObjectId,
-            balance: {
-              value: n.balance
-            }
-          }).toBytes()
-        ),
-        owner: {
-          $kind: "ObjectOwner",
-          ObjectOwner: e.address
-        },
-        previousTransaction: n.previousTransaction
-      })),
-      hasNextPage: r.hasNextPage,
-      cursor: r.nextCursor ?? null
-    };
-  }
-  async getBalance(e) {
-    const r = await i(this, a).getBalance({
-      owner: e.address,
-      coinType: e.coinType,
-      signal: e.signal
-    });
-    return {
-      balance: {
-        coinType: r.coinType,
-        balance: r.totalBalance
-      }
-    };
-  }
-  async getAllBalances(e) {
-    return {
-      balances: (await i(this, a).getAllBalances({
-        owner: e.address,
-        signal: e.signal
-      })).map((n) => ({
-        coinType: n.coinType,
-        balance: n.totalBalance
-      })),
-      hasNextPage: !1,
-      cursor: null
-    };
+}, S = (t, n, e) => n.has(t) || b("Cannot " + e), i = (t, n, e) => (S(t, n, "read from private field"), e ? e.call(t) : n.get(t)), w = (t, n, e) => n.has(t) ? b("Cannot add the same private member more than once") : n instanceof WeakSet ? n.add(t) : n.set(t, e), v = (t, n, e, s) => (S(t, n, "write to private field"), n.set(t, e), e), _ = (t, n, e) => (S(t, n, "access private method"), e), k, u, g, d, f, E, T, W, F, V;
+const J = "/", K = {
+  "Mvr-Source": `@mysten/sui@${H}`
+};
+class ee {
+  constructor({ cache: n, url: e, pageSize: s = 50, overrides: a }) {
+    w(this, f), w(this, k), w(this, u), w(this, g), w(this, d), v(this, k, n), v(this, u, e), v(this, g, s), v(this, d, {
+      packages: a == null ? void 0 : a.packages,
+      types: a == null ? void 0 : a.types
+    }), q(i(this, d));
   }
-  async getTransaction(e) {
-    const r = await i(this, a).getTransactionBlock({
-      digest: e.digest,
-      options: {
-        showRawInput: !0,
-        showObjectChanges: !0,
-        showRawEffects: !0,
-        showEvents: !0,
-        showEffects: !0,
-        showBalanceChanges: !0
-      },
-      signal: e.signal
-    });
-    return {
-      transaction: T(r)
+  async resolvePackage({
+    package: n
+  }) {
+    return l(n) ? {
+      package: await i(this, f, E).load(n)
+    } : {
+      package: n
     };
   }
-  async executeTransaction(e) {
-    const r = await i(this, a).executeTransactionBlock({
-      transactionBlock: e.transaction,
-      signature: e.signatures,
-      options: {
-        showRawEffects: !0,
-        showEvents: !0,
-        showObjectChanges: !0,
-        showRawInput: !0,
-        showEffects: !0,
-        showBalanceChanges: !0
-      },
-      signal: e.signal
-    });
+  async resolveType({
+    type: n
+  }) {
+    if (!l(n))
+      return {
+        type: n
+      };
+    const e = [...$(n)], s = await i(this, f, T).loadMany(e), a = {};
+    for (let o = 0; o < e.length; o++) {
+      const r = s[o];
+      if (r instanceof Error)
+        throw r;
+      a[e[o]] = r;
+    }
     return {
-      transaction: T(r)
+      type: P(n, a)
     };
   }
-  async dryRunTransaction(e) {
-    const r = C.from(e.transaction), n = await i(this, a).dryRunTransactionBlock({
-      transactionBlock: e.transaction,
-      signal: e.signal
-    }), { effects: d, objectTypes: o } = V({
-      effects: n.effects,
-      objectChanges: n.objectChanges
-    });
-    return {
-      transaction: {
-        digest: await r.getDigest(),
-        epoch: null,
-        effects: d,
-        objectTypes: Promise.resolve(o),
-        signatures: [],
-        transaction: N(e.transaction),
-        balanceChanges: n.balanceChanges.map((u) => ({
-          coinType: u.coinType,
-          address: D(u.owner),
-          amount: u.amount
-        }))
-      }
+  async resolve({
+    types: n = [],
+    packages: e = []
+  }) {
+    var N, R, C;
+    const s = /* @__PURE__ */ new Set();
+    for (const h of n ?? [])
+      $(h, s);
+    const a = [...s], [o, r] = await Promise.all([
+      a.length > 0 ? i(this, f, T).loadMany(a) : [],
+      e.length > 0 ? i(this, f, E).loadMany(e) : []
+    ]), c = {
+      ...(N = i(this, d)) == null ? void 0 : N.types
     };
-  }
-  async getReferenceGasPrice(e) {
-    const r = await i(this, a).getReferenceGasPrice({
-      signal: e == null ? void 0 : e.signal
-    });
+    for (const [h, m] of a.entries()) {
+      const y = o[h];
+      if (y instanceof Error)
+        throw y;
+      c[m] = y;
+    }
+    const p = {};
+    for (const h of n ?? []) {
+      const m = P(h, c);
+      p[h] = {
+        type: m
+      };
+    }
+    const A = {};
+    for (const [h, m] of (e ?? []).entries()) {
+      const y = ((C = (R = i(this, d)) == null ? void 0 : R.packages) == null ? void 0 : C[m]) ?? r[h];
+      if (y instanceof Error)
+        throw y;
+      A[m] = {
+        package: y
+      };
+    }
     return {
-      referenceGasPrice: String(r)
+      types: p,
+      packages: A
     };
   }
-  async getDynamicFields(e) {
-    const r = await i(this, a).getDynamicFields({
-      parentId: e.parentId,
-      limit: e.limit,
-      cursor: e.cursor
-    });
-    return {
-      dynamicFields: r.data.map((n) => ({
-        id: n.objectId,
-        type: n.objectType,
-        name: {
-          type: n.name.type,
-          bcs: m(n.bcsName)
+}
+k = /* @__PURE__ */ new WeakMap();
+u = /* @__PURE__ */ new WeakMap();
+g = /* @__PURE__ */ new WeakMap();
+d = /* @__PURE__ */ new WeakMap();
+f = /* @__PURE__ */ new WeakSet();
+E = function() {
+  return i(this, k).readSync(["#mvrPackageDataLoader", i(this, u) ?? ""], () => {
+    var e;
+    const t = new L(async (s) => {
+      if (!i(this, u))
+        throw new Error(
+          `MVR Api URL is not set for the current client (resolving ${s.join(", ")})`
+        );
+      const a = await _(this, f, W).call(this, s);
+      return s.map(
+        (o) => a[o] ?? new Error(`Failed to resolve package: ${o}`)
+      );
+    }), n = (e = i(this, d)) == null ? void 0 : e.packages;
+    if (n)
+      for (const [s, a] of Object.entries(n))
+        t.prime(s, a);
+    return t;
+  });
+};
+T = function() {
+  return i(this, k).readSync(["#mvrTypeDataLoader", i(this, u) ?? ""], () => {
+    var e;
+    const t = new L(async (s) => {
+      if (!i(this, u))
+        throw new Error(
+          `MVR Api URL is not set for the current client (resolving ${s.join(", ")})`
+        );
+      const a = await _(this, f, F).call(this, s);
+      return s.map((o) => a[o] ?? new Error(`Failed to resolve type: ${o}`));
+    }), n = (e = i(this, d)) == null ? void 0 : e.types;
+    if (n)
+      for (const [s, a] of Object.entries(n))
+        t.prime(s, a);
+    return t;
+  });
+};
+W = async function(t) {
+  if (t.length === 0) return {};
+  const n = D(t, i(this, g)), e = {};
+  return await Promise.all(
+    n.map(async (s) => {
+      var o;
+      const a = await _(this, f, V).call(this, "/v1/resolution/bulk", {
+        names: s
+      });
+      if (a != null && a.resolution)
+        for (const r of Object.keys(a == null ? void 0 : a.resolution)) {
+          const c = (o = a.resolution[r]) == null ? void 0 : o.package_id;
+          c && (e[r] = c);
         }
-      })),
-      hasNextPage: r.hasNextPage,
-      cursor: r.nextCursor
-    };
-  }
-  async verifyZkLoginSignature(e) {
-    const r = await i(this, a).verifyZkLoginSignature({
-      bytes: e.bytes,
-      signature: e.signature,
-      intentScope: e.intentScope,
-      author: e.author
-    });
-    return {
-      success: r.success,
-      errors: r.errors
-    };
-  }
-  async defaultNameServiceName(e) {
-    return {
-      data: {
-        name: (await i(this, a).resolveNameServiceNames(e)).data[0]
-      }
-    };
-  }
-  resolveTransactionPlugin() {
-    return I(i(this, a));
-  }
-  async getMoveFunction(e) {
-    const r = await i(this, a).getNormalizedMoveFunction({
-      package: (await this.mvr.resolvePackage({ package: e.packageId })).package,
-      module: e.moduleName,
-      function: e.name
-    });
-    return {
-      function: {
-        packageId: k(e.packageId),
-        moduleName: e.moduleName,
-        name: e.name,
-        visibility: M(r.visibility),
-        isEntry: r.isEntry,
-        typeParameters: r.typeParameters.map((n) => ({
-          isPhantom: !1,
-          constraints: U(n)
-        })),
-        parameters: r.parameters.map((n) => j(n)),
-        returns: r.return.map((n) => j(n))
-      }
-    };
+    })
+  ), e;
+};
+F = async function(t) {
+  if (t.length === 0) return {};
+  const n = D(t, i(this, g)), e = {};
+  return await Promise.all(
+    n.map(async (s) => {
+      var o;
+      const a = await _(this, f, V).call(this, "/v1/struct-definition/bulk", {
+        types: s
+      });
+      if (a != null && a.resolution)
+        for (const r of Object.keys(a == null ? void 0 : a.resolution)) {
+          const c = (o = a.resolution[r]) == null ? void 0 : o.type_tag;
+          c && (e[r] = c);
+        }
+    })
+  ), e;
+};
+V = async function(t, n) {
+  if (!i(this, u))
+    throw new Error("MVR Api URL is not set for the current client");
+  const e = await fetch(`${i(this, u)}${t}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...K
+    },
+    body: JSON.stringify(n)
+  });
+  if (!e.ok) {
+    const s = await e.json().catch(() => ({}));
+    throw new Error(`Failed to resolve types: ${s == null ? void 0 : s.message}`);
   }
+  return e.json();
+};
+function q(t) {
+  if (t != null && t.packages)
+    for (const [n, e] of Object.entries(t.packages)) {
+      if (!O(n))
+        throw new Error(`Invalid package name: ${n}`);
+      if (!I(U(e)))
+        throw new Error(`Invalid package ID: ${e}`);
+    }
+  if (t != null && t.types)
+    for (const [n, e] of Object.entries(t.types)) {
+      if (M(n).typeParams.length > 0)
+        throw new Error(
+          "Type overrides must be first-level only. If you want to supply generic types, just pass each type individually."
+        );
+      const s = M(e);
+      if (!I(s.address))
+        throw new Error(`Invalid type: ${e}`);
+    }
 }
-a = /* @__PURE__ */ new WeakMap();
-function v(t) {
-  var e;
-  return {
-    id: t.objectId,
-    version: t.version,
-    digest: t.digest,
-    type: t.type,
-    content: Promise.resolve(
-      ((e = t.bcs) == null ? void 0 : e.dataType) === "moveObject" ? m(t.bcs.bcsBytes) : new Uint8Array()
-    ),
-    owner: l(t.owner),
-    previousTransaction: t.previousTransaction ?? null
-  };
+function $(t, n = /* @__PURE__ */ new Set()) {
+  if (typeof t == "string" && !l(t)) return n;
+  const e = x(t) ? t : M(t);
+  l(e.address) && n.add(`${e.address}::${e.module}::${e.name}`);
+  for (const s of e.typeParams)
+    $(s, n);
+  return n;
 }
-function l(t) {
-  if (t === "Immutable")
-    return {
-      $kind: "Immutable",
-      Immutable: !0
-    };
-  if ("ConsensusAddressOwner" in t)
-    return {
-      $kind: "ConsensusAddressOwner",
-      ConsensusAddressOwner: {
-        owner: t.ConsensusAddressOwner.owner,
-        startVersion: t.ConsensusAddressOwner.start_version
-      }
-    };
-  if ("AddressOwner" in t)
-    return {
-      $kind: "AddressOwner",
-      AddressOwner: t.AddressOwner
-    };
-  if ("ObjectOwner" in t)
-    return {
-      $kind: "ObjectOwner",
-      ObjectOwner: t.ObjectOwner
-    };
-  if ("Shared" in t)
-    return {
-      $kind: "Shared",
-      Shared: {
-        initialSharedVersion: t.Shared.initial_shared_version
-      }
-    };
-  throw new Error(`Unknown owner type: ${JSON.stringify(t)}`);
+function P(t, n) {
+  const e = x(t) ? t : M(t), s = `${e.address}::${e.module}::${e.name}`, a = n[s];
+  return G({
+    ...e,
+    address: a ? a.split("::")[0] : e.address,
+    typeParams: e.typeParams.map((o) => P(o, n))
+  });
 }
-function D(t) {
-  if (t === "Immutable")
-    return null;
-  if ("ConsensusAddressOwner" in t)
-    return t.ConsensusAddressOwner.owner;
-  if ("AddressOwner" in t)
-    return t.AddressOwner;
-  if ("ObjectOwner" in t)
-    return t.ObjectOwner;
-  if ("Shared" in t)
-    return null;
-  throw new Error(`Unknown owner type: ${JSON.stringify(t)}`);
+function l(t) {
+  return t.includes(J) || t.includes("@") || t.includes(".sui");
 }
-function T(t) {
-  var o, u, s;
-  const e = p.SenderSignedData.parse(m(t.rawTransaction))[0], r = {};
-  (o = t.objectChanges) == null || o.forEach((c) => {
-    c.type !== "published" && (r[c.objectId] = c.objectType);
-  });
-  const n = p.TransactionData.serialize(e.intentMessage.value).toBytes(), d = P.restore({
-    version: 2,
-    sender: e.intentMessage.value.V1.sender,
-    expiration: e.intentMessage.value.V1.expiration,
-    gasData: e.intentMessage.value.V1.gasData,
-    inputs: e.intentMessage.value.V1.kind.ProgrammableTransaction.inputs,
-    commands: e.intentMessage.value.V1.kind.ProgrammableTransaction.commands
-  });
-  return {
-    digest: t.digest,
-    epoch: ((u = t.effects) == null ? void 0 : u.executedEpoch) ?? null,
-    effects: A(new Uint8Array(t.rawEffects)),
-    objectTypes: Promise.resolve(r),
-    transaction: {
-      ...d,
-      bcs: n
-    },
-    signatures: e.txSignatures,
-    balanceChanges: ((s = t.balanceChanges) == null ? void 0 : s.map((c) => ({
-      coinType: c.coinType,
-      address: D(c.owner),
-      amount: c.amount
-    }))) ?? []
-  };
+function x(t) {
+  return typeof t == "object" && "address" in t && "module" in t && "name" in t && "typeParams" in t;
 }
-function V({
-  bytes: t,
-  effects: e,
-  objectChanges: r
-}) {
-  var u;
-  const n = [], d = [], o = {};
-  return r == null || r.forEach((s) => {
-    var c, g, O, f;
-    switch (s.type) {
-      case "published":
-        n.push({
-          id: s.packageId,
-          inputState: "DoesNotExist",
-          inputVersion: null,
-          inputDigest: null,
-          inputOwner: null,
-          outputState: "PackageWrite",
-          outputVersion: s.version,
-          outputDigest: s.digest,
-          outputOwner: null,
-          idOperation: "Created"
+function te(t) {
+  const n = /* @__PURE__ */ new Set(), e = /* @__PURE__ */ new Set();
+  for (const s of t.commands)
+    switch (s.$kind) {
+      case "MakeMoveVec":
+        s.MakeMoveVec.type && j([s.MakeMoveVec.type]).forEach((r) => {
+          e.add(r);
         });
         break;
-      case "transferred":
-        n.push({
-          id: s.objectId,
-          inputState: "Exists",
-          inputVersion: s.version,
-          inputDigest: s.digest,
-          inputOwner: {
-            $kind: "AddressOwner",
-            AddressOwner: s.sender
-          },
-          outputState: "ObjectWrite",
-          outputVersion: s.version,
-          outputDigest: s.digest,
-          outputOwner: l(s.recipient),
-          idOperation: "None"
-        }), o[s.objectId] = s.objectType;
-        break;
-      case "mutated":
-        n.push({
-          id: s.objectId,
-          inputState: "Exists",
-          inputVersion: s.previousVersion,
-          inputDigest: null,
-          inputOwner: l(s.owner),
-          outputState: "ObjectWrite",
-          outputVersion: s.version,
-          outputDigest: s.digest,
-          outputOwner: l(s.owner),
-          idOperation: "None"
-        }), o[s.objectId] = s.objectType;
-        break;
-      case "deleted":
-        n.push({
-          id: s.objectId,
-          inputState: "Exists",
-          inputVersion: s.version,
-          inputDigest: ((g = (c = e.deleted) == null ? void 0 : c.find((b) => b.objectId === s.objectId)) == null ? void 0 : g.digest) ?? null,
-          inputOwner: null,
-          outputState: "DoesNotExist",
-          outputVersion: null,
-          outputDigest: null,
-          outputOwner: null,
-          idOperation: "Deleted"
-        }), o[s.objectId] = s.objectType;
-        break;
-      case "wrapped":
-        n.push({
-          id: s.objectId,
-          inputState: "Exists",
-          inputVersion: s.version,
-          inputDigest: null,
-          inputOwner: {
-            $kind: "AddressOwner",
-            AddressOwner: s.sender
-          },
-          outputState: "ObjectWrite",
-          outputVersion: s.version,
-          outputDigest: ((f = (O = e.wrapped) == null ? void 0 : O.find((b) => b.objectId === s.objectId)) == null ? void 0 : f.digest) ?? null,
-          outputOwner: {
-            $kind: "ObjectOwner",
-            ObjectOwner: s.sender
-          },
-          idOperation: "None"
-        }), o[s.objectId] = s.objectType;
-        break;
-      case "created":
-        n.push({
-          id: s.objectId,
-          inputState: "DoesNotExist",
-          inputVersion: null,
-          inputDigest: null,
-          inputOwner: null,
-          outputState: "ObjectWrite",
-          outputVersion: s.version,
-          outputDigest: s.digest,
-          outputOwner: l(s.owner),
-          idOperation: "Created"
-        }), o[s.objectId] = s.objectType;
+      case "MoveCall":
+        const a = s.MoveCall, o = a.package.split("::")[0];
+        if (l(o)) {
+          if (!O(o)) throw new Error(`Invalid package name: ${o}`);
+          n.add(o);
+        }
+        j(a.typeArguments ?? []).forEach((r) => {
+          e.add(r);
+        });
         break;
     }
-  }), {
-    objectTypes: o,
-    effects: {
-      bcs: t ?? null,
-      digest: e.transactionDigest,
-      version: 2,
-      status: e.status.status === "success" ? { success: !0, error: null } : { success: !1, error: e.status.error },
-      gasUsed: e.gasUsed,
-      transactionDigest: e.transactionDigest,
-      gasObject: {
-        id: (u = e.gasObject) == null ? void 0 : u.reference.objectId,
-        inputState: "Exists",
-        inputVersion: null,
-        inputDigest: null,
-        inputOwner: null,
-        outputState: "ObjectWrite",
-        outputVersion: e.gasObject.reference.version,
-        outputDigest: e.gasObject.reference.digest,
-        outputOwner: l(e.gasObject.owner),
-        idOperation: "None"
-      },
-      eventsDigest: e.eventsDigest ?? null,
-      dependencies: e.dependencies ?? [],
-      lamportVersion: e.gasObject.reference.version,
-      changedObjects: n,
-      unchangedConsensusObjects: d,
-      auxiliaryDataDigest: null
-    }
-  };
-}
-const R = p.struct("Balance", {
-  value: p.u64()
-}), _ = p.struct("Coin", {
-  id: p.Address,
-  balance: R
-});
-function j(t) {
-  if (typeof t != "string") {
-    if ("Reference" in t)
-      return {
-        reference: "immutable",
-        body: w(t.Reference)
-      };
-    if ("MutableReference" in t)
-      return {
-        reference: "mutable",
-        body: w(t.MutableReference)
-      };
-  }
   return {
-    reference: null,
-    body: w(t)
+    packages: [...n],
+    types: [...e]
   };
 }
-function w(t) {
-  switch (t) {
-    case "Address":
-      return { $kind: "address" };
-    case "Bool":
-      return { $kind: "bool" };
-    case "U8":
-      return { $kind: "u8" };
-    case "U16":
-      return { $kind: "u16" };
-    case "U32":
-      return { $kind: "u32" };
-    case "U64":
-      return { $kind: "u64" };
-    case "U128":
-      return { $kind: "u128" };
-    case "U256":
-      return { $kind: "u256" };
+function ne(t, n) {
+  var e;
+  for (const s of t.commands) {
+    if ((e = s.MakeMoveVec) != null && e.type) {
+      if (!l(s.MakeMoveVec.type)) continue;
+      if (!n.types[s.MakeMoveVec.type])
+        throw new Error(`No resolution found for type: ${s.MakeMoveVec.type}`);
+      s.MakeMoveVec.type = n.types[s.MakeMoveVec.type].type;
+    }
+    const a = s.MoveCall;
+    if (!a) continue;
+    const o = a.package.split("::"), r = o[0];
+    if (l(r) && !n.packages[r])
+      throw new Error(`No address found for package: ${r}`);
+    l(r) && (o[0] = n.packages[r].package, a.package = o.join("::"));
+    const c = a.typeArguments;
+    if (c) {
+      for (let p = 0; p < c.length; p++)
+        if (l(c[p])) {
+          if (!n.types[c[p]]) throw new Error(`No resolution found for type: ${c[p]}`);
+          c[p] = n.types[c[p]].type;
+        }
+      a.typeArguments = c;
+    }
   }
-  if (typeof t == "string")
-    throw new Error(`Unknown type: ${t}`);
-  if ("Vector" in t)
-    return {
-      $kind: "vector",
-      vector: w(t.Vector)
-    };
-  if ("Struct" in t)
-    return {
-      $kind: "datatype",
-      datatype: {
-        typeName: `${k(t.Struct.address)}::${t.Struct.module}::${t.Struct.name}`,
-        typeParameters: t.Struct.typeArguments.map((e) => w(e))
-      }
-    };
-  if ("TypeParameter" in t)
-    return {
-      $kind: "typeParameter",
-      index: t.TypeParameter
-    };
-  throw new Error(`Unknown type: ${JSON.stringify(t)}`);
 }
-function U(t) {
-  return t.abilities.map((e) => {
-    switch (e) {
-      case "Copy":
-        return "copy";
-      case "Drop":
-        return "drop";
-      case "Store":
-        return "store";
-      case "Key":
-        return "key";
-      default:
-        return "unknown";
+function j(t) {
+  const n = /* @__PURE__ */ new Set();
+  for (const e of t)
+    if (l(e)) {
+      if (!z(e)) throw new Error(`Invalid type with names: ${e}`);
+      n.add(e);
     }
-  });
-}
-function M(t) {
-  switch (t) {
-    case "Public":
-      return "public";
-    case "Private":
-      return "private";
-    case "Friend":
-      return "friend";
-    default:
-      return "unknown";
-  }
+  return n;
 }
 export {
-  Q as JSONRpcCoreClient
+  ee as MvrClient,
+  $ as extractMvrTypes,
+  te as findNamesInTransaction,
+  l as hasMvrName,
+  ne as replaceNames
 };