@gardenfi/swap 0.1.2 → 0.1.3-beta.1

package/dist/index76.js

@@ -1,730 +1,524 @@
-import { fromBase58 as u } from "./index113.js";
-import { toBase64 as d } from "./index114.js";
-import { toHex as y } from "./index115.js";
-import { Experimental_BaseClient as k } from "./index116.js";
-import { isTransaction as f } from "./index77.js";
-import { isValidSuiAddress as n, normalizeSuiAddress as c, isValidSuiObjectId as m, normalizeSuiObjectId as g, isValidTransactionDigest as w } from "./index117.js";
-import { normalizeSuiNSName as M } from "./index118.js";
-import { JsonRpcHTTPTransport as S } from "./index109.js";
-import { isValidNamedPackage as i } from "./index119.js";
-import { hasMvrName as l } from "./index120.js";
-import { JSONRpcCoreClient as b } from "./index121.js";
-const _ = Symbol.for("@mysten/SuiClient");
-class j extends k {
-  /**
-   * Establish a connection to a Sui RPC endpoint
-   *
-   * @param options configuration options for the API Client
-   */
-  constructor(e) {
-    super({ network: e.network ?? "unknown" }), this.jsonRpc = this, this.transport = e.transport ?? new S({ url: e.url }), this.core = new b({
-      jsonRpcClient: this,
-      mvr: e.mvr
-    });
-  }
-  get [_]() {
-    return !0;
+import { fromBase64 as F } from "./index114.js";
+import { isSerializedBcs as q } from "./index300.js";
+import { parse as P, is as U } from "./index301.js";
+import { normalizeSuiAddress as et } from "./index117.js";
+import { Commands as S } from "./index302.js";
+import { ArgumentSchema as x, TransactionExpiration as nt, ObjectRefSchema as st, NormalizedCallArg as K } from "./index303.js";
+import { serializeV1TransactionData as J } from "./index304.js";
+import { SerializedTransactionDataV2Schema as it } from "./index305.js";
+import { Inputs as $ } from "./index306.js";
+import { needsTransactionResolution as rt, resolveTransactionPlugin as at } from "./index307.js";
+import { createObjectMethods as ot } from "./index308.js";
+import { createPure as lt } from "./index309.js";
+import { TransactionDataBuilder as T } from "./index310.js";
+import { getIdFromCallArg as V } from "./index311.js";
+import { namedPackagesPlugin as ut } from "./index312.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);
+    }
+  });
+}
+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;
   }
-  async getRpcApiVersion({ signal: e } = {}) {
-    return (await this.transport.request({
-      method: "rpc.discover",
-      params: [],
-      signal: e
-    })).info.version;
+}
+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()]);
   }
   /**
-   * Get all Coin<`coin_type`> objects owned by an address.
+   * Converts from a serialize transaction kind (built with `build({ onlyTransactionKind: true })`) to a `Transaction` class.
+   * Supports either a byte array, or base64-encoded bytes.
    */
-  async getCoins({
-    coinType: e,
-    owner: a,
-    cursor: s,
-    limit: t,
-    signal: r
-  }) {
-    if (!a || !n(c(a)))
-      throw new Error("Invalid Sui address");
-    return e && l(e) && (e = (await this.core.mvr.resolveType({
-      type: e
-    })).type), await this.transport.request({
-      method: "suix_getCoins",
-      params: [a, e, s, t],
-      signal: r
-    });
+  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;
   }
   /**
-   * Get all Coin objects owned by an address.
+   * 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.
    */
-  async getAllCoins(e) {
-    if (!e.owner || !n(c(e.owner)))
-      throw new Error("Invalid Sui address");
-    return await this.transport.request({
-      method: "suix_getAllCoins",
-      params: [e.owner, e.cursor, e.limit],
-      signal: e.signal
-    });
+  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;
   }
