wapi-client 0.18.0-beta.5 → 0.18.2

package/dist/api/auth/auth.enums.browser.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/api/auth/auth.enums.ts
+var auth_enums_exports = {};
+module.exports = __toCommonJS(auth_enums_exports);

package/dist/api/auth/auth.enums.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/api/auth/auth.enums.ts
+var auth_enums_exports = {};
+module.exports = __toCommonJS(auth_enums_exports);

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

@@ -0,0 +1,274 @@
+"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_tx_map_generated = require("../txs/tx-map.generated.browser.cjs");
+var import_validator = require("../lib/validator.browser.cjs");
+var txValidators = import_validator.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 import_tx_map_generated.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");
+    __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, "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) {
+      request.stream.destroy(error);
+    } else if (!request.stream.destroyed) {
+      request.stream.push(null);
+    }
+    clearTimeout(request.requestTimeout);
+    clearTimeout(request.sendingTimeout);
+    this._requests.delete(key);
+  }
+  _failRequest(id, error) {
+    const requestInfo = this._requests.get(id);
+    if (!requestInfo) {
+      (0, import_debug.debugLog)("No Request found to fail", id, error);
+      return;
+    }
+    this._completeRequest(requestInfo, error);
+  }
+  _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;
+    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;
+    }
+    const message = responseMessage;
+    const { stream, start } = requestInfo;
+    if (((_a = message.result) == null ? void 0 : _a.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
+      });
+    }
+  }
+  _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);
+    }));
+  }
+};
+installTxMethods(BaseClient.prototype);

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

@@ -0,0 +1,258 @@
+var __defProp = Object.defineProperty;
+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 __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
+import { debugLog } from "../lib/debug.browser.js";
+import { ConfigError, StreamError } from "../lib/errors.browser.js";
+import { StreamPromise } from "../lib/stream-promise.browser.js";
+import { getRandomHex } from "../lib/utils.browser.js";
+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");
+    __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, "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) {
+      request.stream.destroy(error);
+    } else if (!request.stream.destroyed) {
+      request.stream.push(null);
+    }
+    clearTimeout(request.requestTimeout);
+    clearTimeout(request.sendingTimeout);
+    this._requests.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", {
+      method: "connectionLost"
+    });
+    return this._completeRequest(requestInfo, error);
+  }
+  _fireSendingTimeout(requestInfo) {
+    const error = new ConfigError("SENDING_TIMEOUT", {
+      timeout: this.sendingTimeout
+    });
+    return this._completeRequest(requestInfo, error);
+  }
+  _fireRequestTimeout(requestInfo) {
+    const error = new ConfigError("REQUEST_TIMEOUT", {
+      timeout: this.requestTimeout
+    });
+    return this._completeRequest(requestInfo, error);
+  }
+  _handleMessage(incoming) {
+    var _a;
+    if (this.hooks.message) {
+      this.hooks.message(incoming);
+    }
+    if ("method" in incoming) {
+      const message2 = incoming;
+      if (message2.method === JSONRPC.ping) {
+        this._send({
+          jsonrpc: JSONRPC.version,
+          result: JSONRPC.pong,
+          id: message2.id
+        });
+        return;
+      }
+      debugLog("Unexpected JSONRPCRequest", incoming);
+      return;
+    }
+    const responseMessage = incoming;
+    if (responseMessage.id === null) {
+      debugLog("Unexpected JSONRPCResponse", incoming);
+      return;
+    }
+    const requestInfo = this._requests.get(responseMessage.id);
+    if (!requestInfo) {
+      debugLog("No Request found for incoming", incoming);
+      return;
+    }
+    if (responseMessage.result === JSONRPC.acknowledgement) {
+      clearTimeout(requestInfo.requestTimeout);
+      delete requestInfo.requestTimeout;
+      return;
+    }
+    const message = responseMessage;
+    const { stream, start } = requestInfo;
+    if (((_a = message.result) == null ? void 0 : _a.type) === JSONRPC.streamChunk) {
+      stream.push(message.result);
+      return;
+    }
+    stream.push(message);
+    this._completeRequest(requestInfo);
+    if (this.connectionType === WapiClientType.ws) {
+      this._send({
+        jsonrpc: JSONRPC.version,
+        method: JSONRPC.acknowledgement,
+        params: Date.now() - start,
+        id: message.id
+      });
+    }
+  }
+  _sendRaw(method, params) {
+    const jsonRpcMessage = {
+      jsonrpc: JSONRPC.version,
+      method,
+      params,
+      id: getRandomHex()
+    };
+    if (this.hooks.preflight && this.hooks.preflight(jsonRpcMessage) === false) {
+      return new StreamPromise();
+    }
+    return new 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);
+    }));
+  }
+};
+installTxMethods(BaseClient.prototype);
+export {
+  BaseClient
+};