@hinkal/common 0.0.115 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abi/lib.esm/interface.mjs

@@ -0,0 +1,382 @@
+import { getAddress as D } from "../../address/lib.esm/index.mjs";
+import { hexDataSlice as j, isHexString as m, arrayify as _, hexlify as d, concat as C, hexZeroPad as R } from "../../bytes/lib.esm/index.mjs";
+import { id as b } from "../../hash/lib.esm/id.mjs";
+import { keccak256 as I } from "../../keccak256/lib.esm/index.mjs";
+import { defineReadOnly as f, getStatic as w, Description as A } from "../../properties/lib.esm/index.mjs";
+import { defaultAbiCoder as $ } from "./abi-coder.mjs";
+import { Fragment as J, ConstructorFragment as v, FormatTypes as T, FunctionFragment as P, EventFragment as M, ParamType as V } from "./fragments.mjs";
+import { Logger as x } from "../../logger/lib.esm/index.mjs";
+import { version as B } from "./_version.mjs";
+import { BigNumber as L } from "../../bignumber/lib.esm/bignumber.mjs";
+const c = new x(B);
+class H extends A {
+}
+class U extends A {
+}
+class z extends A {
+}
+class N extends A {
+  static isIndexed(t) {
+    return !!(t && t._isIndexed);
+  }
+}
+const G = {
+  "0x08c379a0": { signature: "Error(string)", name: "Error", inputs: ["string"], reason: !0 },
+  "0x4e487b71": { signature: "Panic(uint256)", name: "Panic", inputs: ["uint256"] }
+};
+function k(E, t) {
+  const r = new Error(`deferred error during ABI decoding triggered accessing ${E}`);
+  return r.error = t, r;
+}
+class tt {
+  constructor(t) {
+    let r = [];
+    typeof t == "string" ? r = JSON.parse(t) : r = t, f(this, "fragments", r.map((e) => J.from(e)).filter((e) => e != null)), f(this, "_abiCoder", w(new.target, "getAbiCoder")()), f(this, "functions", {}), f(this, "errors", {}), f(this, "events", {}), f(this, "structs", {}), this.fragments.forEach((e) => {
+      let s = null;
+      switch (e.type) {
+        case "constructor":
+          if (this.deploy) {
+            c.warn("duplicate definition - constructor");
+            return;
+          }
+          f(this, "deploy", e);
+          return;
+        case "function":
+          s = this.functions;
+          break;
+        case "event":
+          s = this.events;
+          break;
+        case "error":
+          s = this.errors;
+          break;
+        default:
+          return;
+      }
+      let i = e.format();
+      if (s[i]) {
+        c.warn("duplicate definition - " + i);
+        return;
+      }
+      s[i] = e;
+    }), this.deploy || f(this, "deploy", v.from({
+      payable: !1,
+      type: "constructor"
+    })), f(this, "_isInterface", !0);
+  }
+  format(t) {
+    t || (t = T.full), t === T.sighash && c.throwArgumentError("interface does not support formatting sighash", "format", t);
+    const r = this.fragments.map((e) => e.format(t));
+    return t === T.json ? JSON.stringify(r.map((e) => JSON.parse(e))) : r;
+  }
+  // Sub-classes can override these to handle other blockchains
+  static getAbiCoder() {
+    return $;
+  }
+  static getAddress(t) {
+    return D(t);
+  }
+  static getSighash(t) {
+    return j(b(t.format()), 0, 4);
+  }
+  static getEventTopic(t) {
+    return b(t.format());
+  }
+  // Find a function definition by any means necessary (unless it is ambiguous)
+  getFunction(t) {
+    if (m(t)) {
+      for (const e in this.functions)
+        if (t === this.getSighash(e))
+          return this.functions[e];
+      c.throwArgumentError("no matching function", "sighash", t);
+    }
+    if (t.indexOf("(") === -1) {
+      const e = t.trim(), s = Object.keys(this.functions).filter((i) => i.split(
+        "("
+        /* fix:) */
+      )[0] === e);
+      return s.length === 0 ? c.throwArgumentError("no matching function", "name", e) : s.length > 1 && c.throwArgumentError("multiple matching functions", "name", e), this.functions[s[0]];
+    }
+    const r = this.functions[P.fromString(t).format()];
+    return r || c.throwArgumentError("no matching function", "signature", t), r;
+  }
+  // Find an event definition by any means necessary (unless it is ambiguous)
+  getEvent(t) {
+    if (m(t)) {
+      const e = t.toLowerCase();
+      for (const s in this.events)
+        if (e === this.getEventTopic(s))
+          return this.events[s];
+      c.throwArgumentError("no matching event", "topichash", e);
+    }
+    if (t.indexOf("(") === -1) {
+      const e = t.trim(), s = Object.keys(this.events).filter((i) => i.split(
+        "("
+        /* fix:) */
+      )[0] === e);
+      return s.length === 0 ? c.throwArgumentError("no matching event", "name", e) : s.length > 1 && c.throwArgumentError("multiple matching events", "name", e), this.events[s[0]];
+    }
+    const r = this.events[M.fromString(t).format()];
+    return r || c.throwArgumentError("no matching event", "signature", t), r;
+  }
+  // Find a function definition by any means necessary (unless it is ambiguous)
+  getError(t) {
+    if (m(t)) {
+      const e = w(this.constructor, "getSighash");
+      for (const s in this.errors) {
+        const i = this.errors[s];
+        if (t === e(i))
+          return this.errors[s];
+      }
+      c.throwArgumentError("no matching error", "sighash", t);
+    }
+    if (t.indexOf("(") === -1) {
+      const e = t.trim(), s = Object.keys(this.errors).filter((i) => i.split(
+        "("
+        /* fix:) */
+      )[0] === e);
+      return s.length === 0 ? c.throwArgumentError("no matching error", "name", e) : s.length > 1 && c.throwArgumentError("multiple matching errors", "name", e), this.errors[s[0]];
+    }
+    const r = this.errors[P.fromString(t).format()];
+    return r || c.throwArgumentError("no matching error", "signature", t), r;
+  }
+  // Get the sighash (the bytes4 selector) used by Solidity to identify a function
+  getSighash(t) {
+    if (typeof t == "string")
+      try {
+        t = this.getFunction(t);
+      } catch (r) {
+        try {
+          t = this.getError(t);
+        } catch {
+          throw r;
+        }
+      }
+    return w(this.constructor, "getSighash")(t);
+  }
+  // Get the topic (the bytes32 hash) used by Solidity to identify an event
+  getEventTopic(t) {
+    return typeof t == "string" && (t = this.getEvent(t)), w(this.constructor, "getEventTopic")(t);
+  }
+  _decodeParams(t, r) {
+    return this._abiCoder.decode(t, r);
+  }
+  _encodeParams(t, r) {
+    return this._abiCoder.encode(t, r);
+  }
+  encodeDeploy(t) {
+    return this._encodeParams(this.deploy.inputs, t || []);
+  }
+  decodeErrorResult(t, r) {
+    typeof t == "string" && (t = this.getError(t));
+    const e = _(r);
+    return d(e.slice(0, 4)) !== this.getSighash(t) && c.throwArgumentError(`data signature does not match error ${t.name}.`, "data", d(e)), this._decodeParams(t.inputs, e.slice(4));
+  }
+  encodeErrorResult(t, r) {
+    return typeof t == "string" && (t = this.getError(t)), d(C([
+      this.getSighash(t),
+      this._encodeParams(t.inputs, r || [])
+    ]));
+  }
+  // Decode the data for a function call (e.g. tx.data)
+  decodeFunctionData(t, r) {
+    typeof t == "string" && (t = this.getFunction(t));
+    const e = _(r);
+    return d(e.slice(0, 4)) !== this.getSighash(t) && c.throwArgumentError(`data signature does not match function ${t.name}.`, "data", d(e)), this._decodeParams(t.inputs, e.slice(4));
+  }
+  // Encode the data for a function call (e.g. tx.data)
+  encodeFunctionData(t, r) {
+    return typeof t == "string" && (t = this.getFunction(t)), d(C([
+      this.getSighash(t),
+      this._encodeParams(t.inputs, r || [])
+    ]));
+  }
+  // Decode the result from a function call (e.g. from eth_call)
+  decodeFunctionResult(t, r) {
+    typeof t == "string" && (t = this.getFunction(t));
+    let e = _(r), s = null, i = "", o = null, h = null, l = null;
+    switch (e.length % this._abiCoder._getWordSize()) {
+      case 0:
+        try {
+          return this._abiCoder.decode(t.outputs, e);
+        } catch {
+        }
+        break;
+      case 4: {
+        const u = d(e.slice(0, 4)), p = G[u];
+        if (p)
+          o = this._abiCoder.decode(p.inputs, e.slice(4)), h = p.name, l = p.signature, p.reason && (s = o[0]), h === "Error" ? i = `; VM Exception while processing transaction: reverted with reason string ${JSON.stringify(o[0])}` : h === "Panic" && (i = `; VM Exception while processing transaction: reverted with panic code ${o[0]}`);
+        else
+          try {
+            const g = this.getError(u);
+            o = this._abiCoder.decode(g.inputs, e.slice(4)), h = g.name, l = g.format();
+          } catch {
+          }
+        break;
+      }
+    }
+    return c.throwError("call revert exception" + i, x.errors.CALL_EXCEPTION, {
+      method: t.format(),
+      data: d(r),
+      errorArgs: o,
+      errorName: h,
+      errorSignature: l,
+      reason: s
+    });
+  }
+  // Encode the result for a function call (e.g. for eth_call)
+  encodeFunctionResult(t, r) {
+    return typeof t == "string" && (t = this.getFunction(t)), d(this._abiCoder.encode(t.outputs, r || []));
+  }
+  // Create the filter for the event with search criteria (e.g. for eth_filterLog)
+  encodeFilterTopics(t, r) {
+    typeof t == "string" && (t = this.getEvent(t)), r.length > t.inputs.length && c.throwError("too many arguments for " + t.format(), x.errors.UNEXPECTED_ARGUMENT, {
+      argument: "values",
+      value: r
+    });
+    let e = [];
+    t.anonymous || e.push(this.getEventTopic(t));
+    const s = (i, o) => i.type === "string" ? b(o) : i.type === "bytes" ? I(d(o)) : (i.type === "bool" && typeof o == "boolean" && (o = o ? "0x01" : "0x00"), i.type.match(/^u?int/) && (o = L.from(o).toHexString()), i.type === "address" && this._abiCoder.encode(["address"], [o]), R(d(o), 32));
+    for (r.forEach((i, o) => {
+      let h = t.inputs[o];
+      if (!h.indexed) {
+        i != null && c.throwArgumentError("cannot filter non-indexed parameters; must be null", "contract." + h.name, i);
+        return;
+      }
+      i == null ? e.push(null) : h.baseType === "array" || h.baseType === "tuple" ? c.throwArgumentError("filtering with tuples or arrays not supported", "contract." + h.name, i) : Array.isArray(i) ? e.push(i.map((l) => s(h, l))) : e.push(s(h, i));
+    }); e.length && e[e.length - 1] === null; )
+      e.pop();
+    return e;
+  }
+  encodeEventLog(t, r) {
+    typeof t == "string" && (t = this.getEvent(t));
+    const e = [], s = [], i = [];
+    return t.anonymous || e.push(this.getEventTopic(t)), r.length !== t.inputs.length && c.throwArgumentError("event arguments/values mismatch", "values", r), t.inputs.forEach((o, h) => {
+      const l = r[h];
+      if (o.indexed)
+        if (o.type === "string")
+          e.push(b(l));
+        else if (o.type === "bytes")
+          e.push(I(l));
+        else {
+          if (o.baseType === "tuple" || o.baseType === "array")
+            throw new Error("not implemented");
+          e.push(this._abiCoder.encode([o.type], [l]));
+        }
+      else
+        s.push(o), i.push(l);
+    }), {
+      data: this._abiCoder.encode(s, i),
+      topics: e
+    };
+  }
+  // Decode a filter for the event and the search criteria
+  decodeEventLog(t, r, e) {
+    if (typeof t == "string" && (t = this.getEvent(t)), e != null && !t.anonymous) {
+      let n = this.getEventTopic(t);
+      (!m(e[0], 32) || e[0].toLowerCase() !== n) && c.throwError("fragment/topic mismatch", x.errors.INVALID_ARGUMENT, { argument: "topics[0]", expected: n, value: e[0] }), e = e.slice(1);
+    }
+    let s = [], i = [], o = [];
+    t.inputs.forEach((n, a) => {
+      n.indexed ? n.type === "string" || n.type === "bytes" || n.baseType === "tuple" || n.baseType === "array" ? (s.push(V.fromObject({ type: "bytes32", name: n.name })), o.push(!0)) : (s.push(n), o.push(!1)) : (i.push(n), o.push(!1));
+    });
+    let h = e != null ? this._abiCoder.decode(s, C(e)) : null, l = this._abiCoder.decode(i, r, !0), u = [], p = 0, g = 0;
+    t.inputs.forEach((n, a) => {
+      if (n.indexed)
+        if (h == null)
+          u[a] = new N({ _isIndexed: !0, hash: null });
+        else if (o[a])
+          u[a] = new N({ _isIndexed: !0, hash: h[g++] });
+        else
+          try {
+            u[a] = h[g++];
+          } catch (y) {
+            u[a] = y;
+          }
+      else
+        try {
+          u[a] = l[p++];
+        } catch (y) {
+          u[a] = y;
+        }
+      if (n.name && u[n.name] == null) {
+        const y = u[a];
+        y instanceof Error ? Object.defineProperty(u, n.name, {
+          enumerable: !0,
+          get: () => {
+            throw k(`property ${JSON.stringify(n.name)}`, y);
+          }
+        }) : u[n.name] = y;
+      }
+    });
+    for (let n = 0; n < u.length; n++) {
+      const a = u[n];
+      a instanceof Error && Object.defineProperty(u, n, {
+        enumerable: !0,
+        get: () => {
+          throw k(`index ${n}`, a);
+        }
+      });
+    }
+    return Object.freeze(u);
+  }
+  // Given a transaction, find the matching function fragment (if any) and
+  // determine all its properties and call parameters
+  parseTransaction(t) {
+    let r = this.getFunction(t.data.substring(0, 10).toLowerCase());
+    return r ? new U({
+      args: this._abiCoder.decode(r.inputs, "0x" + t.data.substring(10)),
+      functionFragment: r,
+      name: r.name,
+      signature: r.format(),
+      sighash: this.getSighash(r),
+      value: L.from(t.value || "0")
+    }) : null;
+  }
+  // @TODO
+  //parseCallResult(data: BytesLike): ??
+  // Given an event log, find the matching event fragment (if any) and
+  // determine all its properties and values
+  parseLog(t) {
+    let r = this.getEvent(t.topics[0]);
+    return !r || r.anonymous ? null : new H({
+      eventFragment: r,
+      name: r.name,
+      signature: r.format(),
+      topic: this.getEventTopic(r),
+      args: this.decodeEventLog(r, t.data, t.topics)
+    });
+  }
+  parseError(t) {
+    const r = d(t);
+    let e = this.getError(r.substring(0, 10).toLowerCase());
+    return e ? new z({
+      args: this._abiCoder.decode(e.inputs, "0x" + r.substring(10)),
+      errorFragment: e,
+      name: e.name,
+      signature: e.format(),
+      sighash: this.getSighash(e)
+    }) : null;
+  }
+  /*
+  static from(value: Array<Fragment | string | JsonAbi> | string | Interface) {
+      if (Interface.isInterface(value)) {
+          return value;
+      }
+      if (typeof(value) === "string") {
+          return new Interface(JSON.parse(value));
+      }
+      return new Interface(value);
+  }
+  */
+  static isInterface(t) {
+    return !!(t && t._isInterface);
+  }
+}
+export {
+  z as ErrorDescription,
+  N as Indexed,
+  tt as Interface,
+  H as LogDescription,
+  U as TransactionDescription
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abstract-provider/lib.esm/_version.mjs

@@ -0,0 +1,4 @@
+const r = "abstract-provider/5.7.0";
+export {
+  r as version
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abstract-provider/lib.esm/index.mjs

@@ -0,0 +1,67 @@
+import { defineReadOnly as m, resolveProperties as h, Description as P } from "../../properties/lib.esm/index.mjs";
+import { Logger as p } from "../../logger/lib.esm/index.mjs";
+import { version as v } from "./_version.mjs";
+import { BigNumber as F } from "../../bignumber/lib.esm/bignumber.mjs";
+var g = function(u, e, t, n) {
+  function s(r) {
+    return r instanceof t ? r : new t(function(o) {
+      o(r);
+    });
+  }
+  return new (t || (t = Promise))(function(r, o) {
+    function d(i) {
+      try {
+        a(n.next(i));
+      } catch (c) {
+        o(c);
+      }
+    }
+    function l(i) {
+      try {
+        a(n.throw(i));
+      } catch (c) {
+        o(c);
+      }
+    }
+    function a(i) {
+      i.done ? r(i.value) : s(i.value).then(d, l);
+    }
+    a((n = n.apply(u, e || [])).next());
+  });
+};
+const b = new p(v);
+class y extends P {
+  static isForkEvent(e) {
+    return !!(e && e._isForkEvent);
+  }
+}
+class f {
+  constructor() {
+    b.checkAbstract(new.target, f), m(this, "_isProvider", !0);
+  }
+  getFeeData() {
+    return g(this, void 0, void 0, function* () {
+      const { block: e, gasPrice: t } = yield h({
+        block: this.getBlock("latest"),
+        gasPrice: this.getGasPrice().catch((o) => null)
+      });
+      let n = null, s = null, r = null;
+      return e && e.baseFeePerGas && (n = e.baseFeePerGas, r = F.from("1500000000"), s = e.baseFeePerGas.mul(2).add(r)), { lastBaseFeePerGas: n, maxFeePerGas: s, maxPriorityFeePerGas: r, gasPrice: t };
+    });
+  }
+  // Alias for "on"
+  addListener(e, t) {
+    return this.on(e, t);
+  }
+  // Alias for "off"
+  removeListener(e, t) {
+    return this.off(e, t);
+  }
+  static isProvider(e) {
+    return !!(e && e._isProvider);
+  }
+}
+export {
+  y as ForkEvent,
+  f as Provider
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abstract-signer/lib.esm/_version.mjs

@@ -0,0 +1,4 @@
+const r = "abstract-signer/5.7.0";
+export {
+  r as version
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/abstract-signer/lib.esm/index.mjs

@@ -0,0 +1,223 @@
+import { defineReadOnly as P, resolveProperties as l, shallowCopy as y } from "../../properties/lib.esm/index.mjs";
+import { Logger as a } from "../../logger/lib.esm/index.mjs";
+import { version as x } from "./_version.mjs";
+var o = function(f, r, e, t) {
+  function i(s) {
+    return s instanceof e ? s : new e(function(d) {
+      d(s);
+    });
+  }
+  return new (e || (e = Promise))(function(s, d) {
+    function p(c) {
+      try {
+        h(t.next(c));
+      } catch (u) {
+        d(u);
+      }
+    }
+    function v(c) {
+      try {
+        h(t.throw(c));
+      } catch (u) {
+        d(u);
+      }
+    }
+    function h(c) {
+      c.done ? s(c.value) : i(c.value).then(p, v);
+    }
+    h((t = t.apply(f, r || [])).next());
+  });
+};
+const n = new a(x), E = [
+  "accessList",
+  "ccipReadEnabled",
+  "chainId",
+  "customData",
+  "data",
+  "from",
+  "gasLimit",
+  "gasPrice",
+  "maxFeePerGas",
+  "maxPriorityFeePerGas",
+  "nonce",
+  "to",
+  "type",
+  "value"
+], G = [
+  a.errors.INSUFFICIENT_FUNDS,
+  a.errors.NONCE_EXPIRED,
+  a.errors.REPLACEMENT_UNDERPRICED
+];
+class g {
+  ///////////////////
+  // Sub-classes MUST call super
+  constructor() {
+    n.checkAbstract(new.target, g), P(this, "_isSigner", !0);
+  }
+  ///////////////////
+  // Sub-classes MAY override these
+  getBalance(r) {
+    return o(this, void 0, void 0, function* () {
+      return this._checkProvider("getBalance"), yield this.provider.getBalance(this.getAddress(), r);
+    });
+  }
+  getTransactionCount(r) {
+    return o(this, void 0, void 0, function* () {
+      return this._checkProvider("getTransactionCount"), yield this.provider.getTransactionCount(this.getAddress(), r);
+    });
+  }
+  // Populates "from" if unspecified, and estimates the gas for the transaction
+  estimateGas(r) {
+    return o(this, void 0, void 0, function* () {
+      this._checkProvider("estimateGas");
+      const e = yield l(this.checkTransaction(r));
+      return yield this.provider.estimateGas(e);
+    });
+  }
+  // Populates "from" if unspecified, and calls with the transaction
+  call(r, e) {
+    return o(this, void 0, void 0, function* () {
+      this._checkProvider("call");
+      const t = yield l(this.checkTransaction(r));
+      return yield this.provider.call(t, e);
+    });
+  }
+  // Populates all fields in a transaction, signs it and sends it to the network
+  sendTransaction(r) {
+    return o(this, void 0, void 0, function* () {
+      this._checkProvider("sendTransaction");
+      const e = yield this.populateTransaction(r), t = yield this.signTransaction(e);
+      return yield this.provider.sendTransaction(t);
+    });
+  }
+  getChainId() {
+    return o(this, void 0, void 0, function* () {
+      return this._checkProvider("getChainId"), (yield this.provider.getNetwork()).chainId;
+    });
+  }
+  getGasPrice() {
+    return o(this, void 0, void 0, function* () {
+      return this._checkProvider("getGasPrice"), yield this.provider.getGasPrice();
+    });
+  }
+  getFeeData() {
+    return o(this, void 0, void 0, function* () {
+      return this._checkProvider("getFeeData"), yield this.provider.getFeeData();
+    });
+  }
+  resolveName(r) {
+    return o(this, void 0, void 0, function* () {
+      return this._checkProvider("resolveName"), yield this.provider.resolveName(r);
+    });
+  }
+  // Checks a transaction does not contain invalid keys and if
+  // no "from" is provided, populates it.
+  // - does NOT require a provider
+  // - adds "from" is not present
+  // - returns a COPY (safe to mutate the result)
+  // By default called from: (overriding these prevents it)
+  //   - call
+  //   - estimateGas
+  //   - populateTransaction (and therefor sendTransaction)
+  checkTransaction(r) {
+    for (const t in r)
+      E.indexOf(t) === -1 && n.throwArgumentError("invalid transaction key: " + t, "transaction", r);
+    const e = y(r);
+    return e.from == null ? e.from = this.getAddress() : e.from = Promise.all([
+      Promise.resolve(e.from),
+      this.getAddress()
+    ]).then((t) => (t[0].toLowerCase() !== t[1].toLowerCase() && n.throwArgumentError("from address mismatch", "transaction", r), t[0])), e;
+  }
+  // Populates ALL keys for a transaction and checks that "from" matches
+  // this Signer. Should be used by sendTransaction but NOT by signTransaction.
+  // By default called from: (overriding these prevents it)
+  //   - sendTransaction
+  //
+  // Notes:
+  //  - We allow gasPrice for EIP-1559 as long as it matches maxFeePerGas
+  populateTransaction(r) {
+    return o(this, void 0, void 0, function* () {
+      const e = yield l(this.checkTransaction(r));
+      e.to != null && (e.to = Promise.resolve(e.to).then((i) => o(this, void 0, void 0, function* () {
+        if (i == null)
+          return null;
+        const s = yield this.resolveName(i);
+        return s == null && n.throwArgumentError("provided ENS name resolves to null", "tx.to", i), s;
+      })), e.to.catch((i) => {
+      }));
+      const t = e.maxFeePerGas != null || e.maxPriorityFeePerGas != null;
+      if (e.gasPrice != null && (e.type === 2 || t) ? n.throwArgumentError("eip-1559 transaction do not support gasPrice", "transaction", r) : (e.type === 0 || e.type === 1) && t && n.throwArgumentError("pre-eip-1559 transaction do not support maxFeePerGas/maxPriorityFeePerGas", "transaction", r), (e.type === 2 || e.type == null) && e.maxFeePerGas != null && e.maxPriorityFeePerGas != null)
+        e.type = 2;
+      else if (e.type === 0 || e.type === 1)
+        e.gasPrice == null && (e.gasPrice = this.getGasPrice());
+      else {
+        const i = yield this.getFeeData();
+        if (e.type == null)
+          if (i.maxFeePerGas != null && i.maxPriorityFeePerGas != null)
+            if (e.type = 2, e.gasPrice != null) {
+              const s = e.gasPrice;
+              delete e.gasPrice, e.maxFeePerGas = s, e.maxPriorityFeePerGas = s;
+            } else
+              e.maxFeePerGas == null && (e.maxFeePerGas = i.maxFeePerGas), e.maxPriorityFeePerGas == null && (e.maxPriorityFeePerGas = i.maxPriorityFeePerGas);
+          else
+            i.gasPrice != null ? (t && n.throwError("network does not support EIP-1559", a.errors.UNSUPPORTED_OPERATION, {
+              operation: "populateTransaction"
+            }), e.gasPrice == null && (e.gasPrice = i.gasPrice), e.type = 0) : n.throwError("failed to get consistent fee data", a.errors.UNSUPPORTED_OPERATION, {
+              operation: "signer.getFeeData"
+            });
+        else
+          e.type === 2 && (e.maxFeePerGas == null && (e.maxFeePerGas = i.maxFeePerGas), e.maxPriorityFeePerGas == null && (e.maxPriorityFeePerGas = i.maxPriorityFeePerGas));
+      }
+      return e.nonce == null && (e.nonce = this.getTransactionCount("pending")), e.gasLimit == null && (e.gasLimit = this.estimateGas(e).catch((i) => {
+        if (G.indexOf(i.code) >= 0)
+          throw i;
+        return n.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", a.errors.UNPREDICTABLE_GAS_LIMIT, {
+          error: i,
+          tx: e
+        });
+      })), e.chainId == null ? e.chainId = this.getChainId() : e.chainId = Promise.all([
+        Promise.resolve(e.chainId),
+        this.getChainId()
+      ]).then((i) => (i[1] !== 0 && i[0] !== i[1] && n.throwArgumentError("chainId address mismatch", "transaction", r), i[0])), yield l(e);
+    });
+  }
+  ///////////////////
+  // Sub-classes SHOULD leave these alone
+  _checkProvider(r) {
+    this.provider || n.throwError("missing provider", a.errors.UNSUPPORTED_OPERATION, {
+      operation: r || "_checkProvider"
+    });
+  }
+  static isSigner(r) {
+    return !!(r && r._isSigner);
+  }
+}
+class m extends g {
+  constructor(r, e) {
+    super(), P(this, "address", r), P(this, "provider", e || null);
+  }
+  getAddress() {
+    return Promise.resolve(this.address);
+  }
+  _fail(r, e) {
+    return Promise.resolve().then(() => {
+      n.throwError(r, a.errors.UNSUPPORTED_OPERATION, { operation: e });
+    });
+  }
+  signMessage(r) {
+    return this._fail("VoidSigner cannot sign messages", "signMessage");
+  }
+  signTransaction(r) {
+    return this._fail("VoidSigner cannot sign transactions", "signTransaction");
+  }
+  _signTypedData(r, e, t) {
+    return this._fail("VoidSigner cannot sign typed data", "signTypedData");
+  }
+  connect(r) {
+    return new m(this.address, r);
+  }
+}
+export {
+  g as Signer,
+  m as VoidSigner
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@ethersproject/address/lib.esm/_version.mjs

@@ -0,0 +1,4 @@
+const s = "address/5.7.0";
+export {
+  s as version
+};