wowok 1.8.2 → 2.1.9

package/dist/esm/transactions/executor/queue.js

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _queue, _queue2;
+class SerialQueue {
+  constructor() {
+    __privateAdd(this, _queue, []);
+  }
+  async runTask(task) {
+    return new Promise((resolve, reject) => {
+      __privateGet(this, _queue).push(() => {
+        task().finally(() => {
+          __privateGet(this, _queue).shift();
+          if (__privateGet(this, _queue).length > 0) {
+            __privateGet(this, _queue)[0]();
+          }
+        }).then(resolve, reject);
+      });
+      if (__privateGet(this, _queue).length === 1) {
+        __privateGet(this, _queue)[0]();
+      }
+    });
+  }
+}
+_queue = new WeakMap();
+class ParallelQueue {
+  constructor(maxTasks) {
+    __privateAdd(this, _queue2, []);
+    __publicField(this, "activeTasks", 0);
+    __publicField(this, "maxTasks");
+    this.maxTasks = maxTasks;
+  }
+  runTask(task) {
+    return new Promise((resolve, reject) => {
+      if (this.activeTasks < this.maxTasks) {
+        this.activeTasks++;
+        task().finally(() => {
+          if (__privateGet(this, _queue2).length > 0) {
+            __privateGet(this, _queue2).shift()();
+          } else {
+            this.activeTasks--;
+          }
+        }).then(resolve, reject);
+      } else {
+        __privateGet(this, _queue2).push(() => {
+          task().finally(() => {
+            if (__privateGet(this, _queue2).length > 0) {
+              __privateGet(this, _queue2).shift()();
+            } else {
+              this.activeTasks--;
+            }
+          }).then(resolve, reject);
+        });
+      }
+    });
+  }
+}
+_queue2 = new WeakMap();
+export {
+  ParallelQueue,
+  SerialQueue
+};

package/dist/esm/transactions/executor/serial.d.ts

@@ -0,0 +1,31 @@
+import type { bcs } from "../../bcs/index.js";
+import type { SuiClient, SuiTransactionBlockResponseOptions } from "../../client/index.js";
+import type { Signer } from "../../cryptography/keypair.js";
+import type { ObjectCacheOptions } from "../ObjectCache.js";
+import { Transaction } from "../Transaction.js";
+export declare class SerialTransactionExecutor {
+    #private;
+    constructor({ signer, defaultGasBudget, ...options }: Omit<ObjectCacheOptions, "address"> & {
+        client: SuiClient;
+        signer: Signer;
+        /** The gasBudget to use if the transaction has not defined it's own gasBudget, defaults to `50_000_000n` */
+        defaultGasBudget?: bigint;
+    });
+    applyEffects(effects: typeof bcs.TransactionEffects.$inferType): Promise<void>;
+    buildTransaction(transaction: Transaction): Promise<Uint8Array<ArrayBuffer>>;
+    resetCache(): Promise<void>;
+    waitForLastTransaction(): Promise<void>;
+    executeTransaction(transaction: Transaction | Uint8Array, options?: SuiTransactionBlockResponseOptions, additionalSignatures?: string[]): Promise<{
+        digest: string;
+        effects: string;
+        data: import("../../client/index.js").SuiTransactionBlockResponse;
+    }>;
+}
+export declare function getGasCoinFromEffects(effects: typeof bcs.TransactionEffects.$inferType): {
+    ref: {
+        objectId: string;
+        digest: string;
+        version: string;
+    };
+    owner: string;
+};

package/dist/esm/transactions/executor/serial.js

