@ledgerhq/live-cli 24.21.3-nightly.8 → 24.21.3-nightly.9

package/lib/cli.js

@@ -516720,7 +516720,7 @@ var require_package7 = __commonJS({
     module2.exports = {
       name: "@ledgerhq/live-common",
       description: "Common ground for the Ledger Live apps",
-      version: "34.47.0-nightly.8",
+      version: "34.47.0-nightly.9",
       repository: {
         type: "git",
         url: "https://github.com/LedgerHQ/ledger-live.git"
@@ -517108,6 +517108,526 @@ var require_testecc = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/@scure+base@1.2.6/node_modules/@scure/base/lib/index.js
+var require_lib67 = __commonJS({
+  "../../node_modules/.pnpm/@scure+base@1.2.6/node_modules/@scure/base/lib/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.bytes = exports2.stringToBytes = exports2.str = exports2.bytesToString = exports2.hex = exports2.utf8 = exports2.bech32m = exports2.bech32 = exports2.base58check = exports2.createBase58check = exports2.base58xmr = exports2.base58xrp = exports2.base58flickr = exports2.base58 = exports2.base64urlnopad = exports2.base64url = exports2.base64nopad = exports2.base64 = exports2.base32crockford = exports2.base32hexnopad = exports2.base32hex = exports2.base32nopad = exports2.base32 = exports2.base16 = exports2.utils = void 0;
+    function isBytes6(a63) {
+      return a63 instanceof Uint8Array || ArrayBuffer.isView(a63) && a63.constructor.name === "Uint8Array";
+    }
+    function abytes2(b18, ...lengths) {
+      if (!isBytes6(b18))
+        throw new Error("Uint8Array expected");
+      if (lengths.length > 0 && !lengths.includes(b18.length))
+        throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b18.length);
+    }
+    function isArrayOf2(isString6, arr) {
+      if (!Array.isArray(arr))
+        return false;
+      if (arr.length === 0)
+        return true;
+      if (isString6) {
+        return arr.every((item) => typeof item === "string");
+      } else {
+        return arr.every((item) => Number.isSafeInteger(item));
+      }
+    }
+    function afn2(input) {
+      if (typeof input !== "function")
+        throw new Error("function expected");
+      return true;
+    }
+    function astr2(label, input) {
+      if (typeof input !== "string")
+        throw new Error(`${label}: string expected`);
+      return true;
+    }
+    function anumber3(n113) {
+      if (!Number.isSafeInteger(n113))
+        throw new Error(`invalid integer: ${n113}`);
+    }
+    function aArr2(input) {
+      if (!Array.isArray(input))
+        throw new Error("array expected");
+    }
+    function astrArr2(label, input) {
+      if (!isArrayOf2(true, input))
+        throw new Error(`${label}: array of strings expected`);
+    }
+    function anumArr2(label, input) {
+      if (!isArrayOf2(false, input))
+        throw new Error(`${label}: array of numbers expected`);
+    }
+    // @__NO_SIDE_EFFECTS__
+    function chain5(...args3) {
+      const id6 = (a63) => a63;
+      const wrap4 = (a63, b18) => (c56) => a63(b18(c56));
+      const encode26 = args3.map((x20) => x20.encode).reduceRight(wrap4, id6);
+      const decode29 = args3.map((x20) => x20.decode).reduce(wrap4, id6);
+      return { encode: encode26, decode: decode29 };
+    }
+    // @__NO_SIDE_EFFECTS__
+    function alphabet4(letters) {
+      const lettersA = typeof letters === "string" ? letters.split("") : letters;
+      const len = lettersA.length;
+      astrArr2("alphabet", lettersA);
+      const indexes3 = new Map(lettersA.map((l66, i56) => [l66, i56]));
+      return {
+        encode: (digits) => {
+          aArr2(digits);
+          return digits.map((i56) => {
+            if (!Number.isSafeInteger(i56) || i56 < 0 || i56 >= len)
+              throw new Error(`alphabet.encode: digit index outside alphabet "${i56}". Allowed: ${letters}`);
+            return lettersA[i56];
+          });
+        },
+        decode: (input) => {
+          aArr2(input);
+          return input.map((letter) => {
+            astr2("alphabet.decode", letter);
+            const i56 = indexes3.get(letter);
+            if (i56 === void 0)
+              throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+            return i56;
+          });
+        }
+      };
+    }
+    // @__NO_SIDE_EFFECTS__
+    function join4(separator = "") {
+      astr2("join", separator);
+      return {
+        encode: (from91) => {
+          astrArr2("join.decode", from91);
+          return from91.join(separator);
+        },
+        decode: (to) => {
+          astr2("join.decode", to);
+          return to.split(separator);
+        }
+      };
+    }
+    // @__NO_SIDE_EFFECTS__
+    function padding3(bits2, chr = "=") {
+      anumber3(bits2);
+      astr2("padding", chr);
+      return {
+        encode(data9) {
+          astrArr2("padding.encode", data9);
+          while (data9.length * bits2 % 8)
+            data9.push(chr);
+          return data9;
+        },
+        decode(input) {
+          astrArr2("padding.decode", input);
+          let end = input.length;
+          if (end * bits2 % 8)
+            throw new Error("padding: invalid, string should have whole number of bytes");
+          for (; end > 0 && input[end - 1] === chr; end--) {
+            const last = end - 1;
+            const byte = last * bits2;
+            if (byte % 8 === 0)
+              throw new Error("padding: invalid, string has too much padding");
+          }
+          return input.slice(0, end);
+        }
+      };
+    }
+    // @__NO_SIDE_EFFECTS__
+    function normalize4(fn3) {
+      afn2(fn3);
+      return { encode: (from91) => from91, decode: (to) => fn3(to) };
+    }
+    function convertRadix4(data9, from91, to) {
+      if (from91 < 2)
+        throw new Error(`convertRadix: invalid from=${from91}, base cannot be less than 2`);
+      if (to < 2)
+        throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+      aArr2(data9);
+      if (!data9.length)
+        return [];
+      let pos = 0;
+      const res = [];
+      const digits = Array.from(data9, (d54) => {
+        anumber3(d54);
+        if (d54 < 0 || d54 >= from91)
+          throw new Error(`invalid integer: ${d54}`);
+        return d54;
+      });
+      const dlen = digits.length;
+      while (true) {
+        let carry = 0;
+        let done = true;
+        for (let i56 = pos; i56 < dlen; i56++) {
+          const digit = digits[i56];
+          const fromCarry = from91 * carry;
+          const digitBase = fromCarry + digit;
+          if (!Number.isSafeInteger(digitBase) || fromCarry / from91 !== carry || digitBase - digit !== fromCarry) {
+            throw new Error("convertRadix: carry overflow");
+          }
+          const div = digitBase / to;
+          carry = digitBase % to;
+          const rounded = Math.floor(div);
+          digits[i56] = rounded;
+          if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+            throw new Error("convertRadix: carry overflow");
+          if (!done)
+            continue;
+          else if (!rounded)
+            pos = i56;
+          else
+            done = false;
+        }
+        res.push(carry);
+        if (done)
+          break;
+      }
+      for (let i56 = 0; i56 < data9.length - 1 && data9[i56] === 0; i56++)
+        res.push(0);
+      return res.reverse();
+    }
+    var gcd = (a63, b18) => b18 === 0 ? a63 : gcd(b18, a63 % b18);
+    var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from91, to) => from91 + (to - gcd(from91, to));
+    var powers = /* @__PURE__ */ (() => {
+      let res = [];
+      for (let i56 = 0; i56 < 40; i56++)
+        res.push(2 ** i56);
+      return res;
+    })();
+    function convertRadix22(data9, from91, to, padding4) {
+      aArr2(data9);
+      if (from91 <= 0 || from91 > 32)
+        throw new Error(`convertRadix2: wrong from=${from91}`);
+      if (to <= 0 || to > 32)
+        throw new Error(`convertRadix2: wrong to=${to}`);
+      if (/* @__PURE__ */ radix2carry(from91, to) > 32) {
+        throw new Error(`convertRadix2: carry overflow from=${from91} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from91, to)}`);
+      }
+      let carry = 0;
+      let pos = 0;
+      const max2 = powers[from91];
+      const mask5 = powers[to] - 1;
+      const res = [];
+      for (const n113 of data9) {
+        anumber3(n113);
+        if (n113 >= max2)
+          throw new Error(`convertRadix2: invalid data word=${n113} from=${from91}`);
+        carry = carry << from91 | n113;
+        if (pos + from91 > 32)
+          throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from91}`);
+        pos += from91;
+        for (; pos >= to; pos -= to)
+          res.push((carry >> pos - to & mask5) >>> 0);
+        const pow3 = powers[pos];
+        if (pow3 === void 0)
+          throw new Error("invalid carry");
+        carry &= pow3 - 1;
+      }
+      carry = carry << to - pos & mask5;
+      if (!padding4 && pos >= from91)
+        throw new Error("Excess padding");
+      if (!padding4 && carry > 0)
+        throw new Error(`Non-zero padding: ${carry}`);
+      if (padding4 && pos > 0)
+        res.push(carry >>> 0);
+      return res;
+    }
+    // @__NO_SIDE_EFFECTS__
+    function radix3(num) {
+      anumber3(num);
+      const _256 = 2 ** 8;
+      return {
+        encode: (bytes5) => {
+          if (!isBytes6(bytes5))
+            throw new Error("radix.encode input should be Uint8Array");
+          return convertRadix4(Array.from(bytes5), _256, num);
+        },
+        decode: (digits) => {
+          anumArr2("radix.decode", digits);
+          return Uint8Array.from(convertRadix4(digits, num, _256));
+        }
+      };
+    }
+    // @__NO_SIDE_EFFECTS__
+    function radix22(bits2, revPadding = false) {
+      anumber3(bits2);
+      if (bits2 <= 0 || bits2 > 32)
+        throw new Error("radix2: bits should be in (0..32]");
+      if (/* @__PURE__ */ radix2carry(8, bits2) > 32 || /* @__PURE__ */ radix2carry(bits2, 8) > 32)
+        throw new Error("radix2: carry overflow");
+      return {
+        encode: (bytes5) => {
+          if (!isBytes6(bytes5))
+            throw new Error("radix2.encode input should be Uint8Array");
+          return convertRadix22(Array.from(bytes5), 8, bits2, !revPadding);
+        },
+        decode: (digits) => {
+          anumArr2("radix2.decode", digits);
+          return Uint8Array.from(convertRadix22(digits, bits2, 8, revPadding));
+        }
+      };
+    }
+    function unsafeWrapper(fn3) {
+      afn2(fn3);
+      return function(...args3) {
+        try {
+          return fn3.apply(null, args3);
+        } catch (e36) {
+        }
+      };
+    }
+    function checksum14(len, fn3) {
+      anumber3(len);
+      afn2(fn3);
+      return {
+        encode(data9) {
+          if (!isBytes6(data9))
+            throw new Error("checksum.encode: input should be Uint8Array");
+          const sum2 = fn3(data9).slice(0, len);
+          const res = new Uint8Array(data9.length + len);
+          res.set(data9);
+          res.set(sum2, data9.length);
+          return res;
+        },
+        decode(data9) {
+          if (!isBytes6(data9))
+            throw new Error("checksum.decode: input should be Uint8Array");
+          const payload = data9.slice(0, -len);
+          const oldChecksum = data9.slice(-len);
+          const newChecksum = fn3(payload).slice(0, len);
+          for (let i56 = 0; i56 < len; i56++)
+            if (newChecksum[i56] !== oldChecksum[i56])
+              throw new Error("Invalid checksum");
+          return payload;
+        }
+      };
+    }
+    exports2.utils = {
+      alphabet: alphabet4,
+      chain: chain5,
+      checksum: checksum14,
+      convertRadix: convertRadix4,
+      convertRadix2: convertRadix22,
+      radix: radix3,
+      radix2: radix22,
+      join: join4,
+      padding: padding3
+    };
+    exports2.base16 = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(4), /* @__PURE__ */ alphabet4("0123456789ABCDEF"), /* @__PURE__ */ join4(""));
+    exports2.base32 = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(5), /* @__PURE__ */ alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), /* @__PURE__ */ padding3(5), /* @__PURE__ */ join4(""));
+    exports2.base32nopad = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(5), /* @__PURE__ */ alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), /* @__PURE__ */ join4(""));
+    exports2.base32hex = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(5), /* @__PURE__ */ alphabet4("0123456789ABCDEFGHIJKLMNOPQRSTUV"), /* @__PURE__ */ padding3(5), /* @__PURE__ */ join4(""));
+    exports2.base32hexnopad = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(5), /* @__PURE__ */ alphabet4("0123456789ABCDEFGHIJKLMNOPQRSTUV"), /* @__PURE__ */ join4(""));
+    exports2.base32crockford = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(5), /* @__PURE__ */ alphabet4("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), /* @__PURE__ */ join4(""), /* @__PURE__ */ normalize4((s48) => s48.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
+    var hasBase64Builtin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function")();
+    var decodeBase64Builtin = (s48, isUrl) => {
+      astr2("base64", s48);
+      const re3 = isUrl ? /^[A-Za-z0-9=_-]+$/ : /^[A-Za-z0-9=+/]+$/;
+      const alphabet5 = isUrl ? "base64url" : "base64";
+      if (s48.length > 0 && !re3.test(s48))
+        throw new Error("invalid base64");
+      return Uint8Array.fromBase64(s48, { alphabet: alphabet5, lastChunkHandling: "strict" });
+    };
+    exports2.base64 = hasBase64Builtin ? {
+      encode(b18) {
+        abytes2(b18);
+        return b18.toBase64();
+      },
+      decode(s48) {
+        return decodeBase64Builtin(s48, false);
+      }
+    } : /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(6), /* @__PURE__ */ alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ padding3(6), /* @__PURE__ */ join4(""));
+    exports2.base64nopad = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(6), /* @__PURE__ */ alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), /* @__PURE__ */ join4(""));
+    exports2.base64url = hasBase64Builtin ? {
+      encode(b18) {
+        abytes2(b18);
+        return b18.toBase64({ alphabet: "base64url" });
+      },
+      decode(s48) {
+        return decodeBase64Builtin(s48, true);
+      }
+    } : /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(6), /* @__PURE__ */ alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), /* @__PURE__ */ padding3(6), /* @__PURE__ */ join4(""));
+    exports2.base64urlnopad = /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(6), /* @__PURE__ */ alphabet4("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), /* @__PURE__ */ join4(""));
+    var genBase583 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain5(/* @__PURE__ */ radix3(58), /* @__PURE__ */ alphabet4(abc), /* @__PURE__ */ join4(""));
+    exports2.base58 = /* @__PURE__ */ genBase583("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+    exports2.base58flickr = /* @__PURE__ */ genBase583("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
+    exports2.base58xrp = /* @__PURE__ */ genBase583("rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz");
+    var XMR_BLOCK_LEN = [0, 2, 3, 5, 6, 7, 9, 10, 11];
+    exports2.base58xmr = {
+      encode(data9) {
+        let res = "";
+        for (let i56 = 0; i56 < data9.length; i56 += 8) {
+          const block2 = data9.subarray(i56, i56 + 8);
+          res += exports2.base58.encode(block2).padStart(XMR_BLOCK_LEN[block2.length], "1");
+        }
+        return res;
+      },
+      decode(str) {
+        let res = [];
+        for (let i56 = 0; i56 < str.length; i56 += 11) {
+          const slice3 = str.slice(i56, i56 + 11);
+          const blockLen = XMR_BLOCK_LEN.indexOf(slice3.length);
+          const block2 = exports2.base58.decode(slice3);
+          for (let j7 = 0; j7 < block2.length - blockLen; j7++) {
+            if (block2[j7] !== 0)
+              throw new Error("base58xmr: wrong padding");
+          }
+          res = res.concat(Array.from(block2.slice(block2.length - blockLen)));
+        }
+        return Uint8Array.from(res);
+      }
+    };
+    var createBase58check2 = (sha25613) => /* @__PURE__ */ chain5(checksum14(4, (data9) => sha25613(sha25613(data9))), exports2.base58);
+    exports2.createBase58check = createBase58check2;
+    exports2.base58check = exports2.createBase58check;
+    var BECH_ALPHABET = /* @__PURE__ */ chain5(/* @__PURE__ */ alphabet4("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join4(""));
+    var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+    function bech32Polymod(pre) {
+      const b18 = pre >> 25;
+      let chk = (pre & 33554431) << 5;
+      for (let i56 = 0; i56 < POLYMOD_GENERATORS.length; i56++) {
+        if ((b18 >> i56 & 1) === 1)
+          chk ^= POLYMOD_GENERATORS[i56];
+      }
+      return chk;
+    }
+    function bechChecksum(prefix3, words13, encodingConst = 1) {
+      const len = prefix3.length;
+      let chk = 1;
+      for (let i56 = 0; i56 < len; i56++) {
+        const c56 = prefix3.charCodeAt(i56);
+        if (c56 < 33 || c56 > 126)
+          throw new Error(`Invalid prefix (${prefix3})`);
+        chk = bech32Polymod(chk) ^ c56 >> 5;
+      }
+      chk = bech32Polymod(chk);
+      for (let i56 = 0; i56 < len; i56++)
+        chk = bech32Polymod(chk) ^ prefix3.charCodeAt(i56) & 31;
+      for (let v31 of words13)
+        chk = bech32Polymod(chk) ^ v31;
+      for (let i56 = 0; i56 < 6; i56++)
+        chk = bech32Polymod(chk);
+      chk ^= encodingConst;
+      return BECH_ALPHABET.encode(convertRadix22([chk % powers[30]], 30, 5, false));
+    }
+    // @__NO_SIDE_EFFECTS__
+    function genBech32(encoding) {
+      const ENCODING_CONST2 = encoding === "bech32" ? 1 : 734539939;
+      const _words = /* @__PURE__ */ radix22(5);
+      const fromWords4 = _words.decode;
+      const toWords3 = _words.encode;
+      const fromWordsUnsafe2 = unsafeWrapper(fromWords4);
+      function encode26(prefix3, words13, limit = 90) {
+        astr2("bech32.encode prefix", prefix3);
+        if (isBytes6(words13))
+          words13 = Array.from(words13);
+        anumArr2("bech32.encode", words13);
+        const plen = prefix3.length;
+        if (plen === 0)
+          throw new TypeError(`Invalid prefix length ${plen}`);
+        const actualLength = plen + 7 + words13.length;
+        if (limit !== false && actualLength > limit)
+          throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+        const lowered = prefix3.toLowerCase();
+        const sum2 = bechChecksum(lowered, words13, ENCODING_CONST2);
+        return `${lowered}1${BECH_ALPHABET.encode(words13)}${sum2}`;
+      }
+      function decode29(str, limit = 90) {
+        astr2("bech32.decode input", str);
+        const slen = str.length;
+        if (slen < 8 || limit !== false && slen > limit)
+          throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
+        const lowered = str.toLowerCase();
+        if (str !== lowered && str !== str.toUpperCase())
+          throw new Error(`String must be lowercase or uppercase`);
+        const sepIndex = lowered.lastIndexOf("1");
+        if (sepIndex === 0 || sepIndex === -1)
+          throw new Error(`Letter "1" must be present between prefix and data only`);
+        const prefix3 = lowered.slice(0, sepIndex);
+        const data9 = lowered.slice(sepIndex + 1);
+        if (data9.length < 6)
+          throw new Error("Data must be at least 6 characters long");
+        const words13 = BECH_ALPHABET.decode(data9).slice(0, -6);
+        const sum2 = bechChecksum(prefix3, words13, ENCODING_CONST2);
+        if (!data9.endsWith(sum2))
+          throw new Error(`Invalid checksum in ${str}: expected "${sum2}"`);
+        return { prefix: prefix3, words: words13 };
+      }
+      const decodeUnsafe4 = unsafeWrapper(decode29);
+      function decodeToBytes(str) {
+        const { prefix: prefix3, words: words13 } = decode29(str, false);
+        return { prefix: prefix3, words: words13, bytes: fromWords4(words13) };
+      }
+      function encodeFromBytes(prefix3, bytes5) {
+        return encode26(prefix3, toWords3(bytes5));
+      }
+      return {
+        encode: encode26,
+        decode: decode29,
+        encodeFromBytes,
+        decodeToBytes,
+        decodeUnsafe: decodeUnsafe4,
+        fromWords: fromWords4,
+        fromWordsUnsafe: fromWordsUnsafe2,
+        toWords: toWords3
+      };
+    }
+    exports2.bech32 = /* @__PURE__ */ genBech32("bech32");
+    exports2.bech32m = /* @__PURE__ */ genBech32("bech32m");
+    exports2.utf8 = {
+      encode: (data9) => new TextDecoder().decode(data9),
+      decode: (str) => new TextEncoder().encode(str)
+    };
+    var hasHexBuiltin2 = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+    var hexBuiltin = {
+      encode(data9) {
+        abytes2(data9);
+        return data9.toHex();
+      },
+      decode(s48) {
+        astr2("hex", s48);
+        return Uint8Array.fromHex(s48);
+      }
+    };
+    exports2.hex = hasHexBuiltin2 ? hexBuiltin : /* @__PURE__ */ chain5(/* @__PURE__ */ radix22(4), /* @__PURE__ */ alphabet4("0123456789abcdef"), /* @__PURE__ */ join4(""), /* @__PURE__ */ normalize4((s48) => {
+      if (typeof s48 !== "string" || s48.length % 2 !== 0)
+        throw new TypeError(`hex.decode: expected string, got ${typeof s48} with length ${s48.length}`);
+      return s48.toLowerCase();
+    }));
+    var CODERS = {
+      utf8: exports2.utf8,
+      hex: exports2.hex,
+      base16: exports2.base16,
+      base32: exports2.base32,
+      base64: exports2.base64,
+      base64url: exports2.base64url,
+      base58: exports2.base58,
+      base58xmr: exports2.base58xmr
+    };
+    var coderTypeError = "Invalid encoding type. Available types: utf8, hex, base16, base32, base64, base64url, base58, base58xmr";
+    var bytesToString = (type4, bytes5) => {
+      if (typeof type4 !== "string" || !CODERS.hasOwnProperty(type4))
+        throw new TypeError(coderTypeError);
+      if (!isBytes6(bytes5))
+        throw new TypeError("bytesToString() expects Uint8Array");
+      return CODERS[type4].encode(bytes5);
+    };
+    exports2.bytesToString = bytesToString;
+    exports2.str = exports2.bytesToString;
+    var stringToBytes3 = (type4, str) => {
+      if (!CODERS.hasOwnProperty(type4))
+        throw new TypeError(coderTypeError);
+      if (typeof str !== "string")
+        throw new TypeError("stringToBytes() expects string");
+      return CODERS[type4].decode(str);
+    };
+    exports2.stringToBytes = stringToBytes3;
+    exports2.bytes = exports2.stringToBytes;
+  }
+});
+
 // ../../node_modules/.pnpm/bip32@4.0.0/node_modules/bip32/src/bip32.js
 var require_bip325 = __commonJS({
   "../../node_modules/.pnpm/bip32@4.0.0/node_modules/bip32/src/bip32.js"(exports2) {
@@ -517116,7 +517636,7 @@ var require_bip325 = __commonJS({
     exports2.BIP32Factory = void 0;
     var crypto35 = require_crypto7();
     var testecc_1 = require_testecc();
-    var base_1 = require_lib63();
+    var base_1 = require_lib67();
     var sha256_1 = require_sha2565();
     var typeforce = require_typeforce();
     var wif = require_wif();
@@ -517466,7 +517986,7 @@ var require_package8 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@ledgerhq/live-cli",
-      version: "24.21.3-nightly.8",
+      version: "24.21.3-nightly.9",
       description: "ledger-live CLI version",
       repository: {
         type: "git",
@@ -522154,6 +522674,16 @@ var envDefinitions = {
     def: "https://delegations-elrond.coin.ledger.com",
     desc: "MultiversX DELEGATION API url"
   },
+  API_KASPA_ENDPOINT: {
+    parser: stringParser,
+    def: "https://kaspa.coin.ledger.com",
+    desc: "Kaspa API url"
+  },
+  API_KASPA_TESTNET_ENDPOINT: {
+    parser: stringParser,
+    def: "https://kaspa.coin.ledger-test.com",
+    desc: "Kaspa testnet API url"
+  },
   API_STELLAR_HORIZON: {
     parser: stringParser,
     def: "https://stellar.coin.ledger.com",
@@ -778786,7 +779316,7 @@ var validateRecipient4 = (recipient) => {
   return Promise.resolve({ recipientError, recipientWarning });
 };
 
-// ../../node_modules/.pnpm/@taquito+http-utils@23.0.0-beta.1/node_modules/@taquito/http-utils/dist/taquito-http-utils.es6.js
+// ../../node_modules/.pnpm/@taquito+http-utils@23.0.0-beta.1_patch_hash=v4hkik3oiwaypgtnmqvg6j46di/node_modules/@taquito/http-utils/dist/taquito-http-utils.es6.js
 function __awaiter8(thisArg, _arguments, P21, generator) {
   function adopt(value5) {
     return value5 instanceof P21 ? value5 : new P21(function(resolve) {
@@ -778915,11 +779445,9 @@ var isNode4 = typeof process !== "undefined" && !!((_a4 = process === null || pr
 if (isNode4) {
   fetch11 = (init_lib12(), __toCommonJS(lib_exports5));
   if (Number(process.versions.node.split(".")[0]) >= 19) {
-    createAgent = (url4) => __awaiter8(void 0, void 0, void 0, function* () {
-      const { Agent: HttpsAgent } = yield import("https");
-      const { Agent: HttpAgent2 } = yield import("http");
-      return url4.startsWith("https") ? new HttpsAgent({ keepAlive: false }) : new HttpAgent2({ keepAlive: false });
-    });
+    createAgent = (url4) => {
+      return url4.startsWith("https") ? new require("https").Agent({ keepAlive: false }) : new require("http").Agent({ keepAlive: false });
+    };
   }
 }
 var HttpBackend = class {
@@ -852089,6 +852617,9 @@ fill-range/index.js:
    * Licensed under the MIT License.
    *)
 
+@scure/base/lib/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
 @scure/base/lib/esm/index.js:
   (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/live-cli",
-  "version": "24.21.3-nightly.8",
+  "version": "24.21.3-nightly.9",
   "description": "ledger-live CLI version",
   "repository": {
     "type": "git",