wapi-client 0.7.2 → 0.8.1

package/dist/api/base-client.browser.cjs

@@ -0,0 +1,916 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/api/base-client.ts
+var base_client_exports = {};
+__export(base_client_exports, {
+  BaseClient: () => BaseClient
+});
+module.exports = __toCommonJS(base_client_exports);
+var import_debug = require('../lib/debug.cjs');
+var import_errors = require('../lib/errors.cjs');
+var import_stream_promise = require('../lib/stream-promise.cjs');
+var import_stream_promise_input = require('../lib/stream-promise-input.cjs');
+var import_streams = require('../lib/isomorphic/web/streams.cjs');
+var import_utils = require('../lib/utils.cjs');
+var import_jsonrpc = require('./jsonrpc/jsonrpc.enums.cjs');
+var import__ = require('../index.cjs');
+var import_txs = require('../txs/index.cjs');
+var import_import_actions = require('../txs/import-actions/import-actions.guards.cjs');
+var BaseClient = class {
+  constructor(connection, connectionType, $connect) {
+    this.isConnected = false;
+    this.hooks = new Proxy(
+      {},
+      {
+        set(obj, prop, value) {
+          if (typeof value !== "function") {
+            throw new TypeError("Hooks can only be functions");
+          }
+          obj[prop] = value;
+          return true;
+        }
+      }
+    );
+    this._requests = /* @__PURE__ */ new Map();
+    this._error = false;
+    this._sending = /* @__PURE__ */ new Set();
+    this.type = connectionType;
+    this._connection = connection;
+    this.connectionType = connectionType;
+    this.$connect = $connect;
+  }
+  _setConnected(value) {
+    this.isConnected = value;
+    if (this.isConnected && this._error !== false) {
+      this._error = false;
+    }
+    if (this.isConnected && this.hooks.connected) {
+      this.hooks.connected(this.socId);
+    }
+    if (!this.isConnected && this.hooks.disconnected) {
+      this.hooks.disconnected();
+    }
+  }
+  _setErrored(err) {
+    this._error = err;
+    if (this.isConnected) {
+      this._setConnected(false);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _send(input) {
+    throw new Error("This method must be implemented by child class");
+  }
+  _reconnect() {
+    throw new Error("This method must be implemented by child class");
+  }
+  close() {
+    return __async(this, null, function* () {
+      throw new Error("This method must be implemented by child class");
+    });
+  }
+  // Will fire this in case we lose connection
+  // This is so we can terminate ongoing requests
+  _connectionLost() {
+    this._requests.forEach((responseObject, key) => {
+      if ("stream" in responseObject) {
+        responseObject.stream.destroy(
+          new import_errors.ConnectionError({
+            message: "connection lost"
+          })
+        );
+      }
+      this._requests.delete(key);
+    });
+    this.socId = void 0;
+  }
+  _handleMessage(incoming) {
+    var _a, _b, _c;
+    if (this.hooks.message) {
+      this.hooks.message(incoming);
+    }
+    if ("method" in incoming) {
+      const message2 = incoming;
+      if (message2.method === import_jsonrpc.JSONRPC.ping) {
+        this._send({
+          jsonrpc: import_jsonrpc.JSONRPC.version,
+          result: import_jsonrpc.JSONRPC.pong,
+          id: message2.id
+        });
+        return;
+      }
+      (0, import_debug.debugLog)("Unexpected JSONRPCRequest", incoming);
+      return;
+    }
+    const responseMessage = incoming;
+    if (this.hooks.message) {
+      this.hooks.message(responseMessage);
+    }
+    if (responseMessage.id === null) {
+      (0, import_debug.debugLog)("Unexpected JSONRPCResponse", incoming);
+      return;
+    }
+    if (responseMessage.result === import_jsonrpc.JSONRPC.acknowledgement) {
+      this._sending.delete(responseMessage.id);
+      return;
+    }
+    const requestInfo = this._requests.get(responseMessage.id);
+    if (!requestInfo) {
+      (0, import_debug.debugLog)("No Request found for incoming", incoming);
+      return;
+    }
+    if ("handle" in requestInfo) {
+      requestInfo.handle(responseMessage);
+      delete requestInfo.handle;
+      return;
+    }
+    if (responseMessage.error && "error" in requestInfo) {
+      requestInfo.error(responseMessage.error);
+    }
+    const message = responseMessage;
+    if (((_a = message.result) == null ? void 0 : _a.type) === import_jsonrpc.JSONRPC.streamPause && "pause" in requestInfo) {
+      requestInfo.pause();
+      return;
+    }
+    if (((_b = message.result) == null ? void 0 : _b.type) === import_jsonrpc.JSONRPC.streamResume && "resume" in requestInfo) {
+      requestInfo.resume();
+      return;
+    }
+    const { stream, start } = requestInfo;
+    if (((_c = message.result) == null ? void 0 : _c.type) === import_jsonrpc.JSONRPC.streamChunk) {
+      stream.push(message.result);
+      return;
+    }
+    stream.push(message);
+    stream.push(null);
+    this._requests.delete(message.id);
+    if (this.connectionType === import__.WapiClientType.ws) {
+      this._send({
+        jsonrpc: import_jsonrpc.JSONRPC.version,
+        method: import_jsonrpc.JSONRPC.acknowledgement,
+        params: Date.now() - start,
+        id: message.id
+      });
+    }
+  }
+  _sendTransaction(name, input) {
+    const { isValid, inputCopy, error } = import_txs.APIValidators[name](input);
+    if (!isValid) {
+      throw error;
+    }
+    const jsonRpcMessage = {
+      jsonrpc: import_jsonrpc.JSONRPC.version,
+      method: name,
+      params: inputCopy,
+      id: (0, import_utils.getRandomHex)()
+    };
+    if (this.hooks.preflight && this.hooks.preflight(jsonRpcMessage) === false) {
+      return new import_stream_promise.StreamPromise();
+    }
+    return new import_stream_promise.StreamPromise((stream) => __async(this, null, function* () {
+      if (this._error) {
+        this._reconnect();
+      }
+      if (!this.isConnected) {
+        yield this.$connect;
+      }
+      this._requests.set(jsonRpcMessage.id, {
+        stream,
+        start: Date.now()
+      });
+      this._sending.add(jsonRpcMessage.id);
+      this._send(jsonRpcMessage);
+    }));
+  }
+  _streamTransaction(name, isInputChunk, options, transform) {
+    const start = Date.now();
+    const streamId = (0, import_utils.getRandomHex)();
+    let _error;
+    const sendToStream = ({
+      method,
+      params
+    }) => {
+      if (_error) {
+        return;
+      }
+      const streamMessage = {
+        jsonrpc: import_jsonrpc.JSONRPC.version,
+        method,
+        params: __spreadValues({
+          streamId
+        }, params),
+        id: (0, import_utils.getRandomHex)()
+      };
+      this._sending.add(streamMessage.id);
+      this._send(streamMessage);
+    };
+    const sendErrorToStream = (stream, error) => {
+      if (_error) {
+        return;
+      }
+      sendToStream({
+        method: "streamError",
+        params: {
+          error
+        }
+      });
+      _error = error;
+      stream.push({
+        error
+      });
+    };
+    const inputStream = new import_streams.ReadWriteStream();
+    const finalInputStream = transform ? inputStream.pipe(transform) : inputStream;
+    const streamStartMessage = {
+      jsonrpc: import_jsonrpc.JSONRPC.version,
+      method: "streamStart",
+      params: {
+        method: name,
+        options
+      },
+      id: streamId
+    };
+    if (this.hooks.preflight && this.hooks.preflight(streamStartMessage) === false) {
+      return new import_stream_promise_input.StreamPromiseInput();
+    }
+    return new import_stream_promise_input.StreamPromiseInput((stream) => __async(this, null, function* () {
+      if (this._error) {
+        this._reconnect();
+      }
+      if (!this.isConnected) {
+        yield this.$connect;
+      }
+      let timeout = setTimeout(() => {
+        stream.push({
+          error: new import_errors.InputError({
+            message: import_errors.ERROR_MESSAGES.INPUT_STREAM_TIMEOUT
+          })
+        });
+      }, 3e4);
+      this._requests.set(streamStartMessage.id, {
+        stream,
+        start,
+        error(error) {
+          _error = error;
+          (0, import_debug.debugLog)("stream:error()>", error);
+        },
+        pause() {
+          inputStream.pause();
+        },
+        resume() {
+          inputStream.resume();
+        },
+        handle(message) {
+          if (message.error) {
+            stream.push(message);
+            return;
+          }
+          finalInputStream.on("data", (chunk) => {
+            if (_error) {
+              return;
+            }
+            if (timeout) {
+              clearTimeout(timeout);
+              timeout = null;
+            }
+            if (!isInputChunk(chunk)) {
+              sendErrorToStream(
+                stream,
+                new import_errors.ValidationError({
+                  message: import_errors.ERROR_MESSAGES.INPUT_INVALID,
+                  data: chunk
+                })
+              );
+              return;
+            }
+            sendToStream({
+              method: "streamData",
+              params: {
+                data: chunk
+              }
+            });
+          }).on("error", (error) => {
+            if (_error) {
+              return;
+            }
+            if (timeout) {
+              clearTimeout(timeout);
+              timeout = null;
+            }
+            sendToStream({
+              method: "streamError",
+              params: {
+                error
+              }
+            });
+            stream.push({
+              error: new import_errors.InputError({
+                message: import_errors.ERROR_MESSAGES.INPUT_STREAM_ERROR,
+                data: error
+              })
+            });
+          }).on("end", () => {
+            if (timeout) {
+              clearTimeout(timeout);
+              timeout = null;
+            }
+            sendToStream({
+              method: "streamEnd",
+              params: {}
+            });
+          });
+        }
+      });
+      this._sending.add(streamStartMessage.id);
+      this._send(streamStartMessage);
+    }), inputStream);
+  }
+  // TXSDEFS
+  /*
+   * THIS IS AUTOGENERATED, DO NOT EDIT MANUALLY
+   * if you need custom code add it outside this block
+   */
+  /**
+   *
+   * @param {AggregateTransferManyTxInput} input
+   * @returns {StreamPromise<AggregateTransferManyTxOutput>}
+   *
+   */
+  aggregateTransferMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.aggregateTransferMany, input);
+  }
+  /**
+   *
+   * @param {AuthenticationCheckTxInput} input
+   * @returns {StreamPromise<AuthenticationCheckTxOutput>}
+   *
+   */
+  authenticationCheck(input) {
+    return this._sendTransaction(import_txs.APIFunctions.authenticationCheck, input);
+  }
+  /**
+   *
+   * @param {CreateAccessTokenTxInput} input
+   * @returns {StreamPromise<CreateAccessTokenTxOutput>}
+   *
+   */
+  createAccessToken(input) {
+    return this._sendTransaction(import_txs.APIFunctions.createAccessToken, input);
+  }
+  /**
+   *
+   * @param {CreateContractTxInput} input
+   * @returns {StreamPromise<CreateContractTxOutput>}
+   *
+   */
+  createContract(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.createContract,
+      input
+    );
+  }
+  /**
+   *
+   * @param {CreateDepositTxInput} input
+   * @returns {StreamPromise<CreateDepositTxOutput>}
+   *
+   */
+  createDeposit(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.createDeposit,
+      input
+    );
+  }
+  /**
+   *
+   * @param {CreateDistributionTxInput} input
+   * @returns {StreamPromise<CreateDistributionTxOutput>}
+   *
+   */
+  createDistribution(input) {
+    return this._sendTransaction(import_txs.APIFunctions.createDistribution, input);
+  }
+  /**
+   *
+   * @param {CreateTokenTxInput} input
+   * @returns {StreamPromise<CreateTokenTxOutput>}
+   *
+   */
+  createToken(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.createToken,
+      input
+    );
+  }
+  /**
+   *
+   * @param {CreateTransferTxInput} input
+   * @returns {StreamPromise<CreateTransferTxOutput>}
+   *
+   */
+  createTransfer(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.createTransfer,
+      input
+    );
+  }
+  /**
+   *
+   * @param {CreateTransferGroupTxInput} input
+   * @returns {StreamPromise<CreateTransferGroupTxOutput>}
+   *
+   */
+  createTransferGroup(input) {
+    return this._sendTransaction(import_txs.APIFunctions.createTransferGroup, input);
+  }
+  /**
+   *
+   * @param {CreateTransferManyTxInput} input
+   * @returns {StreamPromise<CreateTransferManyTxOutput>}
+   *
+   */
+  createTransferMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.createTransferMany, input);
+  }
+  /**
+   *
+   * @param {CreateWalletTxInput} input
+   * @returns {StreamPromise<CreateWalletTxOutput>}
+   *
+   */
+  createWallet(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.createWallet,
+      input
+    );
+  }
+  /**
+   *
+   * @param {CreateWithdrawalTxInput} input
+   * @returns {StreamPromise<CreateWithdrawalTxOutput>}
+   *
+   */
+  createWithdrawal(input) {
+    return this._sendTransaction(import_txs.APIFunctions.createWithdrawal, input);
+  }
+  /**
+   *
+   * @param {ExportDatabaseTxInput} input
+   * @returns {StreamPromise<ExportDatabaseTxOutput>}
+   *
+   */
+  exportDatabase(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.exportDatabase,
+      input
+    );
+  }
+  /**
+   *
+   * @param {FindBalanceManyTxInput} input
+   * @returns {StreamPromise<FindBalanceManyTxOutput>}
+   *
+   */
+  findBalanceMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.findBalanceMany, input);
+  }
+  /**
+   *
+   * @param {FindTokenManyTxInput} input
+   * @returns {StreamPromise<FindTokenManyTxOutput>}
+   *
+   */
+  findTokenMany(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.findTokenMany,
+      input
+    );
+  }
+  /**
+   *
+   * @param {FindTransferGroupManyTxInput} input
+   * @returns {StreamPromise<FindTransferGroupManyTxOutput>}
+   *
+   */
+  findTransferGroupMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.findTransferGroupMany, input);
+  }
+  /**
+   *
+   * @param {FindTransferManyTxInput} input
+   * @returns {StreamPromise<FindTransferManyTxOutput>}
+   *
+   */
+  findTransferMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.findTransferMany, input);
+  }
+  /**
+   *
+   * @param {FindWalletManyTxInput} input
+   * @returns {StreamPromise<FindWalletManyTxOutput>}
+   *
+   */
+  findWalletMany(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.findWalletMany,
+      input
+    );
+  }
+  /**
+   *
+   * @param {FinishTransactionTxInput} input
+   * @returns {StreamPromise<FinishTransactionTxOutput>}
+   *
+   */
+  finishTransaction(input) {
+    return this._sendTransaction(import_txs.APIFunctions.finishTransaction, input);
+  }
+  /**
+   *
+   * @param {GetBalanceTxInput} input
+   * @returns {StreamPromise<GetBalanceTxOutput>}
+   *
+   */
+  getBalance(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getBalance,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetBalanceHistoryTxInput} input
+   * @returns {StreamPromise<GetBalanceHistoryTxOutput>}
+   *
+   */
+  getBalanceHistory(input) {
+    return this._sendTransaction(import_txs.APIFunctions.getBalanceHistory, input);
+  }
+  /**
+   *
+   * @param {GetDatabaseExportProgressTxInput} input
+   * @returns {StreamPromise<GetDatabaseExportProgressTxOutput>}
+   *
+   */
+  getDatabaseExportProgress(input) {
+    return this._sendTransaction(import_txs.APIFunctions.getDatabaseExportProgress, input);
+  }
+  /**
+   *
+   * @param {GetDatabaseImportProgressTxInput} input
+   * @returns {StreamPromise<GetDatabaseImportProgressTxOutput>}
+   *
+   */
+  getDatabaseImportProgress(input) {
+    return this._sendTransaction(import_txs.APIFunctions.getDatabaseImportProgress, input);
+  }
+  /**
+   *
+   * @param {GetFlagsTxInput} input
+   * @returns {StreamPromise<GetFlagsTxOutput>}
+   *
+   */
+  getFlags(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getFlags,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetStatisticsTxInput} input
+   * @returns {StreamPromise<GetStatisticsTxOutput>}
+   *
+   */
+  getStatistics(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getStatistics,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetTokenTxInput} input
+   * @returns {StreamPromise<GetTokenTxOutput>}
+   *
+   */
+  getToken(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getToken,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetTokenManyTxInput} input
+   * @returns {StreamPromise<GetTokenManyTxOutput>}
+   *
+   */
+  getTokenMany(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getTokenMany,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetTransferTxInput} input
+   * @returns {StreamPromise<GetTransferTxOutput>}
+   *
+   */
+  getTransfer(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getTransfer,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetTransferGroupTxInput} input
+   * @returns {StreamPromise<GetTransferGroupTxOutput>}
+   *
+   */
+  getTransferGroup(input) {
+    return this._sendTransaction(import_txs.APIFunctions.getTransferGroup, input);
+  }
+  /**
+   *
+   * @param {GetWalletTxInput} input
+   * @returns {StreamPromise<GetWalletTxOutput>}
+   *
+   */
+  getWallet(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getWallet,
+      input
+    );
+  }
+  /**
+   *
+   * @param {GetWalletManyTxInput} input
+   * @returns {StreamPromise<GetWalletManyTxOutput>}
+   *
+   */
+  getWalletMany(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.getWalletMany,
+      input
+    );
+  }
+  /**
+   *
+   * @param {ImportActionsTxInput} input
+   * @returns {StreamPromise<ImportActionsTxOutput>}
+   *
+   */
+  importActions(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.importActions,
+      input
+    );
+  }
+  /**
+   *
+   * @param {ImportActionsTxOptions} [input]
+   * @param {TransformStream} [transform]
+   * @returns {StreamPromiseInput<ImportActionsTxOutput>}
+   *
+   */
+  importActionsStream(input, transform) {
+    if (input !== void 0 && !(0, import_import_actions.isImportActionsTxOptions)(input)) {
+      throw new import_errors.ValidationError({
+        message: import_errors.ERROR_MESSAGES.INPUT_INVALID,
+        data: input
+      });
+    }
+    return this._streamTransaction(import_txs.APIFunctions.importActions, import_import_actions.isImportActionsTxInput, input, transform);
+  }
+  /**
+   *
+   * @param {ImportDatabaseTxInput} input
+   * @returns {StreamPromise<ImportDatabaseTxOutput>}
+   *
+   */
+  importDatabase(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.importDatabase,
+      input
+    );
+  }
+  /**
+   *
+   * @param {ListDatabaseExportsTxInput} input
+   * @returns {StreamPromise<ListDatabaseExportsTxOutput>}
+   *
+   */
+  listDatabaseExports(input) {
+    return this._sendTransaction(import_txs.APIFunctions.listDatabaseExports, input);
+  }
+  /**
+   *
+   * @param {QueryTxInput} input
+   * @returns {StreamPromise<QueryTxOutput>}
+   *
+   */
+  query(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.query,
+      input
+    );
+  }
+  /**
+   *
+   * @param {QueryLogsTxInput} input
+   * @returns {StreamPromise<QueryLogsTxOutput>}
+   *
+   */
+  queryLogs(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.queryLogs,
+      input
+    );
+  }
+  /**
+   *
+   * @param {ResetDatabaseTxInput} input
+   * @returns {StreamPromise<ResetDatabaseTxOutput>}
+   *
+   */
+  resetDatabase(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.resetDatabase,
+      input
+    );
+  }
+  /**
+   *
+   * @param {ReverseTransferTxInput} input
+   * @returns {StreamPromise<ReverseTransferTxOutput>}
+   *
+   */
+  reverseTransfer(input) {
+    return this._sendTransaction(import_txs.APIFunctions.reverseTransfer, input);
+  }
+  /**
+   *
+   * @param {ReverseTransferGroupTxInput} input
+   * @returns {StreamPromise<ReverseTransferGroupTxOutput>}
+   *
+   */
+  reverseTransferGroup(input) {
+    return this._sendTransaction(import_txs.APIFunctions.reverseTransferGroup, input);
+  }
+  /**
+   *
+   * @param {ReverseTransferGroupManyTxInput} input
+   * @returns {StreamPromise<ReverseTransferGroupManyTxOutput>}
+   *
+   */
+  reverseTransferGroupMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.reverseTransferGroupMany, input);
+  }
+  /**
+   *
+   * @param {ReverseTransferManyTxInput} input
+   * @returns {StreamPromise<ReverseTransferManyTxOutput>}
+   *
+   */
+  reverseTransferMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.reverseTransferMany, input);
+  }
+  /**
+   *
+   * @param {SetFlagsTxInput} input
+   * @returns {StreamPromise<SetFlagsTxOutput>}
+   *
+   */
+  setFlags(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.setFlags,
+      input
+    );
+  }
+  /**
+   *
+   * @param {StartTransactionTxInput} input
+   * @returns {StreamPromise<StartTransactionTxOutput>}
+   *
+   */
+  startTransaction(input) {
+    return this._sendTransaction(import_txs.APIFunctions.startTransaction, input);
+  }
+  /**
+   *
+   * @param {UpdateTokenTxInput} input
+   * @returns {StreamPromise<UpdateTokenTxOutput>}
+   *
+   */
+  updateToken(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.updateToken,
+      input
+    );
+  }
+  /**
+   *
+   * @param {UpdateTransferTxInput} input
+   * @returns {StreamPromise<UpdateTransferTxOutput>}
+   *
+   */
+  updateTransfer(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.updateTransfer,
+      input
+    );
+  }
+  /**
+   *
+   * @param {UpdateTransferGroupTxInput} input
+   * @returns {StreamPromise<UpdateTransferGroupTxOutput>}
+   *
+   */
+  updateTransferGroup(input) {
+    return this._sendTransaction(import_txs.APIFunctions.updateTransferGroup, input);
+  }
+  /**
+   *
+   * @param {UpdateTransferGroupManyTxInput} input
+   * @returns {StreamPromise<UpdateTransferGroupManyTxOutput>}
+   *
+   */
+  updateTransferGroupMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.updateTransferGroupMany, input);
+  }
+  /**
+   *
+   * @param {UpdateTransferManyTxInput} input
+   * @returns {StreamPromise<UpdateTransferManyTxOutput>}
+   *
+   */
+  updateTransferMany(input) {
+    return this._sendTransaction(import_txs.APIFunctions.updateTransferMany, input);
+  }
+  /**
+   *
+   * @param {UpdateWalletTxInput} input
+   * @returns {StreamPromise<UpdateWalletTxOutput>}
+   *
+   */
+  updateWallet(input) {
+    return this._sendTransaction(
+      import_txs.APIFunctions.updateWallet,
+      input
+    );
+  }
+  // TXSDEFS
+};