@gardenfi/swap 0.1.3-beta.13 → 0.1.3-beta.15

package/dist/index79.js

@@ -1,15 +1,730 @@
-import { BaseError as r } from "./index178.js";
-class d extends r {
-  constructor({ address: s }) {
-    super(`Address "${s}" is invalid.`, {
-      metaMessages: [
-        "- Address must be a hex value of 20 bytes (40 hex characters).",
-        "- Address must match its checksum counterpart."
+import { fromBase58 as u } from "./index263.js";
+import { toBase64 as d } from "./index264.js";
+import { toHex as y } from "./index265.js";
+import { Experimental_BaseClient as k } from "./index266.js";
+import { isTransaction as f } from "./index80.js";
+import { isValidSuiAddress as n, normalizeSuiAddress as c, isValidSuiObjectId as m, normalizeSuiObjectId as g, isValidTransactionDigest as w } from "./index267.js";
+import { normalizeSuiNSName as M } from "./index268.js";
+import { JsonRpcHTTPTransport as S } from "./index259.js";
+import { isValidNamedPackage as i } from "./index269.js";
+import { hasMvrName as l } from "./index270.js";
+import { JSONRpcCoreClient as b } from "./index271.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;
+  }
+  async getRpcApiVersion({ signal: e } = {}) {
+    return (await this.transport.request({
+      method: "rpc.discover",
+      params: [],
+      signal: e
+    })).info.version;
+  }
+  /**
+   * Get all Coin<`coin_type`> objects owned by an address.
+   */
+  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
+    });
+  }
+  /**
+   * Get all Coin objects owned by an address.
+   */
+  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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   *  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
+    });
+  }
+  /**
+   * 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 });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * Get a structured representation of Move function
+   */
+  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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  async tryGetPastObject(e) {
+    return await this.transport.request({
+      method: "sui_tryGetPastObject",
+      params: [e.id, e.version, e.options],
+      signal: e.signal
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  /**
+   * 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
+    });
+  }
+  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
+    });
+  }
+  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
+    });
+  }
+  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
       ],
-      name: "InvalidAddressError"
+      signal: r
+    });
+    if (t === "WaitForLocalExecution")
+      try {
+        await this.waitForTransaction({
+          digest: o.digest
+        });
+      } catch {
+      }
+    return o;
+  }
+  async signAndExecuteTransaction({
+    transaction: e,
+    signer: a,
+    ...s
+  }) {
+    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 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
+   *
+   * @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
+    });
+  }
+  /**
+   * 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
+        })
+      );
+    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
+    });
+  }
+  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))
+    };
+  }
+  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
+    });
+  }
+  /**
+   * 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();
+      try {
+        return await this.getTransactionBlock(t);
+      } catch {
+        await Promise.race([
+          new Promise((h) => setTimeout(h, s)),
+          o
+        ]);
+      }
+    }
+    throw r.throwIfAborted(), new Error("Unexpected error while waiting for transaction block.");
   }
 }
 export {
-  d as InvalidAddressError
+  j as SuiJsonRpcClient
 };