@@ -0,0 +1,116 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _queue, _signer, _cache, _defaultGasBudget, _cacheGasCoin, _buildTransaction;
+import { toBase64 } from "@mysten/bcs";
+import { isTransaction, Transaction } from "../Transaction.js";
+import { CachingTransactionExecutor } from "./caching.js";
+import { SerialQueue } from "./queue.js";
+class SerialTransactionExecutor {
+  constructor({
+    signer,
+    defaultGasBudget = 50000000n,
+    ...options
+  }) {
+    __privateAdd(this, _queue, new SerialQueue());
+    __privateAdd(this, _signer);
+    __privateAdd(this, _cache);
+    __privateAdd(this, _defaultGasBudget);
+    __privateAdd(this, _cacheGasCoin, async (effects) => {
+      if (!effects.V2) {
+        return;
+      }
+      const gasCoin = getGasCoinFromEffects(effects).ref;
+      if (gasCoin) {
+        __privateGet(this, _cache).cache.setCustom("gasCoin", gasCoin);
+      } else {
+        __privateGet(this, _cache).cache.deleteCustom("gasCoin");
+      }
+    });
+    __privateAdd(this, _buildTransaction, async (transaction) => {
+      const gasCoin = await __privateGet(this, _cache).cache.getCustom("gasCoin");
+      const copy = Transaction.from(transaction);
+      if (gasCoin) {
+        copy.setGasPayment([gasCoin]);
+      }
+      copy.setGasBudgetIfNotSet(__privateGet(this, _defaultGasBudget));
+      copy.setSenderIfNotSet(__privateGet(this, _signer).toWAddress());
+      return __privateGet(this, _cache).buildTransaction({ transaction: copy });
+    });
+    __privateSet(this, _signer, signer);
+    __privateSet(this, _defaultGasBudget, defaultGasBudget);
+    __privateSet(this, _cache, new CachingTransactionExecutor({
+      client: options.client,
+      cache: options.cache,
+      onEffects: (effects) => __privateGet(this, _cacheGasCoin).call(this, effects)
+    }));
+  }
+  async applyEffects(effects) {
+    return __privateGet(this, _cache).applyEffects(effects);
+  }
+  async buildTransaction(transaction) {
+    return __privateGet(this, _queue).runTask(() => __privateGet(this, _buildTransaction).call(this, transaction));
+  }
+  resetCache() {
+    return __privateGet(this, _cache).reset();
+  }
+  waitForLastTransaction() {
+    return __privateGet(this, _cache).waitForLastTransaction();
+  }
+  executeTransaction(transaction, options, additionalSignatures = []) {
+    return __privateGet(this, _queue).runTask(async () => {
+      const bytes = isTransaction(transaction) ? await __privateGet(this, _buildTransaction).call(this, transaction) : transaction;
+      const { signature } = await __privateGet(this, _signer).signTransaction(bytes);
+      const results = await __privateGet(this, _cache).executeTransaction({
+        signature: [signature, ...additionalSignatures],
+        transaction: bytes,
+        options
+      }).catch(async (error) => {
+        await this.resetCache();
+        throw error;
+      });
+      const effectsBytes = Uint8Array.from(results.rawEffects);
+      return {
+        digest: results.digest,
+        effects: toBase64(effectsBytes),
+        data: results
+      };
+    });
+  }
+}
+_queue = new WeakMap();
+_signer = new WeakMap();
+_cache = new WeakMap();
+_defaultGasBudget = new WeakMap();
+_cacheGasCoin = new WeakMap();
+_buildTransaction = new WeakMap();
+function getGasCoinFromEffects(effects) {
+  if (!effects.V2) {
+    throw new Error("Unexpected effects version");
+  }
+  const gasObjectChange = effects.V2.changedObjects[effects.V2.gasObjectIndex];
+  if (!gasObjectChange) {
+    throw new Error("Gas object not found in effects");
+  }
+  const [objectId, { outputState }] = gasObjectChange;
+  if (!outputState.ObjectWrite) {
+    throw new Error("Unexpected gas object state");
+  }
+  const [digest, owner] = outputState.ObjectWrite;
+  return {
+    ref: {
+      objectId,
+      digest,
+      version: effects.V2.lamportVersion
+    },
+    owner: owner.AddressOwner || owner.ObjectOwner
+  };
+}
+export {
+  SerialTransactionExecutor,
+  getGasCoinFromEffects
+};

