@gardenfi/swap 0.1.3-beta.12 → 0.1.3-beta.14

package/dist/index84.js

@@ -1,174 +1,524 @@
-import { InvalidLegacyVError as H } from "./index200.js";
-import { serializeAuthorizationList as g } from "./index267.js";
-import { blobsToCommitments as B } from "./index232.js";
-import { blobsToProofs as V } from "./index233.js";
-import { commitmentsToVersionedHashes as C } from "./index234.js";
-import { toBlobSidecars as k } from "./index237.js";
-import { concatHex as h } from "./index81.js";
-import { trim as T } from "./index89.js";
-import { numberToHex as o, bytesToHex as w } from "./index82.js";
-import { toRlp as b } from "./index83.js";
-import { assertTransactionEIP1559 as S, assertTransactionEIP2930 as _, assertTransactionEIP4844 as R, assertTransactionEIP7702 as Y, assertTransactionLegacy as j } from "./index263.js";
-import { getTransactionType as q } from "./index265.js";
-import { serializeAccessList as v } from "./index266.js";
-function te(e, r) {
-  const i = q(e);
-  return i === "eip1559" ? K(e, r) : i === "eip2930" ? M(e, r) : i === "eip4844" ? J(e, r) : i === "eip7702" ? D(e, r) : N(e, r);
+import { fromBase64 as F } from "./index261.js";
+import { isSerializedBcs as q } from "./index327.js";
+import { parse as P, is as U } from "./index328.js";
+import { normalizeSuiAddress as et } from "./index264.js";
+import { Commands as S } from "./index329.js";
+import { ArgumentSchema as x, TransactionExpiration as nt, ObjectRefSchema as st, NormalizedCallArg as K } from "./index330.js";
+import { serializeV1TransactionData as J } from "./index331.js";
+import { SerializedTransactionDataV2Schema as it } from "./index332.js";
+import { Inputs as $ } from "./index333.js";
+import { needsTransactionResolution as rt, resolveTransactionPlugin as at } from "./index334.js";
+import { createObjectMethods as ot } from "./index335.js";
+import { createPure as lt } from "./index336.js";
+import { TransactionDataBuilder as T } from "./index337.js";
+import { getIdFromCallArg as V } from "./index338.js";
+import { namedPackagesPlugin as ut } from "./index339.js";
+var H = (s) => {
+  throw TypeError(s);
+}, z = (s, t, e) => t.has(s) || H("Cannot " + e), n = (s, t, e) => (z(s, t, "read from private field"), e ? e.call(s) : t.get(s)), w = (s, t, e) => t.has(s) ? H("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(s) : t.set(s, e), u = (s, t, e, r) => (z(s, t, "write to private field"), t.set(s, e), e), d = (s, t, e) => (z(s, t, "access private method"), e), I, k, y, b, p, m, g, R, i, c, L, j, O, N, C, A, G, Q, X;
+function v(s, t = 1 / 0) {
+  const e = {
+    $kind: "Result",
+    get Result() {
+      return typeof s == "function" ? s() : s;
+    }
+  }, r = [], a = (o) => r[o] ?? (r[o] = {
+    $kind: "NestedResult",
+    get NestedResult() {
+      return [typeof s == "function" ? s() : s, o];
+    }
+  });
+  return new Proxy(e, {
+    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(o, f) {
+      if (f in o)
+        return Reflect.get(o, f);
+      if (f === Symbol.iterator)
+        return function* () {
+          let h = 0;
+          for (; h < t; )
+            yield a(h), h++;
+        };
+      if (typeof f == "symbol") return;
+      const l = parseInt(f, 10);
+      if (!(Number.isNaN(l) || l < 0))
+        return a(l);
+    }
+  });
 }
-function D(e, r) {
-  const { authorizationList: i, chainId: s, gas: n, nonce: c, to: f, value: a, maxFeePerGas: x, maxPriorityFeePerGas: t, accessList: p, data: l } = e;
-  Y(e);
-  const d = v(p), m = g(i);
-  return h([
-    "0x04",
-    b([
-      o(s),
-      c ? o(c) : "0x",
-      t ? o(t) : "0x",
-      x ? o(x) : "0x",
-      n ? o(n) : "0x",
-      f ?? "0x",
-      a ? o(a) : "0x",
-      l ?? "0x",
-      d,
-      m,
-      ...I(e, r)
-    ])
-  ]);
+const Z = Symbol.for("@mysten/transaction");
+function ht(s) {
+  return !!s && typeof s == "object" && s[Z] === !0;
+}
+const Y = {
+  buildPlugins: /* @__PURE__ */ new Map(),
+  serializationPlugins: /* @__PURE__ */ new Map()
+}, M = Symbol.for("@mysten/transaction/registry");
+function _() {
+  try {
+    const s = globalThis;
+    return s[M] || (s[M] = Y), s[M];
+  } catch {
+    return Y;
+  }
 }
-function J(e, r) {
-  const { chainId: i, gas: s, nonce: n, to: c, value: f, maxFeePerBlobGas: a, maxFeePerGas: x, maxPriorityFeePerGas: t, accessList: p, data: l } = e;
-  R(e);
-  let d = e.blobVersionedHashes, m = e.sidecars;
-  if (e.blobs && (typeof d > "u" || typeof m > "u")) {
-    const u = typeof e.blobs[0] == "string" ? e.blobs : e.blobs.map((P) => w(P)), z = e.kzg, y = B({
-      blobs: u,
-      kzg: z
+const tt = class E {
+  constructor() {
+    w(this, c), w(this, I), w(this, k), w(this, y, /* @__PURE__ */ new Map()), w(this, b, []), w(this, p, []), w(this, m, /* @__PURE__ */ new Set()), w(this, g, /* @__PURE__ */ new Set()), w(this, R, /* @__PURE__ */ new Map()), w(this, i), this.object = ot(
+      (e) => {
+        var o, f;
+        if (typeof e == "function")
+          return this.object(this.add(e));
+        if (typeof e == "object" && U(x, e))
+          return e;
+        const r = V(e), a = n(this, i).inputs.find((l) => r === V(l));
+        return (o = a == null ? void 0 : a.Object) != null && o.SharedObject && typeof e == "object" && ((f = e.Object) != null && f.SharedObject) && (a.Object.SharedObject.mutable = a.Object.SharedObject.mutable || e.Object.SharedObject.mutable), a ? { $kind: "Input", Input: n(this, i).inputs.indexOf(a), type: "object" } : d(this, c, O).call(this, "object", typeof e == "string" ? {
+          $kind: "UnresolvedObject",
+          UnresolvedObject: { objectId: et(e) }
+        } : e);
+      }
+    );
+    const t = _();
+    u(this, i, new T()), u(this, k, [...t.buildPlugins.values()]), u(this, I, [...t.serializationPlugins.values()]);
+  }
+  /**
+   * 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(t) {
+    const e = new E();
+    return u(e, i, T.fromKindBytes(
+      typeof t == "string" ? F(t) : t
+    )), u(e, b, n(e, i).inputs.slice()), u(e, p, n(e, i).commands.slice()), u(e, m, new Set(n(e, p).map((r, a) => a))), e;
+  }
+  /**
+   * 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(t) {
+    const e = new E();
+    return ht(t) ? u(e, i, T.restore(
+      t.getData()
+    )) : typeof t != "string" || !t.startsWith("{") ? u(e, i, T.fromBytes(
+      typeof t == "string" ? F(t) : t
+    )) : u(e, i, T.restore(JSON.parse(t))), u(e, b, n(e, i).inputs.slice()), u(e, p, n(e, i).commands.slice()), u(e, m, new Set(n(e, p).map((r, a) => a))), e;
+  }
+  static registerGlobalSerializationPlugin(t, e) {
+    _().serializationPlugins.set(
+      t,
+      e ?? t
+    );
+  }
+  static unregisterGlobalSerializationPlugin(t) {
+    _().serializationPlugins.delete(t);
+  }
+  static registerGlobalBuildPlugin(t, e) {
+    _().buildPlugins.set(
+      t,
+      e ?? t
+    );
+  }
+  static unregisterGlobalBuildPlugin(t) {
+    _().buildPlugins.delete(t);
+  }
+  addSerializationPlugin(t) {
+    n(this, I).push(t);
+  }
+  addBuildPlugin(t) {
+    n(this, k).push(t);
+  }
+  addIntentResolver(t, e) {
+    if (n(this, y).has(t) && n(this, y).get(t) !== e)
+      throw new Error(`Intent resolver for ${t} already exists`);
+    n(this, y).set(t, e);
+  }
+  setSender(t) {
+    n(this, i).sender = t;
+  }
+  /**
+   * 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(t) {
+    n(this, i).sender || (n(this, i).sender = t);
+  }
+  setExpiration(t) {
+    n(this, i).expiration = t ? P(nt, t) : null;
+  }
+  setGasPrice(t) {
+    n(this, i).gasConfig.price = String(t);
+  }
+  setGasBudget(t) {
+    n(this, i).gasConfig.budget = String(t);
+  }
+  setGasBudgetIfNotSet(t) {
+    n(this, i).gasData.budget == null && (n(this, i).gasConfig.budget = String(t));
+  }
+  setGasOwner(t) {
+    n(this, i).gasConfig.owner = t;
+  }
+  setGasPayment(t) {
+    n(this, i).gasConfig.payment = t.map((e) => P(st, e));
+  }
+  /** @deprecated Use `getData()` instead. */
+  get blockData() {
+    return J(n(this, i).snapshot());
+  }
+  /** Get a snapshot of the transaction data, in JSON form: */
+  getData() {
+    return n(this, i).snapshot();
+  }
+  // Used to brand transaction classes so that they can be identified, even between multiple copies
+  // of the builder.
+  get [Z]() {
+    return !0;
+  }
+  // Temporary workaround for the wallet interface accidentally serializing transactions via postMessage
+  get pure() {
+    return Object.defineProperty(this, "pure", {
+      enumerable: !1,
+      value: lt((t) => q(t) ? d(this, c, O).call(this, "pure", {
+        $kind: "Pure",
+        Pure: {
+          bytes: t.toBase64()
+        }
+      }) : d(this, c, O).call(this, "pure", U(K, t) ? P(K, t) : t instanceof Uint8Array ? $.Pure(t) : { $kind: "UnresolvedPure", UnresolvedPure: { value: t } }))
+    }), this.pure;
+  }
+  /** Returns an argument for the gas coin, to be used in a transaction. */
+  get gas() {
+    return { $kind: "GasCoin", GasCoin: !0 };
+  }
+  /**
+   * 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(...t) {
+    return this.object($.ObjectRef(...t));
+  }
+  /**
+   * 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(...t) {
+    return this.object($.ReceivingRef(...t));
+  }
+  /**
+   * 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(...t) {
+    return this.object($.SharedObjectRef(...t));
+  }
+  add(t) {
+    if (typeof t == "function") {
+      if (n(this, R).has(t))
+        return n(this, R).get(t);
+      const e = d(this, c, L).call(this), r = t(e);
+      if (!(r && typeof r == "object" && "then" in r))
+        return u(this, m, n(e, m)), n(this, R).set(t, r), r;
+      const a = d(this, c, j).call(this, {
+        $kind: "$Intent",
+        $Intent: {
+          name: "AsyncTransactionThunk",
+          inputs: {},
+          data: {
+            resultIndex: n(this, i).commands.length,
+            result: null
+          }
+        }
+      });
+      n(this, g).add(
+        Promise.resolve(r).then((f) => {
+          a.$Intent.data.result = f;
+        })
+      );
+      const o = v(() => a.$Intent.data.resultIndex);
+      return n(this, R).set(t, o), o;
+    } else
+      d(this, c, j).call(this, t);
+    return v(n(this, i).commands.length - 1);
+  }
+  // Method shorthands:
+  splitCoins(t, e) {
+    const r = S.SplitCoins(
+      typeof t == "string" ? this.object(t) : d(this, c, C).call(this, t),
+      e.map(
+        (a) => typeof a == "number" || typeof a == "bigint" || typeof a == "string" ? this.pure.u64(a) : d(this, c, N).call(this, a)
+      )
+    );
+    return d(this, c, j).call(this, r), v(n(this, i).commands.length - 1, e.length);
+  }
+  mergeCoins(t, e) {
+    return this.add(
+      S.MergeCoins(
+        this.object(t),
+        e.map((r) => this.object(r))
+      )
+    );
+  }
+  publish({ modules: t, dependencies: e }) {
+    return this.add(
+      S.Publish({
+        modules: t,
+        dependencies: e
+      })
+    );
+  }
+  upgrade({
+    modules: t,
+    dependencies: e,
+    package: r,
+    ticket: a
+  }) {
+    return this.add(
+      S.Upgrade({
+        modules: t,
+        dependencies: e,
+        package: r,
+        ticket: this.object(a)
+      })
+    );
+  }
+  moveCall({
+    arguments: t,
+    ...e
+  }) {
+    return this.add(
+      S.MoveCall({
+        ...e,
+        arguments: t == null ? void 0 : t.map((r) => d(this, c, N).call(this, r))
+      })
+    );
+  }
+  transferObjects(t, e) {
+    return this.add(
+      S.TransferObjects(
+        t.map((r) => this.object(r)),
+        typeof e == "string" ? this.pure.address(e) : d(this, c, N).call(this, e)
+      )
+    );
+  }
+  makeMoveVec({
+    type: t,
+    elements: e
+  }) {
+    return this.add(
+      S.MakeMoveVec({
+        type: t,
+        elements: e.map((r) => this.object(r))
+      })
+    );
+  }
+  /**
+   * @deprecated Use toJSON instead.
+   * For synchronous serialization, you can use `getData()`
+   * */
+  serialize() {
+    return JSON.stringify(J(n(this, i).snapshot()));
+  }
+  async toJSON(t = {}) {
+    await this.prepareForSerialization(t);
+    const e = this.isFullyResolved();
+    return JSON.stringify(
+      P(
+        it,
+        e ? {
+          ...n(this, i).snapshot(),
+          digest: n(this, i).getDigest()
+        } : n(this, i).snapshot()
+      ),
+      (r, a) => typeof a == "bigint" ? a.toString() : a,
+      2
+    );
+  }
+  /** Build the transaction to BCS bytes, and sign it with the provided keypair. */
+  async sign(t) {
+    const { signer: e, ...r } = t, a = await this.build(r);
+    return e.signTransaction(a);
+  }
+  /**
+   *  Ensures that:
+   *  - All objects have been fully resolved to a specific version
+   *  - All pure inputs have been serialized to bytes
+   *  - All async thunks have been fully resolved
+   *  - All transaction intents have been resolved
+   * 	- The gas payment, budget, and price have been set
+   *  - The transaction sender has been set
+   *
+   *  When true, the transaction will always be built to the same bytes and digest (unless the transaction is mutated)
+   */
+  isFullyResolved() {
+    return !(!n(this, i).sender || n(this, g).size > 0 || n(this, i).commands.some((t) => t.$Intent) || rt(n(this, i), {}));
+  }
+  /** Build the transaction to BCS bytes. */
+  async build(t = {}) {
+    return await this.prepareForSerialization(t), await d(this, c, A).call(this, t), n(this, i).build({
+      onlyTransactionKind: t.onlyTransactionKind
     });
-    if (typeof d > "u" && (d = C({
-      commitments: y
-    })), typeof m > "u") {
-      const P = V({ blobs: u, commitments: y, kzg: z });
-      m = k({ blobs: u, commitments: y, proofs: P });
+  }
+  /** Derive transaction digest */
+  async getDigest(t = {}) {
+    return await this.prepareForSerialization(t), await d(this, c, A).call(this, t), n(this, i).getDigest();
+  }
+  async prepareForSerialization(t) {
+    var a;
+    await d(this, c, Q).call(this), d(this, c, X).call(this);
+    const e = /* @__PURE__ */ new Set();
+    for (const o of n(this, i).commands)
+      o.$Intent && e.add(o.$Intent.name);
+    const r = [...n(this, I)];
+    for (const o of e)
+      if (!((a = t.supportedIntents) != null && a.includes(o))) {
+        if (!n(this, y).has(o))
+          throw new Error(`Missing intent resolver for ${o}`);
+        r.push(n(this, y).get(o));
+      }
+    r.push(ut()), await d(this, c, G).call(this, r, t);
+  }
+};
+I = /* @__PURE__ */ new WeakMap();
+k = /* @__PURE__ */ new WeakMap();
+y = /* @__PURE__ */ new WeakMap();
+b = /* @__PURE__ */ new WeakMap();
+p = /* @__PURE__ */ new WeakMap();
+m = /* @__PURE__ */ new WeakMap();
+g = /* @__PURE__ */ new WeakMap();
+R = /* @__PURE__ */ new WeakMap();
+i = /* @__PURE__ */ new WeakMap();
+c = /* @__PURE__ */ new WeakSet();
+L = function() {
+  const s = new tt();
+  return u(s, i, n(this, i)), u(s, I, n(this, I)), u(s, k, n(this, k)), u(s, y, n(this, y)), u(s, g, n(this, g)), u(s, m, new Set(n(this, m))), u(s, R, n(this, R)), n(this, b).push(n(s, b)), n(this, p).push(n(s, p)), s;
+};
+j = function(s) {
+  const t = n(this, i).commands.length;
+  return n(this, p).push(s), n(this, m).add(t), n(this, i).commands.push(s), n(this, i).mapCommandArguments(t, (e) => {
+    if (e.$kind === "Result" && !n(this, m).has(e.Result))
+      throw new Error(
+        `Result { Result: ${e.Result} } is not available to use in the current transaction`
+      );
+    if (e.$kind === "NestedResult" && !n(this, m).has(e.NestedResult[0]))
+      throw new Error(
+        `Result { NestedResult: [${e.NestedResult[0]}, ${e.NestedResult[1]}] } is not available to use in the current transaction`
+      );
+    if (e.$kind === "Input" && e.Input >= n(this, i).inputs.length)
+      throw new Error(
+        `Input { Input: ${e.Input} } references an input that does not exist in the current transaction`
+      );
+    return e;
+  }), s;
+};
+O = function(s, t) {
+  return n(this, b).push(t), n(this, i).addInput(s, t);
+};
+N = function(s) {
+  return q(s) ? this.pure(s) : d(this, c, C).call(this, s);
+};
+C = function(s) {
+  if (typeof s == "function") {
+    const t = this.add(s);
+    return typeof t == "function" ? d(this, c, C).call(this, t) : P(x, t);
+  }
+  return P(x, s);
+};
+A = async function(s) {
+  if (!s.onlyTransactionKind && !n(this, i).sender)
+    throw new Error("Missing transaction sender");
+  await d(this, c, G).call(this, [...n(this, k), at], s);
+};
+G = async function(s, t) {
+  try {
+    const e = (r) => {
+      if (r >= s.length)
+        return () => {
+        };
+      const a = s[r];
+      return async () => {
+        const o = e(r + 1);
+        let f = !1, l = !1;
+        if (await a(n(this, i), t, async () => {
+          if (f)
+            throw new Error(`next() was call multiple times in TransactionPlugin ${r}`);
+          f = !0, await o(), l = !0;
+        }), !f)
+          throw new Error(`next() was not called in TransactionPlugin ${r}`);
+        if (!l)
+          throw new Error(`next() was not awaited in TransactionPlugin ${r}`);
+      };
+    };
+    await e(0)();
+  } finally {
+    u(this, b, n(this, i).inputs.slice()), u(this, p, n(this, i).commands.slice()), u(this, m, new Set(n(this, p).map((e, r) => r)));
+  }
+};
+Q = async function() {
+  for (; n(this, g).size > 0; ) {
+    const s = Promise.all(n(this, g));
+    n(this, g).clear(), n(this, g).add(s), await s, n(this, g).delete(s);
+  }
+};
+X = function() {
+  var f;
+  const s = n(this, i).commands, t = n(this, i).inputs, e = n(this, p).flat(1 / 0), r = n(this, b).flat(1 / 0);
+  if (e.length !== s.length)
+    throw new Error("Unexpected number of commands found in transaction data");
+  if (r.length !== t.length)
+    throw new Error("Unexpected number of inputs found in transaction data");
+  const a = e.filter(
+    (l) => {
+      var h;
+      return ((h = l.$Intent) == null ? void 0 : h.name) !== "AsyncTransactionThunk";
+    }
+  );
+  n(this, i).commands = a, n(this, i).inputs = r, u(this, p, a), u(this, b, r), u(this, m, new Set(a.map((l, h) => h)));
+  function o(l) {
+    var W;
+    const h = s[l];
+    if (((W = h.$Intent) == null ? void 0 : W.name) === "AsyncTransactionThunk") {
+      const D = h.$Intent.data.result;
+      if (D == null)
+        throw new Error("AsyncTransactionThunk has not been resolved");
+      return o(D.Result);
     }
+    const B = a.indexOf(h);
+    if (B === -1)
+      throw new Error("Unable to find original index for command");
+    return B;
   }
-  const L = v(p), E = [
-    o(i),
-    n ? o(n) : "0x",
-    t ? o(t) : "0x",
-    x ? o(x) : "0x",
-    s ? o(s) : "0x",
-    c ?? "0x",
-    f ? o(f) : "0x",
-    l ?? "0x",
-    L,
-    a ? o(a) : "0x",
-    d ?? [],
-    ...I(e, r)
-  ], A = [], F = [], G = [];
-  if (m)
-    for (let u = 0; u < m.length; u++) {
-      const { blob: z, commitment: y, proof: P } = m[u];
-      A.push(z), F.push(y), G.push(P);
+  n(this, i).mapArguments((l) => {
+    if (l.$kind === "Input") {
+      const h = r.indexOf(t[l.Input]);
+      if (h === -1)
+        throw new Error("Input has not been resolved");
+      return { ...l, Input: h };
+    } else if (l.$kind === "Result") {
+      const h = o(l.Result);
+      return { ...l, Result: h };
+    } else if (l.$kind === "NestedResult") {
+      const h = o(l.NestedResult[0]);
+      return { ...l, NestedResult: [h, l.NestedResult[1]] };
     }
-  return h([
-    "0x03",
-    m ? (
-      // If sidecars are enabled, envelope turns into a "wrapper":
-      b([E, A, F, G])
-    ) : (
-      // If sidecars are disabled, standard envelope is used:
-      b(E)
-    )
-  ]);
-}
-function K(e, r) {
-  const { chainId: i, gas: s, nonce: n, to: c, value: f, maxFeePerGas: a, maxPriorityFeePerGas: x, accessList: t, data: p } = e;
-  S(e);
-  const l = v(t), d = [
-    o(i),
-    n ? o(n) : "0x",
-    x ? o(x) : "0x",
-    a ? o(a) : "0x",
-    s ? o(s) : "0x",
-    c ?? "0x",
-    f ? o(f) : "0x",
-    p ?? "0x",
-    l,
-    ...I(e, r)
-  ];
-  return h([
-    "0x02",
-    b(d)
-  ]);
-}
-function M(e, r) {
-  const { chainId: i, gas: s, data: n, nonce: c, to: f, value: a, accessList: x, gasPrice: t } = e;
-  _(e);
-  const p = v(x), l = [
-    o(i),
-    c ? o(c) : "0x",
-    t ? o(t) : "0x",
-    s ? o(s) : "0x",
-    f ?? "0x",
-    a ? o(a) : "0x",
-    n ?? "0x",
-    p,
-    ...I(e, r)
-  ];
-  return h([
-    "0x01",
-    b(l)
-  ]);
-}
-function N(e, r) {
-  const { chainId: i = 0, gas: s, data: n, nonce: c, to: f, value: a, gasPrice: x } = e;
-  j(e);
-  let t = [
-    c ? o(c) : "0x",
-    x ? o(x) : "0x",
-    s ? o(s) : "0x",
-    f ?? "0x",
-    a ? o(a) : "0x",
-    n ?? "0x"
-  ];
-  if (r) {
-    const p = (() => {
-      if (r.v >= 35n)
-        return (r.v - 35n) / 2n > 0 ? r.v : 27n + (r.v === 35n ? 0n : 1n);
-      if (i > 0)
-        return BigInt(i * 2) + BigInt(35n + r.v - 27n);
-      const m = 27n + (r.v === 27n ? 0n : 1n);
-      if (r.v !== m)
-        throw new H({ v: r.v });
-      return m;
-    })(), l = T(r.r), d = T(r.s);
-    t = [
-      ...t,
-      o(p),
-      l === "0x00" ? "0x" : l,
-      d === "0x00" ? "0x" : d
-    ];
-  } else i > 0 && (t = [
-    ...t,
-    o(i),
-    "0x",
-    "0x"
-  ]);
-  return b(t);
-}
-function I(e, r) {
-  const i = r ?? e, { v: s, yParity: n } = i;
-  if (typeof i.r > "u")
-    return [];
-  if (typeof i.s > "u")
-    return [];
-  if (typeof s > "u" && typeof n > "u")
-    return [];
-  const c = T(i.r), f = T(i.s);
-  return [typeof n == "number" ? n ? o(1) : "0x" : s === 0n ? "0x" : s === 1n ? o(1) : s === 27n ? "0x" : o(1), c === "0x00" ? "0x" : c, f === "0x00" ? "0x" : f];
-}
+    return l;
+  });
+  for (const [l, h] of s.entries())
+    if (((f = h.$Intent) == null ? void 0 : f.name) === "AsyncTransactionThunk")
+      try {
+        h.$Intent.data.resultIndex = o(l);
+      } catch {
+      }
+};
+let _t = tt;
 export {
-  te as serializeTransaction,
-  I as toYParitySignatureArray
+  _t as Transaction,
+  ht as isTransaction
 };