signet.js 0.0.1-beta.6 → 0.0.1-beta.8

package/index.js

@@ -0,0 +1,2674 @@
+import $ from "bn.js";
+import { fromHex as K, toBase64 as we, fromBase64 as _e } from "@cosmjs/encoding";
+import { ethers as C, keccak256 as Oe } from "ethers";
+import * as U from "bitcoinjs-lib";
+import ke from "coinselect";
+import { encodeSecp256k1Pubkey as Ne } from "@cosmjs/amino";
+import { sha256 as ee, ripemd160 as Ae } from "@cosmjs/crypto";
+import { Registry as De, encodePubkey as Te, makeAuthInfoBytes as ve, makeSignDoc as Pe, makeSignBytes as Ee } from "@cosmjs/proto-signing";
+import { calculateFee as Ce, GasPrice as xe, StargateClient as ne } from "@cosmjs/stargate";
+import { bech32 as te } from "bech32";
+import { chains as Me, assets as Je } from "chain-registry";
+import { Connection as Ue, Account as Re, Contract as Fe } from "@near-js/accounts";
+import { KeyPair as me } from "@near-js/crypto";
+import { actionCreators as Ke } from "@near-js/transactions";
+import Ge from "borsh";
+import He from "@near-js/utils";
+import { InMemoryKeyStore as Le } from "@near-js/keystores";
+import qe from "bs58";
+class Q {
+}
+let ze = class {
+};
+const pe = (i) => ({
+  r: i.big_r.affine_point.substring(2),
+  s: i.s.scalar,
+  v: i.recovery_id
+}), ge = (i) => {
+  const r = i.slice(2);
+  if (r.length !== 128)
+    throw new Error("Invalid uncompressed public key length");
+  const c = r.slice(0, 64), d = r.slice(64);
+  return (parseInt(d.slice(-1), 16) % 2 === 0 ? "02" : "03") + c;
+};
+async function $e(i, r) {
+  const c = new C.JsonRpcProvider(i), d = await c.estimateGas(r), s = await c.getFeeData(), o = s.maxFeePerGas ?? C.parseUnits("10", "gwei"), a = s.maxPriorityFeePerGas ?? C.parseUnits("10", "gwei");
+  return {
+    gasLimit: d,
+    maxFeePerGas: o,
+    maxPriorityFeePerGas: a,
+    maxFee: o * d
+  };
+}
+class We extends Q {
+  /**
+   * Creates a new EVM chain instance
+   * @param params - Configuration parameters
+   * @param params.rpcUrl - URL of the EVM JSON-RPC provider (e.g., Infura endpoint)
+   * @param params.contract - Instance of the chain signature contract for MPC operations
+   */
+  constructor({
+    rpcUrl: r,
+    contract: c
+  }) {
+    super(), this.contract = c, this.provider = new C.JsonRpcProvider(r);
+  }
+  async attachGasAndNonce(r) {
+    const c = await $e(
+      this.provider._getConnection().url,
+      r
+    ), d = await this.provider.getTransactionCount(
+      r.from,
+      "latest"
+    ), { from: s, ...o } = r;
+    return {
+      ...c,
+      chainId: this.provider._network.chainId,
+      nonce: d,
+      type: 2,
+      ...o
+    };
+  }
+  parseSignature(r) {
+    return C.Signature.from({
+      r: `0x${r.r}`,
+      s: `0x${r.s}`,
+      v: r.v
+    });
+  }
+  async deriveAddressAndPublicKey(r, c) {
+    const d = await this.contract.getDerivedPublicKey({
+      path: c,
+      predecessor: r
+    });
+    if (!d)
+      throw new Error("Failed to get derived public key");
+    const s = d.startsWith("04") ? d.substring(2) : d, o = C.keccak256(K(s));
+    return {
+      address: `0x${o.substring(o.length - 40)}`,
+      publicKey: d
+    };
+  }
+  async getBalance(r) {
+    try {
+      const c = await this.provider.getBalance(r);
+      return C.formatEther(c);
+    } catch (c) {
+      throw console.error(`Failed to fetch balance for address ${r}:`, c), new Error("Failed to fetch balance.");
+    }
+  }
+  setTransaction(r, c) {
+    const d = JSON.stringify(
+      r,
+      (s, o) => typeof o == "bigint" ? o.toString() : o
+    );
+    window.localStorage.setItem(c, d);
+  }
+  getTransaction(r, c) {
+    const d = window.localStorage.getItem(r);
+    return c != null && c.remove && window.localStorage.removeItem(r), d ? JSON.parse(d) : void 0;
+  }
+  async getMPCPayloadAndTransaction(r) {
+    const c = await this.attachGasAndNonce(r), d = C.Transaction.from(c).unsignedSerialized, s = Oe(d), o = Array.from(C.getBytes(s));
+    return {
+      transaction: c,
+      mpcPayloads: [
+        {
+          index: 0,
+          payload: o
+        }
+      ]
+    };
+  }
+  addSignature({
+    transaction: r,
+    mpcSignatures: c
+  }) {
+    return C.Transaction.from({
+      ...r,
+      signature: this.parseSignature(c[0])
+    }).serialized;
+  }
+  async broadcastTx(r) {
+    try {
+      return (await this.provider.broadcastTransaction(r)).hash;
+    } catch (c) {
+      throw console.error("Transaction broadcast failed:", c), new Error("Failed to broadcast transaction.");
+    }
+  }
+}
+function re(i) {
+  switch (i.toLowerCase()) {
+    case "mainnet":
+      return U.networks.bitcoin;
+    case "testnet":
+      return U.networks.testnet;
+    case "regtest":
+      return U.networks.regtest;
+    default:
+      throw new Error(`Unknown Bitcoin network: ${i}`);
+  }
+}
+const F = class F extends Q {
+  /**
+   * Creates a new Bitcoin chain instance
+   * @param params - Configuration parameters
+   * @param params.network - Network identifier (mainnet/testnet)
+   * @param params.contract - Instance of the chain signature contract for MPC operations
+   * @param params.btcRpcAdapter - Bitcoin RPC adapter for network interactions
+   */
+  constructor({
+    network: r,
+    contract: c,
+    btcRpcAdapter: d
+  }) {
+    super(), this.network = r, this.btcRpcAdapter = d, this.contract = c;
+  }
+  /**
+   * Converts satoshis to BTC
+   * @param satoshis - Amount in satoshis
+   * @returns Amount in BTC
+   */
+  static toBTC(r) {
+    return r / F.SATOSHIS_PER_BTC;
+  }
+  /**
+   * Converts BTC to satoshis
+   * @param btc - Amount in BTC
+   * @returns Amount in satoshis (rounded)
+   */
+  static toSatoshi(r) {
+    return Math.round(r * F.SATOSHIS_PER_BTC);
+  }
+  async fetchTransaction(r) {
+    const c = await this.btcRpcAdapter.getTransaction(r), d = new U.Transaction();
+    return c.vout.forEach((s) => {
+      const o = Buffer.from(s.scriptpubkey, "hex");
+      d.addOutput(o, Number(s.value));
+    }), d;
+  }
+  static parseRSVSignature(r) {
+    const c = r.r.padStart(64, "0"), d = r.s.padStart(64, "0"), s = Buffer.from(c + d, "hex");
+    if (s.length !== 64)
+      throw new Error("Invalid signature length.");
+    return s;
+  }
+  /**
+   * Creates a Partially Signed Bitcoin Transaction (PSBT)
+   * @param params - Parameters for creating the PSBT
+   * @param params.transactionRequest - Transaction request containing inputs and outputs
+   * @returns Created PSBT instance
+   */
+  async createPSBT({
+    transactionRequest: r
+  }) {
+    const { inputs: c, outputs: d } = r.inputs && r.outputs ? r : await this.btcRpcAdapter.selectUTXOs(r.from, [
+      {
+        address: r.to,
+        value: parseFloat(r.value)
+      }
+    ]), s = new U.Psbt({ network: re(this.network) });
+    return await Promise.all(
+      c.map(async (o) => {
+        if (!o.scriptPubKey) {
+          const f = (await this.fetchTransaction(o.txid)).outs[o.vout];
+          o.scriptPubKey = f.script;
+        }
+        s.addInput({
+          hash: o.txid,
+          index: o.vout,
+          witnessUtxo: {
+            script: o.scriptPubKey,
+            value: o.value
+          }
+        });
+      })
+    ), d.forEach((o) => {
+      o.address ? s.addOutput({
+        address: o.address,
+        value: o.value
+      }) : o.script && s.addOutput({
+        script: o.script,
+        value: o.value
+      });
+    }), s;
+  }
+  async getBalance(r) {
+    const c = await this.btcRpcAdapter.getBalance(r);
+    return F.toBTC(c).toString();
+  }
+  async deriveAddressAndPublicKey(r, c) {
+    const d = await this.contract.getDerivedPublicKey({
+      path: c,
+      predecessor: r
+    });
+    if (!d)
+      throw new Error("Failed to get derived public key");
+    const s = ge(d), o = Buffer.from(s, "hex"), a = re(this.network), f = U.payments.p2wpkh({
+      pubkey: o,
+      network: a
+    }), { address: g } = f;
+    if (!g)
+      throw new Error("Failed to generate Bitcoin address");
+    return { address: g, publicKey: s };
+  }
+  setTransaction(r, c) {
+    window.localStorage.setItem(
+      c,
+      JSON.stringify({
+        psbt: r.psbt.toHex(),
+        publicKey: r.publicKey
+      })
+    );
+  }
+  getTransaction(r, c) {
+    const d = window.localStorage.getItem(r);
+    if (!d) return;
+    c != null && c.remove && window.localStorage.removeItem(r);
+    const s = JSON.parse(d);
+    return {
+      psbt: U.Psbt.fromHex(s.psbt),
+      publicKey: s.publicKey
+    };
+  }
+  async getMPCPayloadAndTransaction(r) {
+    const c = Buffer.from(r.publicKey, "hex"), d = await this.createPSBT({
+      transactionRequest: r
+    }), s = d.toHex(), o = [], a = (f) => ({
+      publicKey: c,
+      sign: (g) => (o.push({
+        index: f,
+        payload: Array.from(g)
+      }), Buffer.alloc(64))
+    });
+    for (let f = 0; f < d.inputCount; f++)
+      d.signInput(f, a(f));
+    return {
+      transaction: {
+        psbt: U.Psbt.fromHex(s),
+        publicKey: r.publicKey
+      },
+      mpcPayloads: o.sort((f, g) => f.index - g.index)
+    };
+  }
+  addSignature({
+    transaction: { psbt: r, publicKey: c },
+    mpcSignatures: d
+  }) {
+    const s = Buffer.from(c, "hex"), o = (a) => ({
+      publicKey: s,
+      sign: () => {
+        const f = d[a];
+        return F.parseRSVSignature(f);
+      }
+    });
+    for (let a = 0; a < r.inputCount; a++)
+      r.signInput(a, o(a));
+    return r.finalizeAllInputs(), r.extractTransaction().toHex();
+  }
+  async broadcastTx(r) {
+    return await this.btcRpcAdapter.broadcastTransaction(r);
+  }
+};
+F.SATOSHIS_PER_BTC = 1e8;
+let Y = F;
+class Ve {
+}
+class Xe extends Ve {
+  constructor(r) {
+    super(), this.providerUrl = r;
+  }
+  async fetchFeeRate(r = 6) {
+    const d = await (await fetch(`${this.providerUrl}/v1/fees/recommended`)).json();
+    return r <= 1 ? d.fastestFee : r <= 3 ? d.halfHourFee : r <= 6 ? d.hourFee : d.economyFee;
+  }
+  async fetchUTXOs(r) {
+    try {
+      return await (await fetch(
+        `${this.providerUrl}/address/${r}/utxo`
+      )).json();
+    } catch (c) {
+      return console.error("Failed to fetch UTXOs:", c), [];
+    }
+  }
+  async selectUTXOs(r, c, d = 6) {
+    const s = await this.fetchUTXOs(r), o = await this.fetchFeeRate(d), a = ke(s, c, Math.ceil(o + 1));
+    if (!a.inputs || !a.outputs)
+      throw new Error(
+        "Invalid transaction: coinselect failed to find a suitable set of inputs and outputs. This could be due to insufficient funds, or no inputs being available that meet the criteria."
+      );
+    return {
+      inputs: a.inputs,
+      outputs: a.outputs
+    };
+  }
+  async broadcastTransaction(r) {
+    const c = await fetch(`${this.providerUrl}/tx`, {
+      method: "POST",
+      body: r
+    });
+    if (c.ok)
+      return await c.text();
+    throw new Error(`Failed to broadcast transaction: ${await c.text()}`);
+  }
+  async getBalance(r) {
+    const d = await (await fetch(`${this.providerUrl}/address/${r}`)).json();
+    return d.chain_stats.funded_txo_sum - d.chain_stats.spent_txo_sum;
+  }
+  async getTransaction(r) {
+    return await (await fetch(`${this.providerUrl}/tx/${r}`)).json();
+  }
+}
+const Ze = {
+  Mempool: Xe
+};
+var ie = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, V = {}, x = {}, M = {}, J = {}, ae;
+function Ye() {
+  if (ae) return J;
+  ae = 1, Object.defineProperty(J, "__esModule", { value: !0 }), J.utf8Write = J.utf8Read = J.utf8Length = void 0;
+  function i(d) {
+    let s = 0, o = 0;
+    for (let a = 0; a < d.length; ++a)
+      o = d.charCodeAt(a), o < 128 ? s += 1 : o < 2048 ? s += 2 : (o & 64512) === 55296 && (d.charCodeAt(a + 1) & 64512) === 56320 ? (++a, s += 4) : s += 3;
+    return s;
+  }
+  J.utf8Length = i;
+  function r(d, s, o) {
+    if (o - s < 1)
+      return "";
+    const f = [];
+    let g = [], _ = 0, b;
+    for (; s < o; )
+      b = d[s++], b < 128 ? f[_++] = b : b > 191 && b < 224 ? f[_++] = (b & 31) << 6 | d[s++] & 63 : b > 239 && b < 365 ? (b = ((b & 7) << 18 | (d[s++] & 63) << 12 | (d[s++] & 63) << 6 | d[s++] & 63) - 65536, f[_++] = 55296 + (b >> 10), f[_++] = 56320 + (b & 1023)) : f[_++] = (b & 15) << 12 | (d[s++] & 63) << 6 | d[s++] & 63, _ > 8191 && (g.push(String.fromCharCode(...f)), _ = 0);
+    return _ && g.push(String.fromCharCode(...f.slice(0, _))), g.join("");
+  }
+  J.utf8Read = r;
+  function c(d, s, o) {
+    const a = o;
+    let f, g;
+    for (let _ = 0; _ < d.length; ++_)
+      f = d.charCodeAt(_), f < 128 ? s[o++] = f : f < 2048 ? (s[o++] = f >> 6 | 192, s[o++] = f & 63 | 128) : (f & 64512) === 55296 && ((g = d.charCodeAt(_ + 1)) & 64512) === 56320 ? (f = 65536 + ((f & 1023) << 10) + (g & 1023), ++_, s[o++] = f >> 18 | 240, s[o++] = f >> 12 & 63 | 128, s[o++] = f >> 6 & 63 | 128, s[o++] = f & 63 | 128) : (s[o++] = f >> 12 | 224, s[o++] = f >> 6 & 63 | 128, s[o++] = f & 63 | 128);
+    return o - a;
+  }
+  return J.utf8Write = c, J;
+}
+var k = {}, oe;
+function Qe() {
+  if (oe) return k;
+  oe = 1, Object.defineProperty(k, "__esModule", { value: !0 }), k.writeByte = k.writeFixed32 = k.int64Length = k.writeVarint64 = k.writeVarint32 = k.readInt32 = k.readUInt32 = k.zzDecode = k.zzEncode = k.varint32read = k.varint32write = k.uInt64ToString = k.int64ToString = k.int64FromString = k.varint64write = k.varint64read = void 0;
+  function i() {
+    let n = 0, t = 0;
+    for (let h = 0; h < 28; h += 7) {
+      let B = this.buf[this.pos++];
+      if (n |= (B & 127) << h, !(B & 128))
+        return this.assertBounds(), [n, t];
+    }
+    let m = this.buf[this.pos++];
+    if (n |= (m & 15) << 28, t = (m & 112) >> 4, !(m & 128))
+      return this.assertBounds(), [n, t];
+    for (let h = 3; h <= 31; h += 7) {
+      let B = this.buf[this.pos++];
+      if (t |= (B & 127) << h, !(B & 128))
+        return this.assertBounds(), [n, t];
+    }
+    throw new Error("invalid varint");
+  }
+  k.varint64read = i;
+  function r(n, t, m) {
+    for (let A = 0; A < 28; A = A + 7) {
+      const T = n >>> A, E = !(!(T >>> 7) && t == 0), P = (E ? T | 128 : T) & 255;
+      if (m.push(P), !E)
+        return;
+    }
+    const h = n >>> 28 & 15 | (t & 7) << 4, B = !!(t >> 3);
+    if (m.push((B ? h | 128 : h) & 255), !!B) {
+      for (let A = 3; A < 31; A = A + 7) {
+        const T = t >>> A, E = !!(T >>> 7), P = (E ? T | 128 : T) & 255;
+        if (m.push(P), !E)
+          return;
+      }
+      m.push(t >>> 31 & 1);
+    }
+  }
+  k.varint64write = r;
+  const c = 4294967296;
+  function d(n) {
+    const t = n[0] === "-";
+    t && (n = n.slice(1));
+    const m = 1e6;
+    let h = 0, B = 0;
+    function A(T, E) {
+      const P = Number(n.slice(T, E));
+      B *= m, h = h * m + P, h >= c && (B = B + (h / c | 0), h = h % c);
+    }
+    return A(-24, -18), A(-18, -12), A(-12, -6), A(-6), t ? g(h, B) : f(h, B);
+  }
+  k.int64FromString = d;
+  function s(n, t) {
+    let m = f(n, t);
+    const h = m.hi & 2147483648;
+    h && (m = g(m.lo, m.hi));
+    const B = o(m.lo, m.hi);
+    return h ? "-" + B : B;
+  }
+  k.int64ToString = s;
+  function o(n, t) {
+    if ({ lo: n, hi: t } = a(n, t), t <= 2097151)
+      return String(c * t + n);
+    const m = n & 16777215, h = (n >>> 24 | t << 8) & 16777215, B = t >> 16 & 65535;
+    let A = m + h * 6777216 + B * 6710656, T = h + B * 8147497, E = B * 2;
+    const P = 1e7;
+    return A >= P && (T += Math.floor(A / P), A %= P), T >= P && (E += Math.floor(T / P), T %= P), E.toString() + _(T) + _(A);
+  }
+  k.uInt64ToString = o;
+  function a(n, t) {
+    return { lo: n >>> 0, hi: t >>> 0 };
+  }
+  function f(n, t) {
+    return { lo: n | 0, hi: t | 0 };
+  }
+  function g(n, t) {
+    return t = ~t, n ? n = ~n + 1 : t += 1, f(n, t);
+  }
+  const _ = (n) => {
+    const t = String(n);
+    return "0000000".slice(t.length) + t;
+  };
+  function b(n, t) {
+    if (n >= 0) {
+      for (; n > 127; )
+        t.push(n & 127 | 128), n = n >>> 7;
+      t.push(n);
+    } else {
+      for (let m = 0; m < 9; m++)
+        t.push(n & 127 | 128), n = n >> 7;
+      t.push(1);
+    }
+  }
+  k.varint32write = b;
+  function l() {
+    let n = this.buf[this.pos++], t = n & 127;
+    if (!(n & 128))
+      return this.assertBounds(), t;
+    if (n = this.buf[this.pos++], t |= (n & 127) << 7, !(n & 128))
+      return this.assertBounds(), t;
+    if (n = this.buf[this.pos++], t |= (n & 127) << 14, !(n & 128))
+      return this.assertBounds(), t;
+    if (n = this.buf[this.pos++], t |= (n & 127) << 21, !(n & 128))
+      return this.assertBounds(), t;
+    n = this.buf[this.pos++], t |= (n & 15) << 28;
+    for (let m = 5; n & 128 && m < 10; m++)
+      n = this.buf[this.pos++];
+    if (n & 128)
+      throw new Error("invalid varint");
+    return this.assertBounds(), t >>> 0;
+  }
+  k.varint32read = l;
+  function I(n, t) {
+    let m = t >> 31;
+    return t = ((t << 1 | n >>> 31) ^ m) >>> 0, n = (n << 1 ^ m) >>> 0, [n, t];
+  }
+  k.zzEncode = I;
+  function u(n, t) {
+    let m = -(n & 1);
+    return n = ((n >>> 1 | t << 31) ^ m) >>> 0, t = (t >>> 1 ^ m) >>> 0, [n, t];
+  }
+  k.zzDecode = u;
+  function y(n, t) {
+    return (n[t] | n[t + 1] << 8 | n[t + 2] << 16) + n[t + 3] * 16777216;
+  }
+  k.readUInt32 = y;
+  function S(n, t) {
+    return (n[t] | n[t + 1] << 8 | n[t + 2] << 16) + (n[t + 3] << 24);
+  }
+  k.readInt32 = S;
+  function p(n, t, m) {
+    for (; n > 127; )
+      t[m++] = n & 127 | 128, n >>>= 7;
+    t[m] = n;
+  }
+  k.writeVarint32 = p;
+  function w(n, t, m) {
+    for (; n.hi; )
+      t[m++] = n.lo & 127 | 128, n.lo = (n.lo >>> 7 | n.hi << 25) >>> 0, n.hi >>>= 7;
+    for (; n.lo > 127; )
+      t[m++] = n.lo & 127 | 128, n.lo = n.lo >>> 7;
+    t[m++] = n.lo;
+  }
+  k.writeVarint64 = w;
+  function O(n, t) {
+    let m = n, h = (n >>> 28 | t << 4) >>> 0, B = t >>> 24;
+    return B === 0 ? h === 0 ? m < 16384 ? m < 128 ? 1 : 2 : m < 2097152 ? 3 : 4 : h < 16384 ? h < 128 ? 5 : 6 : h < 2097152 ? 7 : 8 : B < 128 ? 9 : 10;
+  }
+  k.int64Length = O;
+  function D(n, t, m) {
+    t[m] = n & 255, t[m + 1] = n >>> 8 & 255, t[m + 2] = n >>> 16 & 255, t[m + 3] = n >>> 24;
+  }
+  k.writeFixed32 = D;
+  function e(n, t, m) {
+    t[m] = n & 255;
+  }
+  return k.writeByte = e, k;
+}
+var se;
+function H() {
+  if (se) return M;
+  se = 1, Object.defineProperty(M, "__esModule", { value: !0 }), M.BinaryWriter = M.BinaryReader = M.WireType = void 0;
+  const i = Ye(), r = Qe();
+  var c;
+  (function(b) {
+    b[b.Varint = 0] = "Varint", b[b.Fixed64 = 1] = "Fixed64", b[b.Bytes = 2] = "Bytes", b[b.Fixed32 = 5] = "Fixed32";
+  })(c || (M.WireType = c = {}));
+  class d {
+    assertBounds() {
+      if (this.pos > this.len)
+        throw new RangeError("premature EOF");
+    }
+    constructor(l) {
+      this.buf = l ? new Uint8Array(l) : new Uint8Array(0), this.pos = 0, this.type = 0, this.len = this.buf.length;
+    }
+    tag() {
+      const l = this.uint32(), I = l >>> 3, u = l & 7;
+      if (I <= 0 || u < 0 || u > 5)
+        throw new Error("illegal tag: field no " + I + " wire type " + u);
+      return [I, u, l];
+    }
+    skip(l) {
+      if (typeof l == "number") {
+        if (this.pos + l > this.len)
+          throw _(this, l);
+        this.pos += l;
+      } else
+        do
+          if (this.pos >= this.len)
+            throw _(this);
+        while (this.buf[this.pos++] & 128);
+      return this;
+    }
+    skipType(l) {
+      switch (l) {
+        case c.Varint:
+          this.skip();
+          break;
+        case c.Fixed64:
+          this.skip(8);
+          break;
+        case c.Bytes:
+          this.skip(this.uint32());
+          break;
+        case 3:
+          for (; (l = this.uint32() & 7) !== 4; )
+            this.skipType(l);
+          break;
+        case c.Fixed32:
+          this.skip(4);
+          break;
+        /* istanbul ignore next */
+        default:
+          throw Error("invalid wire type " + l + " at offset " + this.pos);
+      }
+      return this;
+    }
+    uint32() {
+      return r.varint32read.bind(this)();
+    }
+    int32() {
+      return this.uint32() | 0;
+    }
+    sint32() {
+      const l = this.uint32();
+      return l % 2 === 1 ? (l + 1) / -2 : l / 2;
+    }
+    fixed32() {
+      const l = (0, r.readUInt32)(this.buf, this.pos);
+      return this.pos += 4, l;
+    }
+    sfixed32() {
+      const l = (0, r.readInt32)(this.buf, this.pos);
+      return this.pos += 4, l;
+    }
+    int64() {
+      const [l, I] = r.varint64read.bind(this)();
+      return BigInt((0, r.int64ToString)(l, I));
+    }
+    uint64() {
+      const [l, I] = r.varint64read.bind(this)();
+      return BigInt((0, r.uInt64ToString)(l, I));
+    }
+    sint64() {
+      let [l, I] = r.varint64read.bind(this)();
+      return [l, I] = (0, r.zzDecode)(l, I), BigInt((0, r.int64ToString)(l, I));
+    }
+    fixed64() {
+      const l = this.sfixed32(), I = this.sfixed32();
+      return BigInt((0, r.uInt64ToString)(l, I));
+    }
+    sfixed64() {
+      const l = this.sfixed32(), I = this.sfixed32();
+      return BigInt((0, r.int64ToString)(l, I));
+    }
+    float() {
+      throw new Error("float not supported");
+    }
+    double() {
+      throw new Error("double not supported");
+    }
+    bool() {
+      const [l, I] = r.varint64read.bind(this)();
+      return l !== 0 || I !== 0;
+    }
+    bytes() {
+      const l = this.uint32(), I = this.pos;
+      return this.pos += l, this.assertBounds(), this.buf.subarray(I, I + l);
+    }
+    string() {
+      const l = this.bytes();
+      return (0, i.utf8Read)(l, 0, l.length);
+    }
+  }
+  M.BinaryReader = d;
+  class s {
+    constructor(l, I, u) {
+      this.fn = l, this.len = I, this.val = u;
+    }
+    proceed(l, I) {
+      this.fn && this.fn(this.val, l, I);
+    }
+  }
+  class o {
+    constructor(l) {
+      this.head = l.head, this.tail = l.tail, this.len = l.len, this.next = l.states;
+    }
+  }
+  class a {
+    constructor() {
+      this.len = 0, this.uint64 = a.prototype.int64, this.sfixed64 = a.prototype.fixed64, this.sfixed32 = a.prototype.fixed32, this.head = new s(null, 0, 0), this.tail = this.head, this.states = null;
+    }
+    static create() {
+      return new a();
+    }
+    static alloc(l) {
+      return typeof Uint8Array < "u" ? g((I) => new Uint8Array(I), Uint8Array.prototype.subarray)(l) : new Array(l);
+    }
+    _push(l, I, u) {
+      return this.tail = this.tail.next = new s(l, I, u), this.len += I, this;
+    }
+    finish() {
+      let l = this.head.next, I = 0;
+      const u = a.alloc(this.len);
+      for (; l; )
+        l.proceed(u, I), I += l.len, l = l.next;
+      return u;
+    }
+    fork() {
+      return this.states = new o(this), this.head = this.tail = new s(null, 0, 0), this.len = 0, this;
+    }
+    reset() {
+      return this.states ? (this.head = this.states.head, this.tail = this.states.tail, this.len = this.states.len, this.states = this.states.next) : (this.head = this.tail = new s(null, 0, 0), this.len = 0), this;
+    }
+    ldelim() {
+      const l = this.head, I = this.tail, u = this.len;
+      return this.reset().uint32(u), u && (this.tail.next = l.next, this.tail = I, this.len += u), this;
+    }
+    tag(l, I) {
+      return this.uint32((l << 3 | I) >>> 0);
+    }
+    uint32(l) {
+      return this.len += (this.tail = this.tail.next = new s(r.writeVarint32, (l = l >>> 0) < 128 ? 1 : l < 16384 ? 2 : l < 2097152 ? 3 : l < 268435456 ? 4 : 5, l)).len, this;
+    }
+    int32(l) {
+      return l < 0 ? this._push(r.writeVarint64, 10, (0, r.int64FromString)(l.toString())) : this.uint32(l);
+    }
+    sint32(l) {
+      return this.uint32((l << 1 ^ l >> 31) >>> 0);
+    }
+    int64(l) {
+      const { lo: I, hi: u } = (0, r.int64FromString)(l.toString());
+      return this._push(r.writeVarint64, (0, r.int64Length)(I, u), { lo: I, hi: u });
+    }
+    sint64(l) {
+      let { lo: I, hi: u } = (0, r.int64FromString)(l.toString());
+      return [I, u] = (0, r.zzEncode)(I, u), this._push(r.writeVarint64, (0, r.int64Length)(I, u), { lo: I, hi: u });
+    }
+    fixed64(l) {
+      const { lo: I, hi: u } = (0, r.int64FromString)(l.toString());
+      return this._push(r.writeFixed32, 4, I)._push(r.writeFixed32, 4, u);
+    }
+    bool(l) {
+      return this._push(r.writeByte, 1, l ? 1 : 0);
+    }
+    fixed32(l) {
+      return this._push(r.writeFixed32, 4, l >>> 0);
+    }
+    float(l) {
+      throw new Error("float not supported" + l);
+    }
+    double(l) {
+      throw new Error("double not supported" + l);
+    }
+    bytes(l) {
+      const I = l.length >>> 0;
+      return I ? this.uint32(I)._push(f, I, l) : this._push(r.writeByte, 1, 0);
+    }
+    string(l) {
+      const I = (0, i.utf8Length)(l);
+      return I ? this.uint32(I)._push(i.utf8Write, I, l) : this._push(r.writeByte, 1, 0);
+    }
+  }
+  M.BinaryWriter = a;
+  function f(b, l, I) {
+    if (typeof Uint8Array < "u")
+      l.set(b, I);
+    else
+      for (let u = 0; u < b.length; ++u)
+        l[I + u] = b[u];
+  }
+  function g(b, l, I) {
+    let S = null, p = 8192;
+    return function(O) {
+      if (O < 1 || O > 4096)
+        return b(O);
+      p + O > 8192 && (S = b(8192), p = 0);
+      const D = l.call(S, p, p += O);
+      return p & 7 && (p = (p | 7) + 1), D;
+    };
+  }
+  function _(b, l) {
+    return RangeError("index out of range: " + b.pos + " + " + (l || 1) + " > " + b.len);
+  }
+  return M;
+}
+var N = {}, ue;
+function L() {
+  if (ue) return N;
+  ue = 1, Object.defineProperty(N, "__esModule", { value: !0 }), N.fromJsonTimestamp = N.fromTimestamp = N.toTimestamp = N.setPaginationParams = N.isObject = N.isSet = N.fromDuration = N.toDuration = N.omitDefault = N.base64FromBytes = N.bytesFromBase64 = void 0;
+  var i = (() => {
+    if (typeof i < "u")
+      return i;
+    if (typeof self < "u")
+      return self;
+    if (typeof window < "u")
+      return window;
+    if (typeof ie < "u")
+      return ie;
+    throw "Unable to locate global object";
+  })();
+  const r = i.atob || ((p) => i.Buffer.from(p, "base64").toString("binary"));
+  function c(p) {
+    const w = r(p), O = new Uint8Array(w.length);
+    for (let D = 0; D < w.length; ++D)
+      O[D] = w.charCodeAt(D);
+    return O;
+  }
+  N.bytesFromBase64 = c;
+  const d = i.btoa || ((p) => i.Buffer.from(p, "binary").toString("base64"));
+  function s(p) {
+    const w = [];
+    return p.forEach((O) => {
+      w.push(String.fromCharCode(O));
+    }), d(w.join(""));
+  }
+  N.base64FromBytes = s;
+  function o(p) {
+    if (typeof p == "string")
+      return p === "" ? void 0 : p;
+    if (typeof p == "number")
+      return p === 0 ? void 0 : p;
+    if (typeof p == "bigint")
+      return p === BigInt(0) ? void 0 : p;
+    throw new Error(`Got unsupported type ${typeof p}`);
+  }
+  N.omitDefault = o;
+  function a(p) {
+    return {
+      seconds: BigInt(Math.floor(parseInt(p) / 1e9)),
+      nanos: parseInt(p) % 1e9
+    };
+  }
+  N.toDuration = a;
+  function f(p) {
+    return (parseInt(p.seconds.toString()) * 1e9 + p.nanos).toString();
+  }
+  N.fromDuration = f;
+  function g(p) {
+    return p != null;
+  }
+  N.isSet = g;
+  function _(p) {
+    return typeof p == "object" && p !== null;
+  }
+  N.isObject = _;
+  const b = (p, w) => (w && (typeof (w == null ? void 0 : w.countTotal) < "u" && (p.params["pagination.count_total"] = w.countTotal), typeof (w == null ? void 0 : w.key) < "u" && (p.params["pagination.key"] = Buffer.from(w.key).toString("base64")), typeof (w == null ? void 0 : w.limit) < "u" && (p.params["pagination.limit"] = w.limit.toString()), typeof (w == null ? void 0 : w.offset) < "u" && (p.params["pagination.offset"] = w.offset.toString()), typeof (w == null ? void 0 : w.reverse) < "u" && (p.params["pagination.reverse"] = w.reverse)), p);
+  N.setPaginationParams = b;
+  function l(p) {
+    const w = S(p.getTime() / 1e3), O = p.getTime() % 1e3 * 1e6;
+    return {
+      seconds: w,
+      nanos: O
+    };
+  }
+  N.toTimestamp = l;
+  function I(p) {
+    let w = Number(p.seconds) * 1e3;
+    return w += p.nanos / 1e6, new Date(w);
+  }
+  N.fromTimestamp = I;
+  const u = (p) => ({
+    seconds: g(p.seconds) ? BigInt(p.seconds.toString()) : BigInt(0),
+    nanos: g(p.nanos) ? Number(p.nanos) : 0
+  });
+  function y(p) {
+    return p instanceof Date ? l(p) : typeof p == "string" ? l(new Date(p)) : u(p);
+  }
+  N.fromJsonTimestamp = y;
+  function S(p) {
+    return BigInt(Math.trunc(p));
+  }
+  return N;
+}
+var de;
+function Se() {
+  if (de) return x;
+  de = 1, Object.defineProperty(x, "__esModule", { value: !0 }), x.CompactBitArray = x.MultiSignature = x.protobufPackage = void 0;
+  const i = H(), r = L();
+  x.protobufPackage = "cosmos.crypto.multisig.v1beta1";
+  function c() {
+    return {
+      signatures: []
+    };
+  }
+  x.MultiSignature = {
+    typeUrl: "/cosmos.crypto.multisig.v1beta1.MultiSignature",
+    encode(s, o = i.BinaryWriter.create()) {
+      for (const a of s.signatures)
+        o.uint32(10).bytes(a);
+      return o;
+    },
+    decode(s, o) {
+      const a = s instanceof i.BinaryReader ? s : new i.BinaryReader(s);
+      let f = o === void 0 ? a.len : a.pos + o;
+      const g = c();
+      for (; a.pos < f; ) {
+        const _ = a.uint32();
+        switch (_ >>> 3) {
+          case 1:
+            g.signatures.push(a.bytes());
+            break;
+          default:
+            a.skipType(_ & 7);
+            break;
+        }
+      }
+      return g;
+    },
+    fromJSON(s) {
+      const o = c();
+      return Array.isArray(s == null ? void 0 : s.signatures) && (o.signatures = s.signatures.map((a) => (0, r.bytesFromBase64)(a))), o;
+    },
+    toJSON(s) {
+      const o = {};
+      return s.signatures ? o.signatures = s.signatures.map((a) => (0, r.base64FromBytes)(a !== void 0 ? a : new Uint8Array())) : o.signatures = [], o;
+    },
+    fromPartial(s) {
+      var a;
+      const o = c();
+      return o.signatures = ((a = s.signatures) == null ? void 0 : a.map((f) => f)) || [], o;
+    }
+  };
+  function d() {
+    return {
+      extraBitsStored: 0,
+      elems: new Uint8Array()
+    };
+  }
+  return x.CompactBitArray = {
+    typeUrl: "/cosmos.crypto.multisig.v1beta1.CompactBitArray",
+    encode(s, o = i.BinaryWriter.create()) {
+      return s.extraBitsStored !== 0 && o.uint32(8).uint32(s.extraBitsStored), s.elems.length !== 0 && o.uint32(18).bytes(s.elems), o;
+    },
+    decode(s, o) {
+      const a = s instanceof i.BinaryReader ? s : new i.BinaryReader(s);
+      let f = o === void 0 ? a.len : a.pos + o;
+      const g = d();
+      for (; a.pos < f; ) {
+        const _ = a.uint32();
+        switch (_ >>> 3) {
+          case 1:
+            g.extraBitsStored = a.uint32();
+            break;
+          case 2:
+            g.elems = a.bytes();
+            break;
+          default:
+            a.skipType(_ & 7);
+            break;
+        }
+      }
+      return g;
+    },
+    fromJSON(s) {
+      const o = d();
+      return (0, r.isSet)(s.extraBitsStored) && (o.extraBitsStored = Number(s.extraBitsStored)), (0, r.isSet)(s.elems) && (o.elems = (0, r.bytesFromBase64)(s.elems)), o;
+    },
+    toJSON(s) {
+      const o = {};
+      return s.extraBitsStored !== void 0 && (o.extraBitsStored = Math.round(s.extraBitsStored)), s.elems !== void 0 && (o.elems = (0, r.base64FromBytes)(s.elems !== void 0 ? s.elems : new Uint8Array())), o;
+    },
+    fromPartial(s) {
+      const o = d();
+      return o.extraBitsStored = s.extraBitsStored ?? 0, o.elems = s.elems ?? new Uint8Array(), o;
+    }
+  }, x;
+}
+var R = {}, ce;
+function Ie() {
+  if (ce) return R;
+  ce = 1, Object.defineProperty(R, "__esModule", { value: !0 }), R.Any = R.protobufPackage = void 0;
+  const i = H(), r = L();
+  R.protobufPackage = "google.protobuf";
+  function c() {
+    return {
+      typeUrl: "",
+      value: new Uint8Array()
+    };
+  }
+  return R.Any = {
+    typeUrl: "/google.protobuf.Any",
+    encode(d, s = i.BinaryWriter.create()) {
+      return d.typeUrl !== "" && s.uint32(10).string(d.typeUrl), d.value.length !== 0 && s.uint32(18).bytes(d.value), s;
+    },
+    decode(d, s) {
+      const o = d instanceof i.BinaryReader ? d : new i.BinaryReader(d);
+      let a = s === void 0 ? o.len : o.pos + s;
+      const f = c();
+      for (; o.pos < a; ) {
+        const g = o.uint32();
+        switch (g >>> 3) {
+          case 1:
+            f.typeUrl = o.string();
+            break;
+          case 2:
+            f.value = o.bytes();
+            break;
+          default:
+            o.skipType(g & 7);
+            break;
+        }
+      }
+      return f;
+    },
+    fromJSON(d) {
+      const s = c();
+      return (0, r.isSet)(d.typeUrl) && (s.typeUrl = String(d.typeUrl)), (0, r.isSet)(d.value) && (s.value = (0, r.bytesFromBase64)(d.value)), s;
+    },
+    toJSON(d) {
+      const s = {};
+      return d.typeUrl !== void 0 && (s.typeUrl = d.typeUrl), d.value !== void 0 && (s.value = (0, r.base64FromBytes)(d.value !== void 0 ? d.value : new Uint8Array())), s;
+    },
+    fromPartial(d) {
+      const s = c();
+      return s.typeUrl = d.typeUrl ?? "", s.value = d.value ?? new Uint8Array(), s;
+    }
+  }, R;
+}
+var fe;
+function be() {
+  return fe || (fe = 1, function(i) {
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.SignatureDescriptor_Data_Multi = i.SignatureDescriptor_Data_Single = i.SignatureDescriptor_Data = i.SignatureDescriptor = i.SignatureDescriptors = i.signModeToJSON = i.signModeFromJSON = i.SignMode = i.protobufPackage = void 0;
+    const r = Se(), c = Ie(), d = H(), s = L();
+    i.protobufPackage = "cosmos.tx.signing.v1beta1";
+    var o;
+    (function(u) {
+      u[u.SIGN_MODE_UNSPECIFIED = 0] = "SIGN_MODE_UNSPECIFIED", u[u.SIGN_MODE_DIRECT = 1] = "SIGN_MODE_DIRECT", u[u.SIGN_MODE_TEXTUAL = 2] = "SIGN_MODE_TEXTUAL", u[u.SIGN_MODE_DIRECT_AUX = 3] = "SIGN_MODE_DIRECT_AUX", u[u.SIGN_MODE_LEGACY_AMINO_JSON = 127] = "SIGN_MODE_LEGACY_AMINO_JSON", u[u.SIGN_MODE_EIP_191 = 191] = "SIGN_MODE_EIP_191", u[u.UNRECOGNIZED = -1] = "UNRECOGNIZED";
+    })(o || (i.SignMode = o = {}));
+    function a(u) {
+      switch (u) {
+        case 0:
+        case "SIGN_MODE_UNSPECIFIED":
+          return o.SIGN_MODE_UNSPECIFIED;
+        case 1:
+        case "SIGN_MODE_DIRECT":
+          return o.SIGN_MODE_DIRECT;
+        case 2:
+        case "SIGN_MODE_TEXTUAL":
+          return o.SIGN_MODE_TEXTUAL;
+        case 3:
+        case "SIGN_MODE_DIRECT_AUX":
+          return o.SIGN_MODE_DIRECT_AUX;
+        case 127:
+        case "SIGN_MODE_LEGACY_AMINO_JSON":
+          return o.SIGN_MODE_LEGACY_AMINO_JSON;
+        case 191:
+        case "SIGN_MODE_EIP_191":
+          return o.SIGN_MODE_EIP_191;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+          return o.UNRECOGNIZED;
+      }
+    }
+    i.signModeFromJSON = a;
+    function f(u) {
+      switch (u) {
+        case o.SIGN_MODE_UNSPECIFIED:
+          return "SIGN_MODE_UNSPECIFIED";
+        case o.SIGN_MODE_DIRECT:
+          return "SIGN_MODE_DIRECT";
+        case o.SIGN_MODE_TEXTUAL:
+          return "SIGN_MODE_TEXTUAL";
+        case o.SIGN_MODE_DIRECT_AUX:
+          return "SIGN_MODE_DIRECT_AUX";
+        case o.SIGN_MODE_LEGACY_AMINO_JSON:
+          return "SIGN_MODE_LEGACY_AMINO_JSON";
+        case o.SIGN_MODE_EIP_191:
+          return "SIGN_MODE_EIP_191";
+        case o.UNRECOGNIZED:
+        default:
+          return "UNRECOGNIZED";
+      }
+    }
+    i.signModeToJSON = f;
+    function g() {
+      return {
+        signatures: []
+      };
+    }
+    i.SignatureDescriptors = {
+      typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptors",
+      encode(u, y = d.BinaryWriter.create()) {
+        for (const S of u.signatures)
+          i.SignatureDescriptor.encode(S, y.uint32(10).fork()).ldelim();
+        return y;
+      },
+      decode(u, y) {
+        const S = u instanceof d.BinaryReader ? u : new d.BinaryReader(u);
+        let p = y === void 0 ? S.len : S.pos + y;
+        const w = g();
+        for (; S.pos < p; ) {
+          const O = S.uint32();
+          switch (O >>> 3) {
+            case 1:
+              w.signatures.push(i.SignatureDescriptor.decode(S, S.uint32()));
+              break;
+            default:
+              S.skipType(O & 7);
+              break;
+          }
+        }
+        return w;
+      },
+      fromJSON(u) {
+        const y = g();
+        return Array.isArray(u == null ? void 0 : u.signatures) && (y.signatures = u.signatures.map((S) => i.SignatureDescriptor.fromJSON(S))), y;
+      },
+      toJSON(u) {
+        const y = {};
+        return u.signatures ? y.signatures = u.signatures.map((S) => S ? i.SignatureDescriptor.toJSON(S) : void 0) : y.signatures = [], y;
+      },
+      fromPartial(u) {
+        var S;
+        const y = g();
+        return y.signatures = ((S = u.signatures) == null ? void 0 : S.map((p) => i.SignatureDescriptor.fromPartial(p))) || [], y;
+      }
+    };
+    function _() {
+      return {
+        publicKey: void 0,
+        data: void 0,
+        sequence: BigInt(0)
+      };
+    }
+    i.SignatureDescriptor = {
+      typeUrl: "/cosmos.tx.signing.v1beta1.SignatureDescriptor",
+      encode(u, y = d.BinaryWriter.create()) {
+        return u.publicKey !== void 0 && c.Any.encode(u.publicKey, y.uint32(10).fork()).ldelim(), u.data !== void 0 && i.SignatureDescriptor_Data.encode(u.data, y.uint32(18).fork()).ldelim(), u.sequence !== BigInt(0) && y.uint32(24).uint64(u.sequence), y;
+      },
+      decode(u, y) {
+        const S = u instanceof d.BinaryReader ? u : new d.BinaryReader(u);
+        let p = y === void 0 ? S.len : S.pos + y;
+        const w = _();
+        for (; S.pos < p; ) {
+          const O = S.uint32();
+          switch (O >>> 3) {
+            case 1:
+              w.publicKey = c.Any.decode(S, S.uint32());
+              break;
+            case 2:
+              w.data = i.SignatureDescriptor_Data.decode(S, S.uint32());
+              break;
+            case 3:
+              w.sequence = S.uint64();
+              break;
+            default:
+              S.skipType(O & 7);
+              break;
+          }
+        }
+        return w;
+      },
+      fromJSON(u) {
+        const y = _();
+        return (0, s.isSet)(u.publicKey) && (y.publicKey = c.Any.fromJSON(u.publicKey)), (0, s.isSet)(u.data) && (y.data = i.SignatureDescriptor_Data.fromJSON(u.data)), (0, s.isSet)(u.sequence) && (y.sequence = BigInt(u.sequence.toString())), y;
+      },
+      toJSON(u) {
+        const y = {};
+        return u.publicKey !== void 0 && (y.publicKey = u.publicKey ? c.Any.toJSON(u.publicKey) : void 0), u.data !== void 0 && (y.data = u.data ? i.SignatureDescriptor_Data.toJSON(u.data) : void 0), u.sequence !== void 0 && (y.sequence = (u.sequence || BigInt(0)).toString()), y;
+      },
+      fromPartial(u) {
+        const y = _();
+        return u.publicKey !== void 0 && u.publicKey !== null && (y.publicKey = c.Any.fromPartial(u.publicKey)), u.data !== void 0 && u.data !== null && (y.data = i.SignatureDescriptor_Data.fromPartial(u.data)), u.sequence !== void 0 && u.sequence !== null && (y.sequence = BigInt(u.sequence.toString())), y;
+      }
+    };
+    function b() {
+      return {
+        single: void 0,
+        multi: void 0
+      };
+    }
+    i.SignatureDescriptor_Data = {
+      typeUrl: "/cosmos.tx.signing.v1beta1.Data",
+      encode(u, y = d.BinaryWriter.create()) {
+        return u.single !== void 0 && i.SignatureDescriptor_Data_Single.encode(u.single, y.uint32(10).fork()).ldelim(), u.multi !== void 0 && i.SignatureDescriptor_Data_Multi.encode(u.multi, y.uint32(18).fork()).ldelim(), y;
+      },
+      decode(u, y) {
+        const S = u instanceof d.BinaryReader ? u : new d.BinaryReader(u);
+        let p = y === void 0 ? S.len : S.pos + y;
+        const w = b();
+        for (; S.pos < p; ) {
+          const O = S.uint32();
+          switch (O >>> 3) {
+            case 1:
+              w.single = i.SignatureDescriptor_Data_Single.decode(S, S.uint32());
+              break;
+            case 2:
+              w.multi = i.SignatureDescriptor_Data_Multi.decode(S, S.uint32());
+              break;
+            default:
+              S.skipType(O & 7);
+              break;
+          }
+        }
+        return w;
+      },
+      fromJSON(u) {
+        const y = b();
+        return (0, s.isSet)(u.single) && (y.single = i.SignatureDescriptor_Data_Single.fromJSON(u.single)), (0, s.isSet)(u.multi) && (y.multi = i.SignatureDescriptor_Data_Multi.fromJSON(u.multi)), y;
+      },
+      toJSON(u) {
+        const y = {};
+        return u.single !== void 0 && (y.single = u.single ? i.SignatureDescriptor_Data_Single.toJSON(u.single) : void 0), u.multi !== void 0 && (y.multi = u.multi ? i.SignatureDescriptor_Data_Multi.toJSON(u.multi) : void 0), y;
+      },
+      fromPartial(u) {
+        const y = b();
+        return u.single !== void 0 && u.single !== null && (y.single = i.SignatureDescriptor_Data_Single.fromPartial(u.single)), u.multi !== void 0 && u.multi !== null && (y.multi = i.SignatureDescriptor_Data_Multi.fromPartial(u.multi)), y;
+      }
+    };
+    function l() {
+      return {
+        mode: 0,
+        signature: new Uint8Array()
+      };
+    }
+    i.SignatureDescriptor_Data_Single = {
+      typeUrl: "/cosmos.tx.signing.v1beta1.Single",
+      encode(u, y = d.BinaryWriter.create()) {
+        return u.mode !== 0 && y.uint32(8).int32(u.mode), u.signature.length !== 0 && y.uint32(18).bytes(u.signature), y;
+      },
+      decode(u, y) {
+        const S = u instanceof d.BinaryReader ? u : new d.BinaryReader(u);
+        let p = y === void 0 ? S.len : S.pos + y;
+        const w = l();
+        for (; S.pos < p; ) {
+          const O = S.uint32();
+          switch (O >>> 3) {
+            case 1:
+              w.mode = S.int32();
+              break;
+            case 2:
+              w.signature = S.bytes();
+              break;
+            default:
+              S.skipType(O & 7);
+              break;
+          }
+        }
+        return w;
+      },
+      fromJSON(u) {
+        const y = l();
+        return (0, s.isSet)(u.mode) && (y.mode = a(u.mode)), (0, s.isSet)(u.signature) && (y.signature = (0, s.bytesFromBase64)(u.signature)), y;
+      },
+      toJSON(u) {
+        const y = {};
+        return u.mode !== void 0 && (y.mode = f(u.mode)), u.signature !== void 0 && (y.signature = (0, s.base64FromBytes)(u.signature !== void 0 ? u.signature : new Uint8Array())), y;
+      },
+      fromPartial(u) {
+        const y = l();
+        return y.mode = u.mode ?? 0, y.signature = u.signature ?? new Uint8Array(), y;
+      }
+    };
+    function I() {
+      return {
+        bitarray: void 0,
+        signatures: []
+      };
+    }
+    i.SignatureDescriptor_Data_Multi = {
+      typeUrl: "/cosmos.tx.signing.v1beta1.Multi",
+      encode(u, y = d.BinaryWriter.create()) {
+        u.bitarray !== void 0 && r.CompactBitArray.encode(u.bitarray, y.uint32(10).fork()).ldelim();
+        for (const S of u.signatures)
+          i.SignatureDescriptor_Data.encode(S, y.uint32(18).fork()).ldelim();
+        return y;
+      },
+      decode(u, y) {
+        const S = u instanceof d.BinaryReader ? u : new d.BinaryReader(u);
+        let p = y === void 0 ? S.len : S.pos + y;
+        const w = I();
+        for (; S.pos < p; ) {
+          const O = S.uint32();
+          switch (O >>> 3) {
+            case 1:
+              w.bitarray = r.CompactBitArray.decode(S, S.uint32());
+              break;
+            case 2:
+              w.signatures.push(i.SignatureDescriptor_Data.decode(S, S.uint32()));
+              break;
+            default:
+              S.skipType(O & 7);
+              break;
+          }
+        }
+        return w;
+      },
+      fromJSON(u) {
+        const y = I();
+        return (0, s.isSet)(u.bitarray) && (y.bitarray = r.CompactBitArray.fromJSON(u.bitarray)), Array.isArray(u == null ? void 0 : u.signatures) && (y.signatures = u.signatures.map((S) => i.SignatureDescriptor_Data.fromJSON(S))), y;
+      },
+      toJSON(u) {
+        const y = {};
+        return u.bitarray !== void 0 && (y.bitarray = u.bitarray ? r.CompactBitArray.toJSON(u.bitarray) : void 0), u.signatures ? y.signatures = u.signatures.map((S) => S ? i.SignatureDescriptor_Data.toJSON(S) : void 0) : y.signatures = [], y;
+      },
+      fromPartial(u) {
+        var S;
+        const y = I();
+        return u.bitarray !== void 0 && u.bitarray !== null && (y.bitarray = r.CompactBitArray.fromPartial(u.bitarray)), y.signatures = ((S = u.signatures) == null ? void 0 : S.map((p) => i.SignatureDescriptor_Data.fromPartial(p))) || [], y;
+      }
+    };
+  }(V)), V;
+}
+var je = be(), X = {}, v = {}, le;
+function en() {
+  if (le) return v;
+  le = 1, Object.defineProperty(v, "__esModule", { value: !0 }), v.DecProto = v.IntProto = v.DecCoin = v.Coin = v.protobufPackage = void 0;
+  const i = H(), r = L();
+  v.protobufPackage = "cosmos.base.v1beta1";
+  function c() {
+    return {
+      denom: "",
+      amount: ""
+    };
+  }
+  v.Coin = {
+    typeUrl: "/cosmos.base.v1beta1.Coin",
+    encode(a, f = i.BinaryWriter.create()) {
+      return a.denom !== "" && f.uint32(10).string(a.denom), a.amount !== "" && f.uint32(18).string(a.amount), f;
+    },
+    decode(a, f) {
+      const g = a instanceof i.BinaryReader ? a : new i.BinaryReader(a);
+      let _ = f === void 0 ? g.len : g.pos + f;
+      const b = c();
+      for (; g.pos < _; ) {
+        const l = g.uint32();
+        switch (l >>> 3) {
+          case 1:
+            b.denom = g.string();
+            break;
+          case 2:
+            b.amount = g.string();
+            break;
+          default:
+            g.skipType(l & 7);
+            break;
+        }
+      }
+      return b;
+    },
+    fromJSON(a) {
+      const f = c();
+      return (0, r.isSet)(a.denom) && (f.denom = String(a.denom)), (0, r.isSet)(a.amount) && (f.amount = String(a.amount)), f;
+    },
+    toJSON(a) {
+      const f = {};
+      return a.denom !== void 0 && (f.denom = a.denom), a.amount !== void 0 && (f.amount = a.amount), f;
+    },
+    fromPartial(a) {
+      const f = c();
+      return f.denom = a.denom ?? "", f.amount = a.amount ?? "", f;
+    }
+  };
+  function d() {
+    return {
+      denom: "",
+      amount: ""
+    };
+  }
+  v.DecCoin = {
+    typeUrl: "/cosmos.base.v1beta1.DecCoin",
+    encode(a, f = i.BinaryWriter.create()) {
+      return a.denom !== "" && f.uint32(10).string(a.denom), a.amount !== "" && f.uint32(18).string(a.amount), f;
+    },
+    decode(a, f) {
+      const g = a instanceof i.BinaryReader ? a : new i.BinaryReader(a);
+      let _ = f === void 0 ? g.len : g.pos + f;
+      const b = d();
+      for (; g.pos < _; ) {
+        const l = g.uint32();
+        switch (l >>> 3) {
+          case 1:
+            b.denom = g.string();
+            break;
+          case 2:
+            b.amount = g.string();
+            break;
+          default:
+            g.skipType(l & 7);
+            break;
+        }
+      }
+      return b;
+    },
+    fromJSON(a) {
+      const f = d();
+      return (0, r.isSet)(a.denom) && (f.denom = String(a.denom)), (0, r.isSet)(a.amount) && (f.amount = String(a.amount)), f;
+    },
+    toJSON(a) {
+      const f = {};
+      return a.denom !== void 0 && (f.denom = a.denom), a.amount !== void 0 && (f.amount = a.amount), f;
+    },
+    fromPartial(a) {
+      const f = d();
+      return f.denom = a.denom ?? "", f.amount = a.amount ?? "", f;
+    }
+  };
+  function s() {
+    return {
+      int: ""
+    };
+  }
+  v.IntProto = {
+    typeUrl: "/cosmos.base.v1beta1.IntProto",
+    encode(a, f = i.BinaryWriter.create()) {
+      return a.int !== "" && f.uint32(10).string(a.int), f;
+    },
+    decode(a, f) {
+      const g = a instanceof i.BinaryReader ? a : new i.BinaryReader(a);
+      let _ = f === void 0 ? g.len : g.pos + f;
+      const b = s();
+      for (; g.pos < _; ) {
+        const l = g.uint32();
+        switch (l >>> 3) {
+          case 1:
+            b.int = g.string();
+            break;
+          default:
+            g.skipType(l & 7);
+            break;
+        }
+      }
+      return b;
+    },
+    fromJSON(a) {
+      const f = s();
+      return (0, r.isSet)(a.int) && (f.int = String(a.int)), f;
+    },
+    toJSON(a) {
+      const f = {};
+      return a.int !== void 0 && (f.int = a.int), f;
+    },
+    fromPartial(a) {
+      const f = s();
+      return f.int = a.int ?? "", f;
+    }
+  };
+  function o() {
+    return {
+      dec: ""
+    };
+  }
+  return v.DecProto = {
+    typeUrl: "/cosmos.base.v1beta1.DecProto",
+    encode(a, f = i.BinaryWriter.create()) {
+      return a.dec !== "" && f.uint32(10).string(a.dec), f;
+    },
+    decode(a, f) {
+      const g = a instanceof i.BinaryReader ? a : new i.BinaryReader(a);
+      let _ = f === void 0 ? g.len : g.pos + f;
+      const b = o();
+      for (; g.pos < _; ) {
+        const l = g.uint32();
+        switch (l >>> 3) {
+          case 1:
+            b.dec = g.string();
+            break;
+          default:
+            g.skipType(l & 7);
+            break;
+        }
+      }
+      return b;
+    },
+    fromJSON(a) {
+      const f = o();
+      return (0, r.isSet)(a.dec) && (f.dec = String(a.dec)), f;
+    },
+    toJSON(a) {
+      const f = {};
+      return a.dec !== void 0 && (f.dec = a.dec), f;
+    },
+    fromPartial(a) {
+      const f = o();
+      return f.dec = a.dec ?? "", f;
+    }
+  }, v;
+}
+var ye;
+function nn() {
+  return ye || (ye = 1, function(i) {
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.AuxSignerData = i.Tip = i.Fee = i.ModeInfo_Multi = i.ModeInfo_Single = i.ModeInfo = i.SignerInfo = i.AuthInfo = i.TxBody = i.SignDocDirectAux = i.SignDoc = i.TxRaw = i.Tx = i.protobufPackage = void 0;
+    const r = Ie(), c = be(), d = Se(), s = en(), o = H(), a = L();
+    i.protobufPackage = "cosmos.tx.v1beta1";
+    function f() {
+      return {
+        body: void 0,
+        authInfo: void 0,
+        signatures: []
+      };
+    }
+    i.Tx = {
+      typeUrl: "/cosmos.tx.v1beta1.Tx",
+      encode(e, n = o.BinaryWriter.create()) {
+        e.body !== void 0 && i.TxBody.encode(e.body, n.uint32(10).fork()).ldelim(), e.authInfo !== void 0 && i.AuthInfo.encode(e.authInfo, n.uint32(18).fork()).ldelim();
+        for (const t of e.signatures)
+          n.uint32(26).bytes(t);
+        return n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = f();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.body = i.TxBody.decode(t, t.uint32());
+              break;
+            case 2:
+              h.authInfo = i.AuthInfo.decode(t, t.uint32());
+              break;
+            case 3:
+              h.signatures.push(t.bytes());
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = f();
+        return (0, a.isSet)(e.body) && (n.body = i.TxBody.fromJSON(e.body)), (0, a.isSet)(e.authInfo) && (n.authInfo = i.AuthInfo.fromJSON(e.authInfo)), Array.isArray(e == null ? void 0 : e.signatures) && (n.signatures = e.signatures.map((t) => (0, a.bytesFromBase64)(t))), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.body !== void 0 && (n.body = e.body ? i.TxBody.toJSON(e.body) : void 0), e.authInfo !== void 0 && (n.authInfo = e.authInfo ? i.AuthInfo.toJSON(e.authInfo) : void 0), e.signatures ? n.signatures = e.signatures.map((t) => (0, a.base64FromBytes)(t !== void 0 ? t : new Uint8Array())) : n.signatures = [], n;
+      },
+      fromPartial(e) {
+        var t;
+        const n = f();
+        return e.body !== void 0 && e.body !== null && (n.body = i.TxBody.fromPartial(e.body)), e.authInfo !== void 0 && e.authInfo !== null && (n.authInfo = i.AuthInfo.fromPartial(e.authInfo)), n.signatures = ((t = e.signatures) == null ? void 0 : t.map((m) => m)) || [], n;
+      }
+    };
+    function g() {
+      return {
+        bodyBytes: new Uint8Array(),
+        authInfoBytes: new Uint8Array(),
+        signatures: []
+      };
+    }
+    i.TxRaw = {
+      typeUrl: "/cosmos.tx.v1beta1.TxRaw",
+      encode(e, n = o.BinaryWriter.create()) {
+        e.bodyBytes.length !== 0 && n.uint32(10).bytes(e.bodyBytes), e.authInfoBytes.length !== 0 && n.uint32(18).bytes(e.authInfoBytes);
+        for (const t of e.signatures)
+          n.uint32(26).bytes(t);
+        return n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = g();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.bodyBytes = t.bytes();
+              break;
+            case 2:
+              h.authInfoBytes = t.bytes();
+              break;
+            case 3:
+              h.signatures.push(t.bytes());
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = g();
+        return (0, a.isSet)(e.bodyBytes) && (n.bodyBytes = (0, a.bytesFromBase64)(e.bodyBytes)), (0, a.isSet)(e.authInfoBytes) && (n.authInfoBytes = (0, a.bytesFromBase64)(e.authInfoBytes)), Array.isArray(e == null ? void 0 : e.signatures) && (n.signatures = e.signatures.map((t) => (0, a.bytesFromBase64)(t))), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.bodyBytes !== void 0 && (n.bodyBytes = (0, a.base64FromBytes)(e.bodyBytes !== void 0 ? e.bodyBytes : new Uint8Array())), e.authInfoBytes !== void 0 && (n.authInfoBytes = (0, a.base64FromBytes)(e.authInfoBytes !== void 0 ? e.authInfoBytes : new Uint8Array())), e.signatures ? n.signatures = e.signatures.map((t) => (0, a.base64FromBytes)(t !== void 0 ? t : new Uint8Array())) : n.signatures = [], n;
+      },
+      fromPartial(e) {
+        var t;
+        const n = g();
+        return n.bodyBytes = e.bodyBytes ?? new Uint8Array(), n.authInfoBytes = e.authInfoBytes ?? new Uint8Array(), n.signatures = ((t = e.signatures) == null ? void 0 : t.map((m) => m)) || [], n;
+      }
+    };
+    function _() {
+      return {
+        bodyBytes: new Uint8Array(),
+        authInfoBytes: new Uint8Array(),
+        chainId: "",
+        accountNumber: BigInt(0)
+      };
+    }
+    i.SignDoc = {
+      typeUrl: "/cosmos.tx.v1beta1.SignDoc",
+      encode(e, n = o.BinaryWriter.create()) {
+        return e.bodyBytes.length !== 0 && n.uint32(10).bytes(e.bodyBytes), e.authInfoBytes.length !== 0 && n.uint32(18).bytes(e.authInfoBytes), e.chainId !== "" && n.uint32(26).string(e.chainId), e.accountNumber !== BigInt(0) && n.uint32(32).uint64(e.accountNumber), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = _();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.bodyBytes = t.bytes();
+              break;
+            case 2:
+              h.authInfoBytes = t.bytes();
+              break;
+            case 3:
+              h.chainId = t.string();
+              break;
+            case 4:
+              h.accountNumber = t.uint64();
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = _();
+        return (0, a.isSet)(e.bodyBytes) && (n.bodyBytes = (0, a.bytesFromBase64)(e.bodyBytes)), (0, a.isSet)(e.authInfoBytes) && (n.authInfoBytes = (0, a.bytesFromBase64)(e.authInfoBytes)), (0, a.isSet)(e.chainId) && (n.chainId = String(e.chainId)), (0, a.isSet)(e.accountNumber) && (n.accountNumber = BigInt(e.accountNumber.toString())), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.bodyBytes !== void 0 && (n.bodyBytes = (0, a.base64FromBytes)(e.bodyBytes !== void 0 ? e.bodyBytes : new Uint8Array())), e.authInfoBytes !== void 0 && (n.authInfoBytes = (0, a.base64FromBytes)(e.authInfoBytes !== void 0 ? e.authInfoBytes : new Uint8Array())), e.chainId !== void 0 && (n.chainId = e.chainId), e.accountNumber !== void 0 && (n.accountNumber = (e.accountNumber || BigInt(0)).toString()), n;
+      },
+      fromPartial(e) {
+        const n = _();
+        return n.bodyBytes = e.bodyBytes ?? new Uint8Array(), n.authInfoBytes = e.authInfoBytes ?? new Uint8Array(), n.chainId = e.chainId ?? "", e.accountNumber !== void 0 && e.accountNumber !== null && (n.accountNumber = BigInt(e.accountNumber.toString())), n;
+      }
+    };
+    function b() {
+      return {
+        bodyBytes: new Uint8Array(),
+        publicKey: void 0,
+        chainId: "",
+        accountNumber: BigInt(0),
+        sequence: BigInt(0),
+        tip: void 0
+      };
+    }
+    i.SignDocDirectAux = {
+      typeUrl: "/cosmos.tx.v1beta1.SignDocDirectAux",
+      encode(e, n = o.BinaryWriter.create()) {
+        return e.bodyBytes.length !== 0 && n.uint32(10).bytes(e.bodyBytes), e.publicKey !== void 0 && r.Any.encode(e.publicKey, n.uint32(18).fork()).ldelim(), e.chainId !== "" && n.uint32(26).string(e.chainId), e.accountNumber !== BigInt(0) && n.uint32(32).uint64(e.accountNumber), e.sequence !== BigInt(0) && n.uint32(40).uint64(e.sequence), e.tip !== void 0 && i.Tip.encode(e.tip, n.uint32(50).fork()).ldelim(), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = b();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.bodyBytes = t.bytes();
+              break;
+            case 2:
+              h.publicKey = r.Any.decode(t, t.uint32());
+              break;
+            case 3:
+              h.chainId = t.string();
+              break;
+            case 4:
+              h.accountNumber = t.uint64();
+              break;
+            case 5:
+              h.sequence = t.uint64();
+              break;
+            case 6:
+              h.tip = i.Tip.decode(t, t.uint32());
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = b();
+        return (0, a.isSet)(e.bodyBytes) && (n.bodyBytes = (0, a.bytesFromBase64)(e.bodyBytes)), (0, a.isSet)(e.publicKey) && (n.publicKey = r.Any.fromJSON(e.publicKey)), (0, a.isSet)(e.chainId) && (n.chainId = String(e.chainId)), (0, a.isSet)(e.accountNumber) && (n.accountNumber = BigInt(e.accountNumber.toString())), (0, a.isSet)(e.sequence) && (n.sequence = BigInt(e.sequence.toString())), (0, a.isSet)(e.tip) && (n.tip = i.Tip.fromJSON(e.tip)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.bodyBytes !== void 0 && (n.bodyBytes = (0, a.base64FromBytes)(e.bodyBytes !== void 0 ? e.bodyBytes : new Uint8Array())), e.publicKey !== void 0 && (n.publicKey = e.publicKey ? r.Any.toJSON(e.publicKey) : void 0), e.chainId !== void 0 && (n.chainId = e.chainId), e.accountNumber !== void 0 && (n.accountNumber = (e.accountNumber || BigInt(0)).toString()), e.sequence !== void 0 && (n.sequence = (e.sequence || BigInt(0)).toString()), e.tip !== void 0 && (n.tip = e.tip ? i.Tip.toJSON(e.tip) : void 0), n;
+      },
+      fromPartial(e) {
+        const n = b();
+        return n.bodyBytes = e.bodyBytes ?? new Uint8Array(), e.publicKey !== void 0 && e.publicKey !== null && (n.publicKey = r.Any.fromPartial(e.publicKey)), n.chainId = e.chainId ?? "", e.accountNumber !== void 0 && e.accountNumber !== null && (n.accountNumber = BigInt(e.accountNumber.toString())), e.sequence !== void 0 && e.sequence !== null && (n.sequence = BigInt(e.sequence.toString())), e.tip !== void 0 && e.tip !== null && (n.tip = i.Tip.fromPartial(e.tip)), n;
+      }
+    };
+    function l() {
+      return {
+        messages: [],
+        memo: "",
+        timeoutHeight: BigInt(0),
+        extensionOptions: [],
+        nonCriticalExtensionOptions: []
+      };
+    }
+    i.TxBody = {
+      typeUrl: "/cosmos.tx.v1beta1.TxBody",
+      encode(e, n = o.BinaryWriter.create()) {
+        for (const t of e.messages)
+          r.Any.encode(t, n.uint32(10).fork()).ldelim();
+        e.memo !== "" && n.uint32(18).string(e.memo), e.timeoutHeight !== BigInt(0) && n.uint32(24).uint64(e.timeoutHeight);
+        for (const t of e.extensionOptions)
+          r.Any.encode(t, n.uint32(8186).fork()).ldelim();
+        for (const t of e.nonCriticalExtensionOptions)
+          r.Any.encode(t, n.uint32(16378).fork()).ldelim();
+        return n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = l();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.messages.push(r.Any.decode(t, t.uint32()));
+              break;
+            case 2:
+              h.memo = t.string();
+              break;
+            case 3:
+              h.timeoutHeight = t.uint64();
+              break;
+            case 1023:
+              h.extensionOptions.push(r.Any.decode(t, t.uint32()));
+              break;
+            case 2047:
+              h.nonCriticalExtensionOptions.push(r.Any.decode(t, t.uint32()));
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = l();
+        return Array.isArray(e == null ? void 0 : e.messages) && (n.messages = e.messages.map((t) => r.Any.fromJSON(t))), (0, a.isSet)(e.memo) && (n.memo = String(e.memo)), (0, a.isSet)(e.timeoutHeight) && (n.timeoutHeight = BigInt(e.timeoutHeight.toString())), Array.isArray(e == null ? void 0 : e.extensionOptions) && (n.extensionOptions = e.extensionOptions.map((t) => r.Any.fromJSON(t))), Array.isArray(e == null ? void 0 : e.nonCriticalExtensionOptions) && (n.nonCriticalExtensionOptions = e.nonCriticalExtensionOptions.map((t) => r.Any.fromJSON(t))), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.messages ? n.messages = e.messages.map((t) => t ? r.Any.toJSON(t) : void 0) : n.messages = [], e.memo !== void 0 && (n.memo = e.memo), e.timeoutHeight !== void 0 && (n.timeoutHeight = (e.timeoutHeight || BigInt(0)).toString()), e.extensionOptions ? n.extensionOptions = e.extensionOptions.map((t) => t ? r.Any.toJSON(t) : void 0) : n.extensionOptions = [], e.nonCriticalExtensionOptions ? n.nonCriticalExtensionOptions = e.nonCriticalExtensionOptions.map((t) => t ? r.Any.toJSON(t) : void 0) : n.nonCriticalExtensionOptions = [], n;
+      },
+      fromPartial(e) {
+        var t, m, h;
+        const n = l();
+        return n.messages = ((t = e.messages) == null ? void 0 : t.map((B) => r.Any.fromPartial(B))) || [], n.memo = e.memo ?? "", e.timeoutHeight !== void 0 && e.timeoutHeight !== null && (n.timeoutHeight = BigInt(e.timeoutHeight.toString())), n.extensionOptions = ((m = e.extensionOptions) == null ? void 0 : m.map((B) => r.Any.fromPartial(B))) || [], n.nonCriticalExtensionOptions = ((h = e.nonCriticalExtensionOptions) == null ? void 0 : h.map((B) => r.Any.fromPartial(B))) || [], n;
+      }
+    };
+    function I() {
+      return {
+        signerInfos: [],
+        fee: void 0,
+        tip: void 0
+      };
+    }
+    i.AuthInfo = {
+      typeUrl: "/cosmos.tx.v1beta1.AuthInfo",
+      encode(e, n = o.BinaryWriter.create()) {
+        for (const t of e.signerInfos)
+          i.SignerInfo.encode(t, n.uint32(10).fork()).ldelim();
+        return e.fee !== void 0 && i.Fee.encode(e.fee, n.uint32(18).fork()).ldelim(), e.tip !== void 0 && i.Tip.encode(e.tip, n.uint32(26).fork()).ldelim(), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = I();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.signerInfos.push(i.SignerInfo.decode(t, t.uint32()));
+              break;
+            case 2:
+              h.fee = i.Fee.decode(t, t.uint32());
+              break;
+            case 3:
+              h.tip = i.Tip.decode(t, t.uint32());
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = I();
+        return Array.isArray(e == null ? void 0 : e.signerInfos) && (n.signerInfos = e.signerInfos.map((t) => i.SignerInfo.fromJSON(t))), (0, a.isSet)(e.fee) && (n.fee = i.Fee.fromJSON(e.fee)), (0, a.isSet)(e.tip) && (n.tip = i.Tip.fromJSON(e.tip)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.signerInfos ? n.signerInfos = e.signerInfos.map((t) => t ? i.SignerInfo.toJSON(t) : void 0) : n.signerInfos = [], e.fee !== void 0 && (n.fee = e.fee ? i.Fee.toJSON(e.fee) : void 0), e.tip !== void 0 && (n.tip = e.tip ? i.Tip.toJSON(e.tip) : void 0), n;
+      },
+      fromPartial(e) {
+        var t;
+        const n = I();
+        return n.signerInfos = ((t = e.signerInfos) == null ? void 0 : t.map((m) => i.SignerInfo.fromPartial(m))) || [], e.fee !== void 0 && e.fee !== null && (n.fee = i.Fee.fromPartial(e.fee)), e.tip !== void 0 && e.tip !== null && (n.tip = i.Tip.fromPartial(e.tip)), n;
+      }
+    };
+    function u() {
+      return {
+        publicKey: void 0,
+        modeInfo: void 0,
+        sequence: BigInt(0)
+      };
+    }
+    i.SignerInfo = {
+      typeUrl: "/cosmos.tx.v1beta1.SignerInfo",
+      encode(e, n = o.BinaryWriter.create()) {
+        return e.publicKey !== void 0 && r.Any.encode(e.publicKey, n.uint32(10).fork()).ldelim(), e.modeInfo !== void 0 && i.ModeInfo.encode(e.modeInfo, n.uint32(18).fork()).ldelim(), e.sequence !== BigInt(0) && n.uint32(24).uint64(e.sequence), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = u();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.publicKey = r.Any.decode(t, t.uint32());
+              break;
+            case 2:
+              h.modeInfo = i.ModeInfo.decode(t, t.uint32());
+              break;
+            case 3:
+              h.sequence = t.uint64();
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = u();
+        return (0, a.isSet)(e.publicKey) && (n.publicKey = r.Any.fromJSON(e.publicKey)), (0, a.isSet)(e.modeInfo) && (n.modeInfo = i.ModeInfo.fromJSON(e.modeInfo)), (0, a.isSet)(e.sequence) && (n.sequence = BigInt(e.sequence.toString())), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.publicKey !== void 0 && (n.publicKey = e.publicKey ? r.Any.toJSON(e.publicKey) : void 0), e.modeInfo !== void 0 && (n.modeInfo = e.modeInfo ? i.ModeInfo.toJSON(e.modeInfo) : void 0), e.sequence !== void 0 && (n.sequence = (e.sequence || BigInt(0)).toString()), n;
+      },
+      fromPartial(e) {
+        const n = u();
+        return e.publicKey !== void 0 && e.publicKey !== null && (n.publicKey = r.Any.fromPartial(e.publicKey)), e.modeInfo !== void 0 && e.modeInfo !== null && (n.modeInfo = i.ModeInfo.fromPartial(e.modeInfo)), e.sequence !== void 0 && e.sequence !== null && (n.sequence = BigInt(e.sequence.toString())), n;
+      }
+    };
+    function y() {
+      return {
+        single: void 0,
+        multi: void 0
+      };
+    }
+    i.ModeInfo = {
+      typeUrl: "/cosmos.tx.v1beta1.ModeInfo",
+      encode(e, n = o.BinaryWriter.create()) {
+        return e.single !== void 0 && i.ModeInfo_Single.encode(e.single, n.uint32(10).fork()).ldelim(), e.multi !== void 0 && i.ModeInfo_Multi.encode(e.multi, n.uint32(18).fork()).ldelim(), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = y();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.single = i.ModeInfo_Single.decode(t, t.uint32());
+              break;
+            case 2:
+              h.multi = i.ModeInfo_Multi.decode(t, t.uint32());
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = y();
+        return (0, a.isSet)(e.single) && (n.single = i.ModeInfo_Single.fromJSON(e.single)), (0, a.isSet)(e.multi) && (n.multi = i.ModeInfo_Multi.fromJSON(e.multi)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.single !== void 0 && (n.single = e.single ? i.ModeInfo_Single.toJSON(e.single) : void 0), e.multi !== void 0 && (n.multi = e.multi ? i.ModeInfo_Multi.toJSON(e.multi) : void 0), n;
+      },
+      fromPartial(e) {
+        const n = y();
+        return e.single !== void 0 && e.single !== null && (n.single = i.ModeInfo_Single.fromPartial(e.single)), e.multi !== void 0 && e.multi !== null && (n.multi = i.ModeInfo_Multi.fromPartial(e.multi)), n;
+      }
+    };
+    function S() {
+      return {
+        mode: 0
+      };
+    }
+    i.ModeInfo_Single = {
+      typeUrl: "/cosmos.tx.v1beta1.Single",
+      encode(e, n = o.BinaryWriter.create()) {
+        return e.mode !== 0 && n.uint32(8).int32(e.mode), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = S();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.mode = t.int32();
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = S();
+        return (0, a.isSet)(e.mode) && (n.mode = (0, c.signModeFromJSON)(e.mode)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.mode !== void 0 && (n.mode = (0, c.signModeToJSON)(e.mode)), n;
+      },
+      fromPartial(e) {
+        const n = S();
+        return n.mode = e.mode ?? 0, n;
+      }
+    };
+    function p() {
+      return {
+        bitarray: void 0,
+        modeInfos: []
+      };
+    }
+    i.ModeInfo_Multi = {
+      typeUrl: "/cosmos.tx.v1beta1.Multi",
+      encode(e, n = o.BinaryWriter.create()) {
+        e.bitarray !== void 0 && d.CompactBitArray.encode(e.bitarray, n.uint32(10).fork()).ldelim();
+        for (const t of e.modeInfos)
+          i.ModeInfo.encode(t, n.uint32(18).fork()).ldelim();
+        return n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = p();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.bitarray = d.CompactBitArray.decode(t, t.uint32());
+              break;
+            case 2:
+              h.modeInfos.push(i.ModeInfo.decode(t, t.uint32()));
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = p();
+        return (0, a.isSet)(e.bitarray) && (n.bitarray = d.CompactBitArray.fromJSON(e.bitarray)), Array.isArray(e == null ? void 0 : e.modeInfos) && (n.modeInfos = e.modeInfos.map((t) => i.ModeInfo.fromJSON(t))), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.bitarray !== void 0 && (n.bitarray = e.bitarray ? d.CompactBitArray.toJSON(e.bitarray) : void 0), e.modeInfos ? n.modeInfos = e.modeInfos.map((t) => t ? i.ModeInfo.toJSON(t) : void 0) : n.modeInfos = [], n;
+      },
+      fromPartial(e) {
+        var t;
+        const n = p();
+        return e.bitarray !== void 0 && e.bitarray !== null && (n.bitarray = d.CompactBitArray.fromPartial(e.bitarray)), n.modeInfos = ((t = e.modeInfos) == null ? void 0 : t.map((m) => i.ModeInfo.fromPartial(m))) || [], n;
+      }
+    };
+    function w() {
+      return {
+        amount: [],
+        gasLimit: BigInt(0),
+        payer: "",
+        granter: ""
+      };
+    }
+    i.Fee = {
+      typeUrl: "/cosmos.tx.v1beta1.Fee",
+      encode(e, n = o.BinaryWriter.create()) {
+        for (const t of e.amount)
+          s.Coin.encode(t, n.uint32(10).fork()).ldelim();
+        return e.gasLimit !== BigInt(0) && n.uint32(16).uint64(e.gasLimit), e.payer !== "" && n.uint32(26).string(e.payer), e.granter !== "" && n.uint32(34).string(e.granter), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = w();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.amount.push(s.Coin.decode(t, t.uint32()));
+              break;
+            case 2:
+              h.gasLimit = t.uint64();
+              break;
+            case 3:
+              h.payer = t.string();
+              break;
+            case 4:
+              h.granter = t.string();
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = w();
+        return Array.isArray(e == null ? void 0 : e.amount) && (n.amount = e.amount.map((t) => s.Coin.fromJSON(t))), (0, a.isSet)(e.gasLimit) && (n.gasLimit = BigInt(e.gasLimit.toString())), (0, a.isSet)(e.payer) && (n.payer = String(e.payer)), (0, a.isSet)(e.granter) && (n.granter = String(e.granter)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.amount ? n.amount = e.amount.map((t) => t ? s.Coin.toJSON(t) : void 0) : n.amount = [], e.gasLimit !== void 0 && (n.gasLimit = (e.gasLimit || BigInt(0)).toString()), e.payer !== void 0 && (n.payer = e.payer), e.granter !== void 0 && (n.granter = e.granter), n;
+      },
+      fromPartial(e) {
+        var t;
+        const n = w();
+        return n.amount = ((t = e.amount) == null ? void 0 : t.map((m) => s.Coin.fromPartial(m))) || [], e.gasLimit !== void 0 && e.gasLimit !== null && (n.gasLimit = BigInt(e.gasLimit.toString())), n.payer = e.payer ?? "", n.granter = e.granter ?? "", n;
+      }
+    };
+    function O() {
+      return {
+        amount: [],
+        tipper: ""
+      };
+    }
+    i.Tip = {
+      typeUrl: "/cosmos.tx.v1beta1.Tip",
+      encode(e, n = o.BinaryWriter.create()) {
+        for (const t of e.amount)
+          s.Coin.encode(t, n.uint32(10).fork()).ldelim();
+        return e.tipper !== "" && n.uint32(18).string(e.tipper), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = O();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.amount.push(s.Coin.decode(t, t.uint32()));
+              break;
+            case 2:
+              h.tipper = t.string();
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = O();
+        return Array.isArray(e == null ? void 0 : e.amount) && (n.amount = e.amount.map((t) => s.Coin.fromJSON(t))), (0, a.isSet)(e.tipper) && (n.tipper = String(e.tipper)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.amount ? n.amount = e.amount.map((t) => t ? s.Coin.toJSON(t) : void 0) : n.amount = [], e.tipper !== void 0 && (n.tipper = e.tipper), n;
+      },
+      fromPartial(e) {
+        var t;
+        const n = O();
+        return n.amount = ((t = e.amount) == null ? void 0 : t.map((m) => s.Coin.fromPartial(m))) || [], n.tipper = e.tipper ?? "", n;
+      }
+    };
+    function D() {
+      return {
+        address: "",
+        signDoc: void 0,
+        mode: 0,
+        sig: new Uint8Array()
+      };
+    }
+    i.AuxSignerData = {
+      typeUrl: "/cosmos.tx.v1beta1.AuxSignerData",
+      encode(e, n = o.BinaryWriter.create()) {
+        return e.address !== "" && n.uint32(10).string(e.address), e.signDoc !== void 0 && i.SignDocDirectAux.encode(e.signDoc, n.uint32(18).fork()).ldelim(), e.mode !== 0 && n.uint32(24).int32(e.mode), e.sig.length !== 0 && n.uint32(34).bytes(e.sig), n;
+      },
+      decode(e, n) {
+        const t = e instanceof o.BinaryReader ? e : new o.BinaryReader(e);
+        let m = n === void 0 ? t.len : t.pos + n;
+        const h = D();
+        for (; t.pos < m; ) {
+          const B = t.uint32();
+          switch (B >>> 3) {
+            case 1:
+              h.address = t.string();
+              break;
+            case 2:
+              h.signDoc = i.SignDocDirectAux.decode(t, t.uint32());
+              break;
+            case 3:
+              h.mode = t.int32();
+              break;
+            case 4:
+              h.sig = t.bytes();
+              break;
+            default:
+              t.skipType(B & 7);
+              break;
+          }
+        }
+        return h;
+      },
+      fromJSON(e) {
+        const n = D();
+        return (0, a.isSet)(e.address) && (n.address = String(e.address)), (0, a.isSet)(e.signDoc) && (n.signDoc = i.SignDocDirectAux.fromJSON(e.signDoc)), (0, a.isSet)(e.mode) && (n.mode = (0, c.signModeFromJSON)(e.mode)), (0, a.isSet)(e.sig) && (n.sig = (0, a.bytesFromBase64)(e.sig)), n;
+      },
+      toJSON(e) {
+        const n = {};
+        return e.address !== void 0 && (n.address = e.address), e.signDoc !== void 0 && (n.signDoc = e.signDoc ? i.SignDocDirectAux.toJSON(e.signDoc) : void 0), e.mode !== void 0 && (n.mode = (0, c.signModeToJSON)(e.mode)), e.sig !== void 0 && (n.sig = (0, a.base64FromBytes)(e.sig !== void 0 ? e.sig : new Uint8Array())), n;
+      },
+      fromPartial(e) {
+        const n = D();
+        return n.address = e.address ?? "", e.signDoc !== void 0 && e.signDoc !== null && (n.signDoc = i.SignDocDirectAux.fromPartial(e.signDoc)), n.mode = e.mode ?? 0, n.sig = e.sig ?? new Uint8Array(), n;
+      }
+    };
+  }(X)), X;
+}
+var q = nn();
+const tn = async (i) => {
+  var l, I, u, y, S, p, w, O, D, e, n, t, m;
+  const r = Me.find((h) => h.chain_id === i);
+  if (!r)
+    throw new Error(`Chain info not found for chainId: ${i}`);
+  const { bech32_prefix: c, chain_id: d } = r, s = (u = (I = (l = r.staking) == null ? void 0 : l.staking_tokens) == null ? void 0 : I[0]) == null ? void 0 : u.denom, o = (p = (S = (y = r.apis) == null ? void 0 : y.rpc) == null ? void 0 : S[0]) == null ? void 0 : p.address, a = (D = (O = (w = r.apis) == null ? void 0 : w.rest) == null ? void 0 : O[0]) == null ? void 0 : D.address, f = (t = (n = (e = r.fees) == null ? void 0 : e.fee_tokens) == null ? void 0 : n[0]) == null ? void 0 : t.average_gas_price;
+  if (!c || !s || !o || !a || !d || f === void 0)
+    throw new Error(
+      `Missing required chain information for ${r.chain_name}`
+    );
+  const g = Je.find(
+    (h) => h.chain_name === r.chain_name
+  ), _ = g == null ? void 0 : g.assets.find((h) => h.base === s), b = (m = _ == null ? void 0 : _.denom_units.find(
+    (h) => h.denom === _.display
+  )) == null ? void 0 : m.exponent;
+  if (b === void 0)
+    throw new Error(
+      `Could not find decimals for ${s} on chain ${r.chain_name}`
+    );
+  return { prefix: c, denom: s, rpcUrl: o, restUrl: a, expectedChainId: d, gasPrice: f, decimals: b };
+};
+class rn extends Q {
+  /**
+   * Creates a new Cosmos chain instance
+   * @param params - Configuration parameters
+   * @param params.chainId - Chain id for the Cosmos network
+   * @param params.contract - Instance of the chain signature contract for MPC operations
+   * @param params.endpoints - Optional RPC and REST endpoints
+   * @param params.endpoints.rpcUrl - Optional RPC endpoint URL
+   * @param params.endpoints.restUrl - Optional REST endpoint URL
+   */
+  constructor({
+    chainId: r,
+    contract: c,
+    endpoints: d
+  }) {
+    super(), this.contract = c, this.registry = new De(), this.chainId = r, this.endpoints = d;
+  }
+  parseRSVSignature(r) {
+    return new Uint8Array([
+      ...K(r.r),
+      ...K(r.s)
+    ]);
+  }
+  async getChainInfo() {
+    return {
+      ...await tn(this.chainId),
+      ...this.endpoints
+    };
+  }
+  async getBalance(r) {
+    try {
+      const { restUrl: c, denom: d, decimals: s } = await this.getChainInfo(), o = await fetch(
+        `${c}/cosmos/bank/v1beta1/balances/${r}`
+      );
+      if (!o.ok)
+        throw new Error(`HTTP error! status: ${o.status}`);
+      const f = (await o.json()).balances.find((b) => b.denom === d), g = (f == null ? void 0 : f.amount) ?? "0";
+      return (parseInt(g) / Math.pow(10, s)).toString();
+    } catch (c) {
+      throw console.error("Failed to fetch Cosmos balance:", c), new Error("Failed to fetch Cosmos balance");
+    }
+  }
+  async deriveAddressAndPublicKey(r, c) {
+    const { prefix: d } = await this.getChainInfo(), s = await this.contract.getDerivedPublicKey({
+      path: c,
+      predecessor: r
+    });
+    if (!s)
+      throw new Error("Failed to get derived public key");
+    const o = ge(s), a = ee(K(o)), f = Ae(a);
+    return { address: te.encode(d, te.toWords(f)), publicKey: o };
+  }
+  setTransaction(r, c) {
+    const d = q.TxRaw.encode(r).finish();
+    window.localStorage.setItem(c, we(d));
+  }
+  getTransaction(r, c) {
+    const d = window.localStorage.getItem(r);
+    if (d)
+      return c != null && c.remove && window.localStorage.removeItem(r), q.TxRaw.decode(_e(d));
+  }
+  async getMPCPayloadAndTransaction(r) {
+    const { denom: c, rpcUrl: d, gasPrice: s } = await this.getChainInfo(), o = K(r.publicKey), a = r.gas || 2e5, f = Ce(
+      a,
+      xe.fromString(`${s}${c}`)
+    ), _ = await (await ne.connect(d)).getAccount(r.address);
+    if (!_)
+      throw new Error(
+        `Account ${r.address} does not exist on chain`
+      );
+    const { accountNumber: b, sequence: l } = _, I = {
+      typeUrl: "/cosmos.tx.v1beta1.TxBody",
+      value: {
+        messages: r.messages,
+        memo: r.memo || ""
+      }
+    }, u = this.registry.encode(I), y = Te(Ne(o)), S = ve(
+      [
+        {
+          pubkey: y,
+          sequence: l
+        }
+      ],
+      f.amount,
+      Number(f.gas),
+      void 0,
+      void 0,
+      je.SignMode.SIGN_MODE_DIRECT
+    ), p = Pe(
+      u,
+      S,
+      this.chainId,
+      b
+    ), w = Ee(p), O = Array.from(ee(w));
+    return {
+      transaction: q.TxRaw.fromPartial({
+        bodyBytes: u,
+        authInfoBytes: S,
+        signatures: []
+      }),
+      mpcPayloads: [
+        {
+          index: 0,
+          payload: O
+        }
+      ]
+    };
+  }
+  addSignature({
+    transaction: r,
+    mpcSignatures: c
+  }) {
+    r.signatures = c.map(
+      (s) => this.parseRSVSignature(s)
+    );
+    const d = q.TxRaw.encode(r).finish();
+    return Buffer.from(d).toString("hex");
+  }
+  async broadcastTx(r) {
+    try {
+      const { rpcUrl: c } = await this.getChainInfo(), d = await ne.connect(c), s = K(r), o = await d.broadcastTx(s);
+      if (o.code !== 0)
+        throw new Error(`Broadcast error: ${o.rawLog}`);
+      return o.transactionHash;
+    } catch (c) {
+      throw console.error("Transaction broadcast failed:", c), new Error("Failed to broadcast transaction.");
+    }
+  }
+}
+var Z = {}, he;
+function an() {
+  return he || (he = 1, function(i) {
+    Object.defineProperty(i, "__esModule", { value: !0 }), i.base_decode = i.base_encode = i.deserialize = i.serialize = void 0;
+    var r = Ge;
+    Object.defineProperty(i, "serialize", { enumerable: !0, get: function() {
+      return r.serialize;
+    } }), Object.defineProperty(i, "deserialize", { enumerable: !0, get: function() {
+      return r.deserialize;
+    } });
+    var c = He;
+    Object.defineProperty(i, "base_encode", { enumerable: !0, get: function() {
+      return c.baseEncode;
+    } }), Object.defineProperty(i, "base_decode", { enumerable: !0, get: function() {
+      return c.baseDecode;
+    } });
+  }(Z)), Z;
+}
+var on = an();
+const z = new $("300000000000000"), j = "dontcare", W = async ({
+  networkId: i,
+  accountId: r = j,
+  keypair: c = me.fromRandom("ed25519")
+}) => {
+  const d = new Le();
+  await d.setKey(i, r, c);
+  const s = Ue.fromConfig({
+    networkId: i,
+    provider: {
+      type: "JsonRpcProvider",
+      args: {
+        url: {
+          testnet: "https://rpc.testnet.near.org",
+          mainnet: "https://rpc.mainnet.near.org"
+        }[i]
+      }
+    },
+    signer: { type: "InMemorySigner", keyStore: d }
+  });
+  return new Re(s, r);
+};
+function sn(i) {
+  return {
+    delegate_action: {
+      actions: i.delegateAction.actions.map((r) => {
+        if (r.functionCall)
+          return {
+            FunctionCall: {
+              method_name: r.functionCall.methodName,
+              args: Buffer.from(r.functionCall.args).toString("base64"),
+              gas: Number(r.functionCall.gas),
+              deposit: r.functionCall.deposit.toString()
+            }
+          };
+      }).flatMap((r) => r ? [r] : []),
+      nonce: Number(i.delegateAction.nonce),
+      max_block_height: Number(i.delegateAction.maxBlockHeight),
+      public_key: i.delegateAction.publicKey.toString(),
+      receiver_id: i.delegateAction.receiverId,
+      sender_id: i.delegateAction.senderId
+    },
+    signature: `ed25519:${qe.encode(i.signature.data)}`
+  };
+}
+const un = (i) => `04${Buffer.from(on.base_decode(i.split(":")[1])).toString("hex")}`, dn = (i) => {
+  if (i === j)
+    throw new Error(
+      "A valid account ID and keypair are required for change methods. Please instantiate a new contract with valid credentials."
+    );
+};
+class G extends ze {
+  constructor({
+    networkId: r,
+    contractId: c,
+    accountId: d = j,
+    keypair: s = me.fromRandom("ed25519")
+  }) {
+    super(), this.networkId = r, this.contractId = c, this.accountId = d, this.keypair = s;
+  }
+  async getContract() {
+    const r = await W({
+      networkId: this.networkId,
+      accountId: this.accountId,
+      keypair: this.keypair
+    });
+    return new Fe(r, this.contractId, {
+      viewMethods: [
+        "public_key",
+        "experimental_signature_deposit",
+        "derived_public_key"
+      ],
+      changeMethods: ["sign"],
+      useLocalViewExecution: !1
+    });
+  }
+  async getCurrentSignatureDeposit() {
+    const r = await this.getContract();
+    return new $(
+      (await r.experimental_signature_deposit()).toLocaleString(
+        "fullwide",
+        {
+          useGrouping: !1
+        }
+      )
+    );
+  }
+  async getDerivedPublicKey(r) {
+    const d = await (await this.getContract()).derived_public_key(r);
+    return un(d);
+  }
+  async sign(r) {
+    dn(this.accountId);
+    const c = await this.getContract(), d = await this.getCurrentSignatureDeposit(), s = await c.sign({
+      args: { request: r },
+      gas: z,
+      amount: d
+    });
+    return pe(s);
+  }
+  static async signWithRelayer({
+    account: r,
+    contract: c,
+    signArgs: d,
+    deposit: s,
+    relayerUrl: o
+  }) {
+    const a = Ke.functionCall(
+      "sign",
+      { request: d },
+      BigInt(z.toString()),
+      BigInt(s.toString())
+    ), f = await r.signedDelegate({
+      receiverId: c,
+      actions: [a],
+      blockHeightTtl: 60
+    });
+    delete r.accessKeyByPublicKeyCache[
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      f.delegateAction.publicKey.toString()
+    ];
+    const _ = await (await fetch(`${o}/send_meta_tx_async`, {
+      method: "POST",
+      mode: "cors",
+      body: JSON.stringify(sn(f)),
+      headers: new Headers({ "Content-Type": "application/json" })
+    })).text(), b = await r.connection.provider.txStatus(
+      _,
+      r.accountId,
+      "FINAL"
+    ), l = Be({
+      response: b
+    });
+    if (!l)
+      throw new Error("Signature error, please retry");
+    return l;
+  }
+}
+const cn = async ({
+  networkId: i,
+  contractId: r,
+  mpcPayloads: c,
+  path: d
+}) => {
+  const o = await new G({
+    networkId: i,
+    contractId: r
+  }).getCurrentSignatureDeposit();
+  return {
+    receiverId: r,
+    actions: c.map(({ payload: a }) => ({
+      type: "FunctionCall",
+      params: {
+        methodName: "sign",
+        args: {
+          request: {
+            payload: Array.from(a),
+            path: d,
+            key_version: 0
+          }
+        },
+        gas: z.div(new $(c.length)).toString(),
+        deposit: (o == null ? void 0 : o.toString()) || "1"
+      }
+    }))
+  };
+}, fn = async ({
+  networkId: i,
+  chainSigContract: r,
+  nftKeysContract: c,
+  mpcPayloads: d,
+  path: s,
+  tokenId: o
+}) => {
+  const f = await new G({
+    networkId: i,
+    contractId: r
+  }).getCurrentSignatureDeposit();
+  return {
+    receiverId: c,
+    actions: d.map(({ payload: g }) => ({
+      type: "FunctionCall",
+      params: {
+        methodName: "ckt_sign_hash",
+        args: {
+          token_id: o,
+          path: s,
+          payload: Array.from(g)
+        },
+        gas: z.div(new $(d.length)).toString(),
+        deposit: (f == null ? void 0 : f.toString()) || "1"
+      }
+    }))
+  };
+}, Be = ({
+  response: i
+}) => {
+  const r = i.receipts_outcome.reduce(
+    (c, d) => {
+      if (c)
+        return c;
+      const { status: s } = d.outcome;
+      return typeof s == "object" && s.SuccessValue && s.SuccessValue !== "" && Buffer.from(s.SuccessValue, "base64").toString("utf-8") || "";
+    },
+    ""
+  );
+  if (r) {
+    const c = JSON.parse(r);
+    return pe(c.Ok);
+  } else
+    return;
+}, ln = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  mpcPayloadsToChainSigTransaction: cn,
+  mpcPayloadsToNFTKeysTransaction: fn,
+  responseToMpcSignature: Be
+}, Symbol.toStringTag, { value: "Module" })), yn = async (i, r) => {
+  try {
+    const c = await W({
+      networkId: i.nearAuthentication.networkId,
+      accountId: i.nearAuthentication.accountId,
+      keypair: r
+    }), d = new G({
+      networkId: i.nearAuthentication.networkId,
+      contractId: i.chainConfig.contract,
+      accountId: c.accountId,
+      keypair: r
+    }), s = new We({
+      rpcUrl: i.chainConfig.providerUrl,
+      contract: d
+    }), { transaction: o, mpcPayloads: a } = await s.getMPCPayloadAndTransaction(
+      i.transaction
+    ), f = await d.sign({
+      payload: a[0].payload,
+      path: i.derivationPath,
+      key_version: 0
+    }), g = s.addSignature({
+      transaction: o,
+      mpcSignatures: [f]
+    });
+    return {
+      transactionHash: await s.broadcastTx(g),
+      success: !0
+    };
+  } catch (c) {
+    return console.error(c), {
+      success: !1,
+      errorMessage: c instanceof Error ? c.message : String(c)
+    };
+  }
+}, hn = async (i, r) => {
+  try {
+    const c = await W({
+      networkId: i.nearAuthentication.networkId,
+      accountId: i.nearAuthentication.accountId,
+      keypair: r
+    }), d = new G({
+      networkId: i.nearAuthentication.networkId,
+      contractId: i.chainConfig.contract,
+      accountId: c.accountId,
+      keypair: r
+    }), s = new Y({
+      btcRpcAdapter: new Ze.Mempool(i.chainConfig.providerUrl),
+      contract: d,
+      network: i.chainConfig.network
+    }), { transaction: o, mpcPayloads: a } = await s.getMPCPayloadAndTransaction(
+      i.transaction
+    ), f = await Promise.all(
+      a.map(
+        async ({ payload: b }) => await d.sign({
+          payload: b,
+          path: i.derivationPath,
+          key_version: 0
+        })
+      )
+    ), g = s.addSignature({
+      transaction: o,
+      mpcSignatures: f
+    });
+    return {
+      transactionHash: await s.broadcastTx(g),
+      success: !0
+    };
+  } catch (c) {
+    return {
+      success: !1,
+      errorMessage: c instanceof Error ? c.message : String(c)
+    };
+  }
+}, mn = async (i, r) => {
+  try {
+    const c = await W({
+      networkId: i.nearAuthentication.networkId,
+      accountId: i.nearAuthentication.accountId,
+      keypair: r
+    }), d = new G({
+      networkId: i.nearAuthentication.networkId,
+      contractId: i.chainConfig.contract,
+      accountId: c.accountId,
+      keypair: r
+    }), s = new rn({
+      contract: d,
+      chainId: i.chainConfig.chainId
+    }), { transaction: o, mpcPayloads: a } = await s.getMPCPayloadAndTransaction(i.transaction), f = await Promise.all(
+      a.map(
+        async ({ payload: b }) => await d.sign({
+          payload: b,
+          path: i.derivationPath,
+          key_version: 0
+        })
+      )
+    ), g = s.addSignature({
+      transaction: o,
+      mpcSignatures: f
+    });
+    return {
+      transactionHash: await s.broadcastTx(g),
+      success: !0
+    };
+  } catch (c) {
+    return console.error(c), {
+      success: !1,
+      errorMessage: c instanceof Error ? c.message : String(c)
+    };
+  }
+}, pn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BTCTransaction: hn,
+  CosmosTransaction: mn,
+  EVMTransaction: yn
+}, Symbol.toStringTag, { value: "Module" })), gn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  keypair: pn
+}, Symbol.toStringTag, { value: "Module" })), Sn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ChainSignatureContract: G,
+  signAndSend: gn,
+  transactionBuilder: ln
+}, Symbol.toStringTag, { value: "Module" })), In = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  near: Sn
+}, Symbol.toStringTag, { value: "Module" })), Rn = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  chains: In
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  Ve as BTCRpcAdapter,
+  Ze as BTCRpcAdapters,
+  Y as Bitcoin,
+  Q as Chain,
+  ze as ChainSignatureContract,
+  rn as Cosmos,
+  We as EVM,
+  $e as fetchEVMFeeProperties,
+  Rn as utils
+};
+//# sourceMappingURL=index.js.map