@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/encoding.mjs

@@ -0,0 +1,142 @@
+import { __exports as o } from "../../../../../../../../../_virtual/encoding.mjs";
+import "../../encoding/build/index.mjs";
+import "../../math/build/index.mjs";
+import "../../utils/build/index.mjs";
+import "./pubkeys.mjs";
+import { __exports as P } from "../../../../../../../../../_virtual/index56.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/index58.mjs";
+import { __exports as v } from "../../../../../../../../../_virtual/pubkeys.mjs";
+import { __exports as S } from "../../../../../../../../../_virtual/index59.mjs";
+Object.defineProperty(o, "__esModule", { value: !0 });
+o.encodeBech32Pubkey = o.encodeAminoPubkey = o.decodeBech32Pubkey = o.decodeAminoPubkey = o.encodeEd25519Pubkey = o.encodeSecp256k1Pubkey = void 0;
+const r = P, A = S, i = E, n = v;
+function B(e) {
+  if (e.length !== 33 || e[0] !== 2 && e[0] !== 3)
+    throw new Error("Public key must be compressed secp256k1, i.e. 33 bytes starting with 0x02 or 0x03");
+  return {
+    type: n.pubkeyType.secp256k1,
+    value: (0, r.toBase64)(e)
+  };
+}
+o.encodeSecp256k1Pubkey = B;
+function _(e) {
+  if (e.length !== 32)
+    throw new Error("Ed25519 public key must be 32 bytes long");
+  return {
+    type: n.pubkeyType.ed25519,
+    value: (0, r.toBase64)(e)
+  };
+}
+o.encodeEd25519Pubkey = _;
+const p = (0, r.fromHex)(
+  "eb5ae98721"
+  /* fixed length */
+), l = (0, r.fromHex)(
+  "1624de6420"
+  /* fixed length */
+), f = (0, r.fromHex)(
+  "0dfb100520"
+  /* fixed length */
+), u = (0, r.fromHex)(
+  "22c1f7e2"
+  /* variable length not included */
+);
+function a(e) {
+  if ((0, i.arrayContentStartsWith)(e, p)) {
+    const t = e.slice(p.length);
+    if (t.length !== 33)
+      throw new Error("Invalid rest data length. Expected 33 bytes (compressed secp256k1 pubkey).");
+    return {
+      type: n.pubkeyType.secp256k1,
+      value: (0, r.toBase64)(t)
+    };
+  } else if ((0, i.arrayContentStartsWith)(e, l)) {
+    const t = e.slice(l.length);
+    if (t.length !== 32)
+      throw new Error("Invalid rest data length. Expected 32 bytes (Ed25519 pubkey).");
+    return {
+      type: n.pubkeyType.ed25519,
+      value: (0, r.toBase64)(t)
+    };
+  } else if ((0, i.arrayContentStartsWith)(e, f)) {
+    const t = e.slice(f.length);
+    if (t.length !== 32)
+      throw new Error("Invalid rest data length. Expected 32 bytes (Sr25519 pubkey).");
+    return {
+      type: n.pubkeyType.sr25519,
+      value: (0, r.toBase64)(t)
+    };
+  } else {
+    if ((0, i.arrayContentStartsWith)(e, u))
+      return T(e);
+    throw new Error("Unsupported public key type. Amino data starts with: " + (0, r.toHex)(e.slice(0, 5)));
+  }
+}
+o.decodeAminoPubkey = a;
+function U(e) {
+  const { data: t } = (0, r.fromBech32)(e);
+  return a(t);
+}
+o.decodeBech32Pubkey = U;
+function m(e) {
+  if (e.length < 1)
+    throw new Error("Can't decode varint. EOF");
+  if (e[0] > 127)
+    throw new Error("Decoding numbers > 127 is not supported here. Please tell those lazy CosmJS maintainers to port the binary.Varint implementation from the Go standard library and write some tests.");
+  return [e[0], 1];
+}
+function T(e) {
+  const t = Array.from(e), s = t.splice(0, u.length);
+  if (!(0, i.arrayContentStartsWith)(s, u))
+    throw new Error("Invalid multisig prefix.");
+  if (t.shift() != 8)
+    throw new Error("Invalid multisig data. Expecting 0x08 prefix before threshold.");
+  const [c, k] = m(t);
+  t.splice(0, k);
+  const h = [];
+  for (; t.length > 0; ) {
+    if (t.shift() != 18)
+      throw new Error("Invalid multisig data. Expecting 0x12 prefix before participant pubkey length.");
+    const [y, g] = m(t);
+    if (t.splice(0, g), t.length < y)
+      throw new Error("Invalid multisig data length.");
+    const w = t.splice(0, y), x = a(Uint8Array.from(w));
+    h.push(x);
+  }
+  return {
+    type: n.pubkeyType.multisigThreshold,
+    value: {
+      threshold: c.toString(),
+      pubkeys: h
+    }
+  };
+}
+function b(e) {
+  const t = A.Uint53.fromString(e.toString()).toNumber();
+  if (t > 127)
+    throw new Error("Encoding numbers > 127 is not supported here. Please tell those lazy CosmJS maintainers to port the binary.PutUvarint implementation from the Go standard library and write some tests.");
+  return [t];
+}
+function d(e) {
+  if ((0, n.isMultisigThresholdPubkey)(e)) {
+    const t = Array.from(u);
+    t.push(8), t.push(...b(e.value.threshold));
+    for (const s of e.value.pubkeys.map((c) => d(c)))
+      t.push(18), t.push(...b(s.length)), t.push(...s);
+    return new Uint8Array(t);
+  } else {
+    if ((0, n.isEd25519Pubkey)(e))
+      return new Uint8Array([...l, ...(0, r.fromBase64)(e.value)]);
+    if ((0, n.isSecp256k1Pubkey)(e))
+      return new Uint8Array([...p, ...(0, r.fromBase64)(e.value)]);
+    throw new Error("Unsupported pubkey type");
+  }
+}
+o.encodeAminoPubkey = d;
+function C(e, t) {
+  return (0, r.toBech32)(t, d(e));
+}
+o.encodeBech32Pubkey = C;
+export {
+  o as default
+};

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