package/dist/esm/transactions/hash.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generates a Blake2b hash of typed data as a base64 string.
+ *
+ * @param typeTag type tag (e.g. TransactionData, SenderSignedData)
+ * @param data data to hash
+ */
+export declare function hashTypedData(typeTag: string, data: Uint8Array): Uint8Array;

package/dist/esm/transactions/hash.js

@@ -0,0 +1,11 @@
+import { blake2b } from "@noble/hashes/blake2b";
+function hashTypedData(typeTag, data) {
+  const typeTagBytes = Array.from(`${typeTag}::`).map((e) => e.charCodeAt(0));
+  const dataWithTag = new Uint8Array(typeTagBytes.length + data.length);
+  dataWithTag.set(typeTagBytes);
+  dataWithTag.set(data, typeTagBytes.length);
+  return blake2b(dataWithTag, { dkLen: 32 });
+}
+export {
+  hashTypedData
+};

package/dist/esm/transactions/index.d.ts

@@ -0,0 +1,21 @@
+import type { NamedPackagesOverrides } from "./plugins/NamedPackagesPlugin.js";
+export { normalizedTypeToMoveTypeSignature, getPureBcsSchema, } from "./serializer.js";
+export { Inputs } from "./Inputs.js";
+export { Commands, type TransactionArgument, type TransactionInput, UpgradePolicy, } from "./Commands.js";
+export { Transaction, isTransaction, type TransactionObjectInput, type TransactionObjectArgument, type TransactionResult, } from "./Transaction.js";
+export { type SerializedTransactionDataV2 } from "./data/v2.js";
+export { type SerializedTransactionDataV1 } from "./data/v1.js";
+export type { TransactionData, Argument, ObjectRef, GasData, CallArg, Command, OpenMoveTypeSignature, OpenMoveTypeSignatureBody, } from "./data/internal.js";
+export { TransactionDataBuilder } from "./TransactionData.js";
+export { ObjectCache, AsyncCache } from "./ObjectCache.js";
+export { SerialTransactionExecutor } from "./executor/serial.js";
+export { ParallelTransactionExecutor } from "./executor/parallel.js";
+export type { ParallelTransactionExecutorOptions } from "./executor/parallel.js";
+export { coinWithBalance } from "./intents/CoinWithBalance.js";
+export type { BuildTransactionOptions, SerializeTransactionOptions, TransactionPlugin, } from "./resolve.js";
+export { Arguments } from "./Arguments.js";
+export { namedPackagesPlugin, type NamedPackagesPluginOptions, } from "./plugins/NamedPackagesPlugin.js";
+export type { NamedPackagesOverrides };
+/** @deprecated Use NamedPackagesOverrides instead */
+export type NamedPackagesPluginCache = NamedPackagesOverrides;
+export { isArgument } from "./utils.js";

package/dist/esm/transactions/index.js

@@ -0,0 +1,41 @@
+import {
+  normalizedTypeToMoveTypeSignature,
+  getPureBcsSchema
+} from "./serializer.js";
+import { Inputs } from "./Inputs.js";
+import {
+  Commands,
+  UpgradePolicy
+} from "./Commands.js";
+import {
+  Transaction,
+  isTransaction
+} from "./Transaction.js";
+import { TransactionDataBuilder } from "./TransactionData.js";
+import { ObjectCache, AsyncCache } from "./ObjectCache.js";
+import { SerialTransactionExecutor } from "./executor/serial.js";
+import { ParallelTransactionExecutor } from "./executor/parallel.js";
+import { coinWithBalance } from "./intents/CoinWithBalance.js";
+import { Arguments } from "./Arguments.js";
+import {
+  namedPackagesPlugin
+} from "./plugins/NamedPackagesPlugin.js";
+import { isArgument } from "./utils.js";
+export {
+  Arguments,
+  AsyncCache,
+  Commands,
+  Inputs,
+  ObjectCache,
+  ParallelTransactionExecutor,
+  SerialTransactionExecutor,
+  Transaction,
+  TransactionDataBuilder,
+  UpgradePolicy,
+  coinWithBalance,
+  getPureBcsSchema,
+  isArgument,
+  isTransaction,
+  namedPackagesPlugin,
+  normalizedTypeToMoveTypeSignature
+};

