@wormhole-foundation/wormhole-connect 1.1.8 → 1.1.9-beta.0-development

package/lib/index-DPkB79ju.mjs

@@ -0,0 +1,3816 @@
+var Er = Object.defineProperty;
+var xr = (e, t, r) => t in e ? Er(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var F = (e, t, r) => xr(e, typeof t != "symbol" ? t + "" : t, r);
+import { ak as Ir, F as jr, cM as Or, bV as Ar, bT as kr, bU as Bt, u as _r, bW as Rt, bI as Cr } from "./index-BwifXygO.mjs";
+import { S as Nt, u as Pt } from "./sui-DKW6LQmE.mjs";
+import { S as $r } from "./unsignedTransaction-BD81leu1.mjs";
+class Mr extends TypeError {
+  constructor(t, r) {
+    let n;
+    const { message: i, explanation: s, ...a } = t, { path: o } = t, u = o.length === 0 ? i : `At path: ${o.join(".")} -- ${i}`;
+    super(s ?? u), s != null && (this.cause = u), Object.assign(this, a), this.name = this.constructor.name, this.failures = () => n ?? (n = [t, ...r()]);
+  }
+}
+function Ur(e) {
+  return z(e) && typeof e[Symbol.iterator] == "function";
+}
+function z(e) {
+  return typeof e == "object" && e != null;
+}
+function V(e) {
+  return typeof e == "symbol" ? e.toString() : typeof e == "string" ? JSON.stringify(e) : `${e}`;
+}
+function Br(e) {
+  const { done: t, value: r } = e.next();
+  return t ? void 0 : r;
+}
+function Rr(e, t, r, n) {
+  if (e === !0)
+    return;
+  e === !1 ? e = {} : typeof e == "string" && (e = { message: e });
+  const { path: i, branch: s } = t, { type: a } = r, { refinement: o, message: u = `Expected a value of type \`${a}\`${o ? ` with refinement \`${o}\`` : ""}, but received: \`${V(n)}\`` } = e;
+  return {
+    value: n,
+    type: a,
+    refinement: o,
+    key: i[i.length - 1],
+    path: i,
+    branch: s,
+    ...e,
+    message: u
+  };
+}
+function* Dt(e, t, r, n) {
+  Ur(e) || (e = [e]);
+  for (const i of e) {
+    const s = Rr(i, t, r, n);
+    s && (yield s);
+  }
+}
+function* nt(e, t, r = {}) {
+  const { path: n = [], branch: i = [e], coerce: s = !1, mask: a = !1 } = r, o = { path: n, branch: i };
+  if (s && (e = t.coercer(e, o), a && t.type !== "type" && z(t.schema) && z(e) && !Array.isArray(e)))
+    for (const d in e)
+      t.schema[d] === void 0 && delete e[d];
+  let u = "valid";
+  for (const d of t.validator(e, o))
+    d.explanation = r.message, u = "not_valid", yield [d, void 0];
+  for (let [d, l, g] of t.entries(e, o)) {
+    const m = nt(l, g, {
+      path: d === void 0 ? n : [...n, d],
+      branch: d === void 0 ? i : [...i, l],
+      coerce: s,
+      mask: a,
+      message: r.message
+    });
+    for (const p of m)
+      p[0] ? (u = p[0].refinement != null ? "not_refined" : "not_valid", yield [p[0], void 0]) : s && (l = p[1], d === void 0 ? e = l : e instanceof Map ? e.set(d, l) : e instanceof Set ? e.add(l) : z(e) && (l !== void 0 || d in e) && (e[d] = l));
+  }
+  if (u !== "not_valid")
+    for (const d of t.refiner(e, o))
+      d.explanation = r.message, u = "not_refined", yield [d, void 0];
+  u === "valid" && (yield [void 0, e]);
+}
+class Z {
+  constructor(t) {
+    const { type: r, schema: n, validator: i, refiner: s, coercer: a = (u) => u, entries: o = function* () {
+    } } = t;
+    this.type = r, this.schema = n, this.entries = o, this.coercer = a, i ? this.validator = (u, d) => {
+      const l = i(u, d);
+      return Dt(l, d, this, u);
+    } : this.validator = () => [], s ? this.refiner = (u, d) => {
+      const l = s(u, d);
+      return Dt(l, d, this, u);
+    } : this.refiner = () => [];
+  }
+  /**
+   * Assert that a value passes the struct's validation, throwing if it doesn't.
+   */
+  assert(t, r) {
+    return qe(t, this, r);
+  }
+  /**
+   * Create a value with the struct's coercion logic, then validate it.
+   */
+  create(t, r) {
+    return Lt(t, this, r);
+  }
+  /**
+   * Check if a value passes the struct's validation.
+   */
+  is(t) {
+    return N(t, this);
+  }
+  /**
+   * Mask a value, coercing and validating it, but returning only the subset of
+   * properties defined by the struct's schema.
+   */
+  mask(t, r) {
+    return Kt(t, this, r);
+  }
+  /**
+   * Validate a value with the struct's validation logic, returning a tuple
+   * representing the result.
+   *
+   * You may optionally pass `true` for the `withCoercion` argument to coerce
+   * the value before attempting to validate it. If you do, the result will
+   * contain the coerced result when successful.
+   */
+  validate(t, r = {}) {
+    return Ee(t, this, r);
+  }
+}
+function qe(e, t, r) {
+  const n = Ee(e, t, { message: r });
+  if (n[0])
+    throw n[0];
+}
+function Lt(e, t, r) {
+  const n = Ee(e, t, { coerce: !0, message: r });
+  if (n[0])
+    throw n[0];
+  return n[1];
+}
+function Kt(e, t, r) {
+  const n = Ee(e, t, { coerce: !0, mask: !0, message: r });
+  if (n[0])
+    throw n[0];
+  return n[1];
+}
+function N(e, t) {
+  return !Ee(e, t)[0];
+}
+function Ee(e, t, r = {}) {
+  const n = nt(e, t, r), i = Br(n);
+  return i[0] ? [new Mr(i[0], function* () {
+    for (const a of n)
+      a[0] && (yield a[0]);
+  }), void 0] : [void 0, i[1]];
+}
+function we(...e) {
+  const t = e[0].type === "type", r = e.map((i) => i.schema), n = Object.assign({}, ...r);
+  return t ? Pr(n) : h(n);
+}
+function P(e, t) {
+  return new Z({ type: e, schema: null, validator: t });
+}
+function Ze() {
+  return P("any", () => !0);
+}
+function v(e) {
+  return new Z({
+    type: "array",
+    schema: e,
+    *entries(t) {
+      if (e && Array.isArray(t))
+        for (const [r, n] of t.entries())
+          yield [r, n, e];
+    },
+    coercer(t) {
+      return Array.isArray(t) ? t.slice() : t;
+    },
+    validator(t) {
+      return Array.isArray(t) || `Expected an array value, but received: ${V(t)}`;
+    }
+  });
+}
+function Nr() {
+  return P("bigint", (e) => typeof e == "bigint");
+}
+function U() {
+  return P("boolean", (e) => typeof e == "boolean");
+}
+function q() {
+  return P("integer", (e) => typeof e == "number" && !isNaN(e) && Number.isInteger(e) || `Expected an integer, but received: ${V(e)}`);
+}
+function b(e) {
+  const t = V(e), r = typeof e;
+  return new Z({
+    type: "literal",
+    schema: r === "string" || r === "number" || r === "boolean" ? e : null,
+    validator(n) {
+      return n === e || `Expected the literal \`${t}\`, but received: ${V(n)}`;
+    }
+  });
+}
+function Wt() {
+  return P("never", () => !1);
+}
+function O(e) {
+  return new Z({
+    ...e,
+    validator: (t, r) => t === null || e.validator(t, r),
+    refiner: (t, r) => t === null || e.refiner(t, r)
+  });
+}
+function ue() {
+  return P("number", (e) => typeof e == "number" && !isNaN(e) || `Expected a number, but received: ${V(e)}`);
+}
+function h(e) {
+  const t = e ? Object.keys(e) : [], r = Wt();
+  return new Z({
+    type: "object",
+    schema: e || null,
+    *entries(n) {
+      if (e && z(n)) {
+        const i = new Set(Object.keys(n));
+        for (const s of t)
+          i.delete(s), yield [s, n[s], e[s]];
+        for (const s of i)
+          yield [s, n[s], r];
+      }
+    },
+    validator(n) {
+      return z(n) || `Expected an object, but received: ${V(n)}`;
+    },
+    coercer(n) {
+      return z(n) ? { ...n } : n;
+    }
+  });
+}
+function w(e) {
+  return new Z({
+    ...e,
+    validator: (t, r) => t === void 0 || e.validator(t, r),
+    refiner: (t, r) => t === void 0 || e.refiner(t, r)
+  });
+}
+function H(e, t) {
+  return new Z({
+    type: "record",
+    schema: null,
+    *entries(r) {
+      if (z(r))
+        for (const n in r) {
+          const i = r[n];
+          yield [n, n, e], yield [n, i, t];
+        }
+    },
+    validator(r) {
+      return z(r) || `Expected an object, but received: ${V(r)}`;
+    }
+  });
+}
+function f() {
+  return P("string", (e) => typeof e == "string" || `Expected a string, but received: ${V(e)}`);
+}
+function Jt(e) {
+  const t = Wt();
+  return new Z({
+    type: "tuple",
+    schema: null,
+    *entries(r) {
+      if (Array.isArray(r)) {
+        const n = Math.max(e.length, r.length);
+        for (let i = 0; i < n; i++)
+          yield [i, r[i], e[i] || t];
+      }
+    },
+    validator(r) {
+      return Array.isArray(r) || `Expected an array, but received: ${V(r)}`;
+    }
+  });
+}
+function Pr(e) {
+  const t = Object.keys(e);
+  return new Z({
+    type: "type",
+    schema: e,
+    *entries(r) {
+      if (z(r))
+        for (const n of t)
+          yield [n, r[n], e[n]];
+    },
+    validator(r) {
+      return z(r) || `Expected an object, but received: ${V(r)}`;
+    },
+    coercer(r) {
+      return z(r) ? { ...r } : r;
+    }
+  });
+}
+function k(e) {
+  const t = e.map((r) => r.type).join(" | ");
+  return new Z({
+    type: "union",
+    schema: null,
+    coercer(r) {
+      for (const n of e) {
+        const [i, s] = n.validate(r, { coerce: !0 });
+        if (!i)
+          return s;
+      }
+      return r;
+    },
+    validator(r, n) {
+      const i = [];
+      for (const s of e) {
+        const [...a] = nt(r, s, n), [o] = a;
+        if (o[0])
+          for (const [u] of a)
+            u && i.push(u);
+        else
+          return [];
+      }
+      return [
+        `Expected the value to satisfy a union of \`${t}\`, but received: ${V(r)}`,
+        ...i
+      ];
+    }
+  });
+}
+function Ht() {
+  return P("unknown", () => !0);
+}
+const it = k([
+  h({
+    AddressOwner: f()
+  }),
+  h({
+    ObjectOwner: f()
+  }),
+  h({
+    Shared: h({
+      initial_shared_version: O(f())
+    })
+  }),
+  b("Immutable")
+]);
+P("SuiJsonValue", () => !0);
+const Dr = k([
+  h({ u32: f() }),
+  h({ u64: f() }),
+  h({ f64: f() })
+]);
+h({
+  attributes: H(f(), O(Dr)),
+  featureFlags: H(f(), U()),
+  maxSupportedProtocolVersion: f(),
+  minSupportedProtocolVersion: f(),
+  protocolVersion: f()
+});
+k([f(), b("package")]);
+const se = h({
+  /** Base64 string representing the object digest */
+  digest: f(),
+  /** Hex code as string representing the object id */
+  objectId: f(),
+  /** Object version */
+  version: k([ue(), f(), Nr()])
+});
+h({
+  owner: it,
+  reference: se
+});
+h({
+  objectId: f(),
+  sequenceNumber: f()
+});
+h({
+  payment: v(se),
+  /** Gas Object's owner */
+  owner: f(),
+  price: f(),
+  budget: f()
+});
+const zr = we(
+  se,
+  h({
+    type: f(),
+    owner: it,
+    previousTransaction: f()
+  })
+), Vr = H(f(), Ze()), Gr = H(f(), Ht()), Fr = h({
+  /** Move type (e.g., "0x2::coin::Coin<0x2::sui::SUI>") */
+  type: f(),
+  /** Fields and values stored inside the Move object */
+  fields: Vr,
+  hasPublicTransfer: U()
+}), Lr = h({
+  /** A mapping from module name to disassembled Move bytecode */
+  disassembled: Gr
+}), Kr = k([
+  we(Fr, h({ dataType: b("moveObject") })),
+  we(Lr, h({ dataType: b("package") }))
+]), Wr = h({
+  /** Move type (e.g., "0x2::coin::Coin<0x2::sui::SUI>") */
+  type: f(),
+  hasPublicTransfer: U(),
+  version: f(),
+  bcsBytes: f()
+}), Jr = h({
+  id: f(),
+  /** A mapping from module name to Move bytecode enocded in base64*/
+  moduleMap: H(f(), f())
+}), Hr = k([
+  we(Wr, h({ dataType: b("moveObject") })),
+  we(Jr, h({ dataType: b("package") }))
+]);
+BigInt(1e9);
+const Xt = h({
+  code: f(),
+  error: w(f()),
+  object_id: w(f()),
+  parent_object_id: w(f()),
+  version: w(f()),
+  digest: w(f())
+}), Xr = h({
+  data: O(w(H(f(), f()))),
+  error: O(w(Xt))
+}), qr = k([
+  Xr,
+  w(H(f(), f()))
+]), qt = h({
+  objectId: f(),
+  version: f(),
+  digest: f(),
+  /**
+   * Type of the object, default to be undefined unless SuiObjectDataOptions.showType is set to true
+   */
+  type: O(w(f())),
+  /**
+   * Move object content or package content, default to be undefined unless SuiObjectDataOptions.showContent is set to true
+   */
+  content: O(w(Kr)),
+  /**
+   * Move object content or package content in BCS bytes, default to be undefined unless SuiObjectDataOptions.showBcs is set to true
+   */
+  bcs: O(w(Hr)),
+  /**
+   * The owner of this object. Default to be undefined unless SuiObjectDataOptions.showOwner is set to true
+   */
+  owner: O(w(it)),
+  /**
+   * The digest of the transaction that created or last mutated this object.
+   * Default to be undefined unless SuiObjectDataOptions.showPreviousTransaction is set to true
+   */
+  previousTransaction: O(w(f())),
+  /**
+   * The amount of SUI we would rebate if this object gets deleted.
+   * This number is re-calculated each time the object is mutated based on
+   * the present storage gas price.
+   * Default to be undefined unless SuiObjectDataOptions.showStorageRebate is set to true
+   */
+  storageRebate: O(w(f())),
+  /**
+   * Display metadata for this object, default to be undefined unless SuiObjectDataOptions.showDisplay is set to true
+   * This can also be None if the struct type does not have Display defined
+   * See more details in https://forums.sui.io/t/nft-object-display-proposal/4872
+   */
+  display: O(w(qr))
+});
+h({
+  /* Whether to fetch the object type, default to be true */
+  showType: O(w(U())),
+  /* Whether to fetch the object content, default to be false */
+  showContent: O(w(U())),
+  /* Whether to fetch the object content in BCS bytes, default to be false */
+  showBcs: O(w(U())),
+  /* Whether to fetch the object owner, default to be false */
+  showOwner: O(w(U())),
+  /* Whether to fetch the previous transaction digest, default to be false */
+  showPreviousTransaction: O(w(U())),
+  /* Whether to fetch the storage rebate, default to be false */
+  showStorageRebate: O(w(U())),
+  /* Whether to fetch the display metadata, default to be false */
+  showDisplay: O(w(U()))
+});
+k([b("Exists"), b("notExists"), b("Deleted")]);
+v(zr);
+const Zr = h({
+  data: O(w(qt)),
+  error: O(w(Xt))
+});
+function Yr(e) {
+  return e.data;
+}
+function Qr(e) {
+  if (e.error && "object_id" in e.error && "version" in e.error && "digest" in e.error) {
+    const t = e.error;
+    return {
+      objectId: t.object_id,
+      version: t.version,
+      digest: t.digest
+    };
+  }
+}
+function zt(e) {
+  if ("reference" in e)
+    return e.reference;
+  const t = Yr(e);
+  return t ? {
+    objectId: t.objectId,
+    version: t.version,
+    digest: t.digest
+  } : Qr(e);
+}
+h({
+  objectId: f(),
+  atCheckpoint: w(ue())
+});
+h({
+  data: v(Zr),
+  nextCursor: w(O(f())),
+  hasNextPage: U()
+});
+k([
+  h({
+    details: qt,
+    status: b("VersionFound")
+  }),
+  h({
+    details: f(),
+    status: b("ObjectNotExists")
+  }),
+  h({
+    details: se,
+    status: b("ObjectDeleted")
+  }),
+  h({
+    details: Jt([f(), ue()]),
+    status: b("VersionNotFound")
+  }),
+  h({
+    details: h({
+      asked_version: ue(),
+      latest_version: ue(),
+      object_id: f()
+    }),
+    status: b("VersionTooHigh")
+  })
+]);
+const en = k([f(), h({ Object: f() })]);
+v(en);
+const tn = h({
+  address: f(),
+  name: f()
+}), rn = k([b("Private"), b("Public"), b("Friend")]), st = h({
+  abilities: v(f())
+}), nn = h({
+  constraints: st,
+  isPhantom: U()
+}), sn = h({
+  TypeParameter: ue()
+}), Ge = Jt([
+  h({
+    module: f(),
+    package: f(),
+    function: f()
+  }),
+  f()
+]);
+h({
+  rank3Days: v(Ge),
+  rank7Days: v(Ge),
+  rank30Days: v(Ge)
+});
+function Zt(e) {
+  if (!e)
+    return !1;
+  if (typeof e == "string" || N(e, sn) || Yt(e))
+    return !0;
+  if (typeof e != "object")
+    return !1;
+  const t = e;
+  return !!(N(t.Reference, le) || N(t.MutableReference, le) || N(t.Vector, le));
+}
+const le = P(
+  "SuiMoveNormalizedType",
+  Zt
+);
+function Yt(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = e;
+  if (!t.Struct || typeof t.Struct != "object")
+    return !1;
+  const r = t.Struct;
+  return !(typeof r.address != "string" || typeof r.module != "string" || typeof r.name != "string" || !Array.isArray(r.typeArguments) || !r.typeArguments.every((n) => Zt(n)));
+}
+P(
+  "SuiMoveNormalizedStructType",
+  Yt
+);
+const an = h({
+  visibility: rn,
+  isEntry: U(),
+  typeParameters: v(st),
+  parameters: v(le),
+  return: v(le)
+}), on = h({
+  name: f(),
+  type: le
+}), cn = h({
+  abilities: st,
+  typeParameters: v(nn),
+  fields: v(on)
+}), un = h({
+  fileFormatVersion: ue(),
+  address: f(),
+  name: f(),
+  friends: v(tn),
+  structs: H(f(), cn),
+  exposedFunctions: H(f(), an)
+});
+H(f(), un);
+function Ye(e) {
+  return typeof e == "object" && "MutableReference" in e ? e.MutableReference : void 0;
+}
+function Qt(e) {
+  return typeof e == "object" && "Reference" in e ? e.Reference : void 0;
+}
+function at(e) {
+  if (typeof e == "object" && "Struct" in e)
+    return e;
+  const t = Qt(e), r = Ye(e);
+  if (typeof t == "object" && "Struct" in t)
+    return t;
+  if (typeof r == "object" && "Struct" in r)
+    return r;
+}
+function dn(e) {
+  if (e.length >= 255)
+    throw new TypeError("Alphabet too long");
+  for (var t = new Uint8Array(256), r = 0; r < t.length; r++)
+    t[r] = 255;
+  for (var n = 0; n < e.length; n++) {
+    var i = e.charAt(n), s = i.charCodeAt(0);
+    if (t[s] !== 255)
+      throw new TypeError(i + " is ambiguous");
+    t[s] = n;
+  }
+  var a = e.length, o = e.charAt(0), u = Math.log(a) / Math.log(256), d = Math.log(256) / Math.log(a);
+  function l(p) {
+    if (p instanceof Uint8Array || (ArrayBuffer.isView(p) ? p = new Uint8Array(p.buffer, p.byteOffset, p.byteLength) : Array.isArray(p) && (p = Uint8Array.from(p))), !(p instanceof Uint8Array))
+      throw new TypeError("Expected Uint8Array");
+    if (p.length === 0)
+      return "";
+    for (var y = 0, S = 0, E = 0, A = p.length; E !== A && p[E] === 0; )
+      E++, y++;
+    for (var _ = (A - E) * d + 1 >>> 0, D = new Uint8Array(_); E !== A; ) {
+      for (var X = p[E], ne = 0, G = _ - 1; (X !== 0 || ne < S) && G !== -1; G--, ne++)
+        X += 256 * D[G] >>> 0, D[G] = X % a >>> 0, X = X / a >>> 0;
+      if (X !== 0)
+        throw new Error("Non-zero carry");
+      S = ne, E++;
+    }
+    for (var Y = _ - S; Y !== _ && D[Y] === 0; )
+      Y++;
+    for (var Oe = o.repeat(y); Y < _; ++Y)
+      Oe += e.charAt(D[Y]);
+    return Oe;
+  }
+  function g(p) {
+    if (typeof p != "string")
+      throw new TypeError("Expected String");
+    if (p.length === 0)
+      return new Uint8Array();
+    for (var y = 0, S = 0, E = 0; p[y] === o; )
+      S++, y++;
+    for (var A = (p.length - y) * u + 1 >>> 0, _ = new Uint8Array(A); p[y]; ) {
+      var D = t[p.charCodeAt(y)];
+      if (D === 255)
+        return;
+      for (var X = 0, ne = A - 1; (D !== 0 || X < E) && ne !== -1; ne--, X++)
+        D += a * _[ne] >>> 0, _[ne] = D % 256 >>> 0, D = D / 256 >>> 0;
+      if (D !== 0)
+        throw new Error("Non-zero carry");
+      E = X, y++;
+    }
+    for (var G = A - E; G !== A && _[G] === 0; )
+      G++;
+    for (var Y = new Uint8Array(S + (A - G)), Oe = S; G !== A; )
+      Y[Oe++] = _[G++];
+    return Y;
+  }
+  function m(p) {
+    var y = g(p);
+    if (y)
+      return y;
+    throw new Error("Non-base" + a + " character");
+  }
+  return {
+    encode: l,
+    decodeUnsafe: g,
+    decode: m
+  };
+}
+var fn = dn;
+const ln = fn, hn = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+var gn = ln(hn);
+const er = /* @__PURE__ */ Ir(gn), xe = (e) => er.encode(e), ot = (e) => er.decode(e);
+function ae(e) {
+  return Uint8Array.from(atob(e), (t) => t.charCodeAt(0));
+}
+const Fe = 8192;
+function Ie(e) {
+  if (e.length < Fe)
+    return btoa(String.fromCharCode(...e));
+  let t = "";
+  for (var r = 0; r < e.length; r += Fe) {
+    const n = e.slice(r, r + Fe);
+    t += String.fromCharCode(...n);
+  }
+  return btoa(t);
+}
+function Ve(e) {
+  var i;
+  const t = e.startsWith("0x") ? e.slice(2) : e, n = ((i = (t.length % 2 === 0 ? t : `0${t}}`).match(/.{2}/g)) == null ? void 0 : i.map((s) => parseInt(s, 16))) ?? [];
+  return Uint8Array.from(n);
+}
+function je(e) {
+  return e.reduce((t, r) => t + r.toString(16).padStart(2, "0"), "");
+}
+function ct(e) {
+  let t = [], r = 0;
+  if (e === 0)
+    return [0];
+  for (; e > 0; )
+    t[r] = e & 127, (e >>= 7) && (t[r] |= 128), r += 1;
+  return t;
+}
+function pn(e) {
+  let t = 0, r = 0, n = 0;
+  for (; ; ) {
+    let i = e[n];
+    if (n += 1, t |= (i & 127) << r, !(i & 128))
+      break;
+    r += 7;
+  }
+  return {
+    value: t,
+    length: n
+  };
+}
+class tr {
+  /**
+   * @param {Uint8Array} data Data to use as a buffer.
+   */
+  constructor(t) {
+    this.bytePosition = 0, this.dataView = new DataView(t.buffer);
+  }
+  /**
+   * Shift current cursor position by `bytes`.
+   *
+   * @param {Number} bytes Number of bytes to
+   * @returns {this} Self for possible chaining.
+   */
+  shift(t) {
+    return this.bytePosition += t, this;
+  }
+  /**
+   * Read U8 value from the buffer and shift cursor by 1.
+   * @returns
+   */
+  read8() {
+    let t = this.dataView.getUint8(this.bytePosition);
+    return this.shift(1), t;
+  }
+  /**
+   * Read U16 value from the buffer and shift cursor by 2.
+   * @returns
+   */
+  read16() {
+    let t = this.dataView.getUint16(this.bytePosition, !0);
+    return this.shift(2), t;
+  }
+  /**
+   * Read U32 value from the buffer and shift cursor by 4.
+   * @returns
+   */
+  read32() {
+    let t = this.dataView.getUint32(this.bytePosition, !0);
+    return this.shift(4), t;
+  }
+  /**
+   * Read U64 value from the buffer and shift cursor by 8.
+   * @returns
+   */
+  read64() {
+    let t = this.read32(), n = this.read32().toString(16) + t.toString(16).padStart(8, "0");
+    return BigInt("0x" + n).toString(10);
+  }
+  /**
+   * Read U128 value from the buffer and shift cursor by 16.
+   */
+  read128() {
+    let t = BigInt(this.read64()), n = BigInt(this.read64()).toString(16) + t.toString(16).padStart(16, "0");
+    return BigInt("0x" + n).toString(10);
+  }
+  /**
+   * Read U128 value from the buffer and shift cursor by 32.
+   * @returns
+   */
+  read256() {
+    let t = BigInt(this.read128()), n = BigInt(this.read128()).toString(16) + t.toString(16).padStart(32, "0");
+    return BigInt("0x" + n).toString(10);
+  }
+  /**
+   * Read `num` number of bytes from the buffer and shift cursor by `num`.
+   * @param num Number of bytes to read.
+   */
+  readBytes(t) {
+    let r = this.bytePosition + this.dataView.byteOffset, n = new Uint8Array(this.dataView.buffer, r, t);
+    return this.shift(t), n;
+  }
+  /**
+   * Read ULEB value - an integer of varying size. Used for enum indexes and
+   * vector lengths.
+   * @returns {Number} The ULEB value.
+   */
+  readULEB() {
+    let t = this.bytePosition + this.dataView.byteOffset, r = new Uint8Array(this.dataView.buffer, t), { value: n, length: i } = pn(r);
+    return this.shift(i), n;
+  }
+  /**
+   * Read a BCS vector: read a length and then apply function `cb` X times
+   * where X is the length of the vector, defined as ULEB in BCS bytes.
+   * @param cb Callback to process elements of vector.
+   * @returns {Array<Any>} Array of the resulting values, returned by callback.
+   */
+  readVec(t) {
+    let r = this.readULEB(), n = [];
+    for (let i = 0; i < r; i++)
+      n.push(t(this, i, r));
+    return n;
+  }
+}
+function mn(e, t) {
+  switch (t) {
+    case "base58":
+      return xe(e);
+    case "base64":
+      return Ie(e);
+    case "hex":
+      return je(e);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+function yn(e, t) {
+  switch (t) {
+    case "base58":
+      return ot(e);
+    case "base64":
+      return ae(e);
+    case "hex":
+      return Ve(e);
+    default:
+      throw new Error("Unsupported encoding, supported values are: base64, hex");
+  }
+}
+function rr(e, t = ["<", ">"]) {
+  const [r, n] = t, i = [];
+  let s = "", a = 0;
+  for (let o = 0; o < e.length; o++) {
+    const u = e[o];
+    if (u === r && a++, u === n && a--, a === 0 && u === ",") {
+      i.push(s.trim()), s = "";
+      continue;
+    }
+    s += u;
+  }
+  return i.push(s.trim()), i;
+}
+class nr {
+  constructor({ size: t = 1024, maxSize: r, allocateSize: n = 1024 } = {}) {
+    this.bytePosition = 0, this.size = t, this.maxSize = r || t, this.allocateSize = n, this.dataView = new DataView(new ArrayBuffer(t));
+  }
+  ensureSizeOrGrow(t) {
+    const r = this.bytePosition + t;
+    if (r > this.size) {
+      const n = Math.min(this.maxSize, this.size + this.allocateSize);
+      if (r > n)
+        throw new Error(
+          `Attempting to serialize to BCS, but buffer does not have enough size. Allocated size: ${this.size}, Max size: ${this.maxSize}, Required size: ${r}`
+        );
+      this.size = n;
+      const i = new ArrayBuffer(this.size);
+      new Uint8Array(i).set(new Uint8Array(this.dataView.buffer)), this.dataView = new DataView(i);
+    }
+  }
+  /**
+   * Shift current cursor position by `bytes`.
+   *
+   * @param {Number} bytes Number of bytes to
+   * @returns {this} Self for possible chaining.
+   */
+  shift(t) {
+    return this.bytePosition += t, this;
+  }
+  /**
+   * Write a U8 value into a buffer and shift cursor position by 1.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  write8(t) {
+    return this.ensureSizeOrGrow(1), this.dataView.setUint8(this.bytePosition, Number(t)), this.shift(1);
+  }
+  /**
+   * Write a U16 value into a buffer and shift cursor position by 2.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  write16(t) {
+    return this.ensureSizeOrGrow(2), this.dataView.setUint16(this.bytePosition, Number(t), !0), this.shift(2);
+  }
+  /**
+   * Write a U32 value into a buffer and shift cursor position by 4.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  write32(t) {
+    return this.ensureSizeOrGrow(4), this.dataView.setUint32(this.bytePosition, Number(t), !0), this.shift(4);
+  }
+  /**
+   * Write a U64 value into a buffer and shift cursor position by 8.
+   * @param {bigint} value Value to write.
+   * @returns {this}
+   */
+  write64(t) {
+    return Le(BigInt(t), 8).forEach((r) => this.write8(r)), this;
+  }
+  /**
+   * Write a U128 value into a buffer and shift cursor position by 16.
+   *
+   * @param {bigint} value Value to write.
+   * @returns {this}
+   */
+  write128(t) {
+    return Le(BigInt(t), 16).forEach((r) => this.write8(r)), this;
+  }
+  /**
+   * Write a U256 value into a buffer and shift cursor position by 16.
+   *
+   * @param {bigint} value Value to write.
+   * @returns {this}
+   */
+  write256(t) {
+    return Le(BigInt(t), 32).forEach((r) => this.write8(r)), this;
+  }
+  /**
+   * Write a ULEB value into a buffer and shift cursor position by number of bytes
+   * written.
+   * @param {Number} value Value to write.
+   * @returns {this}
+   */
+  writeULEB(t) {
+    return ct(t).forEach((r) => this.write8(r)), this;
+  }
+  /**
+   * Write a vector into a buffer by first writing the vector length and then calling
+   * a callback on each passed value.
+   *
+   * @param {Array<Any>} vector Array of elements to write.
+   * @param {WriteVecCb} cb Callback to call on each element of the vector.
+   * @returns {this}
+   */
+  writeVec(t, r) {
+    return this.writeULEB(t.length), Array.from(t).forEach((n, i) => r(this, n, i, t.length)), this;
+  }
+  /**
+   * Adds support for iterations over the object.
+   * @returns {Uint8Array}
+   */
+  *[Symbol.iterator]() {
+    for (let t = 0; t < this.bytePosition; t++)
+      yield this.dataView.getUint8(t);
+    return this.toBytes();
+  }
+  /**
+   * Get underlying buffer taking only value bytes (in case initial buffer size was bigger).
+   * @returns {Uint8Array} Resulting bcs.
+   */
+  toBytes() {
+    return new Uint8Array(this.dataView.buffer.slice(0, this.bytePosition));
+  }
+  /**
+   * Represent data as 'hex' or 'base64'
+   * @param encoding Encoding to use: 'base64' or 'hex'
+   */
+  toString(t) {
+    return mn(this.toBytes(), t);
+  }
+}
+function Le(e, t) {
+  let r = new Uint8Array(t), n = 0;
+  for (; e > 0; )
+    r[n] = Number(e % BigInt(256)), e = e / BigInt(256), n += 1;
+  return r;
+}
+var ir = (e, t, r) => {
+  if (!t.has(e))
+    throw TypeError("Cannot " + r);
+}, K = (e, t, r) => (ir(e, t, "read from private field"), r ? r.call(e) : t.get(e)), Be = (e, t, r) => {
+  if (t.has(e))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(e) : t.set(e, r);
+}, Re = (e, t, r, n) => (ir(e, t, "write to private field"), t.set(e, r), r), fe, ge, Ce, ie;
+const sr = class {
+  constructor(e) {
+    Be(this, fe, void 0), Be(this, ge, void 0), this.name = e.name, this.read = e.read, this.serializedSize = e.serializedSize ?? (() => null), Re(this, fe, e.write), Re(this, ge, e.serialize ?? ((t, r) => {
+      const n = new nr({ size: this.serializedSize(t) ?? void 0, ...r });
+      return K(this, fe).call(this, t, n), n.toBytes();
+    })), this.validate = e.validate ?? (() => {
+    });
+  }
+  write(e, t) {
+    this.validate(e), K(this, fe).call(this, e, t);
+  }
+  serialize(e, t) {
+    return this.validate(e), new wn(this, K(this, ge).call(this, e, t));
+  }
+  parse(e) {
+    const t = new tr(e);
+    return this.read(t);
+  }
+  transform({
+    name: e,
+    input: t,
+    output: r
+  }) {
+    return new sr({
+      name: e ?? this.name,
+      read: (n) => r(this.read(n)),
+      write: (n, i) => K(this, fe).call(this, t(n), i),
+      serializedSize: (n) => this.serializedSize(t(n)),
+      serialize: (n, i) => K(this, ge).call(this, t(n), i),
+      validate: (n) => this.validate(t(n))
+    });
+  }
+};
+let W = sr;
+fe = /* @__PURE__ */ new WeakMap();
+ge = /* @__PURE__ */ new WeakMap();
+const ar = Symbol.for("@mysten/serialized-bcs");
+function ut(e) {
+  return !!e && typeof e == "object" && e[ar] === !0;
+}
+class wn {
+  constructor(t, r) {
+    Be(this, Ce, void 0), Be(this, ie, void 0), Re(this, Ce, t), Re(this, ie, r);
+  }
+  // Used to brand SerializedBcs so that they can be identified, even between multiple copies
+  // of the @mysten/bcs package are installed
+  get [ar]() {
+    return !0;
+  }
+  toBytes() {
+    return K(this, ie);
+  }
+  toHex() {
+    return je(K(this, ie));
+  }
+  toBase64() {
+    return Ie(K(this, ie));
+  }
+  toBase58() {
+    return xe(K(this, ie));
+  }
+  parse() {
+    return K(this, Ce).parse(K(this, ie));
+  }
+}
+Ce = /* @__PURE__ */ new WeakMap();
+ie = /* @__PURE__ */ new WeakMap();
+function Ne({
+  size: e,
+  ...t
+}) {
+  return new W({
+    ...t,
+    serializedSize: () => e
+  });
+}
+function Ke({
+  readMethod: e,
+  writeMethod: t,
+  ...r
+}) {
+  return Ne({
+    ...r,
+    read: (n) => n[e](),
+    write: (n, i) => i[t](n),
+    validate: (n) => {
+      var i;
+      if (n < 0 || n > r.maxValue)
+        throw new TypeError(
+          `Invalid ${r.name} value: ${n}. Expected value in range 0-${r.maxValue}`
+        );
+      (i = r.validate) == null || i.call(r, n);
+    }
+  });
+}
+function We({
+  readMethod: e,
+  writeMethod: t,
+  ...r
+}) {
+  return Ne({
+    ...r,
+    read: (n) => n[e](),
+    write: (n, i) => i[t](BigInt(n)),
+    validate: (n) => {
+      var s;
+      const i = BigInt(n);
+      if (i < 0 || i > r.maxValue)
+        throw new TypeError(
+          `Invalid ${r.name} value: ${i}. Expected value in range 0-${r.maxValue}`
+        );
+      (s = r.validate) == null || s.call(r, i);
+    }
+  });
+}
+function bn({
+  serialize: e,
+  ...t
+}) {
+  const r = new W({
+    ...t,
+    serialize: e,
+    write: (n, i) => {
+      for (const s of r.serialize(n).toBytes())
+        i.write8(s);
+    }
+  });
+  return r;
+}
+function Sn({
+  toBytes: e,
+  fromBytes: t,
+  ...r
+}) {
+  return new W({
+    ...r,
+    read: (n) => {
+      const i = n.readULEB(), s = n.readBytes(i);
+      return t(s);
+    },
+    write: (n, i) => {
+      const s = e(n);
+      i.writeULEB(s.length);
+      for (let a = 0; a < s.length; a++)
+        i.write8(s[a]);
+    },
+    serialize: (n) => {
+      const i = e(n), s = ct(i.length), a = new Uint8Array(s.length + i.length);
+      return a.set(s, 0), a.set(i, s.length), a;
+    },
+    validate: (n) => {
+      var i;
+      if (typeof n != "string")
+        throw new TypeError(`Invalid ${r.name} value: ${n}. Expected string`);
+      (i = r.validate) == null || i.call(r, n);
+    }
+  });
+}
+function Tn(e) {
+  let t = null;
+  function r() {
+    return t || (t = e()), t;
+  }
+  return new W({
+    name: "lazy",
+    read: (n) => r().read(n),
+    serializedSize: (n) => r().serializedSize(n),
+    write: (n, i) => r().write(n, i),
+    serialize: (n, i) => r().serialize(n, i).toBytes()
+  });
+}
+const c = {
+  /**
+   * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
+   * @example
+   * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
+   */
+  u8(e) {
+    return Ke({
+      name: "u8",
+      readMethod: "read8",
+      writeMethod: "write8",
+      size: 1,
+      maxValue: 2 ** 8 - 1,
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
+   * @example
+   * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
+   */
+  u16(e) {
+    return Ke({
+      name: "u16",
+      readMethod: "read16",
+      writeMethod: "write16",
+      size: 2,
+      maxValue: 2 ** 16 - 1,
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
+   * @example
+   * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
+   */
+  u32(e) {
+    return Ke({
+      name: "u32",
+      readMethod: "read32",
+      writeMethod: "write32",
+      size: 4,
+      maxValue: 2 ** 32 - 1,
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
+   * @example
+   * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
+   */
+  u64(e) {
+    return We({
+      name: "u64",
+      readMethod: "read64",
+      writeMethod: "write64",
+      size: 8,
+      maxValue: 2n ** 64n - 1n,
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
+   * @example
+   * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u128(e) {
+    return We({
+      name: "u128",
+      readMethod: "read128",
+      writeMethod: "write128",
+      size: 16,
+      maxValue: 2n ** 128n - 1n,
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
+   * @example
+   * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u256(e) {
+    return We({
+      name: "u256",
+      readMethod: "read256",
+      writeMethod: "write256",
+      size: 32,
+      maxValue: 2n ** 256n - 1n,
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write boolean values.
+   * @example
+   * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
+   */
+  bool(e) {
+    return Ne({
+      name: "bool",
+      size: 1,
+      read: (t) => t.read8() === 1,
+      write: (t, r) => r.write8(t ? 1 : 0),
+      ...e,
+      validate: (t) => {
+        var r;
+        if ((r = e == null ? void 0 : e.validate) == null || r.call(e, t), typeof t != "boolean")
+          throw new TypeError(`Expected boolean, found ${typeof t}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
+   * @example
+   *
+   */
+  uleb128(e) {
+    return bn({
+      name: "uleb128",
+      read: (t) => t.readULEB(),
+      serialize: (t) => Uint8Array.from(ct(t)),
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType representing a fixed length byte array
+   * @param size The number of bytes this types represents
+   * @example
+   * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
+   */
+  bytes(e, t) {
+    return Ne({
+      name: `bytes[${e}]`,
+      size: e,
+      read: (r) => r.readBytes(e),
+      write: (r, n) => {
+        for (let i = 0; i < e; i++)
+          n.write8(r[i] ?? 0);
+      },
+      ...t,
+      validate: (r) => {
+        var n;
+        if ((n = t == null ? void 0 : t.validate) == null || n.call(t, r), !("length" in r))
+          throw new TypeError(`Expected array, found ${typeof r}`);
+        if (r.length !== e)
+          throw new TypeError(`Expected array of length ${e}, found ${r.length}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
+   * @example
+   * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
+   */
+  string(e) {
+    return Sn({
+      name: "string",
+      toBytes: (t) => new TextEncoder().encode(t),
+      fromBytes: (t) => new TextDecoder().decode(t),
+      ...e
+    });
+  },
+  /**
+   * Creates a BcsType that represents a fixed length array of a given type
+   * @param size The number of elements in the array
+   * @param type The BcsType of each element in the array
+   * @example
+   * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
+   */
+  fixedArray(e, t, r) {
+    return new W({
+      name: `${t.name}[${e}]`,
+      read: (n) => {
+        const i = new Array(e);
+        for (let s = 0; s < e; s++)
+          i[s] = t.read(n);
+        return i;
+      },
+      write: (n, i) => {
+        for (const s of n)
+          t.write(s, i);
+      },
+      ...r,
+      validate: (n) => {
+        var i;
+        if ((i = r == null ? void 0 : r.validate) == null || i.call(r, n), !("length" in n))
+          throw new TypeError(`Expected array, found ${typeof n}`);
+        if (n.length !== e)
+          throw new TypeError(`Expected array of length ${e}, found ${n.length}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing an optional value
+   * @param type The BcsType of the optional value
+   * @example
+   * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
+   * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
+   */
+  option(e) {
+    return c.enum(`Option<${e.name}>`, {
+      None: null,
+      Some: e
+    }).transform({
+      input: (t) => t == null ? { None: !0 } : { Some: t },
+      output: (t) => "Some" in t ? t.Some : null
+    });
+  },
+  /**
+   * Creates a BcsType representing a variable length vector of a given type
+   * @param type The BcsType of each element in the vector
+   *
+   * @example
+   * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
+   */
+  vector(e, t) {
+    return new W({
+      name: `vector<${e.name}>`,
+      read: (r) => {
+        const n = r.readULEB(), i = new Array(n);
+        for (let s = 0; s < n; s++)
+          i[s] = e.read(r);
+        return i;
+      },
+      write: (r, n) => {
+        n.writeULEB(r.length);
+        for (const i of r)
+          e.write(i, n);
+      },
+      ...t,
+      validate: (r) => {
+        var n;
+        if ((n = t == null ? void 0 : t.validate) == null || n.call(t, r), !("length" in r))
+          throw new TypeError(`Expected array, found ${typeof r}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing a tuple of a given set of types
+   * @param types The BcsTypes for each element in the tuple
+   *
+   * @example
+   * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
+   * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
+   */
+  tuple(e, t) {
+    return new W({
+      name: `(${e.map((r) => r.name).join(", ")})`,
+      serializedSize: (r) => {
+        let n = 0;
+        for (let i = 0; i < e.length; i++) {
+          const s = e[i].serializedSize(r[i]);
+          if (s == null)
+            return null;
+          n += s;
+        }
+        return n;
+      },
+      read: (r) => {
+        const n = [];
+        for (const i of e)
+          n.push(i.read(r));
+        return n;
+      },
+      write: (r, n) => {
+        for (let i = 0; i < e.length; i++)
+          e[i].write(r[i], n);
+      },
+      ...t,
+      validate: (r) => {
+        var n;
+        if ((n = t == null ? void 0 : t.validate) == null || n.call(t, r), !Array.isArray(r))
+          throw new TypeError(`Expected array, found ${typeof r}`);
+        if (r.length !== e.length)
+          throw new TypeError(`Expected array of length ${e.length}, found ${r.length}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing a struct of a given set of fields
+   * @param name The name of the struct
+   * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
+   *
+   * @example
+   * const struct = bcs.struct('MyStruct', {
+   *  a: bcs.u8(),
+   *  b: bcs.string(),
+   * })
+   * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   */
+  struct(e, t, r) {
+    const n = Object.entries(t);
+    return new W({
+      name: e,
+      serializedSize: (i) => {
+        let s = 0;
+        for (const [a, o] of n) {
+          const u = o.serializedSize(i[a]);
+          if (u == null)
+            return null;
+          s += u;
+        }
+        return s;
+      },
+      read: (i) => {
+        const s = {};
+        for (const [a, o] of n)
+          s[a] = o.read(i);
+        return s;
+      },
+      write: (i, s) => {
+        for (const [a, o] of n)
+          o.write(i[a], s);
+      },
+      ...r,
+      validate: (i) => {
+        var s;
+        if ((s = r == null ? void 0 : r.validate) == null || s.call(r, i), typeof i != "object" || i == null)
+          throw new TypeError(`Expected object, found ${typeof i}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing an enum of a given set of options
+   * @param name The name of the enum
+   * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.
+   * null can be used to represent a variant with no data.
+   *
+   * @example
+   * const enum = bcs.enum('MyEnum', {
+   *   A: bcs.u8(),
+   *   B: bcs.string(),
+   *   C: null,
+   * })
+   * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
+   * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
+   */
+  enum(e, t, r) {
+    const n = Object.entries(t);
+    return new W({
+      name: e,
+      read: (i) => {
+        const s = i.readULEB(), [a, o] = n[s];
+        return {
+          [a]: (o == null ? void 0 : o.read(i)) ?? !0
+        };
+      },
+      write: (i, s) => {
+        const [a, o] = Object.entries(i)[0];
+        for (let u = 0; u < n.length; u++) {
+          const [d, l] = n[u];
+          if (d === a) {
+            s.writeULEB(u), l == null || l.write(o, s);
+            return;
+          }
+        }
+      },
+      ...r,
+      validate: (i) => {
+        var o;
+        if ((o = r == null ? void 0 : r.validate) == null || o.call(r, i), typeof i != "object" || i == null)
+          throw new TypeError(`Expected object, found ${typeof i}`);
+        const s = Object.keys(i);
+        if (s.length !== 1)
+          throw new TypeError(`Expected object with one key, found ${s.length}`);
+        const [a] = s;
+        if (!Object.hasOwn(t, a))
+          throw new TypeError(`Invalid enum variant ${a}`);
+      }
+    });
+  },
+  /**
+   * Creates a BcsType representing a map of a given key and value type
+   * @param keyType The BcsType of the key
+   * @param valueType The BcsType of the value
+   * @example
+   * const map = bcs.map(bcs.u8(), bcs.string())
+   * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
+   */
+  map(e, t) {
+    return c.vector(c.tuple([e, t])).transform({
+      name: `Map<${e.name}, ${t.name}>`,
+      input: (r) => [...r.entries()],
+      output: (r) => {
+        const n = /* @__PURE__ */ new Map();
+        for (const [i, s] of r)
+          n.set(i, s);
+        return n;
+      }
+    });
+  },
+  /**
+   * @deprecated
+   *
+   * Generics should be implemented as generic typescript functions instead:
+   *
+   * ```ts
+   * function VecMap<K, V>, (K: BcsType<K>, V: BcsType<V>) {
+   *   return bcs.struct('VecMap<K, V>', {
+   *     keys: bcs.vector(K),
+   *     values: bcs.vector(V),
+   *   })
+   * }
+   * ```
+   */
+  generic(e, t) {
+    return (...r) => t(...r).transform({
+      name: `${t.name}<${r.map((n) => n.name).join(", ")}>`,
+      input: (n) => n,
+      output: (n) => n
+    });
+  },
+  /**
+   * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
+   * @param cb A callback that returns the BcsType
+   */
+  lazy(e) {
+    return Tn(e);
+  }
+}, vn = 32, pe = class {
+  /**
+   * Construct a BCS instance with a prepared schema.
+   *
+   * @param schema A prepared schema with type definitions
+   * @param withPrimitives Whether to register primitive types by default
+   */
+  constructor(e) {
+    if (this.types = /* @__PURE__ */ new Map(), this.counter = 0, e instanceof pe) {
+      this.schema = e.schema, this.types = new Map(e.types);
+      return;
+    }
+    if (this.schema = e, this.registerAddressType(pe.ADDRESS, e.addressLength, e.addressEncoding), this.registerVectorType(e.vectorType), e.types && e.types.structs)
+      for (let t of Object.keys(e.types.structs))
+        this.registerStructType(t, e.types.structs[t]);
+    if (e.types && e.types.enums)
+      for (let t of Object.keys(e.types.enums))
+        this.registerEnumType(t, e.types.enums[t]);
+    if (e.types && e.types.aliases)
+      for (let t of Object.keys(e.types.aliases))
+        this.registerAlias(t, e.types.aliases[t]);
+    e.withPrimitives !== !1 && En(this);
+  }
+  /**
+   * Name of the key to use for temporary struct definitions.
+   * Returns a temp key + index (for a case when multiple temp
+   * structs are processed).
+   */
+  tempKey() {
+    return `bcs-struct-${++this.counter}`;
+  }
+  /**
+   * Serialize data into bcs.
+   *
+   * @example
+   * bcs.registerVectorType('vector<u8>', 'u8');
+   *
+   * let serialized = BCS
+   *   .set('vector<u8>', [1,2,3,4,5,6])
+   *   .toBytes();
+   *
+   * console.assert(toHex(serialized) === '06010203040506');
+   *
+   * @param type Name of the type to serialize (must be registered) or a struct type.
+   * @param data Data to serialize.
+   * @param size Serialization buffer size. Default 1024 = 1KB.
+   * @return A BCS reader instance. Usually you'd want to call `.toBytes()`
+   */
+  ser(e, t, r) {
+    if (typeof e == "string" || Array.isArray(e)) {
+      const { name: n, params: i } = this.parseTypeName(e);
+      return this.getTypeInterface(n).encode(this, t, r, i);
+    }
+    if (typeof e == "object") {
+      const n = this.tempKey();
+      return new pe(this).registerStructType(n, e).ser(n, t, r);
+    }
+    throw new Error(`Incorrect type passed into the '.ser()' function. 
+${JSON.stringify(e)}`);
+  }
+  /**
+   * Deserialize BCS into a JS type.
+   *
+   * @example
+   * let num = bcs.ser('u64', '4294967295').toString('hex');
+   * let deNum = bcs.de('u64', num, 'hex');
+   * console.assert(deNum.toString(10) === '4294967295');
+   *
+   * @param type Name of the type to deserialize (must be registered) or a struct type definition.
+   * @param data Data to deserialize.
+   * @param encoding Optional - encoding to use if data is of type String
+   * @return Deserialized data.
+   */
+  de(e, t, r) {
+    if (typeof t == "string")
+      if (r)
+        t = yn(t, r);
+      else
+        throw new Error("To pass a string to `bcs.de`, specify encoding");
+    if (typeof e == "string" || Array.isArray(e)) {
+      const { name: n, params: i } = this.parseTypeName(e);
+      return this.getTypeInterface(n).decode(this, t, i);
+    }
+    if (typeof e == "object") {
+      const n = new pe(this), i = this.tempKey();
+      return n.registerStructType(i, e).de(i, t, r);
+    }
+    throw new Error(`Incorrect type passed into the '.de()' function. 
+${JSON.stringify(e)}`);
+  }
+  /**
+   * Check whether a `TypeInterface` has been loaded for a `type`.
+   * @param type Name of the type to check.
+   * @returns
+   */
+  hasType(e) {
+    return this.types.has(e);
+  }
+  /**
+   * Create an alias for a type.
+   * WARNING: this can potentially lead to recursion
+   * @param name Alias to use
+   * @param forType Type to reference
+   * @returns
+   *
+   * @example
+   * ```
+   * let bcs = new BCS(getSuiMoveConfig());
+   * bcs.registerAlias('ObjectDigest', BCS.BASE58);
+   * let b58_digest = bcs.de('ObjectDigest', '<digest_bytes>', 'base64');
+   * ```
+   */
+  registerAlias(e, t) {
+    return this.types.set(e, t), this;
+  }
+  /**
+   * Method to register new types for BCS internal representation.
+   * For each registered type 2 callbacks must be specified and one is optional:
+   *
+   * - encodeCb(writer, data) - write a way to serialize data with BcsWriter;
+   * - decodeCb(reader) - write a way to deserialize data with BcsReader;
+   * - validateCb(data) - validate data - either return bool or throw an error
+   *
+   * @example
+   * // our type would be a string that consists only of numbers
+   * bcs.registerType('number_string',
+   *    (writer, data) => writer.writeVec(data, (w, el) => w.write8(el)),
+   *    (reader) => reader.readVec((r) => r.read8()).join(''), // read each value as u8
+   *    (value) => /[0-9]+/.test(value) // test that it has at least one digit
+   * );
+   * console.log(Array.from(bcs.ser('number_string', '12345').toBytes()) == [5,1,2,3,4,5]);
+   *
+   * @param name
+   * @param encodeCb Callback to encode a value.
+   * @param decodeCb Callback to decode a value.
+   * @param validateCb Optional validator Callback to check type before serialization.
+   */
+  registerType(e, t, r, n = () => !0) {
+    const { name: i, params: s } = this.parseTypeName(e);
+    return this.types.set(i, {
+      encode(a, o, u, d) {
+        const l = s.reduce((g, m, p) => Object.assign(g, { [m]: d[p] }), {});
+        return this._encodeRaw.call(a, new nr(u), o, d, l);
+      },
+      decode(a, o, u) {
+        const d = s.reduce((l, g, m) => Object.assign(l, { [g]: u[m] }), {});
+        return this._decodeRaw.call(a, new tr(o), u, d);
+      },
+      // these methods should always be used with caution as they require pre-defined
+      // reader and writer and mainly exist to allow multi-field (de)serialization;
+      _encodeRaw(a, o, u, d) {
+        if (n(o))
+          return t.call(this, a, o, u, d);
+        throw new Error(`Validation failed for type ${i}, data: ${o}`);
+      },
+      _decodeRaw(a, o, u) {
+        return r.call(this, a, o, u);
+      }
+    }), this;
+  }
+  /**
+  	 * Method to register BcsType instances to the registry
+  	 * Types are registered with a callback that provides BcsType instances for each generic
+  	 * passed to the type.
+  	 *
+  	 * - createType(...generics) - Return a BcsType instance
+  	 *
+  	 * @example
+  	 * // our type would be a string that consists only of numbers
+  	 * bcs.registerType('Box<T>', (T) => {
+  	 * 		return bcs.struct({
+  	 * 			value: T
+  	 * 		});
+  	 * });
+  
+  	 * console.log(Array.from(bcs.ser('Box<string>', '12345').toBytes()) == [5,1,2,3,4,5]);
+  	 *
+  	 * @param name
+  	 * @param createType a Callback to create the BcsType with any passed in generics
+  	 */
+  registerBcsType(e, t) {
+    return this.registerType(
+      e,
+      (r, n, i) => {
+        const s = i.map(
+          (a) => new W({
+            name: String(a),
+            write: (o, u) => {
+              const { name: d, params: l } = this.parseTypeName(a), g = this.getTypeInterface(d), m = l.reduce((p, y, S) => Object.assign(p, { [y]: i[S] }), {});
+              return g._encodeRaw.call(this, u, o, l, m);
+            },
+            read: () => {
+              throw new Error("Not implemented");
+            }
+          })
+        );
+        return t(...s).write(n, r), r;
+      },
+      (r, n) => {
+        const i = n.map(
+          (s) => new W({
+            name: String(s),
+            write: (a, o) => {
+              throw new Error("Not implemented");
+            },
+            read: (a) => {
+              const { name: o, params: u } = this.parseTypeName(s), d = this.getTypeInterface(o), l = u.reduce((g, m, p) => Object.assign(g, { [m]: n[p] }), {});
+              return d._decodeRaw.call(this, a, u, l);
+            }
+          })
+        );
+        return t(...i).read(r);
+      }
+    ), this;
+  }
+  /**
+   * Register an address type which is a sequence of U8s of specified length.
+   * @example
+   * bcs.registerAddressType('address', SUI_ADDRESS_LENGTH);
+   * let addr = bcs.de('address', 'c3aca510c785c7094ac99aeaa1e69d493122444df50bb8a99dfa790c654a79af');
+   *
+   * @param name Name of the address type.
+   * @param length Byte length of the address.
+   * @param encoding Encoding to use for the address type
+   * @returns
+   */
+  registerAddressType(e, t, r = "hex") {
+    switch (r) {
+      case "base64":
+        return this.registerType(
+          e,
+          function(i, s) {
+            return ae(s).reduce((a, o) => a.write8(o), i);
+          },
+          function(i) {
+            return Ie(i.readBytes(t));
+          }
+        );
+      case "hex":
+        return this.registerType(
+          e,
+          function(i, s) {
+            return Ve(s).reduce((a, o) => a.write8(o), i);
+          },
+          function(i) {
+            return je(i.readBytes(t));
+          }
+        );
+      default:
+        throw new Error("Unsupported encoding! Use either hex or base64");
+    }
+  }
+  /**
+   * Register custom vector type inside the bcs.
+   *
+   * @example
+   * bcs.registerVectorType('vector<T>'); // generic registration
+   * let array = bcs.de('vector<u8>', '06010203040506', 'hex'); // [1,2,3,4,5,6];
+   * let again = bcs.ser('vector<u8>', [1,2,3,4,5,6]).toString('hex');
+   *
+   * @param name Name of the type to register
+   * @param elementType Optional name of the inner type of the vector
+   * @return Returns self for chaining.
+   */
+  registerVectorType(e) {
+    let { name: t, params: r } = this.parseTypeName(e);
+    if (r.length > 1)
+      throw new Error("Vector can have only one type parameter; got " + t);
+    return this.registerType(
+      e,
+      function(i, s, a, o) {
+        return i.writeVec(s, (u, d) => {
+          let l = a[0];
+          if (!l)
+            throw new Error(`Incorrect number of type parameters passed a to vector '${e}'`);
+          let { name: g, params: m } = this.parseTypeName(l);
+          if (this.hasType(g))
+            return this.getTypeInterface(g)._encodeRaw.call(this, u, d, m, o);
+          if (!(g in o))
+            throw new Error(
+              `Unable to find a matching type definition for ${g} in vector; make sure you passed a generic`
+            );
+          let { name: p, params: y } = this.parseTypeName(o[g]);
+          return this.getTypeInterface(p)._encodeRaw.call(
+            this,
+            u,
+            d,
+            y,
+            o
+          );
+        });
+      },
+      function(i, s, a) {
+        return i.readVec((o) => {
+          let u = s[0];
+          if (!u)
+            throw new Error(`Incorrect number of type parameters passed to a vector '${e}'`);
+          let { name: d, params: l } = this.parseTypeName(u);
+          if (this.hasType(d))
+            return this.getTypeInterface(d)._decodeRaw.call(this, o, l, a);
+          if (!(d in a))
+            throw new Error(
+              `Unable to find a matching type definition for ${d} in vector; make sure you passed a generic`
+            );
+          let { name: g, params: m } = this.parseTypeName(a[d]);
+          return this.getTypeInterface(g)._decodeRaw.call(
+            this,
+            o,
+            m,
+            a
+          );
+        });
+      }
+    );
+  }
+  /**
+   * Safe method to register a custom Move struct. The first argument is a name of the
+   * struct which is only used on the FrontEnd and has no affect on serialization results,
+   * and the second is a struct description passed as an Object.
+   *
+   * The description object MUST have the same order on all of the platforms (ie in Move
+   * or in Rust).
+   *
+   * @example
+   * // Move / Rust struct
+   * // struct Coin {
+   * //   value: u64,
+   * //   owner: vector<u8>, // name // Vec<u8> in Rust
+   * //   is_locked: bool,
+   * // }
+   *
+   * bcs.registerStructType('Coin', {
+   *   value: bcs.U64,
+   *   owner: bcs.STRING,
+   *   is_locked: bcs.BOOL
+   * });
+   *
+   * // Created in Rust with diem/bcs
+   * // let rust_bcs_str = '80d1b105600000000e4269672057616c6c65742047757900';
+   * let rust_bcs_str = [ // using an Array here as BCS works with Uint8Array
+   *  128, 209, 177,   5,  96,  0,  0,
+   *    0,  14,  66, 105, 103, 32, 87,
+   *   97, 108, 108, 101, 116, 32, 71,
+   *  117, 121,   0
+   * ];
+   *
+   * // Let's encode the value as well
+   * let test_set = bcs.ser('Coin', {
+   *   owner: 'Big Wallet Guy',
+   *   value: '412412400000',
+   *   is_locked: false,
+   * });
+   *
+   * console.assert(Array.from(test_set.toBytes()) === rust_bcs_str, 'Whoopsie, result mismatch');
+   *
+   * @param name Name of the type to register.
+   * @param fields Fields of the struct. Must be in the correct order.
+   * @return Returns BCS for chaining.
+   */
+  registerStructType(e, t) {
+    for (let a in t) {
+      let o = this.tempKey(), u = t[a];
+      !Array.isArray(u) && typeof u != "string" && (t[a] = o, this.registerStructType(o, u));
+    }
+    let r = Object.freeze(t), n = Object.keys(r), { name: i, params: s } = this.parseTypeName(e);
+    return this.registerType(
+      e,
+      function(o, u, d, l) {
+        if (!u || u.constructor !== Object)
+          throw new Error(`Expected ${i} to be an Object, got: ${u}`);
+        if (d.length !== s.length)
+          throw new Error(
+            `Incorrect number of generic parameters passed; expected: ${s.length}, got: ${d.length}`
+          );
+        for (let g of n) {
+          if (!(g in u))
+            throw new Error(`Struct ${i} requires field ${g}:${r[g]}`);
+          const { name: m, params: p } = this.parseTypeName(
+            r[g]
+          );
+          if (!s.includes(m))
+            this.getTypeInterface(m)._encodeRaw.call(
+              this,
+              o,
+              u[g],
+              p,
+              l
+            );
+          else {
+            const y = s.indexOf(m);
+            let { name: S, params: E } = this.parseTypeName(d[y]);
+            if (this.hasType(S)) {
+              this.getTypeInterface(S)._encodeRaw.call(
+                this,
+                o,
+                u[g],
+                E,
+                l
+              );
+              continue;
+            }
+            if (!(S in l))
+              throw new Error(
+                `Unable to find a matching type definition for ${S} in ${i}; make sure you passed a generic`
+              );
+            let { name: A, params: _ } = this.parseTypeName(l[S]);
+            this.getTypeInterface(A)._encodeRaw.call(
+              this,
+              o,
+              u[g],
+              _,
+              l
+            );
+          }
+        }
+        return o;
+      },
+      function(o, u, d) {
+        if (u.length !== s.length)
+          throw new Error(
+            `Incorrect number of generic parameters passed; expected: ${s.length}, got: ${u.length}`
+          );
+        let l = {};
+        for (let g of n) {
+          const { name: m, params: p } = this.parseTypeName(
+            r[g]
+          );
+          if (!s.includes(m))
+            l[g] = this.getTypeInterface(m)._decodeRaw.call(
+              this,
+              o,
+              p,
+              d
+            );
+          else {
+            const y = s.indexOf(m);
+            let { name: S, params: E } = this.parseTypeName(u[y]);
+            if (this.hasType(S)) {
+              l[g] = this.getTypeInterface(S)._decodeRaw.call(
+                this,
+                o,
+                E,
+                d
+              );
+              continue;
+            }
+            if (!(S in d))
+              throw new Error(
+                `Unable to find a matching type definition for ${S} in ${i}; make sure you passed a generic`
+              );
+            let { name: A, params: _ } = this.parseTypeName(d[S]);
+            l[g] = this.getTypeInterface(A)._decodeRaw.call(
+              this,
+              o,
+              _,
+              d
+            );
+          }
+        }
+        return l;
+      }
+    );
+  }
+  /**
+   * Safe method to register custom enum type where each invariant holds the value of another type.
+   * @example
+   * bcs.registerStructType('Coin', { value: 'u64' });
+   * bcs.registerEnumType('MyEnum', {
+   *  single: 'Coin',
+   *  multi: 'vector<Coin>',
+   *  empty: null
+   * });
+   *
+   * console.log(
+   *  bcs.de('MyEnum', 'AICWmAAAAAAA', 'base64'), // { single: { value: 10000000 } }
+   *  bcs.de('MyEnum', 'AQIBAAAAAAAAAAIAAAAAAAAA', 'base64')  // { multi: [ { value: 1 }, { value: 2 } ] }
+   * )
+   *
+   * // and serialization
+   * bcs.ser('MyEnum', { single: { value: 10000000 } }).toBytes();
+   * bcs.ser('MyEnum', { multi: [ { value: 1 }, { value: 2 } ] });
+   *
+   * @param name
+   * @param variants
+   */
+  registerEnumType(e, t) {
+    for (let a in t) {
+      let o = this.tempKey(), u = t[a];
+      u !== null && !Array.isArray(u) && typeof u != "string" && (t[a] = o, this.registerStructType(o, u));
+    }
+    let r = Object.freeze(t), n = Object.keys(r), { name: i, params: s } = this.parseTypeName(e);
+    return this.registerType(
+      e,
+      function(o, u, d, l) {
+        if (!u)
+          throw new Error(`Unable to write enum "${i}", missing data.
+Received: "${u}"`);
+        if (typeof u != "object")
+          throw new Error(
+            `Incorrect data passed into enum "${i}", expected object with properties: "${n.join(
+              " | "
+            )}".
+Received: "${JSON.stringify(u)}"`
+          );
+        let g = Object.keys(u)[0];
+        if (g === void 0)
+          throw new Error(`Empty object passed as invariant of the enum "${i}"`);
+        let m = n.indexOf(g);
+        if (m === -1)
+          throw new Error(
+            `Unknown invariant of the enum "${i}", allowed values: "${n.join(
+              " | "
+            )}"; received "${g}"`
+          );
+        let p = n[m], y = r[p];
+        if (o.write8(m), y === null)
+          return o;
+        let S = s.indexOf(y), E = S === -1 ? y : d[S];
+        {
+          let { name: A, params: _ } = this.parseTypeName(E);
+          return this.getTypeInterface(A)._encodeRaw.call(
+            this,
+            o,
+            u[g],
+            _,
+            l
+          );
+        }
+      },
+      function(o, u, d) {
+        let l = o.readULEB(), g = n[l], m = r[g];
+        if (l === -1)
+          throw new Error(
+            `Decoding type mismatch, expected enum "${i}" invariant index, received "${l}"`
+          );
+        if (m === null)
+          return { [g]: !0 };
+        let p = s.indexOf(m), y = p === -1 ? m : u[p];
+        {
+          let { name: S, params: E } = this.parseTypeName(y);
+          return {
+            [g]: this.getTypeInterface(S)._decodeRaw.call(this, o, E, d)
+          };
+        }
+      }
+    );
+  }
+  /**
+   * Get a set of encoders/decoders for specific type.
+   * Mainly used to define custom type de/serialization logic.
+   *
+   * @param type
+   * @returns {TypeInterface}
+   */
+  getTypeInterface(e) {
+    let t = this.types.get(e);
+    if (typeof t == "string") {
+      let r = [];
+      for (; typeof t == "string"; ) {
+        if (r.includes(t))
+          throw new Error(`Recursive definition found: ${r.join(" -> ")} -> ${t}`);
+        r.push(t), t = this.types.get(t);
+      }
+    }
+    if (t === void 0)
+      throw new Error(`Type ${e} is not registered`);
+    return t;
+  }
+  /**
+   * Parse a type name and get the type's generics.
+   * @example
+   * let { typeName, typeParams } = parseTypeName('Option<Coin<SUI>>');
+   * // typeName: Option
+   * // typeParams: [ 'Coin<SUI>' ]
+   *
+   * @param name Name of the type to process
+   * @returns Object with typeName and typeParams listed as Array
+   */
+  parseTypeName(e) {
+    if (Array.isArray(e)) {
+      let [o, ...u] = e;
+      return { name: o, params: u };
+    }
+    if (typeof e != "string")
+      throw new Error(`Illegal type passed as a name of the type: ${e}`);
+    let [t, r] = this.schema.genericSeparators || ["<", ">"], n = e.indexOf(t), i = Array.from(e).reverse().indexOf(r);
+    if (n === -1 && i === -1)
+      return { name: e, params: [] };
+    if (n === -1 || i === -1)
+      throw new Error(`Unclosed generic in name '${e}'`);
+    let s = e.slice(0, n), a = rr(
+      e.slice(n + 1, e.length - i - 1),
+      this.schema.genericSeparators
+    );
+    return { name: s, params: a };
+  }
+};
+let j = pe;
+j.U8 = "u8";
+j.U16 = "u16";
+j.U32 = "u32";
+j.U64 = "u64";
+j.U128 = "u128";
+j.U256 = "u256";
+j.BOOL = "bool";
+j.VECTOR = "vector";
+j.ADDRESS = "address";
+j.STRING = "string";
+j.HEX = "hex-string";
+j.BASE58 = "base58-string";
+j.BASE64 = "base64-string";
+function En(e) {
+  e.registerType(
+    j.U8,
+    function(t, r) {
+      return t.write8(r);
+    },
+    function(t) {
+      return t.read8();
+    },
+    (t) => t < 256
+  ), e.registerType(
+    j.U16,
+    function(t, r) {
+      return t.write16(r);
+    },
+    function(t) {
+      return t.read16();
+    },
+    (t) => t < 65536
+  ), e.registerType(
+    j.U32,
+    function(t, r) {
+      return t.write32(r);
+    },
+    function(t) {
+      return t.read32();
+    },
+    (t) => t <= 4294967296n
+  ), e.registerType(
+    j.U64,
+    function(t, r) {
+      return t.write64(r);
+    },
+    function(t) {
+      return t.read64();
+    }
+  ), e.registerType(
+    j.U128,
+    function(t, r) {
+      return t.write128(r);
+    },
+    function(t) {
+      return t.read128();
+    }
+  ), e.registerType(
+    j.U256,
+    function(t, r) {
+      return t.write256(r);
+    },
+    function(t) {
+      return t.read256();
+    }
+  ), e.registerType(
+    j.BOOL,
+    function(t, r) {
+      return t.write8(r);
+    },
+    function(t) {
+      return t.read8().toString(10) === "1";
+    }
+  ), e.registerType(
+    j.STRING,
+    function(t, r) {
+      return t.writeVec(Array.from(r), (n, i) => n.write8(i.charCodeAt(0)));
+    },
+    function(t) {
+      return t.readVec((r) => r.read8()).map((r) => String.fromCharCode(Number(r))).join("");
+    },
+    (t) => !0
+  ), e.registerType(
+    j.HEX,
+    function(t, r) {
+      return t.writeVec(Array.from(Ve(r)), (n, i) => n.write8(i));
+    },
+    function(t) {
+      let r = t.readVec((n) => n.read8());
+      return je(new Uint8Array(r));
+    }
+  ), e.registerType(
+    j.BASE58,
+    function(t, r) {
+      return t.writeVec(Array.from(ot(r)), (n, i) => n.write8(i));
+    },
+    function(t) {
+      let r = t.readVec((n) => n.read8());
+      return xe(new Uint8Array(r));
+    }
+  ), e.registerType(
+    j.BASE64,
+    function(t, r) {
+      return t.writeVec(Array.from(ae(r)), (n, i) => n.write8(i));
+    },
+    function(t) {
+      let r = t.readVec((n) => n.read8());
+      return Ie(new Uint8Array(r));
+    }
+  );
+}
+function xn() {
+  return {
+    genericSeparators: ["<", ">"],
+    vectorType: "vector",
+    addressLength: vn,
+    addressEncoding: "hex"
+  };
+}
+const dt = 32;
+function In(e) {
+  return jn(e) && On(e) === dt;
+}
+function M(e, t = !1) {
+  let r = e.toLowerCase();
+  return !t && r.startsWith("0x") && (r = r.slice(2)), `0x${r.padStart(dt * 2, "0")}`;
+}
+function be(e, t = !1) {
+  return M(e, t);
+}
+function jn(e) {
+  return /^(0x|0X)?[a-fA-F0-9]+$/.test(e) && e.length % 2 === 0;
+}
+function On(e) {
+  return /^(0x|0X)/.test(e) ? (e.length - 2) / 2 : e.length / 2;
+}
+BigInt(1e9);
+const ft = "0x1", or = "0x2";
+be("0x6");
+const An = `${or}::sui::SUI`;
+be("0x5");
+const kn = "object", _n = "ID", Cn = "ascii", $n = "String", Mn = "string", Un = "String", Bn = "option", Rn = "Option", Nn = {
+  address: or,
+  module: kn,
+  name: _n
+}, Pn = {
+  address: ft,
+  module: Cn,
+  name: $n
+}, Dn = {
+  address: ft,
+  module: Mn,
+  name: Un
+}, zn = {
+  address: ft,
+  module: Bn,
+  name: Rn
+}, Ae = (e, t) => e.address === t.address && e.module === t.module && e.name === t.name;
+function Vn(e) {
+  var r;
+  const t = (r = at(e)) == null ? void 0 : r.Struct;
+  return (t == null ? void 0 : t.address) === "0x2" && (t == null ? void 0 : t.module) === "tx_context" && (t == null ? void 0 : t.name) === "TxContext";
+}
+function Je(e, t) {
+  if (!(typeof t > "u") && typeof t !== e)
+    throw new Error(`Expect ${t} to be ${e}, received ${typeof t}`);
+}
+const Gn = ["Address", "Bool", "U8", "U16", "U32", "U64", "U128", "U256"];
+function Qe(e, t) {
+  if (typeof e == "string" && Gn.includes(e)) {
+    if (e in ["U8", "U16", "U32", "U64", "U128", "U256"])
+      Je("number", t);
+    else if (e === "Bool")
+      Je("boolean", t);
+    else if (e === "Address" && (Je("string", t), t && !In(t)))
+      throw new Error("Invalid Sui Address");
+    return e.toLowerCase();
+  } else if (typeof e == "string")
+    throw new Error(`Unknown pure normalized type ${JSON.stringify(e, null, 2)}`);
+  if ("Vector" in e) {
+    if ((t === void 0 || typeof t == "string") && e.Vector === "U8")
+      return "string";
+    if (t !== void 0 && !Array.isArray(t))
+      throw new Error(`Expect ${t} to be a array, received ${typeof t}`);
+    const r = Qe(
+      e.Vector,
+      // undefined when argVal is empty
+      t ? t[0] : void 0
+    );
+    return r === void 0 ? void 0 : `vector<${r}>`;
+  }
+  if ("Struct" in e) {
+    if (Ae(e.Struct, Pn))
+      return "string";
+    if (Ae(e.Struct, Dn))
+      return "utf8string";
+    if (Ae(e.Struct, Nn))
+      return "address";
+    if (Ae(e.Struct, zn)) {
+      const r = {
+        Vector: e.Struct.typeArguments[0]
+      };
+      return Qe(r, t);
+    }
+  }
+}
+const Fn = /^vector<(.+)>$/, Ln = /^([^:]+)::([^:]+)::([^<]+)(<(.+)>)?/;
+class ee {
+  static parseFromStr(t, r = !1) {
+    if (t === "address")
+      return { address: null };
+    if (t === "bool")
+      return { bool: null };
+    if (t === "u8")
+      return { u8: null };
+    if (t === "u16")
+      return { u16: null };
+    if (t === "u32")
+      return { u32: null };
+    if (t === "u64")
+      return { u64: null };
+    if (t === "u128")
+      return { u128: null };
+    if (t === "u256")
+      return { u256: null };
+    if (t === "signer")
+      return { signer: null };
+    const n = t.match(Fn);
+    if (n)
+      return {
+        vector: ee.parseFromStr(n[1], r)
+      };
+    const i = t.match(Ln);
+    if (i)
+      return {
+        struct: {
+          address: r ? M(i[1]) : i[1],
+          module: i[2],
+          name: i[3],
+          typeParams: i[5] === void 0 ? [] : ee.parseStructTypeArgs(i[5], r)
+        }
+      };
+    throw new Error(`Encountered unexpected token when parsing type args for ${t}`);
+  }
+  static parseStructTypeArgs(t, r = !1) {
+    return rr(t).map(
+      (n) => ee.parseFromStr(n, r)
+    );
+  }
+  static tagToString(t) {
+    if ("bool" in t)
+      return "bool";
+    if ("u8" in t)
+      return "u8";
+    if ("u16" in t)
+      return "u16";
+    if ("u32" in t)
+      return "u32";
+    if ("u64" in t)
+      return "u64";
+    if ("u128" in t)
+      return "u128";
+    if ("u256" in t)
+      return "u256";
+    if ("address" in t)
+      return "address";
+    if ("signer" in t)
+      return "signer";
+    if ("vector" in t)
+      return `vector<${ee.tagToString(t.vector)}>`;
+    if ("struct" in t) {
+      const r = t.struct, n = r.typeParams.map(ee.tagToString).join(", ");
+      return `${r.address}::${r.module}::${r.name}${n ? `<${n}>` : ""}`;
+    }
+    throw new Error("Invalid TypeTag");
+  }
+}
+const I = new j({
+  ...xn(),
+  types: {
+    enums: {
+      "Option<T>": {
+        None: null,
+        Some: "T"
+      }
+    }
+  }
+});
+function cr(e) {
+  return c.u64({
+    name: "unsafe_u64",
+    ...e
+  }).transform({
+    input: (t) => t,
+    output: (t) => Number(t)
+  });
+}
+function Kn(e) {
+  return c.enum("Option", {
+    None: null,
+    Some: e
+  });
+}
+function lt(e) {
+  return e.transform({
+    input: (t) => ({
+      [t.kind]: t
+    }),
+    output: (t) => {
+      const r = Object.keys(t)[0];
+      return { kind: r, ...t[r] };
+    }
+  });
+}
+const J = c.bytes(dt).transform({
+  input: (e) => typeof e == "string" ? Ve(M(e)) : e,
+  output: (e) => M(je(e))
+}), ht = c.vector(c.u8()).transform({
+  name: "ObjectDigest",
+  input: (e) => ot(e),
+  output: (e) => xe(new Uint8Array(e))
+}), Se = c.struct("SuiObjectRef", {
+  objectId: J,
+  version: c.u64(),
+  digest: ht
+}), gt = c.struct("SharedObjectRef", {
+  objectId: J,
+  initialSharedVersion: c.u64(),
+  mutable: c.bool()
+}), Pe = c.enum("ObjectArg", {
+  ImmOrOwned: Se,
+  Shared: gt,
+  Receiving: Se
+}), pt = c.enum("CallArg", {
+  Pure: c.vector(c.u8()),
+  Object: Pe,
+  ObjVec: c.vector(Pe)
+}), he = c.enum("TypeTag", {
+  bool: null,
+  u8: null,
+  u64: null,
+  u128: null,
+  address: null,
+  signer: null,
+  vector: c.lazy(() => he),
+  struct: c.lazy(() => Tt),
+  u16: null,
+  u32: null,
+  u256: null
+}), L = lt(
+  c.enum("Argument", {
+    GasCoin: null,
+    Input: c.struct("Input", { index: c.u16() }),
+    Result: c.struct("Result", { index: c.u16() }),
+    NestedResult: c.struct("NestedResult", { index: c.u16(), resultIndex: c.u16() })
+  })
+), mt = c.struct("ProgrammableMoveCall", {
+  package: J,
+  module: c.string(),
+  function: c.string(),
+  type_arguments: c.vector(he),
+  arguments: c.vector(L)
+}).transform({
+  input: (e) => {
+    const [t, r, n] = e.target.split("::"), i = e.typeArguments.map(
+      (s) => ee.parseFromStr(s, !0)
+    );
+    return {
+      package: M(t),
+      module: r,
+      function: n,
+      type_arguments: i,
+      arguments: e.arguments
+    };
+  },
+  output: (e) => ({
+    target: [e.package, e.module, e.function].join(
+      "::"
+    ),
+    arguments: e.arguments,
+    typeArguments: e.type_arguments.map(ee.tagToString)
+  })
+}), yt = lt(
+  c.enum("Transaction", {
+    /**
+     * A Move Call - any public Move function can be called via
+     * this transaction. The results can be used that instant to pass
+     * into the next transaction.
+     */
+    MoveCall: mt,
+    /**
+     * Transfer vector of objects to a receiver.
+     */
+    TransferObjects: c.struct("TransferObjects", {
+      objects: c.vector(L),
+      address: L
+    }),
+    /**
+     * Split `amount` from a `coin`.
+     */
+    SplitCoins: c.struct("SplitCoins", { coin: L, amounts: c.vector(L) }),
+    /**
+     * Merge Vector of Coins (`sources`) into a `destination`.
+     */
+    MergeCoins: c.struct("MergeCoins", { destination: L, sources: c.vector(L) }),
+    /**
+     * Publish a Move module.
+     */
+    Publish: c.struct("Publish", {
+      modules: c.vector(c.vector(c.u8())),
+      dependencies: c.vector(J)
+    }),
+    /**
+     * Build a vector of objects using the input arguments.
+     * It is impossible to construct a `vector<T: key>` otherwise,
+     * so this call serves a utility function.
+     */
+    MakeMoveVec: c.struct("MakeMoveVec", {
+      type: Kn(he),
+      objects: c.vector(L)
+    }),
+    /**  */
+    Upgrade: c.struct("Upgrade", {
+      modules: c.vector(c.vector(c.u8())),
+      dependencies: c.vector(J),
+      packageId: J,
+      ticket: L
+    })
+  })
+), wt = c.struct("ProgrammableTransaction", {
+  inputs: c.vector(pt),
+  transactions: c.vector(yt)
+}), bt = c.enum("TransactionKind", {
+  ProgrammableTransaction: wt,
+  ChangeEpoch: null,
+  Genesis: null,
+  ConsensusCommitPrologue: null
+}), St = c.enum("TransactionExpiration", {
+  None: null,
+  Epoch: cr()
+}), Tt = c.struct("StructTag", {
+  address: J,
+  module: c.string(),
+  name: c.string(),
+  typeParams: c.vector(he)
+}), vt = c.struct("GasData", {
+  payment: c.vector(Se),
+  owner: J,
+  price: c.u64(),
+  budget: c.u64()
+}), Et = c.struct("TransactionDataV1", {
+  kind: bt,
+  sender: J,
+  gasData: vt,
+  expiration: St
+}), xt = c.enum("TransactionData", {
+  V1: Et
+}), Wn = c.enum("IntentScope", {
+  TransactionData: null,
+  TransactionEffects: null,
+  CheckpointSummary: null,
+  PersonalMessage: null
+}), Jn = c.enum("IntentVersion", {
+  V0: null
+}), Hn = c.enum("AppId", {
+  Sui: null
+}), Xn = c.struct("Intent", {
+  scope: Wn,
+  version: Jn,
+  appId: Hn
+}), qn = c.generic(
+  ["T"],
+  (e) => c.struct("IntentMessage<T>", {
+    intent: Xn,
+    value: e
+  })
+), It = c.enum("CompressedSignature", {
+  ED25519: c.fixedArray(64, c.u8()),
+  Secp256k1: c.fixedArray(64, c.u8()),
+  Secp256r1: c.fixedArray(64, c.u8()),
+  ZkLogin: c.vector(c.u8())
+}), jt = c.enum("PublicKey", {
+  ED25519: c.fixedArray(32, c.u8()),
+  Secp256k1: c.fixedArray(33, c.u8()),
+  Secp256r1: c.fixedArray(33, c.u8()),
+  ZkLogin: c.vector(c.u8())
+}), Ot = c.struct("MultiSigPkMap", {
+  pubKey: jt,
+  weight: c.u8()
+}), At = c.struct("MultiSigPublicKey", {
+  pk_map: c.vector(Ot),
+  threshold: c.u16()
+}), ur = c.struct("MultiSig", {
+  sigs: c.vector(It),
+  bitmap: c.u16(),
+  multisig_pk: At
+}), Zn = c.vector(c.u8()).transform({
+  input: (e) => typeof e == "string" ? ae(e) : e,
+  output: (e) => Ie(new Uint8Array(e))
+}), dr = c.struct("SenderSignedTransaction", {
+  intentMessage: qn(xt),
+  txSignatures: c.vector(Zn)
+}), fr = c.vector(dr, {
+  name: "SenderSignedData"
+}), C = {
+  ...c,
+  U8: c.u8(),
+  U16: c.u16(),
+  U32: c.u32(),
+  U64: c.u64(),
+  U128: c.u128(),
+  U256: c.u256(),
+  ULEB128: c.uleb128(),
+  Bool: c.bool(),
+  String: c.string(),
+  Address: J,
+  Argument: L,
+  CallArg: pt,
+  CompressedSignature: It,
+  GasData: vt,
+  MultiSig: ur,
+  MultiSigPkMap: Ot,
+  MultiSigPublicKey: At,
+  ObjectArg: Pe,
+  ObjectDigest: ht,
+  ProgrammableMoveCall: mt,
+  ProgrammableTransaction: wt,
+  PublicKey: jt,
+  SenderSignedData: fr,
+  SenderSignedTransaction: dr,
+  SharedObjectRef: gt,
+  StructTag: Tt,
+  SuiObjectRef: Se,
+  Transaction: yt,
+  TransactionData: xt,
+  TransactionDataV1: Et,
+  TransactionExpiration: St,
+  TransactionKind: bt,
+  TypeTag: he,
+  // preserve backwards compatibility with old bcs export
+  ser: I.ser.bind(I),
+  de: I.de.bind(I),
+  getTypeInterface: I.getTypeInterface.bind(I),
+  hasType: I.hasType.bind(I),
+  parseTypeName: I.parseTypeName.bind(I),
+  registerAddressType: I.registerAddressType.bind(I),
+  registerAlias: I.registerAlias.bind(I),
+  registerBcsType: I.registerBcsType.bind(I),
+  registerEnumType: I.registerEnumType.bind(I),
+  registerStructType: I.registerStructType.bind(I),
+  registerType: I.registerType.bind(I),
+  types: I.types
+};
+I.registerBcsType("utf8string", () => c.string({ name: "utf8string" }));
+I.registerBcsType("unsafe_u64", () => cr());
+I.registerBcsType("enumKind", (e) => lt(e));
+[
+  J,
+  L,
+  pt,
+  It,
+  vt,
+  ur,
+  Ot,
+  At,
+  Pe,
+  ht,
+  mt,
+  wt,
+  jt,
+  fr,
+  gt,
+  Tt,
+  Se,
+  yt,
+  xt,
+  Et,
+  St,
+  bt,
+  he
+].forEach((e) => {
+  I.registerBcsType(e.name, () => e);
+});
+const Yn = k([
+  h({ ImmOrOwned: se }),
+  h({
+    Shared: h({
+      objectId: f(),
+      initialSharedVersion: k([q(), f()]),
+      mutable: U()
+    })
+  }),
+  h({ Receiving: se })
+]), De = h({ Pure: v(q()) }), et = h({ Object: Yn }), ze = k([De, et]);
+function Qn(e, t) {
+  return {
+    Pure: Array.from(
+      e instanceof Uint8Array ? e : ut(e) ? e.toBytes() : (
+        // NOTE: We explicitly set this to be growable to infinity, because we have maxSize validation at the builder-level:
+        C.ser(t, e, { maxSize: 1 / 0 }).toBytes()
+      )
+    )
+  };
+}
+const R = {
+  Pure: Qn,
+  ObjectRef({ objectId: e, digest: t, version: r }) {
+    return {
+      Object: {
+        ImmOrOwned: {
+          digest: t,
+          version: r,
+          objectId: M(e)
+        }
+      }
+    };
+  },
+  SharedObjectRef({ objectId: e, mutable: t, initialSharedVersion: r }) {
+    return {
+      Object: {
+        Shared: {
+          mutable: t,
+          initialSharedVersion: r,
+          objectId: M(e)
+        }
+      }
+    };
+  },
+  ReceivingRef({ objectId: e, digest: t, version: r }) {
+    return {
+      Object: {
+        Receiving: {
+          digest: t,
+          version: r,
+          objectId: M(e)
+        }
+      }
+    };
+  }
+};
+function Vt(e) {
+  return typeof e == "string" ? M(e) : "ImmOrOwned" in e.Object ? M(e.Object.ImmOrOwned.objectId) : "Receiving" in e.Object ? M(e.Object.Receiving.objectId) : M(e.Object.Shared.objectId);
+}
+function ei(e) {
+  return typeof e == "object" && "Object" in e && "Shared" in e.Object ? e.Object.Shared : void 0;
+}
+function ti(e) {
+  var t;
+  return ((t = ei(e)) == null ? void 0 : t.mutable) ?? !1;
+}
+function B(e, t) {
+  return Lt(e, t);
+}
+const ri = (e) => k([h({ None: k([b(!0), b(null)]) }), h({ Some: e })]), Te = k([
+  h({
+    kind: b("Input"),
+    index: q(),
+    value: w(Ze()),
+    type: w(b("object"))
+  }),
+  h({
+    kind: b("Input"),
+    index: q(),
+    value: w(Ze()),
+    type: b("pure")
+  })
+]), ni = [
+  Te,
+  h({ kind: b("GasCoin") }),
+  h({ kind: b("Result"), index: q() }),
+  h({
+    kind: b("NestedResult"),
+    index: q(),
+    resultIndex: q()
+  })
+], re = k([...ni]), lr = h({
+  kind: b("MoveCall"),
+  target: P("target", f().validator),
+  typeArguments: v(f()),
+  arguments: v(re)
+}), hr = h({
+  kind: b("TransferObjects"),
+  objects: v(re),
+  address: re
+}), gr = h({
+  kind: b("SplitCoins"),
+  coin: re,
+  amounts: v(re)
+}), pr = h({
+  kind: b("MergeCoins"),
+  destination: re,
+  sources: v(re)
+}), mr = h({
+  kind: b("MakeMoveVec"),
+  // TODO: ideally we should use `TypeTag` instead of `record()` here,
+  // but TypeTag is recursively defined and it's tricky to define a
+  // recursive struct in superstruct
+  type: w(ri(H(f(), Ht()))),
+  objects: v(re)
+}), yr = h({
+  kind: b("Publish"),
+  modules: v(v(q())),
+  dependencies: v(f())
+}), wr = h({
+  kind: b("Upgrade"),
+  modules: v(v(q())),
+  dependencies: v(f()),
+  packageId: f(),
+  ticket: re
+}), ii = [
+  lr,
+  hr,
+  gr,
+  pr,
+  yr,
+  wr,
+  mr
+], si = k([...ii]), ce = {
+  MoveCall(e) {
+    return B(
+      {
+        kind: "MoveCall",
+        target: e.target,
+        arguments: e.arguments ?? [],
+        typeArguments: e.typeArguments ?? []
+      },
+      lr
+    );
+  },
+  TransferObjects(e, t) {
+    return t.kind === "Input" && t.type === "pure" && typeof t.value != "object" && (t.value = R.Pure(C.Address.serialize(t.value))), B({ kind: "TransferObjects", objects: e, address: t }, hr);
+  },
+  SplitCoins(e, t) {
+    return t.forEach((r) => {
+      r.kind === "Input" && r.type === "pure" && typeof r.value != "object" && (r.value = R.Pure(C.U64.serialize(r.value)));
+    }), B(
+      {
+        kind: "SplitCoins",
+        coin: e,
+        amounts: t
+      },
+      gr
+    );
+  },
+  MergeCoins(e, t) {
+    return B({ kind: "MergeCoins", destination: e, sources: t }, pr);
+  },
+  Publish({
+    modules: e,
+    dependencies: t
+  }) {
+    return B(
+      {
+        kind: "Publish",
+        modules: e.map(
+          (r) => typeof r == "string" ? Array.from(ae(r)) : r
+        ),
+        dependencies: t.map((r) => be(r))
+      },
+      yr
+    );
+  },
+  Upgrade({
+    modules: e,
+    dependencies: t,
+    packageId: r,
+    ticket: n
+  }) {
+    return B(
+      {
+        kind: "Upgrade",
+        modules: e.map(
+          (i) => typeof i == "string" ? Array.from(ae(i)) : i
+        ),
+        dependencies: t.map((i) => be(i)),
+        packageId: r,
+        ticket: n
+      },
+      wr
+    );
+  },
+  MakeMoveVec({
+    type: e,
+    objects: t
+  }) {
+    return B(
+      {
+        kind: "MakeMoveVec",
+        type: e ? { Some: ee.parseFromStr(e) } : { None: null },
+        objects: t
+      },
+      mr
+    );
+  }
+};
+function ai(e) {
+  function t(r, n) {
+    return e(r, n);
+  }
+  return t.u8 = (r) => e(C.U8.serialize(r)), t.u16 = (r) => e(C.U16.serialize(r)), t.u32 = (r) => e(C.U32.serialize(r)), t.u64 = (r) => e(C.U64.serialize(r)), t.u128 = (r) => e(C.U128.serialize(r)), t.u256 = (r) => e(C.U256.serialize(r)), t.bool = (r) => e(C.Bool.serialize(r)), t.string = (r) => e(C.String.serialize(r)), t.address = (r) => e(C.Address.serialize(r)), t.id = t.address, t;
+}
+function oi(e, t) {
+  const r = Array.from(`${e}::`).map((i) => i.charCodeAt(0)), n = new Uint8Array(r.length + t.length);
+  return n.set(r), n.set(t, r.length), jr(n, { dkLen: 32 });
+}
+const ci = w(
+  O(
+    k([h({ Epoch: q() }), h({ None: k([b(!0), b(null)]) })])
+  )
+), Gt = P("StringEncodedBigint", (e) => {
+  if (!["string", "number", "bigint"].includes(typeof e))
+    return !1;
+  try {
+    return BigInt(e), !0;
+  } catch {
+    return !1;
+  }
+}), ui = h({
+  budget: w(Gt),
+  price: w(Gt),
+  payment: w(v(se)),
+  owner: w(f())
+}), ke = h({
+  version: b(1),
+  sender: w(f()),
+  expiration: ci,
+  gasConfig: ui,
+  inputs: v(Te),
+  transactions: v(si)
+});
+function Ft(e) {
+  return M(e).replace("0x", "");
+}
+class te {
+  constructor(t) {
+    this.version = 1, this.sender = t == null ? void 0 : t.sender, this.expiration = t == null ? void 0 : t.expiration, this.gasConfig = (t == null ? void 0 : t.gasConfig) ?? {}, this.inputs = (t == null ? void 0 : t.inputs) ?? [], this.transactions = (t == null ? void 0 : t.transactions) ?? [];
+  }
+  static fromKindBytes(t) {
+    const r = C.TransactionKind.parse(t), n = "ProgrammableTransaction" in r ? r.ProgrammableTransaction : null;
+    if (!n)
+      throw new Error("Unable to deserialize from bytes.");
+    const i = B(
+      {
+        version: 1,
+        gasConfig: {},
+        inputs: n.inputs.map(
+          (s, a) => B(
+            {
+              kind: "Input",
+              value: s,
+              index: a,
+              type: N(s, De) ? "pure" : "object"
+            },
+            Te
+          )
+        ),
+        transactions: n.transactions
+      },
+      ke
+    );
+    return te.restore(i);
+  }
+  static fromBytes(t) {
+    var a;
+    const r = C.TransactionData.parse(t), n = r == null ? void 0 : r.V1, i = "ProgrammableTransaction" in n.kind ? (a = n == null ? void 0 : n.kind) == null ? void 0 : a.ProgrammableTransaction : null;
+    if (!n || !i)
+      throw new Error("Unable to deserialize from bytes.");
+    const s = B(
+      {
+        version: 1,
+        sender: n.sender,
+        expiration: n.expiration,
+        gasConfig: n.gasData,
+        inputs: i.inputs.map(
+          (o, u) => B(
+            {
+              kind: "Input",
+              value: o,
+              index: u,
+              type: N(o, De) ? "pure" : "object"
+            },
+            Te
+          )
+        ),
+        transactions: i.transactions
+      },
+      ke
+    );
+    return te.restore(s);
+  }
+  static restore(t) {
+    qe(t, ke);
+    const r = new te();
+    return Object.assign(r, t), r;
+  }
+  /**
+   * Generate transaction digest.
+   *
+   * @param bytes BCS serialized transaction data
+   * @returns transaction digest.
+   */
+  static getDigestFromBytes(t) {
+    const r = oi("TransactionData", t);
+    return xe(r);
+  }
+  build({
+    maxSizeBytes: t = 1 / 0,
+    overrides: r,
+    onlyTransactionKind: n
+  } = {}) {
+    const i = this.inputs.map((l) => (qe(l.value, ze), l.value)), s = {
+      ProgrammableTransaction: {
+        inputs: i,
+        transactions: this.transactions
+      }
+    };
+    if (n)
+      return C.TransactionKind.serialize(s, { maxSize: t }).toBytes();
+    const a = (r == null ? void 0 : r.expiration) ?? this.expiration, o = (r == null ? void 0 : r.sender) ?? this.sender, u = { ...this.gasConfig, ...r == null ? void 0 : r.gasConfig };
+    if (!o)
+      throw new Error("Missing transaction sender");
+    if (!u.budget)
+      throw new Error("Missing gas budget");
+    if (!u.payment)
+      throw new Error("Missing gas payment");
+    if (!u.price)
+      throw new Error("Missing gas price");
+    const d = {
+      sender: Ft(o),
+      expiration: a || { None: !0 },
+      gasData: {
+        payment: u.payment,
+        owner: Ft(this.gasConfig.owner ?? o),
+        price: BigInt(u.price),
+        budget: BigInt(u.budget)
+      },
+      kind: {
+        ProgrammableTransaction: {
+          inputs: i,
+          transactions: this.transactions
+        }
+      }
+    };
+    return C.TransactionData.serialize(
+      { V1: d },
+      { maxSize: t }
+    ).toBytes();
+  }
+  getDigest() {
+    const t = this.build({ onlyTransactionKind: !1 });
+    return te.getDigestFromBytes(t);
+  }
+  snapshot() {
+    return B(this, ke);
+  }
+}
+var kt = (e, t, r) => {
+  if (!t.has(e))
+    throw TypeError("Cannot " + r);
+}, x = (e, t, r) => (kt(e, t, "read from private field"), r ? r.call(e) : t.get(e)), Q = (e, t, r) => {
+  if (t.has(e))
+    throw TypeError("Cannot add the same private member more than once");
+  t instanceof WeakSet ? t.add(e) : t.set(e, r);
+}, _e = (e, t, r, n) => (kt(e, t, "write to private field"), t.set(e, r), r), $ = (e, t, r) => (kt(e, t, "access private method"), r), T, me, $e, ye, Me, oe, de, _t, br, Ct, Sr, $t, Tr, Mt, vr, Ue, tt;
+const di = {
+  maxPureArgumentSize: 16 * 1024,
+  maxTxGas: 5e10,
+  maxGasObjects: 256,
+  maxTxSizeBytes: 128 * 1024
+};
+function fi(e) {
+  const t = { kind: "Result", index: e }, r = [], n = (i) => r[i] ?? (r[i] = {
+    kind: "NestedResult",
+    index: e,
+    resultIndex: i
+  });
+  return new Proxy(t, {
+    set() {
+      throw new Error(
+        "The transaction result is a proxy, and does not support setting properties directly"
+      );
+    },
+    // TODO: Instead of making this return a concrete argument, we should ideally
+    // make it reference-based (so that this gets resolved at build-time), which
+    // allows re-ordering transactions.
+    get(i, s) {
+      if (s in i)
+        return Reflect.get(i, s);
+      if (s === Symbol.iterator)
+        return function* () {
+          let o = 0;
+          for (; ; )
+            yield n(o), o++;
+        };
+      if (typeof s == "symbol")
+        return;
+      const a = parseInt(s, 10);
+      if (!(Number.isNaN(a) || a < 0))
+        return n(a);
+    }
+  });
+}
+function li(e) {
+  const t = at(e);
+  return t ? t.Struct.address === "0x2" && t.Struct.module === "transfer" && t.Struct.name === "Receiving" : !1;
+}
+function ve(e) {
+  if (!e.client)
+    throw new Error(
+      "No provider passed to Transaction#build, but transaction data was not sufficient to build offline."
+    );
+  return e.client;
+}
+const hi = Symbol.for("@mysten/transaction"), He = {
+  // The maximum gas that is allowed.
+  maxTxGas: "max_tx_gas",
+  // The maximum number of gas objects that can be selected for one transaction.
+  maxGasObjects: "max_gas_payment_objects",
+  // The maximum size (in bytes) that the transaction can be:
+  maxTxSizeBytes: "max_tx_size_bytes",
+  // The maximum size (in bytes) that pure arguments can be:
+  maxPureArgumentSize: "max_pure_argument_size"
+}, gi = 1000n, pi = 50, mi = (e, t) => Array.from(
+  { length: Math.ceil(e.length / t) },
+  (r, n) => e.slice(n * t, n * t + t)
+), rt = class {
+  constructor(e) {
+    Q(this, me), Q(this, ye), Q(this, oe), Q(this, _t), Q(this, Ct), Q(this, $t), Q(this, Mt), Q(this, Ue), Q(this, T, void 0), _e(this, T, new te(
+      e ? e.blockData : void 0
+    ));
+  }
+  /**
+   * Converts from a serialize transaction kind (built with `build({ onlyTransactionKind: true })`) to a `Transaction` class.
+   * Supports either a byte array, or base64-encoded bytes.
+   */
+  static fromKind(e) {
+    const t = new rt();
+    return _e(t, T, te.fromKindBytes(
+      typeof e == "string" ? ae(e) : e
+    )), t;
+  }
+  /**
+   * Converts from a serialized transaction format to a `Transaction` class.
+   * There are two supported serialized formats:
+   * - A string returned from `Transaction#serialize`. The serialized format must be compatible, or it will throw an error.
+   * - A byte array (or base64-encoded bytes) containing BCS transaction data.
+   */
+  static from(e) {
+    const t = new rt();
+    return typeof e != "string" || !e.startsWith("{") ? _e(t, T, te.fromBytes(
+      typeof e == "string" ? ae(e) : e
+    )) : _e(t, T, te.restore(JSON.parse(e))), t;
+  }
+  setSender(e) {
+    x(this, T).sender = e;
+  }
+  /**
+   * Sets the sender only if it has not already been set.
+   * This is useful for sponsored transaction flows where the sender may not be the same as the signer address.
+   */
+  setSenderIfNotSet(e) {
+    x(this, T).sender || (x(this, T).sender = e);
+  }
+  setExpiration(e) {
+    x(this, T).expiration = e;
+  }
+  setGasPrice(e) {
+    x(this, T).gasConfig.price = String(e);
+  }
+  setGasBudget(e) {
+    x(this, T).gasConfig.budget = String(e);
+  }
+  setGasOwner(e) {
+    x(this, T).gasConfig.owner = e;
+  }
+  setGasPayment(e) {
+    x(this, T).gasConfig.payment = e.map((t) => Kt(t, se));
+  }
+  /** Get a snapshot of the transaction data, in JSON form: */
+  get blockData() {
+    return x(this, T).snapshot();
+  }
+  // Used to brand transaction classes so that they can be identified, even between multiple copies
+  // of the builder.
+  get [hi]() {
+    return !0;
+  }
+  // Temporary workaround for the wallet interface accidentally serializing transaction blocks via postMessage
+  get pure() {
+    return Object.defineProperty(this, "pure", {
+      enumerable: !1,
+      value: ai((e, t) => ut(e) ? $(this, me, $e).call(this, "pure", {
+        Pure: Array.from(e.toBytes())
+      }) : $(this, me, $e).call(this, "pure", e instanceof Uint8Array ? R.Pure(e) : t ? R.Pure(e, t) : e))
+    }), this.pure;
+  }
+  /** Returns an argument for the gas coin, to be used in a transaction. */
+  get gas() {
+    return { kind: "GasCoin" };
+  }
+  /**
+   * Add a new object input to the transaction.
+   */
+  object(e) {
+    if (typeof e == "object" && "kind" in e)
+      return e;
+    const t = Vt(e), r = x(this, T).inputs.find(
+      (n) => n.type === "object" && t === Vt(n.value)
+    );
+    return r && N(r.value, et) && "Shared" in r.value.Object && N(e, et) && "Shared" in e.Object && (r.value.Object.Shared.mutable = r.value.Object.Shared.mutable || e.Object.Shared.mutable), r ?? $(this, me, $e).call(this, "object", typeof e == "string" ? M(e) : e);
+  }
+  /**
+   * Add a new object input to the transaction using the fully-resolved object reference.
+   * If you only have an object ID, use `builder.object(id)` instead.
+   */
+  objectRef(...e) {
+    return this.object(R.ObjectRef(...e));
+  }
+  /**
+   * Add a new receiving input to the transaction using the fully-resolved object reference.
+   * If you only have an object ID, use `builder.object(id)` instead.
+   */
+  receivingRef(...e) {
+    return this.object(R.ReceivingRef(...e));
+  }
+  /**
+   * Add a new shared object input to the transaction using the fully-resolved shared object reference.
+   * If you only have an object ID, use `builder.object(id)` instead.
+   */
+  sharedObjectRef(...e) {
+    return this.object(R.SharedObjectRef(...e));
+  }
+  /** Add a transaction to the transaction block. */
+  add(e) {
+    const t = x(this, T).transactions.push(e);
+    return fi(t - 1);
+  }
+  // Method shorthands:
+  splitCoins(e, t) {
+    return this.add(
+      ce.SplitCoins(
+        typeof e == "string" ? this.object(e) : e,
+        t.map(
+          (r) => typeof r == "number" || typeof r == "bigint" || typeof r == "string" ? this.pure.u64(r) : $(this, ye, Me).call(this, r)
+        )
+      )
+    );
+  }
+  mergeCoins(e, t) {
+    return this.add(
+      ce.MergeCoins(
+        typeof e == "string" ? this.object(e) : e,
+        t.map((r) => typeof r == "string" ? this.object(r) : r)
+      )
+    );
+  }
+  publish({ modules: e, dependencies: t }) {
+    return this.add(
+      ce.Publish({
+        modules: e,
+        dependencies: t
+      })
+    );
+  }
+  upgrade({
+    modules: e,
+    dependencies: t,
+    packageId: r,
+    ticket: n
+  }) {
+    return this.add(
+      ce.Upgrade({
+        modules: e,
+        dependencies: t,
+        packageId: r,
+        ticket: typeof n == "string" ? this.object(n) : n
+      })
+    );
+  }
+  moveCall({
+    arguments: e,
+    typeArguments: t,
+    target: r
+  }) {
+    return this.add(
+      ce.MoveCall({
+        arguments: e == null ? void 0 : e.map((n) => $(this, ye, Me).call(this, n)),
+        typeArguments: t,
+        target: r
+      })
+    );
+  }
+  transferObjects(e, t) {
+    return this.add(
+      ce.TransferObjects(
+        e.map((r) => typeof r == "string" ? this.object(r) : r),
+        typeof t == "string" ? this.pure.address(t) : $(this, ye, Me).call(this, t)
+      )
+    );
+  }
+  makeMoveVec({
+    type: e,
+    objects: t
+  }) {
+    return this.add(
+      ce.MakeMoveVec({
+        type: e,
+        objects: t.map((r) => typeof r == "string" ? this.object(r) : r)
+      })
+    );
+  }
+  /**
+   * Serialize the transaction to a string so that it can be sent to a separate context.
+   * This is different from `build` in that it does not serialize to BCS bytes, and instead
+   * uses a separate format that is unique to the transaction builder. This allows
+   * us to serialize partially-complete transactions, that can then be completed and
+   * built in a separate context.
+   *
+   * For example, a dapp can construct a transaction, but not provide gas objects
+   * or a gas budget. The transaction then can be sent to the wallet, where this
+   * information is automatically filled in (e.g. by querying for coin objects
+   * and performing a dry run).
+   */
+  serialize() {
+    return JSON.stringify(x(this, T).snapshot());
+  }
+  /** Build the transaction to BCS bytes, and sign it with the provided keypair. */
+  async sign(e) {
+    const { signer: t, ...r } = e, n = await this.build(r);
+    return t.signTransactionBlock(n);
+  }
+  /** Build the transaction to BCS bytes. */
+  async build(e = {}) {
+    return await $(this, Ue, tt).call(this, e), x(this, T).build({
+      maxSizeBytes: $(this, oe, de).call(this, "maxTxSizeBytes", e),
+      onlyTransactionKind: e.onlyTransactionKind
+    });
+  }
+  /** Derive transaction digest */
+  async getDigest(e = {}) {
+    return await $(this, Ue, tt).call(this, e), x(this, T).getDigest();
+  }
+};
+let Xe = rt;
+T = /* @__PURE__ */ new WeakMap();
+me = /* @__PURE__ */ new WeakSet();
+$e = function(e, t) {
+  const r = x(this, T).inputs.length, n = B(
+    {
+      kind: "Input",
+      // bigints can't be serialized to JSON, so just string-convert them here:
+      value: typeof t == "bigint" ? String(t) : t,
+      index: r,
+      type: e
+    },
+    Te
+  );
+  return x(this, T).inputs.push(n), n;
+};
+ye = /* @__PURE__ */ new WeakSet();
+Me = function(e) {
+  return ut(e) ? this.pure(e) : e;
+};
+oe = /* @__PURE__ */ new WeakSet();
+de = function(e, { protocolConfig: t, limits: r }) {
+  if (r && typeof r[e] == "number")
+    return r[e];
+  if (!t)
+    return di[e];
+  const n = t == null ? void 0 : t.attributes[He[e]];
+  if (!n)
+    throw new Error(`Missing expected protocol config: "${He[e]}"`);
+  const i = "u64" in n ? n.u64 : "u32" in n ? n.u32 : n.f64;
+  if (!i)
+    throw new Error(`Unexpected protocol config value found for: "${He[e]}"`);
+  return Number(i);
+};
+_t = /* @__PURE__ */ new WeakSet();
+br = function(e) {
+  const t = $(this, oe, de).call(this, "maxPureArgumentSize", e);
+  x(this, T).inputs.forEach((r, n) => {
+    if (N(r.value, De) && r.value.Pure.length > t)
+      throw new Error(
+        `Input at index ${n} is too large, max pure input size is ${t} bytes, got ${r.value.Pure.length} bytes`
+      );
+  });
+};
+Ct = /* @__PURE__ */ new WeakSet();
+Sr = async function(e) {
+  if (x(this, T).gasConfig.payment) {
+    const i = $(this, oe, de).call(this, "maxGasObjects", e);
+    if (x(this, T).gasConfig.payment.length > i)
+      throw new Error(`Payment objects exceed maximum amount: ${i}`);
+  }
+  if (e.onlyTransactionKind || x(this, T).gasConfig.payment)
+    return;
+  const t = x(this, T).gasConfig.owner ?? x(this, T).sender, n = (await ve(e).getCoins({
+    owner: t,
+    coinType: An
+  })).data.filter((i) => !x(this, T).inputs.find((a) => N(a.value, ze) && "Object" in a.value && "ImmOrOwned" in a.value.Object ? i.coinObjectId === a.value.Object.ImmOrOwned.objectId : !1)).slice(0, $(this, oe, de).call(this, "maxGasObjects", e) - 1).map((i) => ({
+    objectId: i.coinObjectId,
+    digest: i.digest,
+    version: i.version
+  }));
+  if (!n.length)
+    throw new Error("No valid gas coins found for the transaction.");
+  this.setGasPayment(n);
+};
+$t = /* @__PURE__ */ new WeakSet();
+Tr = async function(e) {
+  e.onlyTransactionKind || x(this, T).gasConfig.price || this.setGasPrice(await ve(e).getReferenceGasPrice());
+};
+Mt = /* @__PURE__ */ new WeakSet();
+vr = async function(e) {
+  const { inputs: t, transactions: r } = x(this, T), n = [], i = [];
+  if (t.forEach((s) => {
+    if (s.type === "object" && typeof s.value == "string") {
+      i.push({ id: M(s.value), input: s });
+      return;
+    }
+  }), r.forEach((s) => {
+    if (s.kind === "MoveCall" && s.arguments.some(
+      (o) => o.kind === "Input" && !N(t[o.index].value, ze)
+    ) && n.push(s), s.kind === "SplitCoins" && s.amounts.forEach((a) => {
+      if (a.kind === "Input") {
+        const o = t[a.index];
+        typeof o.value != "object" && (o.value = R.Pure(C.U64.serialize(o.value)));
+      }
+    }), s.kind === "TransferObjects" && s.address.kind === "Input") {
+      const a = t[s.address.index];
+      typeof a.value != "object" && (a.value = R.Pure(C.Address.serialize(a.value)));
+    }
+  }), n.length && await Promise.all(
+    n.map(async (s) => {
+      const [a, o, u] = s.target.split("::"), d = await ve(e).getNormalizedMoveFunction({
+        package: be(a),
+        module: o,
+        function: u
+      }), g = d.parameters.length > 0 && Vn(d.parameters.at(-1)) ? d.parameters.slice(0, d.parameters.length - 1) : d.parameters;
+      if (g.length !== s.arguments.length)
+        throw new Error("Incorrect number of arguments.");
+      g.forEach((m, p) => {
+        const y = s.arguments[p];
+        if (y.kind !== "Input")
+          return;
+        const S = t[y.index];
+        if (N(S.value, ze))
+          return;
+        const E = S.value, A = Qe(m, E);
+        if (A) {
+          S.value = R.Pure(E, A);
+          return;
+        }
+        if (at(m) != null || typeof m == "object" && "TypeParameter" in m) {
+          if (typeof E != "string")
+            throw new Error(
+              `Expect the argument to be an object id string, got ${JSON.stringify(
+                E,
+                null,
+                2
+              )}`
+            );
+          i.push({
+            id: E,
+            input: S,
+            normalizedType: m
+          });
+          return;
+        }
+        throw new Error(
+          `Unknown call arg type ${JSON.stringify(m, null, 2)} for value ${JSON.stringify(
+            E,
+            null,
+            2
+          )}`
+        );
+      });
+    })
+  ), i.length) {
+    const s = [...new Set(i.map(({ id: l }) => l))], a = mi(s, pi), o = (await Promise.all(
+      a.map(
+        (l) => ve(e).multiGetObjects({
+          ids: l,
+          options: { showOwner: !0 }
+        })
+      )
+    )).flat();
+    let u = new Map(
+      s.map((l, g) => [l, o[g]])
+    );
+    const d = Array.from(u).filter(([l, g]) => g.error).map(([l, g]) => l);
+    if (d.length)
+      throw new Error(`The following input objects are invalid: ${d.join(", ")}`);
+    i.forEach(({ id: l, input: g, normalizedType: m }) => {
+      var E;
+      const p = u.get(l), y = (E = p.data) == null ? void 0 : E.owner, S = y && typeof y == "object" && "Shared" in y ? y.Shared.initial_shared_version : void 0;
+      if (S) {
+        const A = m != null && Ye(m) == null && Qt(m) == null, _ = ti(g.value) || A || m != null && Ye(m) != null;
+        g.value = R.SharedObjectRef({
+          objectId: l,
+          initialSharedVersion: S,
+          mutable: _
+        });
+      } else m && li(m) ? g.value = R.ReceivingRef(zt(p)) : g.value = R.ObjectRef(zt(p));
+    });
+  }
+};
+Ue = /* @__PURE__ */ new WeakSet();
+tt = async function(e) {
+  if (!e.onlyTransactionKind && !x(this, T).sender)
+    throw new Error("Missing transaction sender");
+  if (!e.protocolConfig && !e.limits && e.client && (e.protocolConfig = await e.client.getProtocolConfig()), await Promise.all([$(this, $t, Tr).call(this, e), $(this, Mt, vr).call(this, e)]), !e.onlyTransactionKind && (await $(this, Ct, Sr).call(this, e), !x(this, T).gasConfig.budget)) {
+    const t = await ve(e).dryRunTransactionBlock({
+      transactionBlock: x(this, T).build({
+        maxSizeBytes: $(this, oe, de).call(this, "maxTxSizeBytes", e),
+        overrides: {
+          gasConfig: {
+            budget: String($(this, oe, de).call(this, "maxTxGas", e)),
+            payment: []
+          }
+        }
+      })
+    });
+    if (t.effects.status.status !== "success")
+      throw new Error(
+        `Dry run failed, could not automatically determine a budget: ${t.effects.status.error}`,
+        { cause: t }
+      );
+    const r = gi * BigInt(this.blockData.gasConfig.price || 1n), n = BigInt(t.effects.gasUsed.computationCost) + r, i = n + BigInt(t.effects.gasUsed.storageCost) - BigInt(t.effects.gasUsed.storageRebate);
+    this.setGasBudget(
+      i > n ? i : n
+    );
+  }
+  $(this, _t, br).call(this, e);
+};
+const yi = [
+  [
+    "Testnet",
+    {
+      tokenMessengerState: "0x5252abd1137094ed1db3e0d75bc36abcd287aee4bc310f8e047727ef5682e7c2",
+      messageTransmitterState: "0x98234bd0fa9ac12cc0a20a144a22e36d6a32f7e0a97baaeaf9c76cdc6d122d2e",
+      usdcTreasury: "0x7170137d4a6431bf83351ac025baf462909bffe2877d87716374fb42b9629ebe"
+    }
+  ],
+  [
+    "Mainnet",
+    {
+      tokenMessengerState: "0x45993eecc0382f37419864992c12faee2238f5cfe22b98ad3bf455baf65c8a2f",
+      messageTransmitterState: "0xf68268c3d9b1df3215f2439400c1c4ea08ac4ef4bb7d6f3ca6a2a239e17510af",
+      usdcTreasury: "0x57d6725e7a8b49a7b2a612f6bd66ab5f39fc95332ca48be421c3229d514a6de7"
+    }
+  ]
+], wi = Or(yi, [0, 1]);
+class Ut {
+  constructor(t, r, n, i) {
+    F(this, "network");
+    F(this, "chain");
+    F(this, "provider");
+    F(this, "contracts");
+    F(this, "usdcId");
+    F(this, "usdcTreasuryId");
+    F(this, "tokenMessengerId");
+    F(this, "tokenMessengerStateId");
+    F(this, "messageTransmitterId");
+    F(this, "messageTransmitterStateId");
+    var d, l, g, m;
+    if (this.network = t, this.chain = r, this.provider = n, this.contracts = i, t === "Devnet")
+      throw new Error("CircleBridge not supported on Devnet");
+    const s = Ar.get(this.network, this.chain);
+    if (!s)
+      throw new Error(`No USDC contract configured for network=${this.network} chain=${this.chain}`);
+    const { tokenMessengerState: a, messageTransmitterState: o, usdcTreasury: u } = wi(t);
+    if (!((d = i.cctp) != null && d.tokenMessenger))
+      throw new Error(`Circle Token Messenger contract for domain ${r} not found`);
+    if (!((l = i.cctp) != null && l.messageTransmitter))
+      throw new Error(`Circle Message Transmitter contract for domain ${r} not found`);
+    this.usdcId = s, this.usdcTreasuryId = u, this.tokenMessengerId = (g = i.cctp) == null ? void 0 : g.tokenMessenger, this.messageTransmitterId = (m = i.cctp) == null ? void 0 : m.messageTransmitter, this.tokenMessengerStateId = a, this.messageTransmitterStateId = o;
+  }
+  async *transfer(t, r, n) {
+    const i = new Xe(), s = kr.get(this.network, r.chain), [a, ...o] = await Nt.getCoins(this.provider, t, this.usdcId);
+    if (a === void 0)
+      throw new Error("No USDC in wallet");
+    const u = i.object(a.coinObjectId);
+    o.length > 0 && i.mergeCoins(u, o.map((l) => i.object(l.coinObjectId)));
+    const [d] = i.splitCoins(u, [n]);
+    i.moveCall({
+      target: `${this.tokenMessengerId}::deposit_for_burn::deposit_for_burn`,
+      arguments: [
+        d,
+        i.pure.u32(s),
+        // destination_domain
+        i.pure.address(r.address.toUniversalAddress().toString()),
+        // mint_recipient
+        i.object(this.tokenMessengerStateId),
+        // token_messenger_minter state
+        i.object(this.messageTransmitterStateId),
+        // message_transmitter state
+        i.object("0x403"),
+        // deny_list id, fixed address
+        i.object(this.usdcTreasuryId)
+        // treasury object Treasury<USDC>
+      ],
+      typeArguments: [this.usdcId]
+    }), yield this.createUnsignedTx(i, "Sui.CircleBridge.Transfer");
+  }
+  async isTransferCompleted(t) {
+    const r = new Xe();
+    r.moveCall({
+      target: `${this.messageTransmitterId}::state::is_nonce_used`,
+      arguments: [
+        r.object(this.messageTransmitterStateId),
+        r.pure.u32(t.sourceDomain),
+        r.pure.u64(t.nonce)
+      ]
+    });
+    const n = await this.provider.devInspectTransactionBlock({
+      sender: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      transactionBlock: r
+    });
+    try {
+      return !!n.results[0].returnValues[0][0][0];
+    } catch (i) {
+      return console.error(`Error reading if nonce was used: ${i}`), !1;
+    }
+  }
+  async *redeem(t, r, n) {
+    const i = new Xe(), [s] = i.moveCall({
+      target: `${this.messageTransmitterId}::receive_message::receive_message`,
+      arguments: [
+        i.pure(Pt(Bt.serialize(r))),
+        i.pure(Pt(_r.decode(n))),
+        i.object(this.messageTransmitterStateId)
+        // message_transmitter state
+      ]
+    });
+    if (!s)
+      throw new Error("Failed to produce receipt");
+    const [a] = i.moveCall({
+      target: `${this.tokenMessengerId}::handle_receive_message::handle_receive_message`,
+      arguments: [
+        s,
+        // Receipt object returned from receive_message call
+        i.object(this.tokenMessengerStateId),
+        // token_messenger_minter state
+        i.object("0x403"),
+        // deny list, fixed address
+        i.object(this.usdcTreasuryId)
+        // usdc treasury object Treasury<T>
+      ],
+      typeArguments: [this.usdcId]
+    });
+    if (!a)
+      throw new Error("Failed to produce stamp receipt ticket with burn message");
+    const [o] = i.moveCall({
+      target: `${this.tokenMessengerId}::handle_receive_message::deconstruct_stamp_receipt_ticket_with_burn_message`,
+      arguments: [a]
+    });
+    if (!o)
+      throw new Error("Failed to produce stamp receipt ticket");
+    const [u] = i.moveCall({
+      target: `${this.messageTransmitterId}::receive_message::stamp_receipt`,
+      arguments: [
+        o,
+        // Receipt ticket returned from deconstruct_stamp_receipt_ticket_with_burn_message call
+        i.object(this.messageTransmitterStateId)
+        // message_transmitter state
+      ],
+      typeArguments: [
+        `${this.tokenMessengerId}::message_transmitter_authenticator::MessageTransmitterAuthenticator`
+      ]
+    });
+    if (!u)
+      throw new Error("Failed to produce stamped receipt");
+    i.moveCall({
+      target: `${this.messageTransmitterId}::receive_message::complete_receive_message`,
+      arguments: [
+        u,
+        // Stamped receipt object returned from handle_receive_message call
+        i.object(this.messageTransmitterStateId)
+        // message_transmitter state
+      ]
+    }), yield this.createUnsignedTx(i, "Sui.CircleBridge.Redeem");
+  }
+  async parseTransactionDetails(t) {
+    var p;
+    const r = await this.provider.waitForTransactionBlock({
+      digest: t,
+      options: { showEvents: !0, showEffects: !0, showInput: !0 }
+    });
+    if (!r)
+      throw new Error("Transaction not found");
+    if (!r.events)
+      throw new Error("Transaction events not found");
+    const n = (p = r.events) == null ? void 0 : p.find((y) => y.type.includes("send_message::MessageSent"));
+    if (!n)
+      throw new Error("No MessageSent event found");
+    const i = new Uint8Array((n == null ? void 0 : n.parsedJson).message), [s, a] = Bt.deserialize(i), { payload: o } = s, u = o.messageSender, d = o.mintRecipient, l = Rt(this.network, s.sourceDomain), g = Rt(this.network, s.destinationDomain), m = { chain: l, address: o.burnToken };
+    return {
+      from: { chain: l, address: u },
+      to: { chain: g, address: d },
+      token: m,
+      amount: o.amount,
+      message: s,
+      id: { hash: a }
+    };
+  }
+  static async fromRpc(t, r) {
+    const [n, i] = await Nt.chainFromRpc(t), s = r[i];
+    if (s.network !== n)
+      throw new Error(`Network mismatch: ${s.network} != ${n}`);
+    return new Ut(n, i, t, s.contracts);
+  }
+  createUnsignedTx(t, r, n = !1) {
+    return new $r(t, this.network, this.chain, r, n);
+  }
+}
+Cr("Sui", "CircleBridge", Ut);
+export {
+  Ut as SuiCircleBridge
+};