@@ -0,0 +1,114 @@
+import { __exports as y } from "../../../../../../../../../_virtual/index50.mjs";
+import "./addresses.mjs";
+import "./coins.mjs";
+import "./encoding.mjs";
+import "./multisig.mjs";
+import "./paths.mjs";
+import "./pubkeys.mjs";
+import "./secp256k1hdwallet.mjs";
+import "./secp256k1wallet.mjs";
+import "./signature.mjs";
+import "./signdoc.mjs";
+import "./stdtx.mjs";
+import "./wallet.mjs";
+import { __exports as k } from "../../../../../../../../../_virtual/addresses2.mjs";
+import { __exports as l } from "../../../../../../../../../_virtual/coins2.mjs";
+import { __exports as P } from "../../../../../../../../../_virtual/encoding.mjs";
+import { __exports as g } from "../../../../../../../../../_virtual/multisig2.mjs";
+import { __exports as s } from "../../../../../../../../../_virtual/paths2.mjs";
+import { __exports as p } from "../../../../../../../../../_virtual/pubkeys.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/secp256k1hdwallet.mjs";
+import { __exports as S } from "../../../../../../../../../_virtual/secp256k1wallet.mjs";
+import { __exports as j } from "../../../../../../../../../_virtual/signature.mjs";
+import { __exports as O } from "../../../../../../../../../_virtual/signdoc.mjs";
+import { __exports as h } from "../../../../../../../../../_virtual/stdtx.mjs";
+import { __exports as T } from "../../../../../../../../../_virtual/wallet3.mjs";
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.executeKdf = e.makeStdTx = e.isStdTx = e.serializeSignDoc = e.makeSignDoc = e.encodeSecp256k1Signature = e.decodeSignature = e.Secp256k1Wallet = e.Secp256k1HdWallet = e.extractKdfConfiguration = e.pubkeyType = e.isSinglePubkey = e.isSecp256k1Pubkey = e.isMultisigThresholdPubkey = e.isEd25519Pubkey = e.makeCosmoshubPath = e.createMultisigThresholdPubkey = e.encodeSecp256k1Pubkey = e.encodeEd25519Pubkey = e.encodeBech32Pubkey = e.encodeAminoPubkey = e.decodeBech32Pubkey = e.decodeAminoPubkey = e.parseCoins = e.coins = e.coin = e.addCoins = e.rawSecp256k1PubkeyToRawAddress = e.rawEd25519PubkeyToRawAddress = e.pubkeyToRawAddress = e.pubkeyToAddress = void 0;
+  var n = k;
+  Object.defineProperty(e, "pubkeyToAddress", { enumerable: !0, get: function() {
+    return n.pubkeyToAddress;
+  } }), Object.defineProperty(e, "pubkeyToRawAddress", { enumerable: !0, get: function() {
+    return n.pubkeyToRawAddress;
+  } }), Object.defineProperty(e, "rawEd25519PubkeyToRawAddress", { enumerable: !0, get: function() {
+    return n.rawEd25519PubkeyToRawAddress;
+  } }), Object.defineProperty(e, "rawSecp256k1PubkeyToRawAddress", { enumerable: !0, get: function() {
+    return n.rawSecp256k1PubkeyToRawAddress;
+  } });
+  var u = l;
+  Object.defineProperty(e, "addCoins", { enumerable: !0, get: function() {
+    return u.addCoins;
+  } }), Object.defineProperty(e, "coin", { enumerable: !0, get: function() {
+    return u.coin;
+  } }), Object.defineProperty(e, "coins", { enumerable: !0, get: function() {
+    return u.coins;
+  } }), Object.defineProperty(e, "parseCoins", { enumerable: !0, get: function() {
+    return u.parseCoins;
+  } });
+  var r = P;
+  Object.defineProperty(e, "decodeAminoPubkey", { enumerable: !0, get: function() {
+    return r.decodeAminoPubkey;
+  } }), Object.defineProperty(e, "decodeBech32Pubkey", { enumerable: !0, get: function() {
+    return r.decodeBech32Pubkey;
+  } }), Object.defineProperty(e, "encodeAminoPubkey", { enumerable: !0, get: function() {
+    return r.encodeAminoPubkey;
+  } }), Object.defineProperty(e, "encodeBech32Pubkey", { enumerable: !0, get: function() {
+    return r.encodeBech32Pubkey;
+  } }), Object.defineProperty(e, "encodeEd25519Pubkey", { enumerable: !0, get: function() {
+    return r.encodeEd25519Pubkey;
+  } }), Object.defineProperty(e, "encodeSecp256k1Pubkey", { enumerable: !0, get: function() {
+    return r.encodeSecp256k1Pubkey;
+  } });
+  var a = g;
+  Object.defineProperty(e, "createMultisigThresholdPubkey", { enumerable: !0, get: function() {
+    return a.createMultisigThresholdPubkey;
+  } });
+  var b = s;
+  Object.defineProperty(e, "makeCosmoshubPath", { enumerable: !0, get: function() {
+    return b.makeCosmoshubPath;
+  } });
+  var t = p;
+  Object.defineProperty(e, "isEd25519Pubkey", { enumerable: !0, get: function() {
+    return t.isEd25519Pubkey;
+  } }), Object.defineProperty(e, "isMultisigThresholdPubkey", { enumerable: !0, get: function() {
+    return t.isMultisigThresholdPubkey;
+  } }), Object.defineProperty(e, "isSecp256k1Pubkey", { enumerable: !0, get: function() {
+    return t.isSecp256k1Pubkey;
+  } }), Object.defineProperty(e, "isSinglePubkey", { enumerable: !0, get: function() {
+    return t.isSinglePubkey;
+  } }), Object.defineProperty(e, "pubkeyType", { enumerable: !0, get: function() {
+    return t.pubkeyType;
+  } });
+  var i = _;
+  Object.defineProperty(e, "extractKdfConfiguration", { enumerable: !0, get: function() {
+    return i.extractKdfConfiguration;
+  } }), Object.defineProperty(e, "Secp256k1HdWallet", { enumerable: !0, get: function() {
+    return i.Secp256k1HdWallet;
+  } });
+  var m = S;
+  Object.defineProperty(e, "Secp256k1Wallet", { enumerable: !0, get: function() {
+    return m.Secp256k1Wallet;
+  } });
+  var c = j;
+  Object.defineProperty(e, "decodeSignature", { enumerable: !0, get: function() {
+    return c.decodeSignature;
+  } }), Object.defineProperty(e, "encodeSecp256k1Signature", { enumerable: !0, get: function() {
+    return c.encodeSecp256k1Signature;
+  } });
+  var d = O;
+  Object.defineProperty(e, "makeSignDoc", { enumerable: !0, get: function() {
+    return d.makeSignDoc;
+  } }), Object.defineProperty(e, "serializeSignDoc", { enumerable: !0, get: function() {
+    return d.serializeSignDoc;
+  } });
+  var o = h;
+  Object.defineProperty(e, "isStdTx", { enumerable: !0, get: function() {
+    return o.isStdTx;
+  } }), Object.defineProperty(e, "makeStdTx", { enumerable: !0, get: function() {
+    return o.makeStdTx;
+  } });
+  var f = T;
+  Object.defineProperty(e, "executeKdf", { enumerable: !0, get: function() {
+    return f.executeKdf;
+  } });
+})(y);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/multisig.mjs