package/dist/esm/transactions/intents/CoinWithBalance.d.ts

@@ -0,0 +1,9 @@
+import type { SuiClient } from "../../client/index.js";
+import type { BuildTransactionOptions } from "../resolve.js";
+import type { Transaction, TransactionResult } from "../Transaction.js";
+export declare function coinWithBalance({ type, balance, useGasCoin, }: {
+    balance: bigint | number;
+    type?: string;
+    useGasCoin?: boolean;
+}): (tx: Transaction) => TransactionResult;
+export declare function getSuiClient(options: BuildTransactionOptions): SuiClient;

package/dist/esm/transactions/intents/CoinWithBalance.js

@@ -0,0 +1,186 @@
+import { bigint, object, parse, string } from "valibot";
+import { bcs } from "../../bcs/index.js";
+import { normalizeStructTag } from "../../utils/sui-types.js";
+import { Commands } from "../Commands.js";
+import { Inputs } from "../Inputs.js";
+import { getClient } from "../resolve.js";
+const COIN_WITH_BALANCE = "CoinWithBalance";
+const SUI_TYPE = normalizeStructTag("0x2::sui::SUI");
+function coinWithBalance({
+  type = SUI_TYPE,
+  balance,
+  useGasCoin = true
+}) {
+  let coinResult = null;
+  return (tx) => {
+    if (coinResult) {
+      return coinResult;
+    }
+    tx.addIntentResolver(COIN_WITH_BALANCE, resolveCoinBalance);
+    const coinType = type === "gas" ? type : normalizeStructTag(type);
+    coinResult = tx.add(
+      Commands.Intent({
+        name: COIN_WITH_BALANCE,
+        inputs: {},
+        data: {
+          type: coinType === SUI_TYPE && useGasCoin ? "gas" : coinType,
+          balance: BigInt(balance)
+        }
+      })
+    );
+    return coinResult;
+  };
+}
+const CoinWithBalanceData = object({
+  type: string(),
+  balance: bigint()
+});
+async function resolveCoinBalance(transactionData, buildOptions, next) {
+  const coinTypes = /* @__PURE__ */ new Set();
+  const totalByType = /* @__PURE__ */ new Map();
+  if (!transactionData.sender) {
+    throw new Error("Sender must be set to resolve CoinWithBalance");
+  }
+  for (const command of transactionData.commands) {
+    if (command.$kind === "$Intent" && command.$Intent.name === COIN_WITH_BALANCE) {
+      const { type, balance } = parse(
+        CoinWithBalanceData,
+        command.$Intent.data
+      );
+      if (type !== "gas" && balance > 0n) {
+        coinTypes.add(type);
+      }
+      totalByType.set(type, (totalByType.get(type) ?? 0n) + balance);
+    }
+  }
+  const usedIds = /* @__PURE__ */ new Set();
+  for (const input of transactionData.inputs) {
+    if (input.Object?.ImmOrOwnedObject) {
+      usedIds.add(input.Object.ImmOrOwnedObject.objectId);
+    }
+    if (input.UnresolvedObject?.objectId) {
+      usedIds.add(input.UnresolvedObject.objectId);
+    }
+  }
+  const coinsByType = /* @__PURE__ */ new Map();
+  const client = getSuiClient(buildOptions);
+  await Promise.all(
+    [...coinTypes].map(async (coinType) => {
+      coinsByType.set(
+        coinType,
+        await getCoinsOfType({
+          coinType,
+          balance: totalByType.get(coinType),
+          client,
+          owner: transactionData.sender,
+          usedIds
+        })
+      );
+    })
+  );
+  const mergedCoins = /* @__PURE__ */ new Map();
+  mergedCoins.set("gas", { $kind: "GasCoin", GasCoin: true });
+  for (const [index, transaction] of transactionData.commands.entries()) {
+    if (transaction.$kind !== "$Intent" || transaction.$Intent.name !== COIN_WITH_BALANCE) {
+      continue;
+    }
+    const { type, balance } = transaction.$Intent.data;
+    if (balance === 0n && type !== "gas") {
+      transactionData.replaceCommand(
+        index,
+        Commands.MoveCall({
+          target: "0x2::coin::zero",
+          typeArguments: [type]
+        })
+      );
+      continue;
+    }
+    const commands = [];
+    if (!mergedCoins.has(type)) {
+      const [first, ...rest] = coinsByType.get(type).map(
+        (coin) => transactionData.addInput(
+          "object",
+          Inputs.ObjectRef({
+            objectId: coin.coinObjectId,
+            digest: coin.digest,
+            version: coin.version
+          })
+        )
+      );
+      if (rest.length > 0) {
+        commands.push(Commands.MergeCoins(first, rest));
+      }
+      mergedCoins.set(type, first);
+    }
+    commands.push(
+      Commands.SplitCoins(mergedCoins.get(type), [
+        transactionData.addInput(
+          "pure",
+          Inputs.Pure(bcs.u64().serialize(balance))
+        )
+      ])
+    );
+    transactionData.replaceCommand(index, commands);
+    transactionData.mapArguments((arg) => {
+      if (arg.$kind === "Result" && arg.Result === index) {
+        return {
+          $kind: "NestedResult",
+          NestedResult: [index + commands.length - 1, 0]
+        };
+      }
+      return arg;
+    });
+  }
+  return next();
+}
+async function getCoinsOfType({
+  coinType,
+  balance,
+  client,
+  owner,
+  usedIds
+}) {
+  let remainingBalance = balance;
+  const coins = [];
+  return loadMoreCoins();
+  async function loadMoreCoins(cursor = null) {
+    const { data, hasNextPage, nextCursor } = await client.getCoins({
+      owner,
+      coinType,
+      cursor
+    });
+    const sortedCoins = data.sort(
+      (a, b) => Number(BigInt(b.balance) - BigInt(a.balance))
+    );
+    for (const coin of sortedCoins) {
+      if (usedIds.has(coin.coinObjectId)) {
+        continue;
+      }
+      const coinBalance = BigInt(coin.balance);
+      coins.push(coin);
+      remainingBalance -= coinBalance;
+      if (remainingBalance <= 0) {
+        return coins;
+      }
+    }
+    if (hasNextPage) {
+      return loadMoreCoins(nextCursor);
+    }
+    throw new Error(
+      `Not enough coins of type ${coinType} to satisfy requested balance`
+    );
+  }
+}
+function getSuiClient(options) {
+  const client = getClient(options);
+  if (!client.jsonRpc) {
+    throw new Error(
+      `CoinWithBalance intent currently only works with SuiClient`
+    );
+  }
+  return client;
+}
+export {
+  coinWithBalance,
+  getSuiClient
+};

