@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/tendermint-rpc/build/tendermint34/tendermint34client.mjs

@@ -0,0 +1,283 @@
+import { commonjsGlobal as a } from "../../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as l } from "../../../../../../../../../../_virtual/tendermint34client.mjs";
+import "../jsonrpc.mjs";
+import "../rpcclients/index.mjs";
+import "./adaptor/index.mjs";
+import "./requests.mjs";
+import { __exports as p } from "../../../../../../../../../../_virtual/requests.mjs";
+import { __exports as m } from "../../../../../../../../../../_virtual/jsonrpc.mjs";
+import { __exports as b } from "../../../../../../../../../../_virtual/index48.mjs";
+import { __exports as y } from "../../../../../../../../../../_virtual/index68.mjs";
+var f = a && a.__createBinding || (Object.create ? function(n, e, t, s) {
+  s === void 0 && (s = t);
+  var o = Object.getOwnPropertyDescriptor(e, t);
+  (!o || ("get" in o ? !e.__esModule : o.writable || o.configurable)) && (o = { enumerable: !0, get: function() {
+    return e[t];
+  } }), Object.defineProperty(n, s, o);
+} : function(n, e, t, s) {
+  s === void 0 && (s = t), n[s] = e[t];
+}), g = a && a.__setModuleDefault || (Object.create ? function(n, e) {
+  Object.defineProperty(n, "default", { enumerable: !0, value: e });
+} : function(n, e) {
+  n.default = e;
+}), x = a && a.__importStar || function(n) {
+  if (n && n.__esModule)
+    return n;
+  var e = {};
+  if (n != null)
+    for (var t in n)
+      t !== "default" && Object.prototype.hasOwnProperty.call(n, t) && f(e, n, t);
+  return g(e, n), e;
+};
+Object.defineProperty(l, "__esModule", { value: !0 });
+l.Tendermint34Client = void 0;
+const C = m, h = b, u = y, r = x(p);
+class d {
+  /**
+   * Creates a new Tendermint client for the given endpoint.
+   *
+   * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+   */
+  static async connect(e) {
+    let t;
+    return typeof e == "object" ? t = new h.HttpClient(e) : t = e.startsWith("http://") || e.startsWith("https://") ? new h.HttpClient(e) : new h.WebsocketClient(e), await this.detectVersion(t), d.create(t);
+  }
+  /**
+   * Creates a new Tendermint client given an RPC client.
+   */
+  static async create(e) {
+    return new d(e);
+  }
+  static async detectVersion(e) {
+    const t = (0, C.createJsonRpcRequest)(r.Method.Status), o = (await e.execute(t)).result;
+    if (!o || !o.node_info)
+      throw new Error("Unrecognized format for status response");
+    const c = o.node_info.version;
+    if (typeof c != "string")
+      throw new Error("Unrecognized version format: must be string");
+    return c;
+  }
+  /**
+   * Use `Tendermint34Client.connect` or `Tendermint34Client.create` to create an instance.
+   */
+  constructor(e) {
+    this.client = e, this.p = u.adaptor34.params, this.r = u.adaptor34.responses;
+  }
+  disconnect() {
+    this.client.disconnect();
+  }
+  async abciInfo() {
+    const e = { method: r.Method.AbciInfo };
+    return this.doCall(e, this.p.encodeAbciInfo, this.r.decodeAbciInfo);
+  }
+  async abciQuery(e) {
+    const t = { params: e, method: r.Method.AbciQuery };
+    return this.doCall(t, this.p.encodeAbciQuery, this.r.decodeAbciQuery);
+  }
+  async block(e) {
+    const t = { method: r.Method.Block, params: { height: e } };
+    return this.doCall(t, this.p.encodeBlock, this.r.decodeBlock);
+  }
+  async blockResults(e) {
+    const t = {
+      method: r.Method.BlockResults,
+      params: { height: e }
+    };
+    return this.doCall(t, this.p.encodeBlockResults, this.r.decodeBlockResults);
+  }
+  /**
+   * Search for events that are in a block.
+   *
+   * NOTE
+   * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+   */
+  async blockSearch(e) {
+    const t = { params: e, method: r.Method.BlockSearch }, s = await this.doCall(t, this.p.encodeBlockSearch, this.r.decodeBlockSearch);
+    return {
+      ...s,
+      // make sure we sort by height, as tendermint may be sorting by string value of the height
+      blocks: [...s.blocks].sort((o, c) => o.block.header.height - c.block.header.height)
+    };
+  }
+  // this should paginate through all blockSearch options to ensure it returns all results.
+  // starts with page 1 or whatever was provided (eg. to start on page 7)
+  //
+  // NOTE
+  // This method will error on any node that is running a Tendermint version lower than 0.34.9.
+  async blockSearchAll(e) {
+    let t = e.page || 1;
+    const s = [];
+    let o = !1;
+    for (; !o; ) {
+      const c = await this.blockSearch({ ...e, page: t });
+      s.push(...c.blocks), s.length < c.totalCount ? t++ : o = !0;
+    }
+    return s.sort((c, i) => c.block.header.height - i.block.header.height), {
+      totalCount: s.length,
+      blocks: s
+    };
+  }
+  /**
+   * Queries block headers filtered by minHeight <= height <= maxHeight.
+   *
+   * @param minHeight The minimum height to be included in the result. Defaults to 0.
+   * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+   */
+  async blockchain(e, t) {
+    const s = {
+      method: r.Method.Blockchain,
+      params: {
+        minHeight: e,
+        maxHeight: t
+      }
+    };
+    return this.doCall(s, this.p.encodeBlockchain, this.r.decodeBlockchain);
+  }
+  /**
+   * Broadcast transaction to mempool and wait for response
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+   */
+  async broadcastTxSync(e) {
+    const t = { params: e, method: r.Method.BroadcastTxSync };
+    return this.doCall(t, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxSync);
+  }
+  /**
+   * Broadcast transaction to mempool and do not wait for result
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+   */
+  async broadcastTxAsync(e) {
+    const t = { params: e, method: r.Method.BroadcastTxAsync };
+    return this.doCall(t, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxAsync);
+  }
+  /**
+   * Broadcast transaction to mempool and wait for block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+   */
+  async broadcastTxCommit(e) {
+    const t = { params: e, method: r.Method.BroadcastTxCommit };
+    return this.doCall(t, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxCommit);
+  }
+  async commit(e) {
+    const t = { method: r.Method.Commit, params: { height: e } };
+    return this.doCall(t, this.p.encodeCommit, this.r.decodeCommit);
+  }
+  async genesis() {
+    const e = { method: r.Method.Genesis };
+    return this.doCall(e, this.p.encodeGenesis, this.r.decodeGenesis);
+  }
+  async health() {
+    const e = { method: r.Method.Health };
+    return this.doCall(e, this.p.encodeHealth, this.r.decodeHealth);
+  }
+  async numUnconfirmedTxs() {
+    const e = { method: r.Method.NumUnconfirmedTxs };
+    return this.doCall(e, this.p.encodeNumUnconfirmedTxs, this.r.decodeNumUnconfirmedTxs);
+  }
+  async status() {
+    const e = { method: r.Method.Status };
+    return this.doCall(e, this.p.encodeStatus, this.r.decodeStatus);
+  }
+  subscribeNewBlock() {
+    const e = {
+      method: r.Method.Subscribe,
+      query: { type: r.SubscriptionEventType.NewBlock }
+    };
+    return this.subscribe(e, this.r.decodeNewBlockEvent);
+  }
+  subscribeNewBlockHeader() {
+    const e = {
+      method: r.Method.Subscribe,
+      query: { type: r.SubscriptionEventType.NewBlockHeader }
+    };
+    return this.subscribe(e, this.r.decodeNewBlockHeaderEvent);
+  }
+  subscribeTx(e) {
+    const t = {
+      method: r.Method.Subscribe,
+      query: {
+        type: r.SubscriptionEventType.Tx,
+        raw: e
+      }
+    };
+    return this.subscribe(t, this.r.decodeTxEvent);
+  }
+  /**
+   * Get a single transaction by hash
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+   */
+  async tx(e) {
+    const t = { params: e, method: r.Method.Tx };
+    return this.doCall(t, this.p.encodeTx, this.r.decodeTx);
+  }
+  /**
+   * Search for transactions that are in a block
+   *
+   * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+   */
+  async txSearch(e) {
+    const t = { params: e, method: r.Method.TxSearch };
+    return this.doCall(t, this.p.encodeTxSearch, this.r.decodeTxSearch);
+  }
+  // this should paginate through all txSearch options to ensure it returns all results.
+  // starts with page 1 or whatever was provided (eg. to start on page 7)
+  async txSearchAll(e) {
+    let t = e.page || 1;
+    const s = [];
+    let o = !1;
+    for (; !o; ) {
+      const c = await this.txSearch({ ...e, page: t });
+      s.push(...c.txs), s.length < c.totalCount ? t++ : o = !0;
+    }
+    return {
+      totalCount: s.length,
+      txs: s
+    };
+  }
+  async validators(e) {
+    const t = {
+      method: r.Method.Validators,
+      params: e
+    };
+    return this.doCall(t, this.p.encodeValidators, this.r.decodeValidators);
+  }
+  async validatorsAll(e) {
+    const t = [];
+    let s = 1, o = !1, c = e;
+    for (; !o; ) {
+      const i = await this.validators({
+        per_page: 50,
+        height: c,
+        page: s
+      });
+      t.push(...i.validators), c = c || i.blockHeight, t.length < i.total ? s++ : o = !0;
+    }
+    return {
+      // NOTE: Default value is for type safety but this should always be set
+      blockHeight: c ?? 0,
+      count: t.length,
+      total: t.length,
+      validators: t
+    };
+  }
+  // doCall is a helper to handle the encode/call/decode logic
+  async doCall(e, t, s) {
+    const o = t(e), c = await this.client.execute(o);
+    return s(c);
+  }
+  subscribe(e, t) {
+    if (!(0, h.instanceOfRpcStreamingClient)(this.client))
+      throw new Error("This RPC client type cannot subscribe to events");
+    const s = this.p.encodeSubscribe(e);
+    return this.client.listen(s).map((c) => t(c));
+  }
+}
+l.Tendermint34Client = d;
+export {
+  l as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/tendermint-rpc/build/tendermint37/adaptor/index.mjs

@@ -0,0 +1,19 @@
+import { __exports as s } from "../../../../../../../../../../../_virtual/index64.mjs";
+import "../hasher.mjs";
+import "./requests.mjs";
+import "./responses.mjs";
+import { __exports as r } from "../../../../../../../../../../../_virtual/hasher.mjs";
+import { __exports as e } from "../../../../../../../../../../../_virtual/requests3.mjs";
+import { __exports as t } from "../../../../../../../../../../../_virtual/responses3.mjs";
+Object.defineProperty(s, "__esModule", { value: !0 });
+s.adaptor37 = void 0;
+const o = r, a = e, p = t;
+s.adaptor37 = {
+  params: a.Params,
+  responses: p.Responses,
+  hashTx: o.hashTx,
+  hashBlock: o.hashBlock
+};
+export {
+  s as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/tendermint-rpc/build/tendermint37/adaptor/requests.mjs

@@ -0,0 +1,146 @@
+import { commonjsGlobal as i } from "../../../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as p } from "../../../../../../../../../../../_virtual/requests3.mjs";
+import "../../../../encoding/build/index.mjs";
+import "../../inthelpers.mjs";
+import "../../jsonrpc.mjs";
+import "../encodings.mjs";
+import "../requests.mjs";
+import { __exports as d } from "../../../../../../../../../../../_virtual/requests2.mjs";
+import { __exports as l } from "../../../../../../../../../../../_virtual/jsonrpc.mjs";
+import { __exports as h } from "../../../../../../../../../../../_virtual/index55.mjs";
+import { __exports as _ } from "../../../../../../../../../../../_virtual/inthelpers.mjs";
+import { __exports as f } from "../../../../../../../../../../../_virtual/encodings.mjs";
+var y = i && i.__createBinding || (Object.create ? function(t, e, n, c) {
+  c === void 0 && (c = n);
+  var s = Object.getOwnPropertyDescriptor(e, n);
+  (!s || ("get" in s ? !e.__esModule : s.writable || s.configurable)) && (s = { enumerable: !0, get: function() {
+    return e[n];
+  } }), Object.defineProperty(t, c, s);
+} : function(t, e, n, c) {
+  c === void 0 && (c = n), t[c] = e[n];
+}), g = i && i.__setModuleDefault || (Object.create ? function(t, e) {
+  Object.defineProperty(t, "default", { enumerable: !0, value: e });
+} : function(t, e) {
+  t.default = e;
+}), R = i && i.__importStar || function(t) {
+  if (t && t.__esModule)
+    return t;
+  var e = {};
+  if (t != null)
+    for (var n in t)
+      n !== "default" && Object.prototype.hasOwnProperty.call(t, n) && y(e, t, n);
+  return g(e, t), e;
+};
+Object.defineProperty(p, "__esModule", { value: !0 });
+p.Params = void 0;
+const m = h, a = _, r = l, o = f, b = R(d);
+function u(t) {
+  return {
+    height: (0, o.may)(a.smallIntToApi, t.height)
+  };
+}
+function x(t) {
+  return {
+    minHeight: (0, o.may)(a.smallIntToApi, t.minHeight),
+    maxHeight: (0, o.may)(a.smallIntToApi, t.maxHeight)
+  };
+}
+function T(t) {
+  return {
+    query: t.query,
+    page: (0, o.may)(a.smallIntToApi, t.page),
+    per_page: (0, o.may)(a.smallIntToApi, t.per_page),
+    order_by: t.order_by
+  };
+}
+function v(t) {
+  return {
+    path: (0, o.assertNotEmpty)(t.path),
+    data: (0, m.toHex)(t.data),
+    height: (0, o.may)(a.smallIntToApi, t.height),
+    prove: t.prove
+  };
+}
+function q(t) {
+  return {
+    tx: (0, m.toBase64)((0, o.assertNotEmpty)(t.tx))
+  };
+}
+function J(t) {
+  return {
+    hash: (0, m.toBase64)((0, o.assertNotEmpty)(t.hash)),
+    prove: t.prove
+  };
+}
+function P(t) {
+  return {
+    query: t.query,
+    prove: t.prove,
+    page: (0, o.may)(a.smallIntToApi, t.page),
+    per_page: (0, o.may)(a.smallIntToApi, t.per_page),
+    order_by: t.order_by
+  };
+}
+function A(t) {
+  return {
+    height: (0, o.may)(a.smallIntToApi, t.height),
+    page: (0, o.may)(a.smallIntToApi, t.page),
+    per_page: (0, o.may)(a.smallIntToApi, t.per_page)
+  };
+}
+class B {
+  static encodeAbciInfo(e) {
+    return (0, r.createJsonRpcRequest)(e.method);
+  }
+  static encodeAbciQuery(e) {
+    return (0, r.createJsonRpcRequest)(e.method, v(e.params));
+  }
+  static encodeBlock(e) {
+    return (0, r.createJsonRpcRequest)(e.method, u(e.params));
+  }
+  static encodeBlockchain(e) {
+    return (0, r.createJsonRpcRequest)(e.method, x(e.params));
+  }
+  static encodeBlockResults(e) {
+    return (0, r.createJsonRpcRequest)(e.method, u(e.params));
+  }
+  static encodeBlockSearch(e) {
+    return (0, r.createJsonRpcRequest)(e.method, T(e.params));
+  }
+  static encodeBroadcastTx(e) {
+    return (0, r.createJsonRpcRequest)(e.method, q(e.params));
+  }
+  static encodeCommit(e) {
+    return (0, r.createJsonRpcRequest)(e.method, u(e.params));
+  }
+  static encodeGenesis(e) {
+    return (0, r.createJsonRpcRequest)(e.method);
+  }
+  static encodeHealth(e) {
+    return (0, r.createJsonRpcRequest)(e.method);
+  }
+  static encodeNumUnconfirmedTxs(e) {
+    return (0, r.createJsonRpcRequest)(e.method);
+  }
+  static encodeStatus(e) {
+    return (0, r.createJsonRpcRequest)(e.method);
+  }
+  static encodeSubscribe(e) {
+    const n = { key: "tm.event", value: e.query.type }, c = b.buildQuery({ tags: [n], raw: e.query.raw });
+    return (0, r.createJsonRpcRequest)("subscribe", { query: c });
+  }
+  static encodeTx(e) {
+    return (0, r.createJsonRpcRequest)(e.method, J(e.params));
+  }
+  // TODO: encode params for query string???
+  static encodeTxSearch(e) {
+    return (0, r.createJsonRpcRequest)(e.method, P(e.params));
+  }
+  static encodeValidators(e) {
+    return (0, r.createJsonRpcRequest)(e.method, A(e.params));
+  }
+}
+p.Params = B;
+export {
+  p as default
+};