@@ -0,0 +1,35 @@
+import { __exports as t } from "../../../../../../../../../_virtual/multisig2.mjs";
+import "../../encoding/build/index.mjs";
+import "../../math/build/index.mjs";
+import "./addresses.mjs";
+import { __exports as h } from "../../../../../../../../../_virtual/index56.mjs";
+import { __exports as p } from "../../../../../../../../../_virtual/index59.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/addresses2.mjs";
+Object.defineProperty(t, "__esModule", { value: !0 });
+t.createMultisigThresholdPubkey = t.compareArrays = void 0;
+const n = h, b = p, i = _;
+function d(e, s) {
+  const o = (0, n.toHex)(e), r = (0, n.toHex)(s);
+  return o === r ? 0 : o < r ? -1 : 1;
+}
+t.compareArrays = d;
+function f(e, s, o = !1) {
+  const r = new b.Uint53(s);
+  if (r.toNumber() > e.length)
+    throw new Error(`Threshold k = ${r.toNumber()} exceeds number of keys n = ${e.length}`);
+  const a = o ? e : Array.from(e).sort((u, l) => {
+    const m = (0, i.pubkeyToRawAddress)(u), c = (0, i.pubkeyToRawAddress)(l);
+    return d(m, c);
+  });
+  return {
+    type: "tendermint/PubKeyMultisigThreshold",
+    value: {
+      threshold: r.toString(),
+      pubkeys: a
+    }
+  };
+}
+t.createMultisigThresholdPubkey = f;
+export {
+  t as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/paths.mjs

@@ -0,0 +1,19 @@
+import { __exports as a } from "../../../../../../../../../_virtual/paths2.mjs";
+import "../../crypto/build/index.mjs";
+import { __exports as r } from "../../../../../../../../../_virtual/index61.mjs";
+Object.defineProperty(a, "__esModule", { value: !0 });
+a.makeCosmoshubPath = void 0;
+const e = r;
+function t(o) {
+  return [
+    e.Slip10RawIndex.hardened(44),
+    e.Slip10RawIndex.hardened(118),
+    e.Slip10RawIndex.hardened(0),
+    e.Slip10RawIndex.normal(0),
+    e.Slip10RawIndex.normal(o)
+  ];
+}
+a.makeCosmoshubPath = t;
+export {
+  a as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/pubkeys.mjs

@@ -0,0 +1,28 @@
+import { __exports as k } from "../../../../../../../../../_virtual/pubkeys.mjs";
+(function(e) {
+  Object.defineProperty(e, "__esModule", { value: !0 }), e.isMultisigThresholdPubkey = e.isSinglePubkey = e.pubkeyType = e.isSecp256k1Pubkey = e.isEd25519Pubkey = void 0;
+  function i(u) {
+    return u.type === "tendermint/PubKeyEd25519";
+  }
+  e.isEd25519Pubkey = i;
+  function y(u) {
+    return u.type === "tendermint/PubKeySecp256k1";
+  }
+  e.isSecp256k1Pubkey = y, e.pubkeyType = {
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/ed25519/ed25519.go#L22 */
+    secp256k1: "tendermint/PubKeySecp256k1",
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/secp256k1/secp256k1.go#L23 */
+    ed25519: "tendermint/PubKeyEd25519",
+    /** @see https://github.com/tendermint/tendermint/blob/v0.33.0/crypto/sr25519/codec.go#L12 */
+    sr25519: "tendermint/PubKeySr25519",
+    multisigThreshold: "tendermint/PubKeyMultisigThreshold"
+  };
+  function n(u) {
+    return [e.pubkeyType.ed25519, e.pubkeyType.secp256k1, e.pubkeyType.sr25519].includes(u.type);
+  }
+  e.isSinglePubkey = n;
+  function b(u) {
+    return u.type === "tendermint/PubKeyMultisigThreshold";
+  }
+  e.isMultisigThresholdPubkey = b;
+})(k);

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/secp256k1hdwallet.mjs

@@ -0,0 +1,218 @@
+import { __exports as l } from "../../../../../../../../../_virtual/secp256k1hdwallet.mjs";
+import "../../crypto/build/index.mjs";
+import "../../encoding/build/index.mjs";
+import "../../utils/build/index.mjs";
+import "./addresses.mjs";
+import "./paths.mjs";
+import "./signature.mjs";
+import "./signdoc.mjs";
+import "./wallet.mjs";
+import { __exports as P } from "../../../../../../../../../_virtual/paths2.mjs";
+import { __exports as x } from "../../../../../../../../../_virtual/index61.mjs";
+import { __exports as b } from "../../../../../../../../../_virtual/index56.mjs";
+import { __exports as _ } from "../../../../../../../../../_virtual/index58.mjs";
+import { __exports as S } from "../../../../../../../../../_virtual/addresses2.mjs";
+import { __exports as v } from "../../../../../../../../../_virtual/signature.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/signdoc.mjs";
+import { __exports as N } from "../../../../../../../../../_virtual/wallet3.mjs";
+Object.defineProperty(l, "__esModule", { value: !0 });
+l.Secp256k1HdWallet = l.extractKdfConfiguration = void 0;
+const s = x, f = b, d = _, K = S, O = P, A = v, z = E, h = N, w = "secp256k1wallet-v1", j = {
+  algorithm: "argon2id",
+  params: {
+    outputLength: 32,
+    opsLimit: 24,
+    memLimitKib: 12 * 1024
+  }
+};
+function C(a) {
+  return !(!(0, d.isNonNullObject)(a) || typeof a.hdPath != "string" || typeof a.prefix != "string");
+}
+function T(a) {
+  return a.kdf;
+}
+function B(a) {
+  const t = JSON.parse(a);
+  if (!(0, d.isNonNullObject)(t))
+    throw new Error("Root document is not an object.");
+  switch (t.type) {
+    case w:
+      return T(t);
+    default:
+      throw new Error("Unsupported serialization type");
+  }
+}
+l.extractKdfConfiguration = B;
+const k = {
+  bip39Password: "",
+  hdPaths: [(0, O.makeCosmoshubPath)(0)],
+  prefix: "cosmos"
+};
+class c {
+  /**
+   * Restores a wallet from the given BIP39 mnemonic.
+   *
+   * @param mnemonic Any valid English mnemonic.
+   * @param options An optional `Secp256k1HdWalletOptions` 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 c(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 `Secp256k1HdWalletOptions` 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 c.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, d.isNonNullObject)(r))
+      throw new Error("Root document is not an object.");
+    switch (r.type) {
+      case w:
+        return c.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, d.isNonNullObject)(r))
+      throw new Error("Root document is not an object.");
+    const o = r;
+    switch (o.type) {
+      case w: {
+        const n = await (0, h.decrypt)((0, f.fromBase64)(o.data), e, o.encryption), y = JSON.parse((0, f.fromUtf8)(n)), { mnemonic: p, accounts: i } = y;
+        if ((0, d.assert)(typeof p == "string"), !Array.isArray(i))
+          throw new Error("Property 'accounts' is not an array");
+        if (!i.every((m) => C(m)))
+          throw new Error("Account is not in the correct format.");
+        const u = i[0].prefix;
+        if (!i.every(({ prefix: m }) => m === u))
+          throw new Error("Accounts do not all have the same prefix");
+        const g = i.map(({ hdPath: m }) => (0, s.stringToPath)(m));
+        return c.fromMnemonic(p, {
+          hdPaths: g,
+          prefix: u
+        });
+      }
+      default:
+        throw new Error("Unsupported serialization type");
+    }
+  }
+  static async deserializeTypeV1(t, e) {
+    const r = JSON.parse(t);
+    if (!(0, d.isNonNullObject)(r))
+      throw new Error("Root document is not an object.");
+    const o = await (0, h.executeKdf)(e, r.kdf);
+    return c.deserializeWithEncryptionKey(t, o);
+  }
+  constructor(t, e) {
+    const r = e.hdPaths ?? k.hdPaths, o = e.prefix ?? k.prefix;
+    this.secret = t, this.seed = e.seed, this.accounts = r.map((n) => ({
+      hdPath: n,
+      prefix: o
+    }));
+  }
+  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 signAmino(t, e) {
+    const o = (await this.getAccountsWithPrivkeys()).find(({ address: g }) => g === t);
+    if (o === void 0)
+      throw new Error(`Address ${t} not found in wallet`);
+    const { privkey: n, pubkey: y } = o, p = (0, s.sha256)((0, z.serializeSignDoc)(e)), i = await s.Secp256k1.createSignature(p, n), u = new Uint8Array([...i.r(32), ...i.s(32)]);
+    return {
+      signed: e,
+      signature: (0, A.encodeSecp256k1Signature)(y, u)
+    };
+  }
+  /**
+   * 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 = j, r = await (0, h.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: u }) => ({
+        hdPath: (0, s.pathToString)(i),
+        prefix: u
+      }))
+    }, o = (0, f.toUtf8)(JSON.stringify(r)), n = {
+      algorithm: h.supportedAlgorithms.xchacha20poly1305Ietf
+    }, y = await (0, h.encrypt)(o, t, n), p = {
+      type: w,
+      kdf: e,
+      encryption: n,
+      data: (0, f.toBase64)(y)
+    };
+    return JSON.stringify(p);
+  }
+  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, f.toBech32)(e, (0, K.rawSecp256k1PubkeyToRawAddress)(o));
+      return {
+        algo: "secp256k1",
+        privkey: r,
+        pubkey: o,
+        address: n
+      };
+    }));
+  }
+}
+l.Secp256k1HdWallet = c;
+export {
+  l as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/secp256k1wallet.mjs

@@ -0,0 +1,54 @@
+import { __exports as o } from "../../../../../../../../../_virtual/secp256k1wallet.mjs";
+import "../../crypto/build/index.mjs";
+import "../../encoding/build/index.mjs";
+import "./addresses.mjs";
+import "./signature.mjs";
+import "./signdoc.mjs";
+import { __exports as p } from "../../../../../../../../../_virtual/index61.mjs";
+import { __exports as c } from "../../../../../../../../../_virtual/index56.mjs";
+import { __exports as u } from "../../../../../../../../../_virtual/addresses2.mjs";
+import { __exports as d } from "../../../../../../../../../_virtual/signature.mjs";
+import { __exports as m } from "../../../../../../../../../_virtual/signdoc.mjs";
+Object.defineProperty(o, "__esModule", { value: !0 });
+o.Secp256k1Wallet = void 0;
+const r = p, k = c, y = u, _ = d, g = m;
+class i {
+  /**
+   * Creates a Secp256k1Wallet 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, s = "cosmos") {
+    const t = (await r.Secp256k1.makeKeypair(e)).pubkey;
+    return new i(e, r.Secp256k1.compressPubkey(t), s);
+  }
+  constructor(e, s, t) {
+    this.privkey = e, this.pubkey = s, this.prefix = t;
+  }
+  get address() {
+    return (0, k.toBech32)(this.prefix, (0, y.rawSecp256k1PubkeyToRawAddress)(this.pubkey));
+  }
+  async getAccounts() {
+    return [
+      {
+        algo: "secp256k1",
+        address: this.address,
+        pubkey: this.pubkey
+      }
+    ];
+  }
+  async signAmino(e, s) {
+    if (e !== this.address)
+      throw new Error(`Address ${e} not found in wallet`);
+    const t = new r.Sha256((0, g.serializeSignDoc)(s)).digest(), a = await r.Secp256k1.createSignature(t, this.privkey), n = new Uint8Array([...a.r(32), ...a.s(32)]);
+    return {
+      signed: s,
+      signature: (0, _.encodeSecp256k1Signature)(this.pubkey, n)
+    };
+  }
+}
+o.Secp256k1Wallet = i;
+export {
+  o as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/@cosmjs/amino/build/signature.mjs

@@ -0,0 +1,34 @@
+import { __exports as o } from "../../../../../../../../../_virtual/signature.mjs";
+import "../../encoding/build/index.mjs";
+import "./encoding.mjs";
+import "./pubkeys.mjs";
+import { __exports as n } from "../../../../../../../../../_virtual/index56.mjs";
+import { __exports as s } from "../../../../../../../../../_virtual/encoding.mjs";
+import { __exports as p } from "../../../../../../../../../_virtual/pubkeys.mjs";
+Object.defineProperty(o, "__esModule", { value: !0 });
+o.decodeSignature = o.encodeSecp256k1Signature = void 0;
+const t = n, u = s, i = p;
+function c(e, r) {
+  if (r.length !== 64)
+    throw new Error("Signature must be 64 bytes long. Cosmos SDK uses a 2x32 byte fixed length encoding for the secp256k1 signature integers r and s.");
+  return {
+    pub_key: (0, u.encodeSecp256k1Pubkey)(e),
+    signature: (0, t.toBase64)(r)
+  };
+}
+o.encodeSecp256k1Signature = c;
+function a(e) {
+  switch (e.pub_key.type) {
+    case i.pubkeyType.secp256k1:
+      return {
+        pubkey: (0, t.fromBase64)(e.pub_key.value),
+        signature: (0, t.fromBase64)(e.signature)
+      };
+    default:
+      throw new Error("Unsupported pubkey type");
+  }
+}
+o.decodeSignature = a;
+export {
+  o as default
+};