package/dist/esm/transactions/object.d.ts

@@ -0,0 +1,24 @@
+import type { Transaction, TransactionObjectInput } from "./Transaction.js";
+export declare function createObjectMethods<T>(makeObject: (value: TransactionObjectInput) => T): {
+    (value: TransactionObjectInput): T;
+    system(options?: {
+        mutable?: boolean;
+    }): T;
+    clock(): T;
+    random(): T;
+    denyList(options?: {
+        mutable?: boolean;
+    }): T;
+    registrar(options?: {
+        mutable?: boolean;
+    }): T;
+    mutRegistrar(): T;
+    entity(options?: {
+        mutable?: boolean;
+    }): T;
+    mutEntity(): T;
+    option({ type, value, }: {
+        type: string;
+        value: TransactionObjectInput | null;
+    }): (tx: Transaction) => import("./Transaction.js").TransactionResult;
+};

package/dist/esm/transactions/object.js

@@ -0,0 +1,96 @@
+import { Inputs } from "./Inputs.js";
+function createObjectMethods(makeObject) {
+  function object(value) {
+    return makeObject(value);
+  }
+  object.system = (options) => {
+    const mutable = options?.mutable;
+    if (mutable !== void 0) {
+      return object(
+        Inputs.SharedObjectRef({
+          objectId: "0x5",
+          initialSharedVersion: 1,
+          mutable
+        })
+      );
+    }
+    return object({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: "0x5",
+        initialSharedVersion: 1
+      }
+    });
+  };
+  object.clock = () => object(
+    Inputs.SharedObjectRef({
+      objectId: "0x6",
+      initialSharedVersion: 1,
+      mutable: false
+    })
+  );
+  object.random = () => object({
+    $kind: "UnresolvedObject",
+    UnresolvedObject: {
+      objectId: "0x8",
+      mutable: false
+    }
+  });
+  object.denyList = (options) => {
+    return object({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: "0x403",
+        mutable: options?.mutable
+      }
+    });
+  };
+  object.registrar = (options) => {
+    return object({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: "0xaaa",
+        mutable: options?.mutable
+      }
+    });
+  };
+  object.mutRegistrar = () => {
+    return object({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: "0xaaa",
+        mutable: true
+      }
+    });
+  };
+  object.entity = (options) => {
+    return object({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: "0xaab",
+        mutable: options?.mutable
+      }
+    });
+  };
+  object.mutEntity = () => {
+    return object({
+      $kind: "UnresolvedObject",
+      UnresolvedObject: {
+        objectId: "0xaab",
+        mutable: true
+      }
+    });
+  };
+  object.option = ({
+    type,
+    value
+  }) => (tx) => tx.moveCall({
+    typeArguments: [type],
+    target: `0x1::option::${value === null ? "none" : "some"}`,
+    arguments: value === null ? [] : [tx.object(value)]
+  });
+  return object;
+}
+export {
+  createObjectMethods
+};

