wapi-client 0.18.0 → 0.18.2

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

@@ -45,7 +45,26 @@ import {
   JSONRPC
 } from "./jsonrpc/jsonrpc.enums.browser.js";
 import { WapiClientType } from "../wapi-client.browser.js";
+import { TX_NAMES } from "../txs/tx-map.generated.browser.js";
 import { Validator } from "../lib/validator.browser.js";
+var txValidators = Validator;
+function sendTx(client, name, input) {
+  const inputCopy = txValidators[`${name}TxInput`].validateInputWOptions(
+    input != null ? input : {}
+  );
+  return client._sendRaw(name, inputCopy);
+}
+function installTxMethods(proto) {
+  for (const name of TX_NAMES) {
+    Object.defineProperty(proto, name, {
+      configurable: false,
+      writable: false,
+      value(input) {
+        return sendTx(this, name, input);
+      }
+    });
+  }
+}
 var BaseClient = class {
   constructor(connection, connectionType, $connect) {
     __publicField(this, "type");
@@ -70,7 +89,6 @@ var BaseClient = class {
     ));
     __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;
@@ -112,18 +130,21 @@ var BaseClient = class {
       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);
-      }
+      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);
+  }
+  _failRequest(id, error) {
+    const requestInfo = this._requests.get(id);
+    if (!requestInfo) {
+      debugLog("No Request found to fail", id, error);
+      return;
+    }
+    this._completeRequest(requestInfo, error);
   }
   _fireConnectionLost(requestInfo) {
     const error = new StreamError("CONNECTION_LOST", {
@@ -144,7 +165,7 @@ var BaseClient = class {
     return this._completeRequest(requestInfo, error);
   }
   _handleMessage(incoming) {
-    var _a, _b, _c;
+    var _a;
     if (this.hooks.message) {
       this.hooks.message(incoming);
     }
@@ -176,25 +197,9 @@ var BaseClient = class {
       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) === JSONRPC.streamPause && "pause" in requestInfo) {
-      requestInfo.pause();
-      return;
-    }
-    if (((_b = message.result) == null ? void 0 : _b.type) === JSONRPC.streamResume && "resume" in requestInfo) {
-      requestInfo.resume();
-      return;
-    }
     const { stream, start } = requestInfo;
-    if (((_c = message.result) == null ? void 0 : _c.type) === JSONRPC.streamChunk) {
+    if (((_a = message.result) == null ? void 0 : _a.type) === JSONRPC.streamChunk) {
       stream.push(message.result);
       return;
     }
@@ -209,14 +214,6 @@ var BaseClient = class {
       });
     }
   }
-  // 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: JSONRPC.version,
@@ -254,931 +251,8 @@ var BaseClient = class {
       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 = Validator.aggregateTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("aggregateTransferMany", inputCopy);
-  }
-  /**
-   *
-   * @param {AuthenticationCheckTxInput} input
-   * @returns {StreamPromise<AuthenticationCheckTxOutput>}
-   *
-   */
-  authenticationCheck(input) {
-    const inputCopy = Validator.authenticationCheckTxInput.validateInputWOptions(input != null ? input : {});
-    return this._sendRaw("authenticationCheck", inputCopy);
-  }
-  /**
-   *
-   * @param {CreateAccessTokenTxInput} input
-   * @returns {StreamPromise<CreateAccessTokenTxOutput>}
-   *
-   */
-  createAccessToken(input) {
-    const inputCopy = Validator.createAccessTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createAccessToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateApikeyTxInput} input
-   * @returns {StreamPromise<CreateApikeyTxOutput>}
-   *
-   */
-  createApikey(input) {
-    const inputCopy = Validator.createApikeyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createApikey",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateContractTxInput} input
-   * @returns {StreamPromise<CreateContractTxOutput>}
-   *
-   */
-  createContract(input) {
-    const inputCopy = Validator.createContractTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createContract",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateDepositTxInput} input
-   * @returns {StreamPromise<CreateDepositTxOutput>}
-   *
-   */
-  createDeposit(input) {
-    const inputCopy = Validator.createDepositTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createDeposit",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateDistributionTxInput} input
-   * @returns {StreamPromise<CreateDistributionTxOutput>}
-   *
-   */
-  createDistribution(input) {
-    const inputCopy = Validator.createDistributionTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createDistribution",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateIndexTxInput} input
-   * @returns {StreamPromise<CreateIndexTxOutput>}
-   *
-   */
-  createIndex(input) {
-    const inputCopy = Validator.createIndexTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createIndex",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateTokenTxInput} input
-   * @returns {StreamPromise<CreateTokenTxOutput>}
-   *
-   */
-  createToken(input) {
-    const inputCopy = Validator.createTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateTransferTxInput} input
-   * @returns {StreamPromise<CreateTransferTxOutput>}
-   *
-   */
-  createTransfer(input) {
-    const inputCopy = Validator.createTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateTransferGroupTxInput} input
-   * @returns {StreamPromise<CreateTransferGroupTxOutput>}
-   *
-   */
-  createTransferGroup(input) {
-    const inputCopy = Validator.createTransferGroupTxInput.validateInputWOptions(input != null ? input : {});
-    return this._sendRaw("createTransferGroup", inputCopy);
-  }
-  /**
-   *
-   * @param {CreateTransferManyTxInput} input
-   * @returns {StreamPromise<CreateTransferManyTxOutput>}
-   *
-   */
-  createTransferMany(input) {
-    const inputCopy = Validator.createTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateWalletTxInput} input
-   * @returns {StreamPromise<CreateWalletTxOutput>}
-   *
-   */
-  createWallet(input) {
-    const inputCopy = Validator.createWalletTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createWallet",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {CreateWithdrawalTxInput} input
-   * @returns {StreamPromise<CreateWithdrawalTxOutput>}
-   *
-   */
-  createWithdrawal(input) {
-    const inputCopy = Validator.createWithdrawalTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "createWithdrawal",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {DropIndexTxInput} input
-   * @returns {StreamPromise<DropIndexTxOutput>}
-   *
-   */
-  dropIndex(input) {
-    const inputCopy = Validator.dropIndexTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "dropIndex",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportBalanceHistoryTxInput} input
-   * @returns {StreamPromise<ExportBalanceHistoryTxOutput>}
-   *
-   */
-  exportBalanceHistory(input) {
-    const inputCopy = Validator.exportBalanceHistoryTxInput.validateInputWOptions(input);
-    return this._sendRaw("exportBalanceHistory", inputCopy);
-  }
-  /**
-   *
-   * @param {ExportBalanceManyTxInput} input
-   * @returns {StreamPromise<ExportBalanceManyTxOutput>}
-   *
-   */
-  exportBalanceMany(input) {
-    const inputCopy = Validator.exportBalanceManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportBalanceMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportTokenManyTxInput} input
-   * @returns {StreamPromise<ExportTokenManyTxOutput>}
-   *
-   */
-  exportTokenMany(input) {
-    const inputCopy = Validator.exportTokenManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportTokenMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportTransferGroupManyTxInput} input
-   * @returns {StreamPromise<ExportTransferGroupManyTxOutput>}
-   *
-   */
-  exportTransferGroupMany(input) {
-    const inputCopy = Validator.exportTransferGroupManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw("exportTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {ExportTransferManyTxInput} input
-   * @returns {StreamPromise<ExportTransferManyTxOutput>}
-   *
-   */
-  exportTransferMany(input) {
-    const inputCopy = Validator.exportTransferManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ExportWalletManyTxInput} input
-   * @returns {StreamPromise<ExportWalletManyTxOutput>}
-   *
-   */
-  exportWalletMany(input) {
-    const inputCopy = Validator.exportWalletManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "exportWalletMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindApikeyManyTxInput} input
-   * @returns {StreamPromise<FindApikeyManyTxOutput>}
-   *
-   */
-  findApikeyMany(input) {
-    const inputCopy = Validator.findApikeyManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findApikeyMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindBalanceManyTxInput} input
-   * @returns {StreamPromise<FindBalanceManyTxOutput>}
-   *
-   */
-  findBalanceMany(input) {
-    const inputCopy = Validator.findBalanceManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findBalanceMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindIndexManyTxInput} input
-   * @returns {StreamPromise<FindIndexManyTxOutput>}
-   *
-   */
-  findIndexMany(input) {
-    const inputCopy = Validator.findIndexManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findIndexMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindTokenManyTxInput} input
-   * @returns {StreamPromise<FindTokenManyTxOutput>}
-   *
-   */
-  findTokenMany(input) {
-    const inputCopy = Validator.findTokenManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findTokenMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindTransferGroupManyTxInput} input
-   * @returns {StreamPromise<FindTransferGroupManyTxOutput>}
-   *
-   */
-  findTransferGroupMany(input) {
-    const inputCopy = Validator.findTransferGroupManyTxInput.validateInputWOptions(input != null ? input : {});
-    return this._sendRaw("findTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {FindTransferManyTxInput} input
-   * @returns {StreamPromise<FindTransferManyTxOutput>}
-   *
-   */
-  findTransferMany(input) {
-    const inputCopy = Validator.findTransferManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FindWalletManyTxInput} input
-   * @returns {StreamPromise<FindWalletManyTxOutput>}
-   *
-   */
-  findWalletMany(input) {
-    const inputCopy = Validator.findWalletManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "findWalletMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {FinishTransactionTxInput} input
-   * @returns {StreamPromise<FinishTransactionTxOutput>}
-   *
-   */
-  finishTransaction(input) {
-    const inputCopy = Validator.finishTransactionTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "finishTransaction",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetBalanceTxInput} input
-   * @returns {StreamPromise<GetBalanceTxOutput>}
-   *
-   */
-  getBalance(input) {
-    const inputCopy = Validator.getBalanceTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getBalance",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetBalanceHistoryTxInput} input
-   * @returns {StreamPromise<GetBalanceHistoryTxOutput>}
-   *
-   */
-  getBalanceHistory(input) {
-    const inputCopy = Validator.getBalanceHistoryTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getBalanceHistory",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetExportTxInput} input
-   * @returns {StreamPromise<GetExportTxOutput>}
-   *
-   */
-  getExport(input) {
-    const inputCopy = Validator.getExportTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getExport",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetFlagsTxInput} input
-   * @returns {StreamPromise<GetFlagsTxOutput>}
-   *
-   */
-  getFlags(input) {
-    const inputCopy = Validator.getFlagsTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "getFlags",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetStatisticsTxInput} input
-   * @returns {StreamPromise<GetStatisticsTxOutput>}
-   *
-   */
-  getStatistics(input) {
-    const inputCopy = Validator.getStatisticsTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "getStatistics",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTokenTxInput} input
-   * @returns {StreamPromise<GetTokenTxOutput>}
-   *
-   */
-  getToken(input) {
-    const inputCopy = Validator.getTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTokenManyTxInput} input
-   * @returns {StreamPromise<GetTokenManyTxOutput>}
-   *
-   */
-  getTokenMany(input) {
-    const inputCopy = Validator.getTokenManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getTokenMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTransferTxInput} input
-   * @returns {StreamPromise<GetTransferTxOutput>}
-   *
-   */
-  getTransfer(input) {
-    const inputCopy = Validator.getTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetTransferGroupTxInput} input
-   * @returns {StreamPromise<GetTransferGroupTxOutput>}
-   *
-   */
-  getTransferGroup(input) {
-    const inputCopy = Validator.getTransferGroupTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getTransferGroup",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetWalletTxInput} input
-   * @returns {StreamPromise<GetWalletTxOutput>}
-   *
-   */
-  getWallet(input) {
-    const inputCopy = Validator.getWalletTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getWallet",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {GetWalletManyTxInput} input
-   * @returns {StreamPromise<GetWalletManyTxOutput>}
-   *
-   */
-  getWalletMany(input) {
-    const inputCopy = Validator.getWalletManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "getWalletMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {HealthcheckTxInput} input
-   * @returns {StreamPromise<HealthcheckTxOutput>}
-   *
-   */
-  healthcheck(input) {
-    const inputCopy = Validator.healthcheckTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "healthcheck",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ListExportManyTxInput} input
-   * @returns {StreamPromise<ListExportManyTxOutput>}
-   *
-   */
-  listExportMany(input) {
-    const inputCopy = Validator.listExportManyTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "listExportMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {QueryLogsTxInput} input
-   * @returns {StreamPromise<QueryLogsTxOutput>}
-   *
-   */
-  queryLogs(input) {
-    const inputCopy = Validator.queryLogsTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "queryLogs",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ResetDatabaseTxInput} input
-   * @returns {StreamPromise<ResetDatabaseTxOutput>}
-   *
-   */
-  resetDatabase(input) {
-    const inputCopy = Validator.resetDatabaseTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "resetDatabase",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ReverseTransferTxInput} input
-   * @returns {StreamPromise<ReverseTransferTxOutput>}
-   *
-   */
-  reverseTransfer(input) {
-    const inputCopy = Validator.reverseTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "reverseTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {ReverseTransferGroupTxInput} input
-   * @returns {StreamPromise<ReverseTransferGroupTxOutput>}
-   *
-   */
-  reverseTransferGroup(input) {
-    const inputCopy = Validator.reverseTransferGroupTxInput.validateInputWOptions(input);
-    return this._sendRaw("reverseTransferGroup", inputCopy);
-  }
-  /**
-   *
-   * @param {ReverseTransferGroupManyTxInput} input
-   * @returns {StreamPromise<ReverseTransferGroupManyTxOutput>}
-   *
-   */
-  reverseTransferGroupMany(input) {
-    const inputCopy = Validator.reverseTransferGroupManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("reverseTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {ReverseTransferManyTxInput} input
-   * @returns {StreamPromise<ReverseTransferManyTxOutput>}
-   *
-   */
-  reverseTransferMany(input) {
-    const inputCopy = Validator.reverseTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("reverseTransferMany", inputCopy);
-  }
-  /**
-   *
-   * @param {SetFlagsTxInput} input
-   * @returns {StreamPromise<SetFlagsTxOutput>}
-   *
-   */
-  setFlags(input) {
-    const inputCopy = Validator.setFlagsTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "setFlags",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {StartTransactionTxInput} input
-   * @returns {StreamPromise<StartTransactionTxOutput>}
-   *
-   */
-  startTransaction(input) {
-    const inputCopy = Validator.startTransactionTxInput.validateInputWOptions(
-      input != null ? input : {}
-    );
-    return this._sendRaw(
-      "startTransaction",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateApikeyTxInput} input
-   * @returns {StreamPromise<UpdateApikeyTxOutput>}
-   *
-   */
-  updateApikey(input) {
-    const inputCopy = Validator.updateApikeyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateApikey",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateTokenTxInput} input
-   * @returns {StreamPromise<UpdateTokenTxOutput>}
-   *
-   */
-  updateToken(input) {
-    const inputCopy = Validator.updateTokenTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateToken",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateTransferTxInput} input
-   * @returns {StreamPromise<UpdateTransferTxOutput>}
-   *
-   */
-  updateTransfer(input) {
-    const inputCopy = Validator.updateTransferTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateTransfer",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateTransferGroupTxInput} input
-   * @returns {StreamPromise<UpdateTransferGroupTxOutput>}
-   *
-   */
-  updateTransferGroup(input) {
-    const inputCopy = Validator.updateTransferGroupTxInput.validateInputWOptions(input);
-    return this._sendRaw("updateTransferGroup", inputCopy);
-  }
-  /**
-   *
-   * @param {UpdateTransferGroupManyTxInput} input
-   * @returns {StreamPromise<UpdateTransferGroupManyTxOutput>}
-   *
-   */
-  updateTransferGroupMany(input) {
-    const inputCopy = Validator.updateTransferGroupManyTxInput.validateInputWOptions(input);
-    return this._sendRaw("updateTransferGroupMany", inputCopy);
-  }
-  /**
-   *
-   * @param {UpdateTransferManyTxInput} input
-   * @returns {StreamPromise<UpdateTransferManyTxOutput>}
-   *
-   */
-  updateTransferMany(input) {
-    const inputCopy = Validator.updateTransferManyTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateTransferMany",
-      inputCopy
-    );
-  }
-  /**
-   *
-   * @param {UpdateWalletTxInput} input
-   * @returns {StreamPromise<UpdateWalletTxOutput>}
-   *
-   */
-  updateWallet(input) {
-    const inputCopy = Validator.updateWalletTxInput.validateInputWOptions(input);
-    return this._sendRaw(
-      "updateWallet",
-      inputCopy
-    );
-  }
-  // TXSDEFS
 };
+installTxMethods(BaseClient.prototype);
 export {
   BaseClient
 };