wapi-client 0.18.0-beta.5 → 0.18.0

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

@@ -0,0 +1,1200 @@
+"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;
+  }
+  // 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 (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 {CreateIndexTxInput} input
+   * @returns {StreamPromise<CreateIndexTxOutput>}
+   *
+   */
+  createIndex(input) {
+    const inputCopy = import_validator.Validator.createIndexTxInput.validateInputWOptions(input);
+    return this._sendRaw(
+      "createIndex",
+      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 {DropIndexTxInput} input
+   * @returns {StreamPromise<DropIndexTxOutput>}
+   *
+   */
+  dropIndex(input) {
+    const inputCopy = import_validator.Validator.dropIndexTxInput.validateInputWOptions(input);
+    return this._sendRaw(
+      "dropIndex",
+      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 {FindIndexManyTxInput} input
+   * @returns {StreamPromise<FindIndexManyTxOutput>}
+   *
+   */
+  findIndexMany(input) {
+    const inputCopy = import_validator.Validator.findIndexManyTxInput.validateInputWOptions(
+      input != null ? input : {}
+    );
+    return this._sendRaw(
+      "findIndexMany",
+      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
+};