package/dist/esm/transactions/plugins/NamedPackagesPlugin.d.ts

@@ -0,0 +1,31 @@
+import type { BuildTransactionOptions } from "../resolve.js";
+import type { TransactionDataBuilder } from "../TransactionData.js";
+export type NamedPackagesPluginOptions = {
+    /**
+     * The URL of the MVR API to use for resolving names.
+     * @deprecated MVR support has been disabled
+     */
+    url?: string;
+    /**
+     * The number of names to resolve in each batch request.
+     * @deprecated MVR support has been disabled
+     */
+    pageSize?: number;
+    /**
+     * Local overrides for the resolution plugin.
+     * @deprecated MVR support has been disabled
+     */
+    overrides?: NamedPackagesOverrides;
+};
+export type NamedPackagesOverrides = {
+    packages?: Record<string, string>;
+    types?: Record<string, string>;
+};
+/**
+ * @deprecated MVR support has been disabled. This plugin now passes through without any name resolution.
+ *
+ * Previously added named resolution so that you could use .move names in your transactions.
+ * e.g. `@org/app::type::Type` would be resolved to `0x1234::type::Type`.
+ */
+export declare const namedPackagesPlugin: (_options?: NamedPackagesPluginOptions) => (_transactionData: TransactionDataBuilder, _buildOptions: BuildTransactionOptions, next: () => Promise<void>) => Promise<void>;
+export declare function getClient(options: BuildTransactionOptions): import("../../index.js").ClientWithCoreApi;

package/dist/esm/transactions/plugins/NamedPackagesPlugin.js

@@ -0,0 +1,17 @@
+const namedPackagesPlugin = (_options) => {
+  return async (_transactionData, _buildOptions, next) => {
+    await next();
+  };
+};
+function getClient(options) {
+  if (!options.client) {
+    throw new Error(
+      `No sui client passed to Transaction#build, but transaction data was not sufficient to build offline.`
+    );
+  }
+  return options.client;
+}
+export {
+  getClient,
+  namedPackagesPlugin
+};