@hinkal/common 0.0.116 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/math/build/decimal.mjs

@@ -0,0 +1,175 @@
+import { commonjsGlobal as f } from "../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as l } from "../../../../../../../../../_virtual/decimal.mjs";
+import { b as d } from "../../../bn.js/lib/bn.mjs";
+var w = f && f.__importDefault || function(s) {
+  return s && s.__esModule ? s : { default: s };
+};
+Object.defineProperty(l, "__esModule", { value: !0 });
+l.Decimal = void 0;
+const a = w(d), h = 100;
+class i {
+  static fromUserInput(t, r) {
+    i.verifyFractionalDigits(r);
+    const o = t.match(/[^0-9.]/);
+    if (o)
+      throw new Error(`Invalid character at position ${o.index + 1}`);
+    let e, n;
+    if (t === "")
+      e = "0", n = "";
+    else if (t.search(/\./) === -1)
+      e = t, n = "";
+    else {
+      const c = t.split(".");
+      switch (c.length) {
+        case 0:
+        case 1:
+          throw new Error("Fewer than two elements in split result. This must not happen here.");
+        case 2:
+          if (!c[1])
+            throw new Error("Fractional part missing");
+          e = c[0], n = c[1].replace(/0+$/, "");
+          break;
+        default:
+          throw new Error("More than one separator found");
+      }
+    }
+    if (n.length > r)
+      throw new Error("Got more fractional digits than supported");
+    const u = `${e}${n.padEnd(r, "0")}`;
+    return new i(u, r);
+  }
+  static fromAtomics(t, r) {
+    return i.verifyFractionalDigits(r), new i(t, r);
+  }
+  /**
+   * Creates a Decimal with value 0.0 and the given number of fractial digits.
+   *
+   * Fractional digits are not relevant for the value but needed to be able
+   * to perform arithmetic operations with other decimals.
+   */
+  static zero(t) {
+    return i.verifyFractionalDigits(t), new i("0", t);
+  }
+  /**
+   * Creates a Decimal with value 1.0 and the given number of fractial digits.
+   *
+   * Fractional digits are not relevant for the value but needed to be able
+   * to perform arithmetic operations with other decimals.
+   */
+  static one(t) {
+    return i.verifyFractionalDigits(t), new i("1" + "0".repeat(t), t);
+  }
+  static verifyFractionalDigits(t) {
+    if (!Number.isInteger(t))
+      throw new Error("Fractional digits is not an integer");
+    if (t < 0)
+      throw new Error("Fractional digits must not be negative");
+    if (t > h)
+      throw new Error(`Fractional digits must not exceed ${h}`);
+  }
+  static compare(t, r) {
+    if (t.fractionalDigits !== r.fractionalDigits)
+      throw new Error("Fractional digits do not match");
+    return t.data.atomics.cmp(new a.default(r.atomics));
+  }
+  get atomics() {
+    return this.data.atomics.toString();
+  }
+  get fractionalDigits() {
+    return this.data.fractionalDigits;
+  }
+  constructor(t, r) {
+    if (!t.match(/^[0-9]+$/))
+      throw new Error("Invalid string format. Only non-negative integers in decimal representation supported.");
+    this.data = {
+      atomics: new a.default(t),
+      fractionalDigits: r
+    };
+  }
+  /** Creates a new instance with the same value */
+  clone() {
+    return new i(this.atomics, this.fractionalDigits);
+  }
+  /** Returns the greatest decimal <= this which has no fractional part (rounding down) */
+  floor() {
+    const t = new a.default(10).pow(new a.default(this.data.fractionalDigits)), r = this.data.atomics.div(t);
+    return this.data.atomics.mod(t).isZero() ? this.clone() : i.fromAtomics(r.mul(t).toString(), this.fractionalDigits);
+  }
+  /** Returns the smallest decimal >= this which has no fractional part (rounding up) */
+  ceil() {
+    const t = new a.default(10).pow(new a.default(this.data.fractionalDigits)), r = this.data.atomics.div(t);
+    return this.data.atomics.mod(t).isZero() ? this.clone() : i.fromAtomics(r.addn(1).mul(t).toString(), this.fractionalDigits);
+  }
+  toString() {
+    const t = new a.default(10).pow(new a.default(this.data.fractionalDigits)), r = this.data.atomics.div(t), o = this.data.atomics.mod(t);
+    if (o.isZero())
+      return r.toString();
+    {
+      const n = o.toString().padStart(this.data.fractionalDigits, "0").replace(/0+$/, "");
+      return `${r.toString()}.${n}`;
+    }
+  }
+  /**
+   * Returns an approximation as a float type. Only use this if no
+   * exact calculation is required.
+   */
+  toFloatApproximation() {
+    const t = Number(this.toString());
+    if (Number.isNaN(t))
+      throw new Error("Conversion to number failed");
+    return t;
+  }
+  /**
+   * a.plus(b) returns a+b.
+   *
+   * Both values need to have the same fractional digits.
+   */
+  plus(t) {
+    if (this.fractionalDigits !== t.fractionalDigits)
+      throw new Error("Fractional digits do not match");
+    const r = this.data.atomics.add(new a.default(t.atomics));
+    return new i(r.toString(), this.fractionalDigits);
+  }
+  /**
+   * a.minus(b) returns a-b.
+   *
+   * Both values need to have the same fractional digits.
+   * The resulting difference needs to be non-negative.
+   */
+  minus(t) {
+    if (this.fractionalDigits !== t.fractionalDigits)
+      throw new Error("Fractional digits do not match");
+    const r = this.data.atomics.sub(new a.default(t.atomics));
+    if (r.ltn(0))
+      throw new Error("Difference must not be negative");
+    return new i(r.toString(), this.fractionalDigits);
+  }
+  /**
+   * a.multiply(b) returns a*b.
+   *
+   * We only allow multiplication by unsigned integers to avoid rounding errors.
+   */
+  multiply(t) {
+    const r = this.data.atomics.mul(new a.default(t.toString()));
+    return new i(r.toString(), this.fractionalDigits);
+  }
+  equals(t) {
+    return i.compare(this, t) === 0;
+  }
+  isLessThan(t) {
+    return i.compare(this, t) < 0;
+  }
+  isLessThanOrEqual(t) {
+    return i.compare(this, t) <= 0;
+  }
+  isGreaterThan(t) {
+    return i.compare(this, t) > 0;
+  }
+  isGreaterThanOrEqual(t) {
+    return i.compare(this, t) >= 0;
+  }
+}
+l.Decimal = i;
+export {
+  l as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/math/build/index.mjs

@@ -0,0 +1,22 @@
+import { __exports as r } from "../../../../../../../../../_virtual/index54.mjs";
+import "./decimal.mjs";
+import "./integers.mjs";
+import { __exports as i } from "../../../../../../../../../_virtual/decimal.mjs";
+import { __exports as u } from "../../../../../../../../../_virtual/integers.mjs";
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.Uint64 = e.Uint53 = e.Uint32 = e.Int53 = e.Decimal = void 0;
+  var n = i;
+  Object.defineProperty(e, "Decimal", { enumerable: !0, get: function() {
+    return n.Decimal;
+  } });
+  var t = u;
+  Object.defineProperty(e, "Int53", { enumerable: !0, get: function() {
+    return t.Int53;
+  } }), Object.defineProperty(e, "Uint32", { enumerable: !0, get: function() {
+    return t.Uint32;
+  } }), Object.defineProperty(e, "Uint53", { enumerable: !0, get: function() {
+    return t.Uint53;
+  } }), Object.defineProperty(e, "Uint64", { enumerable: !0, get: function() {
+    return t.Uint64;
+  } });
+})(r);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/math/build/integers.mjs