-  /**
-   * Get the total coin balance for one coin type, owned by the address owner.
-   */
-  async getBalance({ owner: e, coinType: a, signal: s }) {
-    if (!e || !n(c(e)))
-      throw new Error("Invalid Sui address");
-    return a && l(a) && (a = (await this.core.mvr.resolveType({
-      type: a
-    })).type), await this.transport.request({
-      method: "suix_getBalance",
-      params: [e, a],
-      signal: s
-    });
+  static registerGlobalSerializationPlugin(t, e) {
+    _().serializationPlugins.set(
+      t,
+      e ?? t
+    );
   }
-  /**
-   * Get the total coin balance for all coin types, owned by the address owner.
-   */
-  async getAllBalances(e) {
-    if (!e.owner || !n(c(e.owner)))
-      throw new Error("Invalid Sui address");
-    return await this.transport.request({
-      method: "suix_getAllBalances",
-      params: [e.owner],
-      signal: e.signal
-    });
+  static unregisterGlobalSerializationPlugin(t) {
+    _().serializationPlugins.delete(t);
   }
-  /**
-   * Fetch CoinMetadata for a given coin type
-   */
-  async getCoinMetadata({ coinType: e, signal: a }) {
-    return e && l(e) && (e = (await this.core.mvr.resolveType({
-      type: e
-    })).type), await this.transport.request({
-      method: "suix_getCoinMetadata",
-      params: [e],
-      signal: a
-    });
+  static registerGlobalBuildPlugin(t, e) {
+    _().buildPlugins.set(
+      t,
+      e ?? t
+    );
   }
-  /**
-   *  Fetch total supply for a coin
-   */
-  async getTotalSupply({ coinType: e, signal: a }) {
-    return e && l(e) && (e = (await this.core.mvr.resolveType({
-      type: e
-    })).type), await this.transport.request({
-      method: "suix_getTotalSupply",
-      params: [e],
-      signal: a
-    });
+  static unregisterGlobalBuildPlugin(t) {
+    _().buildPlugins.delete(t);
   }
-  /**
-   * Invoke any RPC method
-   * @param method the method to be invoked
-   * @param args the arguments to be passed to the RPC request
-   */
-  async call(e, a, { signal: s } = {}) {
-    return await this.transport.request({ method: e, params: a, signal: s });
+  addSerializationPlugin(t) {
+    n(this, I).push(t);
   }
-  /**
-   * Get Move function argument types like read, write and full access
-   */
-  async getMoveFunctionArgTypes({
-    package: e,
-    module: a,
-    function: s,
-    signal: t
-  }) {
-    return e && i(e) && (e = (await this.core.mvr.resolvePackage({
-      package: e
-    })).package), await this.transport.request({
-      method: "sui_getMoveFunctionArgTypes",
-      params: [e, a, s],
-      signal: t
-    });
+  addBuildPlugin(t) {
+    n(this, k).push(t);
   }
-  /**
-   * Get a map from module name to
-   * structured representations of Move modules
-   */
-  async getNormalizedMoveModulesByPackage({
-    package: e,
-    signal: a
-  }) {
-    return e && i(e) && (e = (await this.core.mvr.resolvePackage({
-      package: e
-    })).package), await this.transport.request({
-      method: "sui_getNormalizedMoveModulesByPackage",
-      params: [e],
-      signal: a
-    });
+  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);
   }
-  /**
-   * Get a structured representation of Move module
-   */
-  async getNormalizedMoveModule({
-    package: e,
-    module: a,
-    signal: s
-  }) {
-    return e && i(e) && (e = (await this.core.mvr.resolvePackage({
-      package: e
-    })).package), await this.transport.request({
-      method: "sui_getNormalizedMoveModule",
-      params: [e, a],
-      signal: s
-    });
+  setSender(t) {
+    n(this, i).sender = t;
   }
   /**
-   * Get a structured representation of Move function
+   * 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.
    */
-  async getNormalizedMoveFunction({
-    package: e,
-    module: a,
-    function: s,
-    signal: t
-  }) {
-    return e && i(e) && (e = (await this.core.mvr.resolvePackage({
-      package: e
-    })).package), await this.transport.request({
-      method: "sui_getNormalizedMoveFunction",
-      params: [e, a, s],
-      signal: t
-    });
+  setSenderIfNotSet(t) {
+    n(this, i).sender || (n(this, i).sender = t);
   }
-  /**
-   * Get a structured representation of Move struct
-   */
-  async getNormalizedMoveStruct({
-    package: e,
-    module: a,
-    struct: s,
-    signal: t
-  }) {
-    return e && i(e) && (e = (await this.core.mvr.resolvePackage({
-      package: e
-    })).package), await this.transport.request({
-      method: "sui_getNormalizedMoveStruct",
-      params: [e, a, s],
-      signal: t
-    });
+  setExpiration(t) {
+    n(this, i).expiration = t ? P(nt, t) : null;
   }
-  /**
-   * Get all objects owned by an address
-   */
-  async getOwnedObjects(e) {
-    if (!e.owner || !n(c(e.owner)))
-      throw new Error("Invalid Sui address");
-    const a = e.filter ? {
-      ...e.filter
-    } : void 0;
-    return a && "MoveModule" in a && i(a.MoveModule.package) ? a.MoveModule = {
-      module: a.MoveModule.module,
-      package: (await this.core.mvr.resolvePackage({
-        package: a.MoveModule.package
-      })).package
-    } : a && "StructType" in a && l(a.StructType) && (a.StructType = (await this.core.mvr.resolveType({
-      type: a.StructType
-    })).type), await this.transport.request({
-      method: "suix_getOwnedObjects",
-      params: [
-        e.owner,
-        {
-          filter: a,
-          options: e.options
-        },
-        e.cursor,
-        e.limit
-      ],
-      signal: e.signal
-    });
+  setGasPrice(t) {
+    n(this, i).gasConfig.price = String(t);
   }
-  /**
-   * Get details about an object
-   */
-  async getObject(e) {
-    if (!e.id || !m(g(e.id)))
-      throw new Error("Invalid Sui Object id");
-    return await this.transport.request({
-      method: "sui_getObject",
-      params: [e.id, e.options],
-      signal: e.signal
-    });
+  setGasBudget(t) {
+    n(this, i).gasConfig.budget = String(t);
   }
-  async tryGetPastObject(e) {
-    return await this.transport.request({
-      method: "sui_tryGetPastObject",
-      params: [e.id, e.version, e.options],
-      signal: e.signal
-    });
+  setGasBudgetIfNotSet(t) {
+    n(this, i).gasData.budget == null && (n(this, i).gasConfig.budget = String(t));
   }
-  /**
-   * Batch get details about a list of objects. If any of the object ids are duplicates the call will fail
-   */
-  async multiGetObjects(e) {
-    if (e.ids.forEach((s) => {
-      if (!s || !m(g(s)))
-        throw new Error(`Invalid Sui Object id ${s}`);
-    }), e.ids.length !== new Set(e.ids).size)
-      throw new Error(`Duplicate object ids in batch call ${e.ids}`);
-    return await this.transport.request({
-      method: "sui_multiGetObjects",
-      params: [e.ids, e.options],
-      signal: e.signal
-    });
+  setGasOwner(t) {
+    n(this, i).gasConfig.owner = t;
   }
-  /**
-   * Get transaction blocks for a given query criteria
-   */
-  async queryTransactionBlocks({
-    filter: e,
-    options: a,
-    cursor: s,
-    limit: t,
-    order: r,
-    signal: o
-  }) {
-    return e && "MoveFunction" in e && i(e.MoveFunction.package) && (e = {
-      ...e,
-      MoveFunction: {
-        package: (await this.core.mvr.resolvePackage({
-          package: e.MoveFunction.package
-        })).package
-      }
-    }), await this.transport.request({
-      method: "suix_queryTransactionBlocks",
-      params: [
-        {
-          filter: e,
-          options: a
-        },
-        s,
-        t,
-        (r || "descending") === "descending"
-      ],
-      signal: o
-    });
+  setGasPayment(t) {
+    n(this, i).gasConfig.payment = t.map((e) => P(st, e));
   }
-  async getTransactionBlock(e) {
-    if (!w(e.digest))
-      throw new Error("Invalid Transaction digest");
-    return await this.transport.request({
-      method: "sui_getTransactionBlock",
-      params: [e.digest, e.options],
-      signal: e.signal
-    });
+  /** @deprecated Use `getData()` instead. */
+  get blockData() {
+    return J(n(this, i).snapshot());
   }
-  async multiGetTransactionBlocks(e) {
-    if (e.digests.forEach((s) => {
-      if (!w(s))
-        throw new Error(`Invalid Transaction digest ${s}`);
-    }), e.digests.length !== new Set(e.digests).size)
-      throw new Error(`Duplicate digests in batch call ${e.digests}`);
-    return await this.transport.request({
-      method: "sui_multiGetTransactionBlocks",
-      params: [e.digests, e.options],
-      signal: e.signal
-    });
+  /** Get a snapshot of the transaction data, in JSON form: */
+  getData() {
+    return n(this, i).snapshot();
   }
-  async executeTransactionBlock({
-    transactionBlock: e,
-    signature: a,
-    options: s,
-    requestType: t,
-    signal: r
-  }) {
-    const o = await this.transport.request({
-      method: "sui_executeTransactionBlock",
-      params: [
-        typeof e == "string" ? e : d(e),
-        Array.isArray(a) ? a : [a],
-        s
-      ],
-      signal: r
-    });
-    if (t === "WaitForLocalExecution")
-      try {
-        await this.waitForTransaction({
-          digest: o.digest
-        });
-      } catch {
-      }
-    return o;
+  // Used to brand transaction classes so that they can be identified, even between multiple copies
+  // of the builder.
+  get [Z]() {
+    return !0;
   }
-  async signAndExecuteTransaction({
-    transaction: e,
-    signer: a,
-    ...s
+  // 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
   }) {
-    let t;
-    e instanceof Uint8Array ? t = e : (e.setSenderIfNotSet(a.toSuiAddress()), t = await e.build({ client: this }));
-    const { signature: r, bytes: o } = await a.signTransaction(t);
-    return this.executeTransactionBlock({
-      transactionBlock: o,
-      signature: r,
-      ...s
-    });
-  }
-  /**
-   * Get total number of transactions
-   */
-  async getTotalTransactionBlocks({ signal: e } = {}) {
-    const a = await this.transport.request({
-      method: "sui_getTotalTransactionBlocks",
-      params: [],
-      signal: e
-    });
-    return BigInt(a);
-  }
-  /**
-   * Getting the reference gas price for the network
-   */
-  async getReferenceGasPrice({ signal: e } = {}) {
-    const a = await this.transport.request({
-      method: "suix_getReferenceGasPrice",
-      params: [],
-      signal: e
-    });
-    return BigInt(a);
-  }
-  /**
-   * Return the delegated stakes for an address
-   */
-  async getStakes(e) {
-    if (!e.owner || !n(c(e.owner)))
-      throw new Error("Invalid Sui address");
-    return await this.transport.request({
-      method: "suix_getStakes",
-      params: [e.owner],
-      signal: e.signal
-    });
-  }
-  /**
-   * Return the delegated stakes queried by id.
-   */
-  async getStakesByIds(e) {
-    return e.stakedSuiIds.forEach((a) => {
-      if (!a || !m(g(a)))
-        throw new Error(`Invalid Sui Stake id ${a}`);
-    }), await this.transport.request({
-      method: "suix_getStakesByIds",
-      params: [e.stakedSuiIds],
-      signal: e.signal
-    });
-  }
-  /**
-   * Return the latest system state content.
-   */
-  async getLatestSuiSystemState({
-    signal: e
-  } = {}) {
-    return await this.transport.request({
-      method: "suix_getLatestSuiSystemState",
-      params: [],
-      signal: e
-    });
-  }
-  /**
-   * Get events for a given query criteria
-   */
-  async queryEvents({
-    query: e,
-    cursor: a,
-    limit: s,
-    order: t,
-    signal: r
+    return this.add(
+      S.Upgrade({
+        modules: t,
+        dependencies: e,
+        package: r,
+        ticket: this.object(a)
+      })
+    );
+  }
+  moveCall({
+    arguments: t,
+    ...e
   }) {
-    return e && "MoveEventType" in e && l(e.MoveEventType) && (e = {
-      ...e,
-      MoveEventType: (await this.core.mvr.resolveType({
-        type: e.MoveEventType
-      })).type
-    }), e && "MoveEventModule" in e && i(e.MoveEventModule.package) && (e = {
-      ...e,
-      MoveEventModule: {
-        module: e.MoveEventModule.module,
-        package: (await this.core.mvr.resolvePackage({
-          package: e.MoveEventModule.package
-        })).package
-      }
-    }), "MoveModule" in e && i(e.MoveModule.package) && (e = {
-      ...e,
-      MoveModule: {
-        module: e.MoveModule.module,
-        package: (await this.core.mvr.resolvePackage({
-          package: e.MoveModule.package
-        })).package
-      }
-    }), await this.transport.request({
-      method: "suix_queryEvents",
-      params: [e, a, s, (t || "descending") === "descending"],
-      signal: r
-    });
-  }
-  /**
-   * Subscribe to get notifications whenever an event matching the filter occurs
+    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
    *
-   * @deprecated
-   */
-  async subscribeEvent(e) {
-    return this.transport.subscribe({
-      method: "suix_subscribeEvent",
-      unsubscribe: "suix_unsubscribeEvent",
-      params: [e.filter],
-      onMessage: e.onMessage,
-      signal: e.signal
-    });
-  }
-  /**
-   * @deprecated
-   */
-  async subscribeTransaction(e) {
-    return this.transport.subscribe({
-      method: "suix_subscribeTransaction",
-      unsubscribe: "suix_unsubscribeTransaction",
-      params: [e.filter],
-      onMessage: e.onMessage,
-      signal: e.signal
-    });
+   *  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
+    });
+  }
+  /** 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);
   }
-  /**
-   * Runs the transaction block in dev-inspect mode. Which allows for nearly any
-   * transaction (or Move call) with any arguments. Detailed results are
-   * provided, including both the transaction effects and any return values.
-   */
-  async devInspectTransactionBlock(e) {
-    var s, t;
-    let a;
-    if (f(e.transactionBlock))
-      e.transactionBlock.setSenderIfNotSet(e.sender), a = d(
-        await e.transactionBlock.build({
-          client: this,
-          onlyTransactionKind: !0
-        })
+};
+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`
       );
-    else if (typeof e.transactionBlock == "string")
-      a = e.transactionBlock;
-    else if (e.transactionBlock instanceof Uint8Array)
-      a = d(e.transactionBlock);
-    else
-      throw new Error("Unknown transaction block format.");
-    return (s = e.signal) == null || s.throwIfAborted(), await this.transport.request({
-      method: "sui_devInspectTransactionBlock",
-      params: [e.sender, a, (t = e.gasPrice) == null ? void 0 : t.toString(), e.epoch],
-      signal: e.signal
-    });
-  }
-  /**
-   * Dry run a transaction block and return the result.
-   */
-  async dryRunTransactionBlock(e) {
-    return await this.transport.request({
-      method: "sui_dryRunTransactionBlock",
-      params: [
-        typeof e.transactionBlock == "string" ? e.transactionBlock : d(e.transactionBlock)
-      ]
-    });
-  }
-  /**
-   * Return the list of dynamic field objects owned by an object
-   */
-  async getDynamicFields(e) {
-    if (!e.parentId || !m(g(e.parentId)))
-      throw new Error("Invalid Sui Object id");
-    return await this.transport.request({
-      method: "suix_getDynamicFields",
-      params: [e.parentId, e.cursor, e.limit],
-      signal: e.signal
-    });
-  }
-  /**
-   * Return the dynamic field object information for a specified object
-   */
-  async getDynamicFieldObject(e) {
-    return await this.transport.request({
-      method: "suix_getDynamicFieldObject",
-      params: [e.parentId, e.name],
-      signal: e.signal
-    });
-  }
-  /**
-   * Get the sequence number of the latest checkpoint that has been executed
-   */
-  async getLatestCheckpointSequenceNumber({
-    signal: e
-  } = {}) {
-    const a = await this.transport.request({
-      method: "sui_getLatestCheckpointSequenceNumber",
-      params: [],
-      signal: e
-    });
-    return String(a);
-  }
-  /**
-   * Returns information about a given checkpoint
-   */
-  async getCheckpoint(e) {
-    return await this.transport.request({
-      method: "sui_getCheckpoint",
-      params: [e.id],
-      signal: e.signal
-    });
-  }
-  /**
-   * Returns historical checkpoints paginated
-   */
-  async getCheckpoints(e) {
-    return await this.transport.request({
-      method: "sui_getCheckpoints",
-      params: [e.cursor, e == null ? void 0 : e.limit, e.descendingOrder],
-      signal: e.signal
-    });
-  }
-  /**
-   * Return the committee information for the asked epoch
-   */
-  async getCommitteeInfo(e) {
-    return await this.transport.request({
-      method: "suix_getCommitteeInfo",
-      params: [e == null ? void 0 : e.epoch],
-      signal: e == null ? void 0 : e.signal
-    });
-  }
-  async getNetworkMetrics({ signal: e } = {}) {
-    return await this.transport.request({
-      method: "suix_getNetworkMetrics",
-      params: [],
-      signal: e
-    });
-  }
-  async getAddressMetrics({ signal: e } = {}) {
-    return await this.transport.request({
-      method: "suix_getLatestAddressMetrics",
-      params: [],
-      signal: e
-    });
-  }
-  async getEpochMetrics(e) {
-    return await this.transport.request({
-      method: "suix_getEpochMetrics",
-      params: [e == null ? void 0 : e.cursor, e == null ? void 0 : e.limit, e == null ? void 0 : e.descendingOrder],
-      signal: e == null ? void 0 : e.signal
-    });
-  }
-  async getAllEpochAddressMetrics(e) {
-    return await this.transport.request({
-      method: "suix_getAllEpochAddressMetrics",
-      params: [e == null ? void 0 : e.descendingOrder],
-      signal: e == null ? void 0 : e.signal
-    });
-  }
-  /**
-   * Return the committee information for the asked epoch
-   */
-  async getEpochs(e) {
-    return await this.transport.request({
-      method: "suix_getEpochs",
-      params: [e == null ? void 0 : e.cursor, e == null ? void 0 : e.limit, e == null ? void 0 : e.descendingOrder],
-      signal: e == null ? void 0 : e.signal
-    });
-  }
-  /**
-   * Returns list of top move calls by usage
-   */
-  async getMoveCallMetrics({ signal: e } = {}) {
-    return await this.transport.request({
-      method: "suix_getMoveCallMetrics",
-      params: [],
-      signal: e
-    });
-  }
-  /**
-   * Return the committee information for the asked epoch
-   */
-  async getCurrentEpoch({ signal: e } = {}) {
-    return await this.transport.request({
-      method: "suix_getCurrentEpoch",
-      params: [],
-      signal: e
-    });
-  }
-  /**
-   * Return the Validators APYs
-   */
-  async getValidatorsApy({ signal: e } = {}) {
-    return await this.transport.request({
-      method: "suix_getValidatorsApy",
-      params: [],
-      signal: e
-    });
-  }
-  // TODO: Migrate this to `sui_getChainIdentifier` once it is widely available.
-  async getChainIdentifier({ signal: e } = {}) {
-    const a = await this.getCheckpoint({ id: "0", signal: e }), s = u(a.digest);
-    return y(s.slice(0, 4));
-  }
-  async resolveNameServiceAddress(e) {
-    return await this.transport.request({
-      method: "suix_resolveNameServiceAddress",
-      params: [e.name],
-      signal: e.signal
-    });
+    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);
   }
-  async resolveNameServiceNames({
-    format: e = "dot",
-    ...a
-  }) {
-    const { nextCursor: s, hasNextPage: t, data: r } = await this.transport.request({
-      method: "suix_resolveNameServiceNames",
-      params: [a.address, a.cursor, a.limit],
-      signal: a.signal
-    });
-    return {
-      hasNextPage: t,
-      nextCursor: s,
-      data: r.map((o) => M(o, e))
+  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)));
   }
-  async getProtocolConfig(e) {
-    return await this.transport.request({
-      method: "sui_getProtocolConfig",
-      params: [e == null ? void 0 : e.version],
-      signal: e == null ? void 0 : e.signal
-    });
-  }
-  async verifyZkLoginSignature(e) {
-    return await this.transport.request({
-      method: "sui_verifyZkLoginSignature",
-      params: [e.bytes, e.signature, e.intentScope, e.author],
-      signal: e.signal
-    });
+};
+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);
   }
-  /**
-   * Wait for a transaction block result to be available over the API.
-   * This can be used in conjunction with `executeTransactionBlock` to wait for the transaction to
-   * be available via the API.
-   * This currently polls the `getTransactionBlock` API to check for the transaction.
-   */
-  async waitForTransaction({
-    signal: e,
-    timeout: a = 60 * 1e3,
-    pollInterval: s = 2 * 1e3,
-    ...t
-  }) {
-    const r = AbortSignal.timeout(a), o = new Promise((h, v) => {
-      r.addEventListener("abort", () => v(r.reason));
-    });
-    for (o.catch(() => {
-    }); !r.aborted; ) {
-      e == null || e.throwIfAborted();
+};
+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;
+  }
+  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 l;
+  });
+  for (const [l, h] of s.entries())
+    if (((f = h.$Intent) == null ? void 0 : f.name) === "AsyncTransactionThunk")
       try {
-        return await this.getTransactionBlock(t);
+        h.$Intent.data.resultIndex = o(l);
       } catch {
-        await Promise.race([
-          new Promise((h) => setTimeout(h, s)),
-          o
-        ]);
       }
-    }
-    throw r.throwIfAborted(), new Error("Unexpected error while waiting for transaction block.");
-  }
-}
+};
+let _t = tt;
 export {
-  j as SuiJsonRpcClient
+  _t as Transaction,
+  ht as isTransaction
 };