wapi-client 0.17.18 → 0.18.0-beta.2

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

@@ -1,1175 +0,0 @@
-"use strict";
-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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-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.browser.cjs");
-var import_errors = require("../lib/errors.browser.cjs");
-var import_stream_promise = require("../lib/stream-promise.browser.cjs");
-var import_utils = require("../lib/utils.browser.cjs");
-var import_jsonrpc_enums = require("./jsonrpc/jsonrpc.enums.browser.cjs");
-var import_wapi_client = require("../wapi-client.browser.cjs");
-var import_validator = require("../lib/validator.browser.cjs");
-var BaseClient = class {
-  constructor(connection, connectionType, $connect) {
-    __publicField(this, "type");
-    __publicField(this, "_connection");
-    __publicField(this, "$connect");
-    __publicField(this, "connectionType");
-    __publicField(this, "jwt", "");
-    __publicField(this, "host", "");
-    __publicField(this, "isConnected", false);
-    __publicField(this, "socId");
-    __publicField(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;
-        }
-      }
-    ));
-    __publicField(this, "_requests", /* @__PURE__ */ new Map());
-    __publicField(this, "_error", false);
-    __publicField(this, "_sending", /* @__PURE__ */ new Map());
-    __publicField(this, "sendingTimeout");
-    __publicField(this, "requestTimeout", 12e4);
-    this.type = connectionType;
-    this._connection = connection;
-    this.connectionType = connectionType;
-    this.$connect = $connect;
-  }
-  _setConnected(value) {
-    this.$connect = void 0;
-    if (value && this._error !== false) {
-      this._error = false;
-    }
-    if (!this.isConnected && value && this.hooks.connected) {
-      this.hooks.connected(this.socId);
-    }
-    if (this.isConnected && !value && this.hooks.disconnected) {
-      this.hooks.disconnected();
-    }
-    this.isConnected = value;
-  }
-  _setErrored(err) {
-    this._error = err;
-    this._setConnected(false);
-  }
-  _clearError() {
-    this._error = false;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _send(input) {
-    throw new Error("This method must be implemented by child class");
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _reconnect(nrOfAttempts) {
-    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((requestInfo) => {
-      this._fireConnectionLost(requestInfo);
-    });
-    this.socId = void 0;
-  }
-  _completeRequest(request, error) {
-    const key = request.message.id;
-    if (key === null) {
-      throw new Error("JSONRPCMessage.id should not be null");
-    }
-    if (error) {
-      if ("error" in request) {
-        request.error(error);
-      } else if ("stream" in request) {
-        request.stream.destroy(error);
-      }
-    } else if (!request.stream.destroyed) {
-      request.stream.push(null);
-    }
-    clearTimeout(request.requestTimeout);
-    clearTimeout(request.sendingTimeout);
-    this._requests.delete(key);
-    this._sending.delete(key);
-  }
-  _fireConnectionLost(requestInfo) {
-    const error = new import_errors.StreamError("CONNECTION_LOST", {
-      method: "connectionLost"
-    });
-    return this._completeRequest(requestInfo, error);
-  }
-  _fireSendingTimeout(requestInfo) {
-    const error = new import_errors.ConfigError("SENDING_TIMEOUT", {
-      timeout: this.sendingTimeout
-    });
-    return this._completeRequest(requestInfo, error);
-  }
-  _fireRequestTimeout(requestInfo) {
-    const error = new import_errors.ConfigError("REQUEST_TIMEOUT", {
-      timeout: this.requestTimeout
-    });
-    return this._completeRequest(requestInfo, error);
-  }
-  _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_enums.JSONRPC.ping) {
-        this._send({
-          jsonrpc: import_jsonrpc_enums.JSONRPC.version,
-          result: import_jsonrpc_enums.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;
-    }
-    const requestInfo = this._requests.get(responseMessage.id);
-    if (!requestInfo) {
-      (0, import_debug.debugLog)("No Request found for incoming", incoming);
-      return;
-    }
-    if (responseMessage.result === import_jsonrpc_enums.JSONRPC.acknowledgement) {
-      clearTimeout(requestInfo.requestTimeout);
-      delete requestInfo.requestTimeout;
-      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_enums.JSONRPC.streamPause && "pause" in requestInfo) {
-      requestInfo.pause();
-      return;
-    }
-    if (((_b = message.result) == null ? void 0 : _b.type) === import_jsonrpc_enums.JSONRPC.streamResume && "resume" in requestInfo) {
-      requestInfo.resume();
-      return;
-    }
-    const { stream, start } = requestInfo;
-    if (((_c = message.result) == null ? void 0 : _c.type) === import_jsonrpc_enums.JSONRPC.streamChunk) {
-      stream.push(message.result);
-      return;
-    }
-    stream.push(message);
-    this._completeRequest(requestInfo);
-    if (this.connectionType === import_wapi_client.WapiClientType.ws) {
-      this._send({
-        jsonrpc: import_jsonrpc_enums.JSONRPC.version,
-        method: import_jsonrpc_enums.JSONRPC.acknowledgement,
-        params: Date.now() - start,
-        id: message.id
-      });
-    }
-  }
-  // private _sendTransaction<Input, Output>(
-  //   name: ValuesOf<typeof APIFunctions>,
-  //   input: Input,
-  // ): StreamPromise<Output> {
-  //   // This will throw if invalid
-  //   const inputCopy = APIValidators[name](input);
-  //   return this._sendRaw<Input, Output>(name, inputCopy as Input);
-  // }
-  _sendRaw(method, params) {
-    const jsonRpcMessage = {
-      jsonrpc: import_jsonrpc_enums.JSONRPC.version,
-      method,
-      params,
-      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(5);
-      }
-      if (!this.isConnected) {
-        yield this.$connect;
-      }
-      if (this._error) {
-        throw this._error;
-      }
-      const outboundRequest = __spreadValues(__spreadValues({
-        stream,
-        start: Date.now(),
-        message: jsonRpcMessage
-      }, this.sendingTimeout && {
-        sendingTimeout: setTimeout(() => {
-          this._fireSendingTimeout(outboundRequest);
-        }, this.sendingTimeout)
-      }), this.requestTimeout && {
-        requestTimeout: setTimeout(() => {
-          this._fireRequestTimeout(outboundRequest);
-        }, this.requestTimeout)
-      });
-      this._requests.set(jsonRpcMessage.id, outboundRequest);
-      this._send(jsonRpcMessage);
-    }));
-  }
-  // private _streamTransaction<
-  //   InputOptions,
-  //   InputChunk,
-  //   Output,
-  //   PreTransformChunkType = InputChunk,
-  // >(
-  //   name: ValuesOf<typeof APIFunctions>,
-  //   isInputChunk: (data: unknown) => data is InputChunk,
-  //   options?: InputOptions,
-  //   transform?: TransformStream<PreTransformChunkType, InputChunk>,
-  // ): StreamPromiseInput<Output, PreTransformChunkType> {
-  //   const start = Date.now();
-  //   const streamId = getRandomHex();
-  //   let _error: Error | IJSONRPCError;
-  //   const sendToStream = ({
-  //     stream,
-  //     method,
-  //     params,
-  //   }: {
-  //     stream: ReadStream;
-  //     method: 'streamData' | 'streamError' | 'streamEnd';
-  //     params: { data?: InputChunk; error?: Error; encoding?: string };
-  //   }) => {
-  //     if (_error) {
-  //       return;
-  //     }
-  //     const streamMessage: JSONRPCRequest = {
-  //       jsonrpc: JSONRPC.version,
-  //       method,
-  //       params: {
-  //         streamId,
-  //         ...params,
-  //       },
-  //       id: getRandomHex(),
-  //     };
-  //     this._setSending(streamMessage, stream);
-  //     this._send(streamMessage);
-  //   };
-  //   const sendErrorToStream = (stream: ReadStream, error: Error) => {
-  //     if (_error) {
-  //       return;
-  //     }
-  //     sendToStream({
-  //       stream,
-  //       method: 'streamError',
-  //       params: {
-  //         error,
-  //       },
-  //     });
-  //     _error = error;
-  //     stream.push({
-  //       error,
-  //     });
-  //   };
-  //   const inputStream = new ReadWriteStream();
-  //   const finalInputStream = transform
-  //     ? inputStream.pipe(transform)
-  //     : inputStream;
-  //   const streamStartMessage: JSONRPCRequest = {
-  //     jsonrpc: JSONRPC.version,
-  //     method: 'streamStart',
-  //     params: {
-  //       method: name,
-  //       options,
-  //     },
-  //     id: streamId,
-  //   };
-  //   if (
-  //     this.hooks.preflight &&
-  //     this.hooks.preflight(streamStartMessage) === false
-  //   ) {
-  //     // If this.hooks.preflight returns false then we dont send
-  //     return new StreamPromiseInput<Output, PreTransformChunkType>();
-  //   }
-  //   return new StreamPromiseInput(async (stream: ReadStream) => {
-  //     if (this._error) {
-  //       this._reconnect(5);
-  //     }
-  //     if (!this.isConnected) {
-  //       await this.$connect;
-  //     }
-  //     if (this._error) {
-  //       throw this._error;
-  //     }
-  //     let timeout: ReturnType<typeof setTimeout> | null = setTimeout(() => {
-  //       stream.push({
-  //         error: new StreamError('INPUT_STREAM_TIMEOUT', { streamId }),
-  //       });
-  //     }, 30000);
-  //     // Open response
-  //     this._requests.set(streamStartMessage.id!, {
-  //       stream,
-  //       start,
-  //       error(error: IJSONRPCError) {
-  //         _error = error;
-  //         debugLog('stream:error()>', error);
-  //       },
-  //       pause() {
-  //         inputStream.pause();
-  //       },
-  //       resume() {
-  //         inputStream.resume();
-  //       },
-  //       handle(message: JSONRPCResponse) {
-  //         if (message.error) {
-  //           stream.push(message);
-  //           return;
-  //         }
-  //         finalInputStream
-  //           .on('data', (chunk: InputChunk) => {
-  //             if (_error) {
-  //               return;
-  //             }
-  //             if (timeout) {
-  //               clearTimeout(timeout);
-  //               timeout = null;
-  //             }
-  //             if (!isInputChunk(chunk)) {
-  //               sendErrorToStream(
-  //                 stream,
-  //                 new StreamError('INVALID_INPUT_STREAM_CHUNK', {
-  //                   streamId,
-  //                   chunk,
-  //                 }),
-  //               );
-  //               return;
-  //             }
-  //             sendToStream({
-  //               stream,
-  //               method: 'streamData',
-  //               params: {
-  //                 data: chunk,
-  //               },
-  //             });
-  //           })
-  //           .on('error', (error: Error) => {
-  //             if (_error) {
-  //               return;
-  //             }
-  //             if (timeout) {
-  //               clearTimeout(timeout);
-  //               timeout = null;
-  //             }
-  //             sendToStream({
-  //               stream,
-  //               method: 'streamError',
-  //               params: {
-  //                 error,
-  //               },
-  //             });
-  //             stream.push({
-  //               error: new StreamError('INPUT_STREAM_ERROR', {
-  //                 streamId,
-  //                 error,
-  //               }),
-  //             });
-  //           })
-  //           .on('end', () => {
-  //             if (timeout) {
-  //               clearTimeout(timeout);
-  //               timeout = null;
-  //             }
-  //             sendToStream({
-  //               stream,
-  //               method: 'streamEnd',
-  //               params: {},
-  //             });
-  //           });
-  //       },
-  //     });
-  //     this._setSending(streamStartMessage, stream);
-  //     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) {
-    const inputCopy = import_validator.Validator.aggregateTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("aggregateTransferMany", inputCopy);
-  }
-  /**
-   *
-   * @param {AuthenticationCheckTxInput} input
-   * @returns {StreamPromise<AuthenticationCheckTxOutput>}
-   *
-   */
-  authenticationCheck(input) {
-    const inputCopy = import_validator.Validator.authenticationCheckTxInput.validateInputWOptions(input != null ? input : {});
-    return this._sendRaw("authenticationCheck", inputCopy);
-  }
-  /**
-   *
-   * @param {CreateAccessTokenTxInput} input
-   * @returns {StreamPromise<CreateAccessTokenTxOutput>}
-   *
-   */
-  createAccessToken(input) {
-    const inputCopy = import_validator.Validator.createAccessTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createAccessToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateApikeyTxInput} input
-   * @returns {StreamPromise<CreateApikeyTxOutput>}
-   *
-   */
-  createApikey(input) {
-    const inputCopy = import_validator.Validator.createApikeyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createApikey",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateContractTxInput} input
-   * @returns {StreamPromise<CreateContractTxOutput>}
-   *
-   */
-  createContract(input) {
-    const inputCopy = import_validator.Validator.createContractTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createContract",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateDepositTxInput} input
-   * @returns {StreamPromise<CreateDepositTxOutput>}
-   *
-   */
-  createDeposit(input) {
-    const inputCopy = import_validator.Validator.createDepositTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createDeposit",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateDistributionTxInput} input
-   * @returns {StreamPromise<CreateDistributionTxOutput>}
-   *
-   */
-  createDistribution(input) {
-    const inputCopy = import_validator.Validator.createDistributionTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createDistribution",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateTokenTxInput} input
-   * @returns {StreamPromise<CreateTokenTxOutput>}
-   *
-   */
-  createToken(input) {
-    const inputCopy = import_validator.Validator.createTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateTransferTxInput} input
-   * @returns {StreamPromise<CreateTransferTxOutput>}
-   *
-   */
-  createTransfer(input) {
-    const inputCopy = import_validator.Validator.createTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateTransferGroupTxInput} input
-   * @returns {StreamPromise<CreateTransferGroupTxOutput>}
-   *
-   */
-  createTransferGroup(input) {
-    const inputCopy = import_validator.Validator.createTransferGroupTxInput.validateInputWOptions(input != null ? input : {});
-    return this._sendRaw("createTransferGroup", inputCopy);
-  }
-  /**
-   *
-   * @param {CreateTransferManyTxInput} input
-   * @returns {StreamPromise<CreateTransferManyTxOutput>}
-   *
-   */
-  createTransferMany(input) {
-    const inputCopy = import_validator.Validator.createTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateWalletTxInput} input
-   * @returns {StreamPromise<CreateWalletTxOutput>}
-   *
-   */
-  createWallet(input) {
-    const inputCopy = import_validator.Validator.createWalletTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createWallet",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateWithdrawalTxInput} input
-   * @returns {StreamPromise<CreateWithdrawalTxOutput>}
-   *
-   */
-  createWithdrawal(input) {
-    const inputCopy = import_validator.Validator.createWithdrawalTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createWithdrawal",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportBalanceHistoryTxInput} input
-   * @returns {StreamPromise<ExportBalanceHistoryTxOutput>}
-   *
-   */
-  exportBalanceHistory(input) {
-    const inputCopy = import_validator.Validator.exportBalanceHistoryTxInput.validateInputWOptions(input);
-    return this._sendRaw("exportBalanceHistory", inputCopy);
-  }
-  /**
-   *
-   * @param {ExportBalanceManyTxInput} input
-   * @returns {StreamPromise<ExportBalanceManyTxOutput>}
-   *
-   */
-  exportBalanceMany(input) {
-    const inputCopy = import_validator.Validator.exportBalanceManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportBalanceMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportTokenManyTxInput} input
-   * @returns {StreamPromise<ExportTokenManyTxOutput>}
-   *
-   */
-  exportTokenMany(input) {
-    const inputCopy = import_validator.Validator.exportTokenManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportTokenMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportTransferGroupManyTxInput} input
-   * @returns {StreamPromise<ExportTransferGroupManyTxOutput>}
-   *
-   */
-  exportTransferGroupMany(input) {
-    const inputCopy = import_validator.Validator.exportTransferGroupManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw("exportTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {ExportTransferManyTxInput} input
-   * @returns {StreamPromise<ExportTransferManyTxOutput>}
-   *
-   */
-  exportTransferMany(input) {
-    const inputCopy = import_validator.Validator.exportTransferManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportWalletManyTxInput} input
-   * @returns {StreamPromise<ExportWalletManyTxOutput>}
-   *
-   */
-  exportWalletMany(input) {
-    const inputCopy = import_validator.Validator.exportWalletManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportWalletMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindApikeyManyTxInput} input
-   * @returns {StreamPromise<FindApikeyManyTxOutput>}
-   *
-   */
-  findApikeyMany(input) {
-    const inputCopy = import_validator.Validator.findApikeyManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findApikeyMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindBalanceManyTxInput} input
-   * @returns {StreamPromise<FindBalanceManyTxOutput>}
-   *
-   */
-  findBalanceMany(input) {
-    const inputCopy = import_validator.Validator.findBalanceManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findBalanceMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindTokenManyTxInput} input
-   * @returns {StreamPromise<FindTokenManyTxOutput>}
-   *
-   */
-  findTokenMany(input) {
-    const inputCopy = import_validator.Validator.findTokenManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findTokenMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindTransferGroupManyTxInput} input
-   * @returns {StreamPromise<FindTransferGroupManyTxOutput>}
-   *
-   */
-  findTransferGroupMany(input) {
-    const inputCopy = import_validator.Validator.findTransferGroupManyTxInput.validateInputWOptions(input != null ? input : {});
-    return this._sendRaw("findTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {FindTransferManyTxInput} input
-   * @returns {StreamPromise<FindTransferManyTxOutput>}
-   *
-   */
-  findTransferMany(input) {
-    const inputCopy = import_validator.Validator.findTransferManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindWalletManyTxInput} input
-   * @returns {StreamPromise<FindWalletManyTxOutput>}
-   *
-   */
-  findWalletMany(input) {
-    const inputCopy = import_validator.Validator.findWalletManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findWalletMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FinishTransactionTxInput} input
-   * @returns {StreamPromise<FinishTransactionTxOutput>}
-   *
-   */
-  finishTransaction(input) {
-    const inputCopy = import_validator.Validator.finishTransactionTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "finishTransaction",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetBalanceTxInput} input
-   * @returns {StreamPromise<GetBalanceTxOutput>}
-   *
-   */
-  getBalance(input) {
-    const inputCopy = import_validator.Validator.getBalanceTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getBalance",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetBalanceHistoryTxInput} input
-   * @returns {StreamPromise<GetBalanceHistoryTxOutput>}
-   *
-   */
-  getBalanceHistory(input) {
-    const inputCopy = import_validator.Validator.getBalanceHistoryTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getBalanceHistory",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetExportTxInput} input
-   * @returns {StreamPromise<GetExportTxOutput>}
-   *
-   */
-  getExport(input) {
-    const inputCopy = import_validator.Validator.getExportTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getExport",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetFlagsTxInput} input
-   * @returns {StreamPromise<GetFlagsTxOutput>}
-   *
-   */
-  getFlags(input) {
-    const inputCopy = import_validator.Validator.getFlagsTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "getFlags",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetStatisticsTxInput} input
-   * @returns {StreamPromise<GetStatisticsTxOutput>}
-   *
-   */
-  getStatistics(input) {
-    const inputCopy = import_validator.Validator.getStatisticsTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "getStatistics",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTokenTxInput} input
-   * @returns {StreamPromise<GetTokenTxOutput>}
-   *
-   */
-  getToken(input) {
-    const inputCopy = import_validator.Validator.getTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTokenManyTxInput} input
-   * @returns {StreamPromise<GetTokenManyTxOutput>}
-   *
-   */
-  getTokenMany(input) {
-    const inputCopy = import_validator.Validator.getTokenManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getTokenMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTransferTxInput} input
-   * @returns {StreamPromise<GetTransferTxOutput>}
-   *
-   */
-  getTransfer(input) {
-    const inputCopy = import_validator.Validator.getTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTransferGroupTxInput} input
-   * @returns {StreamPromise<GetTransferGroupTxOutput>}
-   *
-   */
-  getTransferGroup(input) {
-    const inputCopy = import_validator.Validator.getTransferGroupTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getTransferGroup",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetWalletTxInput} input
-   * @returns {StreamPromise<GetWalletTxOutput>}
-   *
-   */
-  getWallet(input) {
-    const inputCopy = import_validator.Validator.getWalletTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getWallet",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetWalletManyTxInput} input
-   * @returns {StreamPromise<GetWalletManyTxOutput>}
-   *
-   */
-  getWalletMany(input) {
-    const inputCopy = import_validator.Validator.getWalletManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getWalletMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {HealthcheckTxInput} input
-   * @returns {StreamPromise<HealthcheckTxOutput>}
-   *
-   */
-  healthcheck(input) {
-    const inputCopy = import_validator.Validator.healthcheckTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "healthcheck",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ListExportManyTxInput} input
-   * @returns {StreamPromise<ListExportManyTxOutput>}
-   *
-   */
-  listExportMany(input) {
-    const inputCopy = import_validator.Validator.listExportManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "listExportMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {QueryLogsTxInput} input
-   * @returns {StreamPromise<QueryLogsTxOutput>}
-   *
-   */
-  queryLogs(input) {
-    const inputCopy = import_validator.Validator.queryLogsTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "queryLogs",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ResetDatabaseTxInput} input
-   * @returns {StreamPromise<ResetDatabaseTxOutput>}
-   *
-   */
-  resetDatabase(input) {
-    const inputCopy = import_validator.Validator.resetDatabaseTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "resetDatabase",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ReverseTransferTxInput} input
-   * @returns {StreamPromise<ReverseTransferTxOutput>}
-   *
-   */
-  reverseTransfer(input) {
-    const inputCopy = import_validator.Validator.reverseTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "reverseTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ReverseTransferGroupTxInput} input
-   * @returns {StreamPromise<ReverseTransferGroupTxOutput>}
-   *
-   */
-  reverseTransferGroup(input) {
-    const inputCopy = import_validator.Validator.reverseTransferGroupTxInput.validateInputWOptions(input);
-    return this._sendRaw("reverseTransferGroup", inputCopy);
-  }
-  /**
-   *
-   * @param {ReverseTransferGroupManyTxInput} input
-   * @returns {StreamPromise<ReverseTransferGroupManyTxOutput>}
-   *
-   */
-  reverseTransferGroupMany(input) {
-    const inputCopy = import_validator.Validator.reverseTransferGroupManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("reverseTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {ReverseTransferManyTxInput} input
-   * @returns {StreamPromise<ReverseTransferManyTxOutput>}
-   *
-   */
-  reverseTransferMany(input) {
-    const inputCopy = import_validator.Validator.reverseTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("reverseTransferMany", inputCopy);
-  }
-  /**
-   *
-   * @param {SetFlagsTxInput} input
-   * @returns {StreamPromise<SetFlagsTxOutput>}
-   *
-   */
-  setFlags(input) {
-    const inputCopy = import_validator.Validator.setFlagsTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "setFlags",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {StartTransactionTxInput} input
-   * @returns {StreamPromise<StartTransactionTxOutput>}
-   *
-   */
-  startTransaction(input) {
-    const inputCopy = import_validator.Validator.startTransactionTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "startTransaction",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateApikeyTxInput} input
-   * @returns {StreamPromise<UpdateApikeyTxOutput>}
-   *
-   */
-  updateApikey(input) {
-    const inputCopy = import_validator.Validator.updateApikeyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateApikey",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateTokenTxInput} input
-   * @returns {StreamPromise<UpdateTokenTxOutput>}
-   *
-   */
-  updateToken(input) {
-    const inputCopy = import_validator.Validator.updateTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateTransferTxInput} input
-   * @returns {StreamPromise<UpdateTransferTxOutput>}
-   *
-   */
-  updateTransfer(input) {
-    const inputCopy = import_validator.Validator.updateTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateTransferGroupTxInput} input
-   * @returns {StreamPromise<UpdateTransferGroupTxOutput>}
-   *
-   */
-  updateTransferGroup(input) {
-    const inputCopy = import_validator.Validator.updateTransferGroupTxInput.validateInputWOptions(input);
-    return this._sendRaw("updateTransferGroup", inputCopy);
-  }
-  /**
-   *
-   * @param {UpdateTransferGroupManyTxInput} input
-   * @returns {StreamPromise<UpdateTransferGroupManyTxOutput>}
-   *
-   */
-  updateTransferGroupMany(input) {
-    const inputCopy = import_validator.Validator.updateTransferGroupManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("updateTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {UpdateTransferManyTxInput} input
-   * @returns {StreamPromise<UpdateTransferManyTxOutput>}
-   *
-   */
-  updateTransferMany(input) {
-    const inputCopy = import_validator.Validator.updateTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateWalletTxInput} input
-   * @returns {StreamPromise<UpdateWalletTxOutput>}
-   *
-   */
-  updateWallet(input) {
-    const inputCopy = import_validator.Validator.updateWalletTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateWallet",
-      inputCopy
-    );
-  }
-  // TXSDEFS
-};