@@ -0,0 +1,183 @@
+import { commonjsGlobal as g } from "../../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { __exports as e } from "../../../../../../../../../_virtual/integers.mjs";
+import { b as m } from "../../../bn.js/lib/bn.mjs";
+var w = g && g.__importDefault || function(u) {
+  return u && u.__esModule ? u : { default: u };
+};
+Object.defineProperty(e, "__esModule", { value: !0 });
+e.Uint64 = e.Uint53 = e.Int53 = e.Uint32 = void 0;
+const f = w(m), d = new f.default("18446744073709551615", 10, "be");
+class a {
+  /** @deprecated use Uint32.fromBytes */
+  static fromBigEndianBytes(t) {
+    return a.fromBytes(t);
+  }
+  /**
+   * Creates a Uint32 from a fixed length byte array.
+   *
+   * @param bytes a list of exactly 4 bytes
+   * @param endianess defaults to big endian
+   */
+  static fromBytes(t, n = "be") {
+    if (t.length !== 4)
+      throw new Error("Invalid input length. Expected 4 bytes.");
+    for (let r = 0; r < t.length; ++r)
+      if (!Number.isInteger(t[r]) || t[r] > 255 || t[r] < 0)
+        throw new Error("Invalid value in byte. Found: " + t[r]);
+    const o = n === "be" ? t : Array.from(t).reverse();
+    return new a(o[0] * 2 ** 24 + o[1] * 2 ** 16 + o[2] * 2 ** 8 + o[3]);
+  }
+  static fromString(t) {
+    if (!t.match(/^[0-9]+$/))
+      throw new Error("Invalid string format");
+    return new a(Number.parseInt(t, 10));
+  }
+  constructor(t) {
+    if (Number.isNaN(t))
+      throw new Error("Input is not a number");
+    if (!Number.isInteger(t))
+      throw new Error("Input is not an integer");
+    if (t < 0 || t > 4294967295)
+      throw new Error("Input not in uint32 range: " + t.toString());
+    this.data = t;
+  }
+  toBytesBigEndian() {
+    return new Uint8Array([
+      Math.floor(this.data / 2 ** 24) & 255,
+      Math.floor(this.data / 2 ** 16) & 255,
+      Math.floor(this.data / 2 ** 8) & 255,
+      Math.floor(this.data / 2 ** 0) & 255
+    ]);
+  }
+  toBytesLittleEndian() {
+    return new Uint8Array([
+      Math.floor(this.data / 2 ** 0) & 255,
+      Math.floor(this.data / 2 ** 8) & 255,
+      Math.floor(this.data / 2 ** 16) & 255,
+      Math.floor(this.data / 2 ** 24) & 255
+    ]);
+  }
+  toNumber() {
+    return this.data;
+  }
+  toBigInt() {
+    return BigInt(this.toNumber());
+  }
+  toString() {
+    return this.data.toString();
+  }
+}
+e.Uint32 = a;
+class s {
+  static fromString(t) {
+    if (!t.match(/^-?[0-9]+$/))
+      throw new Error("Invalid string format");
+    return new s(Number.parseInt(t, 10));
+  }
+  constructor(t) {
+    if (Number.isNaN(t))
+      throw new Error("Input is not a number");
+    if (!Number.isInteger(t))
+      throw new Error("Input is not an integer");
+    if (t < Number.MIN_SAFE_INTEGER || t > Number.MAX_SAFE_INTEGER)
+      throw new Error("Input not in int53 range: " + t.toString());
+    this.data = t;
+  }
+  toNumber() {
+    return this.data;
+  }
+  toBigInt() {
+    return BigInt(this.toNumber());
+  }
+  toString() {
+    return this.data.toString();
+  }
+}
+e.Int53 = s;
+class h {
+  static fromString(t) {
+    const n = s.fromString(t);
+    return new h(n.toNumber());
+  }
+  constructor(t) {
+    const n = new s(t);
+    if (n.toNumber() < 0)
+      throw new Error("Input is negative");
+    this.data = n;
+  }
+  toNumber() {
+    return this.data.toNumber();
+  }
+  toBigInt() {
+    return BigInt(this.toNumber());
+  }
+  toString() {
+    return this.data.toString();
+  }
+}
+e.Uint53 = h;
+class i {
+  /** @deprecated use Uint64.fromBytes */
+  static fromBytesBigEndian(t) {
+    return i.fromBytes(t);
+  }
+  /**
+   * Creates a Uint64 from a fixed length byte array.
+   *
+   * @param bytes a list of exactly 8 bytes
+   * @param endianess defaults to big endian
+   */
+  static fromBytes(t, n = "be") {
+    if (t.length !== 8)
+      throw new Error("Invalid input length. Expected 8 bytes.");
+    for (let r = 0; r < t.length; ++r)
+      if (!Number.isInteger(t[r]) || t[r] > 255 || t[r] < 0)
+        throw new Error("Invalid value in byte. Found: " + t[r]);
+    const o = n === "be" ? Array.from(t) : Array.from(t).reverse();
+    return new i(new f.default(o));
+  }
+  static fromString(t) {
+    if (!t.match(/^[0-9]+$/))
+      throw new Error("Invalid string format");
+    return new i(new f.default(t, 10, "be"));
+  }
+  static fromNumber(t) {
+    if (Number.isNaN(t))
+      throw new Error("Input is not a number");
+    if (!Number.isInteger(t))
+      throw new Error("Input is not an integer");
+    let n;
+    try {
+      n = new f.default(t);
+    } catch {
+      throw new Error("Input is not a safe integer");
+    }
+    return new i(n);
+  }
+  constructor(t) {
+    if (t.isNeg())
+      throw new Error("Input is negative");
+    if (t.gt(d))
+      throw new Error("Input exceeds uint64 range");
+    this.data = t;
+  }
+  toBytesBigEndian() {
+    return Uint8Array.from(this.data.toArray("be", 8));
+  }
+  toBytesLittleEndian() {
+    return Uint8Array.from(this.data.toArray("le", 8));
+  }
+  toString() {
+    return this.data.toString(10);
+  }
+  toBigInt() {
+    return BigInt(this.toString());
+  }
+  toNumber() {
+    return this.data.toNumber();
+  }
+}
+e.Uint64 = i;
+export {
+  e as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/proto-signing/build/coins.mjs

@@ -0,0 +1,18 @@
+import { __exports as r } from "../../../../../../../../../_virtual/coins.mjs";
+Object.defineProperty(r, "__esModule", { value: !0 });
+r.parseCoins = void 0;
+function a(o) {
+  return o.replace(/\s/g, "").split(",").filter(Boolean).map((t) => {
+    const e = t.match(/^([0-9]+)([a-zA-Z][a-zA-Z0-9/]{2,127})$/);
+    if (!e)
+      throw new Error("Got an invalid coin string");
+    return {
+      amount: e[1].replace(/^0+/, "") || "0",
+      denom: e[2]
+    };
+  });
+}
+r.parseCoins = a;
+export {
+  r as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/proto-signing/build/decode.mjs

@@ -0,0 +1,18 @@
+import { __exports as t } from "../../../../../../../../../_virtual/decode.mjs";
+import "../../../cosmjs-types/cosmos/tx/v1beta1/tx.mjs";
+import { __exports as r } from "../../../../../../../../../_virtual/tx2.mjs";
+Object.defineProperty(t, "__esModule", { value: !0 });
+t.decodeTxRaw = void 0;
+const o = r;
+function a(d) {
+  const e = o.TxRaw.decode(d);
+  return {
+    authInfo: o.AuthInfo.decode(e.authInfoBytes),
+    body: o.TxBody.decode(e.bodyBytes),
+    signatures: e.signatures
+  };
+}
+t.decodeTxRaw = a;
+export {
+  t as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/proto-signing/build/directsecp256k1hdwallet.mjs

@@ -0,0 +1,214 @@
+import { __exports as l } from "../../../../../../../../../_virtual/directsecp256k1hdwallet.mjs";
+import "../../amino/build/index.mjs";
+import "../../crypto/build/index.mjs";
+import "../../encoding/build/index.mjs";
+import "../../utils/build/index.mjs";
+import "./signing.mjs";
+import "./wallet.mjs";
+import { __exports as x } from "../../../../../../../../../_virtual/index45.mjs";
+import { __exports as S } from "../../../../../../../../../_virtual/index57.mjs";
+import { __exports as v } from "../../../../../../../../../_virtual/index55.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/index53.mjs";
+import { __exports as N } from "../../../../../../../../../_virtual/signing.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/wallet2.mjs";
+Object.defineProperty(l, "__esModule", { value: !0 });
+l.DirectSecp256k1HdWallet = l.extractKdfConfiguration = void 0;
+const k = x, s = S, h = v, y = E, K = N, m = _, w = "directsecp256k1hdwallet-v1", O = {
+  algorithm: "argon2id",
+  params: {
+    outputLength: 32,
+    opsLimit: 24,
+    memLimitKib: 12 * 1024
+  }
+};
+function A(a) {
+  return !(!(0, y.isNonNullObject)(a) || typeof a.hdPath != "string" || typeof a.prefix != "string");
+}
+function j(a) {
+  return a.kdf;
+}
+function z(a) {
+  const t = JSON.parse(a);
+  if (!(0, y.isNonNullObject)(t))
+    throw new Error("Root document is not an object.");
+  switch (t.type) {
+    case w:
+      return j(t);
+    default:
+      throw new Error("Unsupported serialization type");
+  }
+}
+l.extractKdfConfiguration = z;
+const P = {
+  bip39Password: "",
+  hdPaths: [(0, k.makeCosmoshubPath)(0)],
+  prefix: "cosmos"
+};
+class u {
+  /**
+   * Restores a wallet from the given BIP39 mnemonic.
+   *
+   * @param mnemonic Any valid English mnemonic.
+   * @param options An optional `DirectSecp256k1HdWalletOptions` object optionally containing a bip39Password, hdPaths, and prefix.
+   */
+  static async fromMnemonic(t, e = {}) {
+    const r = new s.EnglishMnemonic(t), o = await s.Bip39.mnemonicToSeed(r, e.bip39Password);
+    return new u(r, {
+      ...e,
+      seed: o
+    });
+  }
+  /**
+   * Generates a new wallet with a BIP39 mnemonic of the given length.
+   *
+   * @param length The number of words in the mnemonic (12, 15, 18, 21 or 24).
+   * @param options An optional `DirectSecp256k1HdWalletOptions` object optionally containing a bip39Password, hdPaths, and prefix.
+   */
+  static async generate(t = 12, e = {}) {
+    const r = 4 * Math.floor(11 * t / 33), o = s.Random.getBytes(r), n = s.Bip39.encode(o);
+    return u.fromMnemonic(n.toString(), e);
+  }
+  /**
+   * Restores a wallet from an encrypted serialization.
+   *
+   * @param password The user provided password used to generate an encryption key via a KDF.
+   *                 This is not normalized internally (see "Unicode normalization" to learn more).
+   */
+  static async deserialize(t, e) {
+    const r = JSON.parse(t);
+    if (!(0, y.isNonNullObject)(r))
+      throw new Error("Root document is not an object.");
+    switch (r.type) {
+      case w:
+        return u.deserializeTypeV1(t, e);
+      default:
+        throw new Error("Unsupported serialization type");
+    }
+  }
+  /**
+   * Restores a wallet from an encrypted serialization.
+   *
+   * This is an advanced alternative to calling `deserialize(serialization, password)` directly, which allows
+   * you to offload the KDF execution to a non-UI thread (e.g. in a WebWorker).
+   *
+   * The caller is responsible for ensuring the key was derived with the given KDF configuration. This can be
+   * done using `extractKdfConfiguration(serialization)` and `executeKdf(password, kdfConfiguration)` from this package.
+   */
+  static async deserializeWithEncryptionKey(t, e) {
+    const r = JSON.parse(t);
+    if (!(0, y.isNonNullObject)(r))
+      throw new Error("Root document is not an object.");
+    const o = r;
+    switch (o.type) {
+      case w: {
+        const n = await (0, m.decrypt)((0, h.fromBase64)(o.data), e, o.encryption), f = JSON.parse((0, h.fromUtf8)(n)), { mnemonic: d, accounts: i } = f;
+        if ((0, y.assert)(typeof d == "string"), !Array.isArray(i))
+          throw new Error("Property 'accounts' is not an array");
+        if (!i.every((p) => A(p)))
+          throw new Error("Account is not in the correct format.");
+        const c = i[0].prefix;
+        if (!i.every(({ prefix: p }) => p === c))
+          throw new Error("Accounts do not all have the same prefix");
+        const g = i.map(({ hdPath: p }) => (0, s.stringToPath)(p));
+        return u.fromMnemonic(d, {
+          hdPaths: g,
+          prefix: c
+        });
+      }
+      default:
+        throw new Error("Unsupported serialization type");
+    }
+  }
+  static async deserializeTypeV1(t, e) {
+    const r = JSON.parse(t);
+    if (!(0, y.isNonNullObject)(r))
+      throw new Error("Root document is not an object.");
+    const o = await (0, m.executeKdf)(e, r.kdf);
+    return u.deserializeWithEncryptionKey(t, o);
+  }
+  constructor(t, e) {
+    const r = e.prefix ?? P.prefix, o = e.hdPaths ?? P.hdPaths;
+    this.secret = t, this.seed = e.seed, this.accounts = o.map((n) => ({
+      hdPath: n,
+      prefix: r
+    }));
+  }
+  get mnemonic() {
+    return this.secret.toString();
+  }
+  async getAccounts() {
+    return (await this.getAccountsWithPrivkeys()).map(({ algo: e, pubkey: r, address: o }) => ({
+      algo: e,
+      pubkey: r,
+      address: o
+    }));
+  }
+  async signDirect(t, e) {
+    const o = (await this.getAccountsWithPrivkeys()).find(({ address: b }) => b === t);
+    if (o === void 0)
+      throw new Error(`Address ${t} not found in wallet`);
+    const { privkey: n, pubkey: f } = o, d = (0, K.makeSignBytes)(e), i = (0, s.sha256)(d), c = await s.Secp256k1.createSignature(i, n), g = new Uint8Array([...c.r(32), ...c.s(32)]), p = (0, k.encodeSecp256k1Signature)(f, g);
+    return {
+      signed: e,
+      signature: p
+    };
+  }
+  /**
+   * Generates an encrypted serialization of this wallet.
+   *
+   * @param password The user provided password used to generate an encryption key via a KDF.
+   *                 This is not normalized internally (see "Unicode normalization" to learn more).
+   */
+  async serialize(t) {
+    const e = O, r = await (0, m.executeKdf)(t, e);
+    return this.serializeWithEncryptionKey(r, e);
+  }
+  /**
+   * Generates an encrypted serialization of this wallet.
+   *
+   * This is an advanced alternative to calling `serialize(password)` directly, which allows you to
+   * offload the KDF execution to a non-UI thread (e.g. in a WebWorker).
+   *
+   * The caller is responsible for ensuring the key was derived with the given KDF options. If this
+   * is not the case, the wallet cannot be restored with the original password.
+   */
+  async serializeWithEncryptionKey(t, e) {
+    const r = {
+      mnemonic: this.mnemonic,
+      accounts: this.accounts.map(({ hdPath: i, prefix: c }) => ({
+        hdPath: (0, s.pathToString)(i),
+        prefix: c
+      }))
+    }, o = (0, h.toUtf8)(JSON.stringify(r)), n = {
+      algorithm: m.supportedAlgorithms.xchacha20poly1305Ietf
+    }, f = await (0, m.encrypt)(o, t, n), d = {
+      type: w,
+      kdf: e,
+      encryption: n,
+      data: (0, h.toBase64)(f)
+    };
+    return JSON.stringify(d);
+  }
+  async getKeyPair(t) {
+    const { privkey: e } = s.Slip10.derivePath(s.Slip10Curve.Secp256k1, this.seed, t), { pubkey: r } = await s.Secp256k1.makeKeypair(e);
+    return {
+      privkey: e,
+      pubkey: s.Secp256k1.compressPubkey(r)
+    };
+  }
+  async getAccountsWithPrivkeys() {
+    return Promise.all(this.accounts.map(async ({ hdPath: t, prefix: e }) => {
+      const { privkey: r, pubkey: o } = await this.getKeyPair(t), n = (0, h.toBech32)(e, (0, k.rawSecp256k1PubkeyToRawAddress)(o));
+      return {
+        algo: "secp256k1",
+        privkey: r,
+        pubkey: o,
+        address: n
+      };
+    }));
+  }
+}
+l.DirectSecp256k1HdWallet = u;
+export {
+  l as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/proto-signing/build/directsecp256k1wallet.mjs

@@ -0,0 +1,53 @@
+import { __exports as i } from "../../../../../../../../../_virtual/directsecp256k1wallet.mjs";
+import "../../amino/build/index.mjs";
+import "../../crypto/build/index.mjs";
+import "../../encoding/build/index.mjs";
+import "./signing.mjs";
+import { __exports as d } from "../../../../../../../../../_virtual/index45.mjs";
+import { __exports as m } from "../../../../../../../../../_virtual/index57.mjs";
+import { __exports as k } from "../../../../../../../../../_virtual/index55.mjs";
+import { __exports as y } from "../../../../../../../../../_virtual/signing.mjs";
+Object.defineProperty(i, "__esModule", { value: !0 });
+i.DirectSecp256k1Wallet = void 0;
+const a = d, r = m, g = k, l = y;
+class o {
+  /**
+   * Creates a DirectSecp256k1Wallet from the given private key
+   *
+   * @param privkey The private key.
+   * @param prefix The bech32 address prefix (human readable part). Defaults to "cosmos".
+   */
+  static async fromKey(e, t = "cosmos") {
+    const s = (await r.Secp256k1.makeKeypair(e)).pubkey;
+    return new o(e, r.Secp256k1.compressPubkey(s), t);
+  }
+  constructor(e, t, s) {
+    this.privkey = e, this.pubkey = t, this.prefix = s;
+  }
+  get address() {
+    return (0, g.toBech32)(this.prefix, (0, a.rawSecp256k1PubkeyToRawAddress)(this.pubkey));
+  }
+  async getAccounts() {
+    return [
+      {
+        algo: "secp256k1",
+        address: this.address,
+        pubkey: this.pubkey
+      }
+    ];
+  }
+  async signDirect(e, t) {
+    const s = (0, l.makeSignBytes)(t);
+    if (e !== this.address)
+      throw new Error(`Address ${e} not found in wallet`);
+    const c = (0, r.sha256)(s), n = await r.Secp256k1.createSignature(c, this.privkey), p = new Uint8Array([...n.r(32), ...n.s(32)]), u = (0, a.encodeSecp256k1Signature)(this.pubkey, p);
+    return {
+      signed: t,
+      signature: u
+    };
+  }
+}
+i.DirectSecp256k1Wallet = o;
+export {
+  i as default
+};