@meshsdk/wallet 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/index.js

@@ -21893,7 +21893,7 @@ var require_src = __commonJS({
       }).then((res) => Buffer.from(res));
     }
     exports.mnemonicToSeed = mnemonicToSeed;
-    function mnemonicToEntropy2(mnemonic, wordlist) {
+    function mnemonicToEntropy3(mnemonic, wordlist) {
       wordlist = wordlist || DEFAULT_WORDLIST;
       if (!wordlist) {
         throw new Error(WORDLIST_REQUIRED);
@@ -21929,7 +21929,7 @@ var require_src = __commonJS({
       }
       return entropy.toString("hex");
     }
-    exports.mnemonicToEntropy = mnemonicToEntropy2;
+    exports.mnemonicToEntropy = mnemonicToEntropy3;
     function entropyToMnemonic(entropy, wordlist) {
       if (!Buffer.isBuffer(entropy)) {
         entropy = Buffer.from(entropy, "hex");
@@ -21958,7 +21958,7 @@ var require_src = __commonJS({
       return wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093" ? words.join("\u3000") : words.join(" ");
     }
     exports.entropyToMnemonic = entropyToMnemonic;
-    function generateMnemonic(strength, rng, wordlist) {
+    function generateMnemonic2(strength, rng, wordlist) {
       strength = strength || 128;
       if (strength % 32 !== 0) {
         throw new TypeError(INVALID_ENTROPY);
@@ -21966,10 +21966,10 @@ var require_src = __commonJS({
       rng = rng || ((size) => Buffer.from(utils_1.randomBytes(size)));
       return entropyToMnemonic(rng(strength / 8), wordlist);
     }
-    exports.generateMnemonic = generateMnemonic;
+    exports.generateMnemonic = generateMnemonic2;
     function validateMnemonic(mnemonic, wordlist) {
       try {
-        mnemonicToEntropy2(mnemonic, wordlist);
+        mnemonicToEntropy3(mnemonic, wordlist);
       } catch (e) {
         return false;
       }
@@ -22002,580 +22002,3906 @@ var require_src = __commonJS({
   }
 });
 
+// node_modules/bech32/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/bech32/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.bech32m = exports.bech32 = void 0;
+    var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+    var ALPHABET_MAP = {};
+    for (let z = 0; z < ALPHABET.length; z++) {
+      const x = ALPHABET.charAt(z);
+      ALPHABET_MAP[x] = z;
+    }
+    function polymodStep(pre) {
+      const b = pre >> 25;
+      return (pre & 33554431) << 5 ^ -(b >> 0 & 1) & 996825010 ^ -(b >> 1 & 1) & 642813549 ^ -(b >> 2 & 1) & 513874426 ^ -(b >> 3 & 1) & 1027748829 ^ -(b >> 4 & 1) & 705979059;
+    }
+    function prefixChk(prefix) {
+      let chk = 1;
+      for (let i = 0; i < prefix.length; ++i) {
+        const c = prefix.charCodeAt(i);
+        if (c < 33 || c > 126)
+          return "Invalid prefix (" + prefix + ")";
+        chk = polymodStep(chk) ^ c >> 5;
+      }
+      chk = polymodStep(chk);
+      for (let i = 0; i < prefix.length; ++i) {
+        const v = prefix.charCodeAt(i);
+        chk = polymodStep(chk) ^ v & 31;
+      }
+      return chk;
+    }
+    function convert(data, inBits, outBits, pad) {
+      let value = 0;
+      let bits = 0;
+      const maxV = (1 << outBits) - 1;
+      const result = [];
+      for (let i = 0; i < data.length; ++i) {
+        value = value << inBits | data[i];
+        bits += inBits;
+        while (bits >= outBits) {
+          bits -= outBits;
+          result.push(value >> bits & maxV);
+        }
+      }
+      if (pad) {
+        if (bits > 0) {
+          result.push(value << outBits - bits & maxV);
+        }
+      } else {
+        if (bits >= inBits)
+          return "Excess padding";
+        if (value << outBits - bits & maxV)
+          return "Non-zero padding";
+      }
+      return result;
+    }
+    function toWords(bytes) {
+      return convert(bytes, 8, 5, true);
+    }
+    function fromWordsUnsafe(words) {
+      const res = convert(words, 5, 8, false);
+      if (Array.isArray(res))
+        return res;
+    }
+    function fromWords(words) {
+      const res = convert(words, 5, 8, false);
+      if (Array.isArray(res))
+        return res;
+      throw new Error(res);
+    }
+    function getLibraryFromEncoding(encoding) {
+      let ENCODING_CONST;
+      if (encoding === "bech32") {
+        ENCODING_CONST = 1;
+      } else {
+        ENCODING_CONST = 734539939;
+      }
+      function encode(prefix, words, LIMIT) {
+        LIMIT = LIMIT || 90;
+        if (prefix.length + 7 + words.length > LIMIT)
+          throw new TypeError("Exceeds length limit");
+        prefix = prefix.toLowerCase();
+        let chk = prefixChk(prefix);
+        if (typeof chk === "string")
+          throw new Error(chk);
+        let result = prefix + "1";
+        for (let i = 0; i < words.length; ++i) {
+          const x = words[i];
+          if (x >> 5 !== 0)
+            throw new Error("Non 5-bit word");
+          chk = polymodStep(chk) ^ x;
+          result += ALPHABET.charAt(x);
+        }
+        for (let i = 0; i < 6; ++i) {
+          chk = polymodStep(chk);
+        }
+        chk ^= ENCODING_CONST;
+        for (let i = 0; i < 6; ++i) {
+          const v = chk >> (5 - i) * 5 & 31;
+          result += ALPHABET.charAt(v);
+        }
+        return result;
+      }
+      function __decode(str, LIMIT) {
+        LIMIT = LIMIT || 90;
+        if (str.length < 8)
+          return str + " too short";
+        if (str.length > LIMIT)
+          return "Exceeds length limit";
+        const lowered = str.toLowerCase();
+        const uppered = str.toUpperCase();
+        if (str !== lowered && str !== uppered)
+          return "Mixed-case string " + str;
+        str = lowered;
+        const split = str.lastIndexOf("1");
+        if (split === -1)
+          return "No separator character for " + str;
+        if (split === 0)
+          return "Missing prefix for " + str;
+        const prefix = str.slice(0, split);
+        const wordChars = str.slice(split + 1);
+        if (wordChars.length < 6)
+          return "Data too short";
+        let chk = prefixChk(prefix);
+        if (typeof chk === "string")
+          return chk;
+        const words = [];
+        for (let i = 0; i < wordChars.length; ++i) {
+          const c = wordChars.charAt(i);
+          const v = ALPHABET_MAP[c];
+          if (v === void 0)
+            return "Unknown character " + c;
+          chk = polymodStep(chk) ^ v;
+          if (i + 6 >= wordChars.length)
+            continue;
+          words.push(v);
+        }
+        if (chk !== ENCODING_CONST)
+          return "Invalid checksum for " + str;
+        return { prefix, words };
+      }
+      function decodeUnsafe(str, LIMIT) {
+        const res = __decode(str, LIMIT);
+        if (typeof res === "object")
+          return res;
+      }
+      function decode(str, LIMIT) {
+        const res = __decode(str, LIMIT);
+        if (typeof res === "object")
+          return res;
+        throw new Error(res);
+      }
+      return {
+        decodeUnsafe,
+        decode,
+        encode,
+        toWords,
+        fromWordsUnsafe,
+        fromWords
+      };
+    }
+    exports.bech32 = getLibraryFromEncoding("bech32");
+    exports.bech32m = getLibraryFromEncoding("bech32m");
+  }
+});
+
+// node_modules/nanoassert/index.js
+var require_nanoassert = __commonJS({
+  "node_modules/nanoassert/index.js"(exports, module) {
+    module.exports = assert;
+    var AssertionError = class extends Error {
+    };
+    AssertionError.prototype.name = "AssertionError";
+    function assert(t, m) {
+      if (!t) {
+        var err = new AssertionError(m);
+        if (Error.captureStackTrace) Error.captureStackTrace(err, assert);
+        throw err;
+      }
+    }
+  }
+});
+
+// node_modules/b4a/index.js
+var require_b4a = __commonJS({
+  "node_modules/b4a/index.js"(exports, module) {
+    function isBuffer(value) {
+      return Buffer.isBuffer(value) || value instanceof Uint8Array;
+    }
+    function isEncoding(encoding) {
+      return Buffer.isEncoding(encoding);
+    }
+    function alloc(size, fill2, encoding) {
+      return Buffer.alloc(size, fill2, encoding);
+    }
+    function allocUnsafe(size) {
+      return Buffer.allocUnsafe(size);
+    }
+    function allocUnsafeSlow(size) {
+      return Buffer.allocUnsafeSlow(size);
+    }
+    function byteLength(string, encoding) {
+      return Buffer.byteLength(string, encoding);
+    }
+    function compare(a, b) {
+      return Buffer.compare(a, b);
+    }
+    function concat(buffers, totalLength) {
+      return Buffer.concat(buffers, totalLength);
+    }
+    function copy(source, target, targetStart, start, end) {
+      return toBuffer(source).copy(target, targetStart, start, end);
+    }
+    function equals(a, b) {
+      return toBuffer(a).equals(b);
+    }
+    function fill(buffer, value, offset, end, encoding) {
+      return toBuffer(buffer).fill(value, offset, end, encoding);
+    }
+    function from(value, encodingOrOffset, length) {
+      return Buffer.from(value, encodingOrOffset, length);
+    }
+    function includes(buffer, value, byteOffset, encoding) {
+      return toBuffer(buffer).includes(value, byteOffset, encoding);
+    }
+    function indexOf(buffer, value, byfeOffset, encoding) {
+      return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
+    }
+    function lastIndexOf(buffer, value, byteOffset, encoding) {
+      return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
+    }
+    function swap16(buffer) {
+      return toBuffer(buffer).swap16();
+    }
+    function swap32(buffer) {
+      return toBuffer(buffer).swap32();
+    }
+    function swap64(buffer) {
+      return toBuffer(buffer).swap64();
+    }
+    function toBuffer(buffer) {
+      if (Buffer.isBuffer(buffer)) return buffer;
+      return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    function toString(buffer, encoding, start, end) {
+      return toBuffer(buffer).toString(encoding, start, end);
+    }
+    function write(buffer, string, offset, length, encoding) {
+      return toBuffer(buffer).write(string, offset, length, encoding);
+    }
+    function readDoubleBE(buffer, offset) {
+      return toBuffer(buffer).readDoubleBE(offset);
+    }
+    function readDoubleLE(buffer, offset) {
+      return toBuffer(buffer).readDoubleLE(offset);
+    }
+    function readFloatBE(buffer, offset) {
+      return toBuffer(buffer).readFloatBE(offset);
+    }
+    function readFloatLE(buffer, offset) {
+      return toBuffer(buffer).readFloatLE(offset);
+    }
+    function readInt32BE(buffer, offset) {
+      return toBuffer(buffer).readInt32BE(offset);
+    }
+    function readInt32LE(buffer, offset) {
+      return toBuffer(buffer).readInt32LE(offset);
+    }
+    function readUInt32BE(buffer, offset) {
+      return toBuffer(buffer).readUInt32BE(offset);
+    }
+    function readUInt32LE(buffer, offset) {
+      return toBuffer(buffer).readUInt32LE(offset);
+    }
+    function writeDoubleBE(buffer, value, offset) {
+      return toBuffer(buffer).writeDoubleBE(value, offset);
+    }
+    function writeDoubleLE(buffer, value, offset) {
+      return toBuffer(buffer).writeDoubleLE(value, offset);
+    }
+    function writeFloatBE(buffer, value, offset) {
+      return toBuffer(buffer).writeFloatBE(value, offset);
+    }
+    function writeFloatLE(buffer, value, offset) {
+      return toBuffer(buffer).writeFloatLE(value, offset);
+    }
+    function writeInt32BE(buffer, value, offset) {
+      return toBuffer(buffer).writeInt32BE(value, offset);
+    }
+    function writeInt32LE(buffer, value, offset) {
+      return toBuffer(buffer).writeInt32LE(value, offset);
+    }
+    function writeUInt32BE(buffer, value, offset) {
+      return toBuffer(buffer).writeUInt32BE(value, offset);
+    }
+    function writeUInt32LE(buffer, value, offset) {
+      return toBuffer(buffer).writeUInt32LE(value, offset);
+    }
+    module.exports = {
+      isBuffer,
+      isEncoding,
+      alloc,
+      allocUnsafe,
+      allocUnsafeSlow,
+      byteLength,
+      compare,
+      concat,
+      copy,
+      equals,
+      fill,
+      from,
+      includes,
+      indexOf,
+      lastIndexOf,
+      swap16,
+      swap32,
+      swap64,
+      toBuffer,
+      toString,
+      write,
+      readDoubleBE,
+      readDoubleLE,
+      readFloatBE,
+      readFloatLE,
+      readInt32BE,
+      readInt32LE,
+      readUInt32BE,
+      readUInt32LE,
+      writeDoubleBE,
+      writeDoubleLE,
+      writeFloatBE,
+      writeFloatLE,
+      writeInt32BE,
+      writeInt32LE,
+      writeUInt32BE,
+      writeUInt32LE
+    };
+  }
+});
+
+// node_modules/blake2b-wasm/blake2b.js
+var require_blake2b = __commonJS({
+  "node_modules/blake2b-wasm/blake2b.js"(exports, module) {
+    var __commonJS2 = (cb, mod) => function __require2() {
+      return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+    };
+    var __toBinary = /* @__PURE__ */ (() => {
+      var table = new Uint8Array(128);
+      for (var i = 0; i < 64; i++)
+        table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;
+      return (base64) => {
+        var n = base64.length, bytes2 = new Uint8Array((n - (base64[n - 1] == "=") - (base64[n - 2] == "=")) * 3 / 4 | 0);
+        for (var i2 = 0, j = 0; i2 < n; ) {
+          var c0 = table[base64.charCodeAt(i2++)], c1 = table[base64.charCodeAt(i2++)];
+          var c2 = table[base64.charCodeAt(i2++)], c3 = table[base64.charCodeAt(i2++)];
+          bytes2[j++] = c0 << 2 | c1 >> 4;
+          bytes2[j++] = c1 << 4 | c2 >> 2;
+          bytes2[j++] = c2 << 6 | c3;
+        }
+        return bytes2;
+      };
+    })();
+    var require_blake2b4 = __commonJS2({
+      "wasm-binary:./blake2b.wat"(exports2, module2) {
+        module2.exports = __toBinary("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");
+      }
+    });
+    var bytes = require_blake2b4();
+    var compiled = WebAssembly.compile(bytes);
+    module.exports = async (imports) => {
+      const instance = await WebAssembly.instantiate(await compiled, imports);
+      return instance.exports;
+    };
+  }
+});
+
+// node_modules/blake2b-wasm/index.js
+var require_blake2b_wasm = __commonJS({
+  "node_modules/blake2b-wasm/index.js"(exports, module) {
+    var assert = require_nanoassert();
+    var b4a = require_b4a();
+    var wasm = null;
+    var wasmPromise = typeof WebAssembly !== "undefined" && require_blake2b()().then((mod) => {
+      wasm = mod;
+    });
+    var head = 64;
+    var freeList = [];
+    module.exports = Blake2b;
+    var BYTES_MIN = module.exports.BYTES_MIN = 16;
+    var BYTES_MAX = module.exports.BYTES_MAX = 64;
+    var BYTES = module.exports.BYTES = 32;
+    var KEYBYTES_MIN = module.exports.KEYBYTES_MIN = 16;
+    var KEYBYTES_MAX = module.exports.KEYBYTES_MAX = 64;
+    var KEYBYTES = module.exports.KEYBYTES = 32;
+    var SALTBYTES = module.exports.SALTBYTES = 16;
+    var PERSONALBYTES = module.exports.PERSONALBYTES = 16;
+    function Blake2b(digestLength, key, salt, personal, noAssert) {
+      if (!(this instanceof Blake2b)) return new Blake2b(digestLength, key, salt, personal, noAssert);
+      if (!wasm) throw new Error("WASM not loaded. Wait for Blake2b.ready(cb)");
+      if (!digestLength) digestLength = 32;
+      if (noAssert !== true) {
+        assert(digestLength >= BYTES_MIN, "digestLength must be at least " + BYTES_MIN + ", was given " + digestLength);
+        assert(digestLength <= BYTES_MAX, "digestLength must be at most " + BYTES_MAX + ", was given " + digestLength);
+        if (key != null) {
+          assert(key instanceof Uint8Array, "key must be Uint8Array or Buffer");
+          assert(key.length >= KEYBYTES_MIN, "key must be at least " + KEYBYTES_MIN + ", was given " + key.length);
+          assert(key.length <= KEYBYTES_MAX, "key must be at least " + KEYBYTES_MAX + ", was given " + key.length);
+        }
+        if (salt != null) {
+          assert(salt instanceof Uint8Array, "salt must be Uint8Array or Buffer");
+          assert(salt.length === SALTBYTES, "salt must be exactly " + SALTBYTES + ", was given " + salt.length);
+        }
+        if (personal != null) {
+          assert(personal instanceof Uint8Array, "personal must be Uint8Array or Buffer");
+          assert(personal.length === PERSONALBYTES, "personal must be exactly " + PERSONALBYTES + ", was given " + personal.length);
+        }
+      }
+      if (!freeList.length) {
+        freeList.push(head);
+        head += 216;
+      }
+      this.digestLength = digestLength;
+      this.finalized = false;
+      this.pointer = freeList.pop();
+      this._memory = new Uint8Array(wasm.memory.buffer);
+      this._memory.fill(0, 0, 64);
+      this._memory[0] = this.digestLength;
+      this._memory[1] = key ? key.length : 0;
+      this._memory[2] = 1;
+      this._memory[3] = 1;
+      if (salt) this._memory.set(salt, 32);
+      if (personal) this._memory.set(personal, 48);
+      if (this.pointer + 216 > this._memory.length) this._realloc(this.pointer + 216);
+      wasm.blake2b_init(this.pointer, this.digestLength);
+      if (key) {
+        this.update(key);
+        this._memory.fill(0, head, head + key.length);
+        this._memory[this.pointer + 200] = 128;
+      }
+    }
+    Blake2b.prototype._realloc = function(size) {
+      wasm.memory.grow(Math.max(0, Math.ceil(Math.abs(size - this._memory.length) / 65536)));
+      this._memory = new Uint8Array(wasm.memory.buffer);
+    };
+    Blake2b.prototype.update = function(input) {
+      assert(this.finalized === false, "Hash instance finalized");
+      assert(input instanceof Uint8Array, "input must be Uint8Array or Buffer");
+      if (head + input.length > this._memory.length) this._realloc(head + input.length);
+      this._memory.set(input, head);
+      wasm.blake2b_update(this.pointer, head, head + input.length);
+      return this;
+    };
+    Blake2b.prototype.digest = function(enc) {
+      assert(this.finalized === false, "Hash instance finalized");
+      this.finalized = true;
+      freeList.push(this.pointer);
+      wasm.blake2b_final(this.pointer);
+      if (!enc || enc === "binary") {
+        return this._memory.slice(this.pointer + 128, this.pointer + 128 + this.digestLength);
+      }
+      if (typeof enc === "string") {
+        return b4a.toString(this._memory, enc, this.pointer + 128, this.pointer + 128 + this.digestLength);
+      }
+      assert(enc instanceof Uint8Array && enc.length >= this.digestLength, "input must be Uint8Array or Buffer");
+      for (var i = 0; i < this.digestLength; i++) {
+        enc[i] = this._memory[this.pointer + 128 + i];
+      }
+      return enc;
+    };
+    Blake2b.prototype.final = Blake2b.prototype.digest;
+    Blake2b.WASM = wasm;
+    Blake2b.SUPPORTED = typeof WebAssembly !== "undefined";
+    Blake2b.ready = function(cb) {
+      if (!cb) cb = noop;
+      if (!wasmPromise) return cb(new Error("WebAssembly not supported"));
+      return wasmPromise.then(() => cb(), cb);
+    };
+    Blake2b.prototype.ready = Blake2b.ready;
+    Blake2b.prototype.getPartialHash = function() {
+      return this._memory.slice(this.pointer, this.pointer + 216);
+    };
+    Blake2b.prototype.setPartialHash = function(ph) {
+      this._memory.set(ph, this.pointer);
+    };
+    function noop() {
+    }
+  }
+});
+
+// node_modules/blake2b/index.js
+var require_blake2b2 = __commonJS({
+  "node_modules/blake2b/index.js"(exports, module) {
+    var assert = require_nanoassert();
+    var b2wasm = require_blake2b_wasm();
+    function ADD64AA(v2, a, b) {
+      var o0 = v2[a] + v2[b];
+      var o1 = v2[a + 1] + v2[b + 1];
+      if (o0 >= 4294967296) {
+        o1++;
+      }
+      v2[a] = o0;
+      v2[a + 1] = o1;
+    }
+    function ADD64AC(v2, a, b0, b1) {
+      var o0 = v2[a] + b0;
+      if (b0 < 0) {
+        o0 += 4294967296;
+      }
+      var o1 = v2[a + 1] + b1;
+      if (o0 >= 4294967296) {
+        o1++;
+      }
+      v2[a] = o0;
+      v2[a + 1] = o1;
+    }
+    function B2B_GET32(arr, i) {
+      return arr[i] ^ arr[i + 1] << 8 ^ arr[i + 2] << 16 ^ arr[i + 3] << 24;
+    }
+    function B2B_G(a, b, c, d, ix, iy) {
+      var x0 = m[ix];
+      var x1 = m[ix + 1];
+      var y0 = m[iy];
+      var y1 = m[iy + 1];
+      ADD64AA(v, a, b);
+      ADD64AC(v, a, x0, x1);
+      var xor0 = v[d] ^ v[a];
+      var xor1 = v[d + 1] ^ v[a + 1];
+      v[d] = xor1;
+      v[d + 1] = xor0;
+      ADD64AA(v, c, d);
+      xor0 = v[b] ^ v[c];
+      xor1 = v[b + 1] ^ v[c + 1];
+      v[b] = xor0 >>> 24 ^ xor1 << 8;
+      v[b + 1] = xor1 >>> 24 ^ xor0 << 8;
+      ADD64AA(v, a, b);
+      ADD64AC(v, a, y0, y1);
+      xor0 = v[d] ^ v[a];
+      xor1 = v[d + 1] ^ v[a + 1];
+      v[d] = xor0 >>> 16 ^ xor1 << 16;
+      v[d + 1] = xor1 >>> 16 ^ xor0 << 16;
+      ADD64AA(v, c, d);
+      xor0 = v[b] ^ v[c];
+      xor1 = v[b + 1] ^ v[c + 1];
+      v[b] = xor1 >>> 31 ^ xor0 << 1;
+      v[b + 1] = xor0 >>> 31 ^ xor1 << 1;
+    }
+    var BLAKE2B_IV32 = new Uint32Array([
+      4089235720,
+      1779033703,
+      2227873595,
+      3144134277,
+      4271175723,
+      1013904242,
+      1595750129,
+      2773480762,
+      2917565137,
+      1359893119,
+      725511199,
+      2600822924,
+      4215389547,
+      528734635,
+      327033209,
+      1541459225
+    ]);
+    var SIGMA8 = [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      14,
+      10,
+      4,
+      8,
+      9,
+      15,
+      13,
+      6,
+      1,
+      12,
+      0,
+      2,
+      11,
+      7,
+      5,
+      3,
+      11,
+      8,
+      12,
+      0,
+      5,
+      2,
+      15,
+      13,
+      10,
+      14,
+      3,
+      6,
+      7,
+      1,
+      9,
+      4,
+      7,
+      9,
+      3,
+      1,
+      13,
+      12,
+      11,
+      14,
+      2,
+      6,
+      5,
+      10,
+      4,
+      0,
+      15,
+      8,
+      9,
+      0,
+      5,
+      7,
+      2,
+      4,
+      10,
+      15,
+      14,
+      1,
+      11,
+      12,
+      6,
+      8,
+      3,
+      13,
+      2,
+      12,
+      6,
+      10,
+      0,
+      11,
+      8,
+      3,
+      4,
+      13,
+      7,
+      5,
+      15,
+      14,
+      1,
+      9,
+      12,
+      5,
+      1,
+      15,
+      14,
+      13,
+      4,
+      10,
+      0,
+      7,
+      6,
+      3,
+      9,
+      2,
+      8,
+      11,
+      13,
+      11,
+      7,
+      14,
+      12,
+      1,
+      3,
+      9,
+      5,
+      0,
+      15,
+      4,
+      8,
+      6,
+      2,
+      10,
+      6,
+      15,
+      14,
+      9,
+      11,
+      3,
+      0,
+      8,
+      12,
+      2,
+      13,
+      7,
+      1,
+      4,
+      10,
+      5,
+      10,
+      2,
+      8,
+      4,
+      7,
+      6,
+      1,
+      5,
+      15,
+      11,
+      9,
+      14,
+      3,
+      12,
+      13,
+      0,
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      14,
+      10,
+      4,
+      8,
+      9,
+      15,
+      13,
+      6,
+      1,
+      12,
+      0,
+      2,
+      11,
+      7,
+      5,
+      3
+    ];
+    var SIGMA82 = new Uint8Array(SIGMA8.map(function(x) {
+      return x * 2;
+    }));
+    var v = new Uint32Array(32);
+    var m = new Uint32Array(32);
+    function blake2bCompress(ctx, last) {
+      var i = 0;
+      for (i = 0; i < 16; i++) {
+        v[i] = ctx.h[i];
+        v[i + 16] = BLAKE2B_IV32[i];
+      }
+      v[24] = v[24] ^ ctx.t;
+      v[25] = v[25] ^ ctx.t / 4294967296;
+      if (last) {
+        v[28] = ~v[28];
+        v[29] = ~v[29];
+      }
+      for (i = 0; i < 32; i++) {
+        m[i] = B2B_GET32(ctx.b, 4 * i);
+      }
+      for (i = 0; i < 12; i++) {
+        B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+        B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+        B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+        B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+        B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+        B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+        B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+        B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+      }
+      for (i = 0; i < 16; i++) {
+        ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
+      }
+    }
+    var parameter_block = new Uint8Array([
+      0,
+      0,
+      0,
+      0,
+      //  0: outlen, keylen, fanout, depth
+      0,
+      0,
+      0,
+      0,
+      //  4: leaf length, sequential mode
+      0,
+      0,
+      0,
+      0,
+      //  8: node offset
+      0,
+      0,
+      0,
+      0,
+      // 12: node offset
+      0,
+      0,
+      0,
+      0,
+      // 16: node depth, inner length, rfu
+      0,
+      0,
+      0,
+      0,
+      // 20: rfu
+      0,
+      0,
+      0,
+      0,
+      // 24: rfu
+      0,
+      0,
+      0,
+      0,
+      // 28: rfu
+      0,
+      0,
+      0,
+      0,
+      // 32: salt
+      0,
+      0,
+      0,
+      0,
+      // 36: salt
+      0,
+      0,
+      0,
+      0,
+      // 40: salt
+      0,
+      0,
+      0,
+      0,
+      // 44: salt
+      0,
+      0,
+      0,
+      0,
+      // 48: personal
+      0,
+      0,
+      0,
+      0,
+      // 52: personal
+      0,
+      0,
+      0,
+      0,
+      // 56: personal
+      0,
+      0,
+      0,
+      0
+      // 60: personal
+    ]);
+    function Blake2b(outlen, key, salt, personal) {
+      parameter_block.fill(0);
+      this.b = new Uint8Array(128);
+      this.h = new Uint32Array(16);
+      this.t = 0;
+      this.c = 0;
+      this.outlen = outlen;
+      parameter_block[0] = outlen;
+      if (key) parameter_block[1] = key.length;
+      parameter_block[2] = 1;
+      parameter_block[3] = 1;
+      if (salt) parameter_block.set(salt, 32);
+      if (personal) parameter_block.set(personal, 48);
+      for (var i = 0; i < 16; i++) {
+        this.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameter_block, i * 4);
+      }
+      if (key) {
+        blake2bUpdate(this, key);
+        this.c = 128;
+      }
+    }
+    Blake2b.prototype.update = function(input) {
+      assert(input instanceof Uint8Array, "input must be Uint8Array or Buffer");
+      blake2bUpdate(this, input);
+      return this;
+    };
+    Blake2b.prototype.digest = function(out) {
+      var buf = !out || out === "binary" || out === "hex" ? new Uint8Array(this.outlen) : out;
+      assert(buf instanceof Uint8Array, 'out must be "binary", "hex", Uint8Array, or Buffer');
+      assert(buf.length >= this.outlen, "out must have at least outlen bytes of space");
+      blake2bFinal(this, buf);
+      if (out === "hex") return hexSlice(buf);
+      return buf;
+    };
+    Blake2b.prototype.final = Blake2b.prototype.digest;
+    Blake2b.ready = function(cb) {
+      b2wasm.ready(function() {
+        cb();
+      });
+    };
+    function blake2bUpdate(ctx, input) {
+      for (var i = 0; i < input.length; i++) {
+        if (ctx.c === 128) {
+          ctx.t += ctx.c;
+          blake2bCompress(ctx, false);
+          ctx.c = 0;
+        }
+        ctx.b[ctx.c++] = input[i];
+      }
+    }
+    function blake2bFinal(ctx, out) {
+      ctx.t += ctx.c;
+      while (ctx.c < 128) {
+        ctx.b[ctx.c++] = 0;
+      }
+      blake2bCompress(ctx, true);
+      for (var i = 0; i < ctx.outlen; i++) {
+        out[i] = ctx.h[i >> 2] >> 8 * (i & 3);
+      }
+      return out;
+    }
+    function hexSlice(buf) {
+      var str = "";
+      for (var i = 0; i < buf.length; i++) str += toHex(buf[i]);
+      return str;
+    }
+    function toHex(n) {
+      if (n < 16) return "0" + n.toString(16);
+      return n.toString(16);
+    }
+    var Proto = Blake2b;
+    module.exports = function createHash(outlen, key, salt, personal, noAssert) {
+      if (noAssert !== true) {
+        assert(outlen >= BYTES_MIN, "outlen must be at least " + BYTES_MIN + ", was given " + outlen);
+        assert(outlen <= BYTES_MAX, "outlen must be at most " + BYTES_MAX + ", was given " + outlen);
+        if (key != null) {
+          assert(key instanceof Uint8Array, "key must be Uint8Array or Buffer");
+          assert(key.length >= KEYBYTES_MIN, "key must be at least " + KEYBYTES_MIN + ", was given " + key.length);
+          assert(key.length <= KEYBYTES_MAX, "key must be at most " + KEYBYTES_MAX + ", was given " + key.length);
+        }
+        if (salt != null) {
+          assert(salt instanceof Uint8Array, "salt must be Uint8Array or Buffer");
+          assert(salt.length === SALTBYTES, "salt must be exactly " + SALTBYTES + ", was given " + salt.length);
+        }
+        if (personal != null) {
+          assert(personal instanceof Uint8Array, "personal must be Uint8Array or Buffer");
+          assert(personal.length === PERSONALBYTES, "personal must be exactly " + PERSONALBYTES + ", was given " + personal.length);
+        }
+      }
+      return new Proto(outlen, key, salt, personal);
+    };
+    module.exports.ready = function(cb) {
+      b2wasm.ready(function() {
+        cb();
+      });
+    };
+    module.exports.WASM_SUPPORTED = b2wasm.SUPPORTED;
+    module.exports.WASM_LOADED = false;
+    var BYTES_MIN = module.exports.BYTES_MIN = 16;
+    var BYTES_MAX = module.exports.BYTES_MAX = 64;
+    var BYTES = module.exports.BYTES = 32;
+    var KEYBYTES_MIN = module.exports.KEYBYTES_MIN = 16;
+    var KEYBYTES_MAX = module.exports.KEYBYTES_MAX = 64;
+    var KEYBYTES = module.exports.KEYBYTES = 32;
+    var SALTBYTES = module.exports.SALTBYTES = 16;
+    var PERSONALBYTES = module.exports.PERSONALBYTES = 16;
+    b2wasm.ready(function(err) {
+      if (!err) {
+        module.exports.WASM_LOADED = true;
+        module.exports = b2wasm;
+      }
+    });
+  }
+});
+
+// node_modules/blakejs/util.js
+var require_util = __commonJS({
+  "node_modules/blakejs/util.js"(exports, module) {
+    var ERROR_MSG_INPUT = "Input must be an string, Buffer or Uint8Array";
+    function normalizeInput(input) {
+      let ret;
+      if (input instanceof Uint8Array) {
+        ret = input;
+      } else if (typeof input === "string") {
+        const encoder = new TextEncoder();
+        ret = encoder.encode(input);
+      } else {
+        throw new Error(ERROR_MSG_INPUT);
+      }
+      return ret;
+    }
+    function toHex(bytes) {
+      return Array.prototype.map.call(bytes, function(n) {
+        return (n < 16 ? "0" : "") + n.toString(16);
+      }).join("");
+    }
+    function uint32ToHex(val) {
+      return (4294967296 + val).toString(16).substring(1);
+    }
+    function debugPrint(label, arr, size) {
+      let msg = "\n" + label + " = ";
+      for (let i = 0; i < arr.length; i += 2) {
+        if (size === 32) {
+          msg += uint32ToHex(arr[i]).toUpperCase();
+          msg += " ";
+          msg += uint32ToHex(arr[i + 1]).toUpperCase();
+        } else if (size === 64) {
+          msg += uint32ToHex(arr[i + 1]).toUpperCase();
+          msg += uint32ToHex(arr[i]).toUpperCase();
+        } else throw new Error("Invalid size " + size);
+        if (i % 6 === 4) {
+          msg += "\n" + new Array(label.length + 4).join(" ");
+        } else if (i < arr.length - 2) {
+          msg += " ";
+        }
+      }
+      console.log(msg);
+    }
+    function testSpeed(hashFn, N, M) {
+      let startMs = (/* @__PURE__ */ new Date()).getTime();
+      const input = new Uint8Array(N);
+      for (let i = 0; i < N; i++) {
+        input[i] = i % 256;
+      }
+      const genMs = (/* @__PURE__ */ new Date()).getTime();
+      console.log("Generated random input in " + (genMs - startMs) + "ms");
+      startMs = genMs;
+      for (let i = 0; i < M; i++) {
+        const hashHex = hashFn(input);
+        const hashMs = (/* @__PURE__ */ new Date()).getTime();
+        const ms = hashMs - startMs;
+        startMs = hashMs;
+        console.log("Hashed in " + ms + "ms: " + hashHex.substring(0, 20) + "...");
+        console.log(
+          Math.round(N / (1 << 20) / (ms / 1e3) * 100) / 100 + " MB PER SECOND"
+        );
+      }
+    }
+    module.exports = {
+      normalizeInput,
+      toHex,
+      debugPrint,
+      testSpeed
+    };
+  }
+});
+
+// node_modules/blakejs/blake2b.js
+var require_blake2b3 = __commonJS({
+  "node_modules/blakejs/blake2b.js"(exports, module) {
+    var util = require_util();
+    function ADD64AA(v2, a, b) {
+      const o0 = v2[a] + v2[b];
+      let o1 = v2[a + 1] + v2[b + 1];
+      if (o0 >= 4294967296) {
+        o1++;
+      }
+      v2[a] = o0;
+      v2[a + 1] = o1;
+    }
+    function ADD64AC(v2, a, b0, b1) {
+      let o0 = v2[a] + b0;
+      if (b0 < 0) {
+        o0 += 4294967296;
+      }
+      let o1 = v2[a + 1] + b1;
+      if (o0 >= 4294967296) {
+        o1++;
+      }
+      v2[a] = o0;
+      v2[a + 1] = o1;
+    }
+    function B2B_GET32(arr, i) {
+      return arr[i] ^ arr[i + 1] << 8 ^ arr[i + 2] << 16 ^ arr[i + 3] << 24;
+    }
+    function B2B_G(a, b, c, d, ix, iy) {
+      const x0 = m[ix];
+      const x1 = m[ix + 1];
+      const y0 = m[iy];
+      const y1 = m[iy + 1];
+      ADD64AA(v, a, b);
+      ADD64AC(v, a, x0, x1);
+      let xor0 = v[d] ^ v[a];
+      let xor1 = v[d + 1] ^ v[a + 1];
+      v[d] = xor1;
+      v[d + 1] = xor0;
+      ADD64AA(v, c, d);
+      xor0 = v[b] ^ v[c];
+      xor1 = v[b + 1] ^ v[c + 1];
+      v[b] = xor0 >>> 24 ^ xor1 << 8;
+      v[b + 1] = xor1 >>> 24 ^ xor0 << 8;
+      ADD64AA(v, a, b);
+      ADD64AC(v, a, y0, y1);
+      xor0 = v[d] ^ v[a];
+      xor1 = v[d + 1] ^ v[a + 1];
+      v[d] = xor0 >>> 16 ^ xor1 << 16;
+      v[d + 1] = xor1 >>> 16 ^ xor0 << 16;
+      ADD64AA(v, c, d);
+      xor0 = v[b] ^ v[c];
+      xor1 = v[b + 1] ^ v[c + 1];
+      v[b] = xor1 >>> 31 ^ xor0 << 1;
+      v[b + 1] = xor0 >>> 31 ^ xor1 << 1;
+    }
+    var BLAKE2B_IV32 = new Uint32Array([
+      4089235720,
+      1779033703,
+      2227873595,
+      3144134277,
+      4271175723,
+      1013904242,
+      1595750129,
+      2773480762,
+      2917565137,
+      1359893119,
+      725511199,
+      2600822924,
+      4215389547,
+      528734635,
+      327033209,
+      1541459225
+    ]);
+    var SIGMA8 = [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      14,
+      10,
+      4,
+      8,
+      9,
+      15,
+      13,
+      6,
+      1,
+      12,
+      0,
+      2,
+      11,
+      7,
+      5,
+      3,
+      11,
+      8,
+      12,
+      0,
+      5,
+      2,
+      15,
+      13,
+      10,
+      14,
+      3,
+      6,
+      7,
+      1,
+      9,
+      4,
+      7,
+      9,
+      3,
+      1,
+      13,
+      12,
+      11,
+      14,
+      2,
+      6,
+      5,
+      10,
+      4,
+      0,
+      15,
+      8,
+      9,
+      0,
+      5,
+      7,
+      2,
+      4,
+      10,
+      15,
+      14,
+      1,
+      11,
+      12,
+      6,
+      8,
+      3,
+      13,
+      2,
+      12,
+      6,
+      10,
+      0,
+      11,
+      8,
+      3,
+      4,
+      13,
+      7,
+      5,
+      15,
+      14,
+      1,
+      9,
+      12,
+      5,
+      1,
+      15,
+      14,
+      13,
+      4,
+      10,
+      0,
+      7,
+      6,
+      3,
+      9,
+      2,
+      8,
+      11,
+      13,
+      11,
+      7,
+      14,
+      12,
+      1,
+      3,
+      9,
+      5,
+      0,
+      15,
+      4,
+      8,
+      6,
+      2,
+      10,
+      6,
+      15,
+      14,
+      9,
+      11,
+      3,
+      0,
+      8,
+      12,
+      2,
+      13,
+      7,
+      1,
+      4,
+      10,
+      5,
+      10,
+      2,
+      8,
+      4,
+      7,
+      6,
+      1,
+      5,
+      15,
+      11,
+      9,
+      14,
+      3,
+      12,
+      13,
+      0,
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      14,
+      10,
+      4,
+      8,
+      9,
+      15,
+      13,
+      6,
+      1,
+      12,
+      0,
+      2,
+      11,
+      7,
+      5,
+      3
+    ];
+    var SIGMA82 = new Uint8Array(
+      SIGMA8.map(function(x) {
+        return x * 2;
+      })
+    );
+    var v = new Uint32Array(32);
+    var m = new Uint32Array(32);
+    function blake2bCompress(ctx, last) {
+      let i = 0;
+      for (i = 0; i < 16; i++) {
+        v[i] = ctx.h[i];
+        v[i + 16] = BLAKE2B_IV32[i];
+      }
+      v[24] = v[24] ^ ctx.t;
+      v[25] = v[25] ^ ctx.t / 4294967296;
+      if (last) {
+        v[28] = ~v[28];
+        v[29] = ~v[29];
+      }
+      for (i = 0; i < 32; i++) {
+        m[i] = B2B_GET32(ctx.b, 4 * i);
+      }
+      for (i = 0; i < 12; i++) {
+        B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+        B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+        B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+        B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+        B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+        B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+        B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+        B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+      }
+      for (i = 0; i < 16; i++) {
+        ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
+      }
+    }
+    var parameterBlock = new Uint8Array([
+      0,
+      0,
+      0,
+      0,
+      //  0: outlen, keylen, fanout, depth
+      0,
+      0,
+      0,
+      0,
+      //  4: leaf length, sequential mode
+      0,
+      0,
+      0,
+      0,
+      //  8: node offset
+      0,
+      0,
+      0,
+      0,
+      // 12: node offset
+      0,
+      0,
+      0,
+      0,
+      // 16: node depth, inner length, rfu
+      0,
+      0,
+      0,
+      0,
+      // 20: rfu
+      0,
+      0,
+      0,
+      0,
+      // 24: rfu
+      0,
+      0,
+      0,
+      0,
+      // 28: rfu
+      0,
+      0,
+      0,
+      0,
+      // 32: salt
+      0,
+      0,
+      0,
+      0,
+      // 36: salt
+      0,
+      0,
+      0,
+      0,
+      // 40: salt
+      0,
+      0,
+      0,
+      0,
+      // 44: salt
+      0,
+      0,
+      0,
+      0,
+      // 48: personal
+      0,
+      0,
+      0,
+      0,
+      // 52: personal
+      0,
+      0,
+      0,
+      0,
+      // 56: personal
+      0,
+      0,
+      0,
+      0
+      // 60: personal
+    ]);
+    function blake2bInit(outlen, key, salt, personal) {
+      if (outlen === 0 || outlen > 64) {
+        throw new Error("Illegal output length, expected 0 < length <= 64");
+      }
+      if (key && key.length > 64) {
+        throw new Error("Illegal key, expected Uint8Array with 0 < length <= 64");
+      }
+      if (salt && salt.length !== 16) {
+        throw new Error("Illegal salt, expected Uint8Array with length is 16");
+      }
+      if (personal && personal.length !== 16) {
+        throw new Error("Illegal personal, expected Uint8Array with length is 16");
+      }
+      const ctx = {
+        b: new Uint8Array(128),
+        h: new Uint32Array(16),
+        t: 0,
+        // input count
+        c: 0,
+        // pointer within buffer
+        outlen
+        // output length in bytes
+      };
+      parameterBlock.fill(0);
+      parameterBlock[0] = outlen;
+      if (key) parameterBlock[1] = key.length;
+      parameterBlock[2] = 1;
+      parameterBlock[3] = 1;
+      if (salt) parameterBlock.set(salt, 32);
+      if (personal) parameterBlock.set(personal, 48);
+      for (let i = 0; i < 16; i++) {
+        ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4);
+      }
+      if (key) {
+        blake2bUpdate(ctx, key);
+        ctx.c = 128;
+      }
+      return ctx;
+    }
+    function blake2bUpdate(ctx, input) {
+      for (let i = 0; i < input.length; i++) {
+        if (ctx.c === 128) {
+          ctx.t += ctx.c;
+          blake2bCompress(ctx, false);
+          ctx.c = 0;
+        }
+        ctx.b[ctx.c++] = input[i];
+      }
+    }
+    function blake2bFinal(ctx) {
+      ctx.t += ctx.c;
+      while (ctx.c < 128) {
+        ctx.b[ctx.c++] = 0;
+      }
+      blake2bCompress(ctx, true);
+      const out = new Uint8Array(ctx.outlen);
+      for (let i = 0; i < ctx.outlen; i++) {
+        out[i] = ctx.h[i >> 2] >> 8 * (i & 3);
+      }
+      return out;
+    }
+    function blake2b4(input, key, outlen, salt, personal) {
+      outlen = outlen || 64;
+      input = util.normalizeInput(input);
+      if (salt) {
+        salt = util.normalizeInput(salt);
+      }
+      if (personal) {
+        personal = util.normalizeInput(personal);
+      }
+      const ctx = blake2bInit(outlen, key, salt, personal);
+      blake2bUpdate(ctx, input);
+      return blake2bFinal(ctx);
+    }
+    function blake2bHex(input, key, outlen, salt, personal) {
+      const output = blake2b4(input, key, outlen, salt, personal);
+      return util.toHex(output);
+    }
+    module.exports = {
+      blake2b: blake2b4,
+      blake2bHex,
+      blake2bInit,
+      blake2bUpdate,
+      blake2bFinal
+    };
+  }
+});
+
+// node_modules/blakejs/blake2s.js
+var require_blake2s = __commonJS({
+  "node_modules/blakejs/blake2s.js"(exports, module) {
+    var util = require_util();
+    function B2S_GET32(v2, i) {
+      return v2[i] ^ v2[i + 1] << 8 ^ v2[i + 2] << 16 ^ v2[i + 3] << 24;
+    }
+    function B2S_G(a, b, c, d, x, y) {
+      v[a] = v[a] + v[b] + x;
+      v[d] = ROTR32(v[d] ^ v[a], 16);
+      v[c] = v[c] + v[d];
+      v[b] = ROTR32(v[b] ^ v[c], 12);
+      v[a] = v[a] + v[b] + y;
+      v[d] = ROTR32(v[d] ^ v[a], 8);
+      v[c] = v[c] + v[d];
+      v[b] = ROTR32(v[b] ^ v[c], 7);
+    }
+    function ROTR32(x, y) {
+      return x >>> y ^ x << 32 - y;
+    }
+    var BLAKE2S_IV = new Uint32Array([
+      1779033703,
+      3144134277,
+      1013904242,
+      2773480762,
+      1359893119,
+      2600822924,
+      528734635,
+      1541459225
+    ]);
+    var SIGMA = new Uint8Array([
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+      10,
+      11,
+      12,
+      13,
+      14,
+      15,
+      14,
+      10,
+      4,
+      8,
+      9,
+      15,
+      13,
+      6,
+      1,
+      12,
+      0,
+      2,
+      11,
+      7,
+      5,
+      3,
+      11,
+      8,
+      12,
+      0,
+      5,
+      2,
+      15,
+      13,
+      10,
+      14,
+      3,
+      6,
+      7,
+      1,
+      9,
+      4,
+      7,
+      9,
+      3,
+      1,
+      13,
+      12,
+      11,
+      14,
+      2,
+      6,
+      5,
+      10,
+      4,
+      0,
+      15,
+      8,
+      9,
+      0,
+      5,
+      7,
+      2,
+      4,
+      10,
+      15,
+      14,
+      1,
+      11,
+      12,
+      6,
+      8,
+      3,
+      13,
+      2,
+      12,
+      6,
+      10,
+      0,
+      11,
+      8,
+      3,
+      4,
+      13,
+      7,
+      5,
+      15,
+      14,
+      1,
+      9,
+      12,
+      5,
+      1,
+      15,
+      14,
+      13,
+      4,
+      10,
+      0,
+      7,
+      6,
+      3,
+      9,
+      2,
+      8,
+      11,
+      13,
+      11,
+      7,
+      14,
+      12,
+      1,
+      3,
+      9,
+      5,
+      0,
+      15,
+      4,
+      8,
+      6,
+      2,
+      10,
+      6,
+      15,
+      14,
+      9,
+      11,
+      3,
+      0,
+      8,
+      12,
+      2,
+      13,
+      7,
+      1,
+      4,
+      10,
+      5,
+      10,
+      2,
+      8,
+      4,
+      7,
+      6,
+      1,
+      5,
+      15,
+      11,
+      9,
+      14,
+      3,
+      12,
+      13,
+      0
+    ]);
+    var v = new Uint32Array(16);
+    var m = new Uint32Array(16);
+    function blake2sCompress(ctx, last) {
+      let i = 0;
+      for (i = 0; i < 8; i++) {
+        v[i] = ctx.h[i];
+        v[i + 8] = BLAKE2S_IV[i];
+      }
+      v[12] ^= ctx.t;
+      v[13] ^= ctx.t / 4294967296;
+      if (last) {
+        v[14] = ~v[14];
+      }
+      for (i = 0; i < 16; i++) {
+        m[i] = B2S_GET32(ctx.b, 4 * i);
+      }
+      for (i = 0; i < 10; i++) {
+        B2S_G(0, 4, 8, 12, m[SIGMA[i * 16 + 0]], m[SIGMA[i * 16 + 1]]);
+        B2S_G(1, 5, 9, 13, m[SIGMA[i * 16 + 2]], m[SIGMA[i * 16 + 3]]);
+        B2S_G(2, 6, 10, 14, m[SIGMA[i * 16 + 4]], m[SIGMA[i * 16 + 5]]);
+        B2S_G(3, 7, 11, 15, m[SIGMA[i * 16 + 6]], m[SIGMA[i * 16 + 7]]);
+        B2S_G(0, 5, 10, 15, m[SIGMA[i * 16 + 8]], m[SIGMA[i * 16 + 9]]);
+        B2S_G(1, 6, 11, 12, m[SIGMA[i * 16 + 10]], m[SIGMA[i * 16 + 11]]);
+        B2S_G(2, 7, 8, 13, m[SIGMA[i * 16 + 12]], m[SIGMA[i * 16 + 13]]);
+        B2S_G(3, 4, 9, 14, m[SIGMA[i * 16 + 14]], m[SIGMA[i * 16 + 15]]);
+      }
+      for (i = 0; i < 8; i++) {
+        ctx.h[i] ^= v[i] ^ v[i + 8];
+      }
+    }
+    function blake2sInit(outlen, key) {
+      if (!(outlen > 0 && outlen <= 32)) {
+        throw new Error("Incorrect output length, should be in [1, 32]");
+      }
+      const keylen = key ? key.length : 0;
+      if (key && !(keylen > 0 && keylen <= 32)) {
+        throw new Error("Incorrect key length, should be in [1, 32]");
+      }
+      const ctx = {
+        h: new Uint32Array(BLAKE2S_IV),
+        // hash state
+        b: new Uint8Array(64),
+        // input block
+        c: 0,
+        // pointer within block
+        t: 0,
+        // input count
+        outlen
+        // output length in bytes
+      };
+      ctx.h[0] ^= 16842752 ^ keylen << 8 ^ outlen;
+      if (keylen > 0) {
+        blake2sUpdate(ctx, key);
+        ctx.c = 64;
+      }
+      return ctx;
+    }
+    function blake2sUpdate(ctx, input) {
+      for (let i = 0; i < input.length; i++) {
+        if (ctx.c === 64) {
+          ctx.t += ctx.c;
+          blake2sCompress(ctx, false);
+          ctx.c = 0;
+        }
+        ctx.b[ctx.c++] = input[i];
+      }
+    }
+    function blake2sFinal(ctx) {
+      ctx.t += ctx.c;
+      while (ctx.c < 64) {
+        ctx.b[ctx.c++] = 0;
+      }
+      blake2sCompress(ctx, true);
+      const out = new Uint8Array(ctx.outlen);
+      for (let i = 0; i < ctx.outlen; i++) {
+        out[i] = ctx.h[i >> 2] >> 8 * (i & 3) & 255;
+      }
+      return out;
+    }
+    function blake2s(input, key, outlen) {
+      outlen = outlen || 32;
+      input = util.normalizeInput(input);
+      const ctx = blake2sInit(outlen, key);
+      blake2sUpdate(ctx, input);
+      return blake2sFinal(ctx);
+    }
+    function blake2sHex(input, key, outlen) {
+      const output = blake2s(input, key, outlen);
+      return util.toHex(output);
+    }
+    module.exports = {
+      blake2s,
+      blake2sHex,
+      blake2sInit,
+      blake2sUpdate,
+      blake2sFinal
+    };
+  }
+});
+
+// node_modules/blakejs/index.js
+var require_blakejs = __commonJS({
+  "node_modules/blakejs/index.js"(exports, module) {
+    var b2b = require_blake2b3();
+    var b2s = require_blake2s();
+    module.exports = {
+      blake2b: b2b.blake2b,
+      blake2bHex: b2b.blake2bHex,
+      blake2bInit: b2b.blake2bInit,
+      blake2bUpdate: b2b.blake2bUpdate,
+      blake2bFinal: b2b.blake2bFinal,
+      blake2s: b2s.blake2s,
+      blake2sHex: b2s.blake2sHex,
+      blake2sInit: b2s.blake2sInit,
+      blake2sUpdate: b2s.blake2sUpdate,
+      blake2sFinal: b2s.blake2sFinal
+    };
+  }
+});
+
+// src/bip32/in-memory-bip32.ts
+import {
+  Bip32PrivateKey,
+  ready
+} from "@cardano-sdk/crypto";
+
+// node_modules/@scure/base/lib/esm/index.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode, decode };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0; i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function unsafeWrapper(fn) {
+  afn(fn);
+  return function(...args) {
+    try {
+      return fn.apply(null, args);
+    } catch (e) {
+    }
+  };
+}
+var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join(""));
+var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function bech32Polymod(pre) {
+  const b = pre >> 25;
+  let chk = (pre & 33554431) << 5;
+  for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
+    if ((b >> i & 1) === 1)
+      chk ^= POLYMOD_GENERATORS[i];
+  }
+  return chk;
+}
+function bechChecksum(prefix, words, encodingConst = 1) {
+  const len = prefix.length;
+  let chk = 1;
+  for (let i = 0; i < len; i++) {
+    const c = prefix.charCodeAt(i);
+    if (c < 33 || c > 126)
+      throw new Error(`Invalid prefix (${prefix})`);
+    chk = bech32Polymod(chk) ^ c >> 5;
+  }
+  chk = bech32Polymod(chk);
+  for (let i = 0; i < len; i++)
+    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
+  for (let v of words)
+    chk = bech32Polymod(chk) ^ v;
+  for (let i = 0; i < 6; i++)
+    chk = bech32Polymod(chk);
+  chk ^= encodingConst;
+  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
+}
+// @__NO_SIDE_EFFECTS__
+function genBech32(encoding) {
+  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
+  const _words = /* @__PURE__ */ radix2(5);
+  const fromWords = _words.decode;
+  const toWords = _words.encode;
+  const fromWordsUnsafe = unsafeWrapper(fromWords);
+  function encode(prefix, words, limit = 90) {
+    astr("bech32.encode prefix", prefix);
+    if (isBytes(words))
+      words = Array.from(words);
+    anumArr("bech32.encode", words);
+    const plen = prefix.length;
+    if (plen === 0)
+      throw new TypeError(`Invalid prefix length ${plen}`);
+    const actualLength = plen + 7 + words.length;
+    if (limit !== false && actualLength > limit)
+      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
+    const lowered = prefix.toLowerCase();
+    const sum = bechChecksum(lowered, words, ENCODING_CONST);
+    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  }
+  function decode(str, limit = 90) {
+    astr("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 prefix = lowered.slice(0, sepIndex);
+    const data = lowered.slice(sepIndex + 1);
+    if (data.length < 6)
+      throw new Error("Data must be at least 6 characters long");
+    const words = BECH_ALPHABET.decode(data).slice(0, -6);
+    const sum = bechChecksum(prefix, words, ENCODING_CONST);
+    if (!data.endsWith(sum))
+      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
+    return { prefix, words };
+  }
+  const decodeUnsafe = unsafeWrapper(decode);
+  function decodeToBytes(str) {
+    const { prefix, words } = decode(str, false);
+    return { prefix, words, bytes: fromWords(words) };
+  }
+  function encodeFromBytes(prefix, bytes) {
+    return encode(prefix, toWords(bytes));
+  }
+  return {
+    encode,
+    decode,
+    encodeFromBytes,
+    decodeToBytes,
+    decodeUnsafe,
+    fromWords,
+    fromWordsUnsafe,
+    toWords
+  };
+}
+var bech32 = /* @__PURE__ */ genBech32("bech32");
+
 // src/bip32/in-memory-bip32.ts
-import { setInConwayEra as setInConwayEra2 } from "@cardano-sdk/core";
+var import_bip39 = __toESM(require_src(), 1);
+
+// src/cardano/utils/constants.ts
+var HARDENED_OFFSET = 2147483648;
+var DEFAULT_ACCOUNT_KEY_DERIVATION_PATH = [
+  1852 + HARDENED_OFFSET,
+  1815 + HARDENED_OFFSET,
+  0 + HARDENED_OFFSET
+];
+var DEFAULT_PAYMENT_KEY_DERIVATION_PATH = [
+  ...DEFAULT_ACCOUNT_KEY_DERIVATION_PATH,
+  0
+];
+var DEFAULT_STAKE_KEY_DERIVATION_PATH = [
+  ...DEFAULT_ACCOUNT_KEY_DERIVATION_PATH,
+  2
+];
+var DEFAULT_DREP_KEY_DERIVATION_PATH = [
+  ...DEFAULT_ACCOUNT_KEY_DERIVATION_PATH,
+  3
+];
+
+// src/interfaces/secret-manager.ts
+var derivationPathVectorFromString = (path) => {
+  if (!/^m?\/\d+(\/\d+)*$/.test(path)) {
+    throw new Error(`Invalid derivation path: ${path}`);
+  }
+  let pathString = path;
+  if (pathString.startsWith("m/")) {
+    pathString = pathString.slice(2);
+  }
+  return pathString.split("/").map((part) => {
+    if (part.endsWith("'")) {
+      return Number.parseInt(part.slice(0, -1)) + HARDENED_OFFSET;
+    } else {
+      return Number.parseInt(part);
+    }
+  });
+};
+
+// src/signer/base-signer.ts
+import { setInConwayEra } from "@cardano-sdk/core";
 import {
-  Bip32PrivateKey,
-  ready
+  Ed25519PrivateExtendedKeyHex,
+  Ed25519PrivateKey,
+  Ed25519PrivateNormalKeyHex,
+  Ed25519Signature,
+  Ed25519SignatureHex
 } from "@cardano-sdk/crypto";
+import { HexBlob } from "@cardano-sdk/util";
+var BaseSigner = class _BaseSigner {
+  constructor(ed25519PrivateKey) {
+    setInConwayEra(true);
+    this.ed25519PrivateKey = ed25519PrivateKey;
+  }
+  /**
+   * Create a BaseSigner instance from an Ed25519 private key in extended hex format.
+   * @param keyHex Ed25519 private key in extended hex format
+   * @returns {BaseSigner} A BaseSigner instance
+   */
+  static fromExtendedKeyHex(keyHex) {
+    return new _BaseSigner(
+      Ed25519PrivateKey.fromExtendedHex(Ed25519PrivateExtendedKeyHex(keyHex))
+    );
+  }
+  /**
+   * Create a BaseSigner instance from an Ed25519 private key in normal hex format.
+   * @param keyHex Ed25519 private key in normal hex format
+   * @returns {BaseSigner} A BaseSigner instance
+   */
+  static fromNormalKeyHex(keyHex) {
+    return new _BaseSigner(
+      Ed25519PrivateKey.fromNormalHex(Ed25519PrivateNormalKeyHex(keyHex))
+    );
+  }
+  static fromKeyHex(keyHex) {
+    const hexLength = keyHex.length;
+    if (hexLength === 128) {
+      return this.fromExtendedKeyHex(keyHex);
+    } else if (hexLength === 64) {
+      return this.fromNormalKeyHex(keyHex);
+    } else {
+      throw new Error(
+        `Invalid key length: ${hexLength}. Expected 64 (normal key) or 128 (extended key) hex characters.`
+      );
+    }
+  }
+  /**
+   * Get the Ed25519 public key in hex format.
+   * @returns {Promise<string>} A promise that resolves to the public key in hex format.
+   */
+  async getPublicKey() {
+    return this.ed25519PrivateKey.toPublic().hex();
+  }
+  /**
+   * Get the Ed25519 public key hash in hex format.
+   * @returns {Promise<string>} A promise that resolves to the public key hash in hex format.
+   */
+  async getPublicKeyHash() {
+    return this.ed25519PrivateKey.toPublic().hash().hex();
+  }
+  /**
+   * Sign data using the Ed25519 private key.
+   * @param data data to be signed in hex format
+   * @returns {Promise<string>} A promise that resolves to the signature in hex format.
+   */
+  async sign(data) {
+    return this.ed25519PrivateKey.sign(HexBlob(data)).hex();
+  }
+  /**
+   * Verify a signature using the Ed25519 public key.
+   * @param data The original data in hex format.
+   * @param signature The signature to verify in hex format.
+   * @returns {Promise<boolean>} A promise that resolves to true if the signature is valid, false otherwise.
+   */
+  async verify(data, signature) {
+    return this.ed25519PrivateKey.toPublic().verify(
+      Ed25519Signature.fromHex(Ed25519SignatureHex(signature)),
+      HexBlob(data)
+    );
+  }
+};
+
+// src/bip32/in-memory-bip32.ts
+var InMemoryBip32 = class _InMemoryBip32 {
+  constructor(privateKey) {
+    this.bip32PrivateKey = privateKey;
+  }
+  static async fromMnemonic(mnemonic, password) {
+    await ready();
+    const entropy = (0, import_bip39.mnemonicToEntropy)(mnemonic.join(" "));
+    const bip32PrivateKey = Bip32PrivateKey.fromBip39Entropy(
+      Buffer.from(entropy, "hex"),
+      password || ""
+    );
+    return new _InMemoryBip32(bip32PrivateKey);
+  }
+  static async fromEntropy(entropy, password) {
+    await ready();
+    const bip32PrivateKey = Bip32PrivateKey.fromBip39Entropy(
+      Buffer.from(entropy, "hex"),
+      password || ""
+    );
+    return new _InMemoryBip32(bip32PrivateKey);
+  }
+  static fromKeyHex(keyHex) {
+    const bip32PrivateKey = Bip32PrivateKey.fromHex(
+      keyHex
+    );
+    return new _InMemoryBip32(bip32PrivateKey);
+  }
+  static fromBech32(bech323) {
+    const bech32DecodedBytes = bech32.decodeToBytes(bech323).bytes;
+    const bip32PrivateKey = Bip32PrivateKey.fromBytes(bech32DecodedBytes);
+    return new _InMemoryBip32(bip32PrivateKey);
+  }
+  /**
+   * Get the Bip32 public key in hex format.
+   * @returns {Promise<string>} A promise that resolves to the public key in hex format.
+   */
+  async getPublicKey() {
+    await ready();
+    return this.bip32PrivateKey.toPublic().hex();
+  }
+  /**
+   * Get an ISigner instance initialized with the current Bip32 private key.
+   * @returns {Promise<ISigner>} A promise that resolves to an ISigner instance initialized with the current Bip32 private key.
+   */
+  async getSigner(derivationPath) {
+    const path = Array.isArray(derivationPath) ? derivationPath : derivationPathVectorFromString(derivationPath);
+    const bip32PrivateKey = this.bip32PrivateKey.derive(path);
+    return BaseSigner.fromExtendedKeyHex(bip32PrivateKey.toRawKey().hex());
+  }
+};
+
+// src/cardano/address/cardano-address.ts
+import { Cardano, setInConwayEra as setInConwayEra2 } from "@cardano-sdk/core";
+import { Hash28ByteBase16 } from "@cardano-sdk/crypto";
+var CredentialType = /* @__PURE__ */ ((CredentialType2) => {
+  CredentialType2[CredentialType2["KeyHash"] = 0] = "KeyHash";
+  CredentialType2[CredentialType2["ScriptHash"] = 1] = "ScriptHash";
+  return CredentialType2;
+})(CredentialType || {});
+var AddressType = /* @__PURE__ */ ((AddressType2) => {
+  AddressType2[AddressType2["Enterprise"] = 0] = "Enterprise";
+  AddressType2[AddressType2["Base"] = 1] = "Base";
+  AddressType2[AddressType2["Reward"] = 2] = "Reward";
+  return AddressType2;
+})(AddressType || {});
+var CardanoAddress = class {
+  constructor(addressType, networkId, paymentCredential, stakeCredential) {
+    setInConwayEra2(true);
+    if (addressType === 1 /* Base */ && !stakeCredential) {
+      throw new Error("No stake credential");
+    }
+    this.addressType = addressType;
+    this.networkId = networkId;
+    this.paymentCredential = paymentCredential;
+    this.stakeCredential = stakeCredential;
+  }
+  getAddressBech32() {
+    if (this.addressType === 0 /* Enterprise */) {
+      return this.getEnterpriseAddressBech32();
+    } else if (this.addressType === 1 /* Base */) {
+      return this.getBaseAddressBech32();
+    } else if (this.addressType === 2 /* Reward */) {
+      return this.getRewardAddressBech32();
+    }
+    throw new Error(`Invalid address type: ${this.addressType}`);
+  }
+  getAddressHex() {
+    if (this.addressType === 0 /* Enterprise */) {
+      return this.getEnterpriseAddressHex();
+    } else if (this.addressType === 1 /* Base */) {
+      return this.getBaseAddressHex();
+    } else if (this.addressType === 2 /* Reward */) {
+      return this.getRewardAddressHex();
+    }
+    throw new Error(`Invalid address type: ${this.addressType}`);
+  }
+  getEnterpriseAddressBech32() {
+    const enterpriseAddress = Cardano.EnterpriseAddress.fromCredentials(
+      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+      {
+        hash: Hash28ByteBase16(this.paymentCredential.hash),
+        type: mapCredentialTypeToCredential(this.paymentCredential.type)
+      }
+    );
+    return enterpriseAddress.toAddress().toBech32();
+  }
+  getEnterpriseAddressHex() {
+    const enterpriseAddress = Cardano.EnterpriseAddress.fromCredentials(
+      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+      {
+        hash: Hash28ByteBase16(this.paymentCredential.hash),
+        type: mapCredentialTypeToCredential(this.paymentCredential.type)
+      }
+    );
+    return enterpriseAddress.toAddress().toBytes();
+  }
+  getBaseAddressBech32() {
+    if (!this.stakeCredential) throw new Error("No stake credential");
+    const baseAddress = Cardano.BaseAddress.fromCredentials(
+      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+      {
+        hash: Hash28ByteBase16(this.paymentCredential.hash),
+        type: mapCredentialTypeToCredential(this.paymentCredential.type)
+      },
+      {
+        hash: Hash28ByteBase16(this.stakeCredential.hash),
+        type: mapCredentialTypeToCredential(this.stakeCredential.type)
+      }
+    );
+    return baseAddress.toAddress().toBech32();
+  }
+  getBaseAddressHex() {
+    if (!this.stakeCredential) throw new Error("No stake credential");
+    const baseAddress = Cardano.BaseAddress.fromCredentials(
+      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+      {
+        hash: Hash28ByteBase16(this.paymentCredential.hash),
+        type: mapCredentialTypeToCredential(this.paymentCredential.type)
+      },
+      {
+        hash: Hash28ByteBase16(this.stakeCredential.hash),
+        type: this.stakeCredential.type
+      }
+    );
+    return baseAddress.toAddress().toBytes();
+  }
+  getRewardAddressBech32() {
+    if (!this.stakeCredential) throw new Error("No stake credential");
+    const rewardAddress = Cardano.RewardAddress.fromCredentials(
+      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+      {
+        hash: Hash28ByteBase16(this.stakeCredential.hash),
+        type: this.stakeCredential.type
+      }
+    );
+    return rewardAddress.toAddress().toBech32();
+  }
+  getRewardAddressHex() {
+    if (!this.stakeCredential) throw new Error("No stake credential");
+    const rewardAddress = Cardano.RewardAddress.fromCredentials(
+      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+      {
+        hash: Hash28ByteBase16(this.stakeCredential.hash),
+        type: this.stakeCredential.type
+      }
+    );
+    return rewardAddress.toAddress().toBytes();
+  }
+};
+var mapCredentialTypeToCredential = (credentialType) => {
+  switch (credentialType) {
+    case 0 /* KeyHash */:
+      return Cardano.CredentialType.KeyHash;
+    case 1 /* ScriptHash */:
+      return Cardano.CredentialType.ScriptHash;
+  }
+};
 
-// node_modules/@scure/base/lib/esm/index.js
-function isBytes(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-function isArrayOf(isString, arr) {
-  if (!Array.isArray(arr))
-    return false;
-  if (arr.length === 0)
-    return true;
-  if (isString) {
-    return arr.every((item) => typeof item === "string");
-  } else {
-    return arr.every((item) => Number.isSafeInteger(item));
+// src/cardano/wallet/browser/cardano-browser-wallet.ts
+var CardanoBrowserWallet = class _CardanoBrowserWallet {
+  constructor(walletInstance) {
+    this.walletInstance = walletInstance;
   }
-}
-function afn(input) {
-  if (typeof input !== "function")
-    throw new Error("function expected");
-  return true;
-}
-function astr(label, input) {
-  if (typeof input !== "string")
-    throw new Error(`${label}: string expected`);
-  return true;
-}
-function anumber(n) {
-  if (!Number.isSafeInteger(n))
-    throw new Error(`invalid integer: ${n}`);
-}
-function aArr(input) {
-  if (!Array.isArray(input))
-    throw new Error("array expected");
-}
-function astrArr(label, input) {
-  if (!isArrayOf(true, input))
-    throw new Error(`${label}: array of strings expected`);
-}
-function anumArr(label, input) {
-  if (!isArrayOf(false, input))
-    throw new Error(`${label}: array of numbers expected`);
-}
-// @__NO_SIDE_EFFECTS__
-function chain(...args) {
-  const id = (a) => a;
-  const wrap = (a, b) => (c) => a(b(c));
-  const encode = args.map((x) => x.encode).reduceRight(wrap, id);
-  const decode = args.map((x) => x.decode).reduce(wrap, id);
-  return { encode, decode };
-}
-// @__NO_SIDE_EFFECTS__
-function alphabet(letters) {
-  const lettersA = typeof letters === "string" ? letters.split("") : letters;
-  const len = lettersA.length;
-  astrArr("alphabet", lettersA);
-  const indexes = new Map(lettersA.map((l, i) => [l, i]));
-  return {
-    encode: (digits) => {
-      aArr(digits);
-      return digits.map((i) => {
-        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
-          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
-        return lettersA[i];
-      });
-    },
-    decode: (input) => {
-      aArr(input);
-      return input.map((letter) => {
-        astr("alphabet.decode", letter);
-        const i = indexes.get(letter);
-        if (i === void 0)
-          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
-        return i;
-      });
+  async getNetworkId() {
+    return this.walletInstance.getNetworkId();
+  }
+  async getUtxos() {
+    return this.walletInstance.getUtxos();
+  }
+  async getCollateral() {
+    return this.walletInstance.getCollateral();
+  }
+  async getBalance() {
+    return this.walletInstance.getBalance();
+  }
+  async getUsedAddresses() {
+    return this.walletInstance.getUsedAddresses();
+  }
+  async getUnusedAddresses() {
+    return this.walletInstance.getUnusedAddresses();
+  }
+  async getRewardAddresses() {
+    return this.walletInstance.getRewardAddresses();
+  }
+  async getChangeAddress() {
+    return this.walletInstance.getChangeAddress();
+  }
+  async signTx(data, partialSign) {
+    return this.walletInstance.signTx(data, partialSign);
+  }
+  async signData(addressBech32, data) {
+    return this.walletInstance.signData(addressBech32, data);
+  }
+  async submitTx(tx) {
+    return this.walletInstance.submitTx(tx);
+  }
+  /**
+   * Returns a list of wallets installed on user's device. Each wallet is an object with the following properties:
+   * - A name is provided to display wallet's name on the user interface.
+   * - A version is provided to display wallet's version on the user interface.
+   * - An icon is provided to display wallet's icon on the user interface.
+   *
+   * @returns a list of wallet names
+   */
+  static getInstalledWallets() {
+    if (globalThis === void 0) return [];
+    if (globalThis.cardano === void 0) return [];
+    let wallets = [];
+    for (const key in globalThis.cardano) {
+      try {
+        const _wallet = globalThis.cardano[key];
+        if (_wallet === void 0) continue;
+        if (_wallet.name === void 0) continue;
+        if (_wallet.icon === void 0) continue;
+        if (_wallet.apiVersion === void 0) continue;
+        wallets.push({
+          id: key,
+          name: key == "nufiSnap" ? "MetaMask" : _wallet.name,
+          icon: _wallet.icon,
+          version: _wallet.apiVersion
+        });
+      } catch (e) {
+      }
     }
-  };
-}
-// @__NO_SIDE_EFFECTS__
-function join(separator = "") {
-  astr("join", separator);
+    return wallets;
+  }
+  /**
+   * This is the entrypoint to start communication with the user's wallet. The wallet should request the user's permission to connect the web page to the user's wallet, and if permission has been granted, the wallet will be returned and exposing the full API for the app to use.
+   *
+   * Query BrowserWallet.getInstalledWallets() to get a list of available wallets, then provide the wallet name for which wallet the user would like to connect with.
+   *
+   * @param walletName - the name of the wallet to enable (e.g. "eternl", "begin")
+   * @param extensions - optional, a list of CIPs that the wallet should support
+   * @returns WalletInstance
+   */
+  static async enable(walletName, extensions = []) {
+    try {
+      const walletInstance = extensions.length > 0 ? await globalThis.cardano[walletName].enable({
+        extensions
+      }) : await globalThis.cardano[walletName].enable();
+      if (walletInstance !== void 0)
+        return new _CardanoBrowserWallet(walletInstance);
+      throw new Error(`Couldn't create an instance of wallet: ${walletName}`);
+    } catch (error) {
+      throw new Error(
+        `[BrowserWallet] An error occurred during enable: ${JSON.stringify(
+          error
+        )}.`
+      );
+    }
+  }
+};
+
+// src/cardano/wallet/browser/mesh-browser-wallet.ts
+import { Serialization as Serialization2, Cardano as Cardano3 } from "@cardano-sdk/core";
+import { HexBlob as HexBlob3 } from "@cardano-sdk/util";
+
+// src/cardano/utils/converter.ts
+import { Cardano as Cardano2, Serialization } from "@cardano-sdk/core";
+import { Hash32ByteBase16 } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob2 } from "@cardano-sdk/util";
+var toTxUnspentOutput = (utxo) => {
+  const txInput = new Serialization.TransactionInput(
+    Cardano2.TransactionId(utxo.input.txHash),
+    BigInt(utxo.input.outputIndex)
+  );
+  const txOutput = new Serialization.TransactionOutput(
+    Cardano2.Address.fromBech32(utxo.output.address),
+    toValue(utxo.output.amount)
+  );
+  if (utxo.output.dataHash !== void 0) {
+    txOutput.setDatum(
+      Serialization.Datum.fromCore(Hash32ByteBase16(utxo.output.dataHash))
+    );
+  }
+  if (utxo.output.plutusData !== void 0) {
+    const plutusData = Serialization.PlutusData.fromCbor(
+      HexBlob2(utxo.output.plutusData)
+    );
+    const datum = new Serialization.Datum(void 0, plutusData);
+    txOutput.setDatum(datum);
+  }
+  if (utxo.output.scriptRef !== void 0) {
+    txOutput.setScriptRef(
+      Serialization.Script.fromCbor(HexBlob2(utxo.output.scriptRef))
+    );
+  }
+  return new Serialization.TransactionUnspentOutput(txInput, txOutput);
+};
+var fromTxUnspentOutput = (txUnspentOutput) => {
+  const dataHash = txUnspentOutput.output().datum() ? txUnspentOutput.output().datum()?.asDataHash()?.toString() : void 0;
+  const scriptRef = txUnspentOutput.output().scriptRef() ? txUnspentOutput.output().scriptRef()?.toCbor().toString() : void 0;
+  const plutusData = txUnspentOutput.output().datum()?.asInlineData() ? txUnspentOutput.output().datum()?.asInlineData()?.toCbor().toString() : void 0;
   return {
-    encode: (from) => {
-      astrArr("join.decode", from);
-      return from.join(separator);
+    input: {
+      outputIndex: Number(txUnspentOutput.input().index()),
+      txHash: txUnspentOutput.input().transactionId()
     },
-    decode: (to) => {
-      astr("join.decode", to);
-      return to.split(separator);
+    output: {
+      address: txUnspentOutput.output().address().toBech32(),
+      amount: fromValue(txUnspentOutput.output().amount()),
+      dataHash,
+      // todo not sure if correct
+      plutusData,
+      // todo not sure if correct
+      scriptRef
+      // todo not sure if correct
     }
   };
+};
+var toValue = (assets) => {
+  const multiAsset = /* @__PURE__ */ new Map();
+  assets.filter((asset) => asset.unit !== "lovelace" && asset.unit !== "").forEach((asset) => {
+    multiAsset.set(Cardano2.AssetId(asset.unit), BigInt(asset.quantity));
+  });
+  const lovelace = assets.find(
+    (asset) => asset.unit === "lovelace" || asset.unit === ""
+  );
+  const value = new Serialization.Value(
+    BigInt(lovelace ? lovelace.quantity : 0)
+  );
+  if (assets.length > 1 || !lovelace) {
+    value.setMultiasset(multiAsset);
+  }
+  return value;
+};
+var fromValue = (value) => {
+  const assets = [
+    { unit: "lovelace", quantity: value.coin().toString() }
+  ];
+  const multiAsset = value.multiasset();
+  if (multiAsset !== void 0) {
+    const _assets = Array.from(multiAsset.keys());
+    for (let i = 0; i < _assets.length; i += 1) {
+      const assetId = _assets[i];
+      if (assetId !== void 0) {
+        const assetQuantity = multiAsset.get(assetId);
+        if (assetQuantity !== void 0) {
+          assets.push({
+            unit: assetId,
+            quantity: assetQuantity.toString()
+          });
+        }
+      }
+    }
+  }
+  return assets;
+};
+
+// src/cardano/wallet/browser/mesh-browser-wallet.ts
+var MeshCardanoBrowserWallet = class _MeshCardanoBrowserWallet extends CardanoBrowserWallet {
+  constructor(walletInstance) {
+    super(walletInstance);
+  }
+  static async enable(walletName, extensions = []) {
+    const walletInstance = await super.enable(walletName, extensions);
+    return new _MeshCardanoBrowserWallet(walletInstance);
+  }
+  async getUtxosMesh() {
+    const utxosCbor = await this.getUtxos();
+    return utxosCbor.map(
+      (utxoCbor) => fromTxUnspentOutput(
+        Serialization2.TransactionUnspentOutput.fromCbor(HexBlob3(utxoCbor))
+      )
+    );
+  }
+  async getCollateralMesh() {
+    const collateralCbor = await this.getCollateral();
+    return collateralCbor.map(
+      (utxoCbor) => fromTxUnspentOutput(
+        Serialization2.TransactionUnspentOutput.fromCbor(HexBlob3(utxoCbor))
+      )
+    );
+  }
+  async getBalanceMesh() {
+    const balanceCbor = await this.getBalance();
+    const value = Serialization2.Value.fromCbor(HexBlob3(balanceCbor));
+    return fromValue(value);
+  }
+  async getUsedAddressesBech32() {
+    const addressesHex = await this.getUsedAddresses();
+    return addressesHex.map((addr) => {
+      const cardanoAddr = Cardano3.Address.fromBytes(HexBlob3(addr));
+      return cardanoAddr.toBech32();
+    });
+  }
+  async getUnusedAddressesBech32() {
+    const addressesHex = await this.getUnusedAddresses();
+    return addressesHex.map((addr) => {
+      const cardanoAddr = Cardano3.Address.fromBytes(HexBlob3(addr));
+      return cardanoAddr.toBech32();
+    });
+  }
+  async getChangeAddressBech32() {
+    const addressHex = await this.getChangeAddress();
+    const cardanoAddr = Cardano3.Address.fromBytes(HexBlob3(addressHex));
+    return cardanoAddr.toBech32();
+  }
+  async getRewardAddressesBech32() {
+    const addresses = await this.getRewardAddresses();
+    return addresses.map((addr) => {
+      const cardanoAddr = Cardano3.Address.fromBytes(HexBlob3(addr));
+      return cardanoAddr.toBech32();
+    });
+  }
+  async signTxReturnFullTx(tx, partialSign = false) {
+    const witnessCbor = await this.signTx(tx, partialSign);
+    const addedWitnesses = Serialization2.TransactionWitnessSet.fromCbor(
+      HexBlob3(witnessCbor)
+    );
+    const transaction = Serialization2.Transaction.fromCbor(
+      Serialization2.TxCBOR(tx)
+    );
+    let witnessSet = transaction.witnessSet();
+    let witnessSetVkeys = witnessSet.vkeys();
+    let witnessSetVkeysValues = witnessSetVkeys ? [
+      ...witnessSetVkeys.values(),
+      ...addedWitnesses.vkeys()?.values() ?? []
+    ] : [...addedWitnesses.vkeys()?.values() ?? []];
+    witnessSet.setVkeys(
+      Serialization2.CborSet.fromCore(
+        witnessSetVkeysValues.map((vkw) => vkw.toCore()),
+        Serialization2.VkeyWitness.fromCore
+      )
+    );
+    const signedTx = new Serialization2.Transaction(
+      transaction.body(),
+      witnessSet,
+      transaction.auxiliaryData()
+    );
+    return signedTx.toCbor();
+  }
+};
+
+// src/cardano/wallet/mesh/cardano-base-wallet.ts
+import { Cardano as Cardano6, Serialization as Serialization6, setInConwayEra as setInConwayEra5 } from "@cardano-sdk/core";
+
+// src/utils/value.ts
+import { Serialization as Serialization3 } from "@cardano-sdk/core";
+function mergeValue(a, b) {
+  const ma = a.multiasset() ?? /* @__PURE__ */ new Map();
+  b.multiasset()?.forEach((v, k) => {
+    const newVal = (ma.get(k) ?? 0n) + v;
+    if (newVal == 0n) {
+      ma.delete(k);
+    } else {
+      ma.set(k, newVal);
+    }
+  });
+  return new Serialization3.Value(
+    BigInt(a.coin()) + BigInt(b.coin()),
+    ma.size > 0 ? ma : void 0
+  );
 }
-var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
-var powers = /* @__PURE__ */ (() => {
-  let res = [];
-  for (let i = 0; i < 40; i++)
-    res.push(2 ** i);
-  return res;
-})();
-function convertRadix2(data, from, to, padding) {
-  aArr(data);
-  if (from <= 0 || from > 32)
-    throw new Error(`convertRadix2: wrong from=${from}`);
-  if (to <= 0 || to > 32)
-    throw new Error(`convertRadix2: wrong to=${to}`);
-  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
-    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+
+// src/cardano/address/single-address-manager.ts
+import { setInConwayEra as setInConwayEra3 } from "@cardano-sdk/core";
+var AddressManager = class _AddressManager {
+  static async create(config) {
+    let paymentSigner;
+    let paymentCredential;
+    if (config.addressSource.type === "credentials") {
+      if (config.addressSource.paymentCredential.type === "scriptHash") {
+        throw new Error(
+          "Payment credential cannot be a script hash. Payment credentials must be key hashes that can sign transactions."
+        );
+      } else {
+        paymentSigner = config.addressSource.paymentCredential.signer;
+        paymentCredential = {
+          type: 0 /* KeyHash */,
+          hash: await paymentSigner.getPublicKeyHash()
+        };
+      }
+    } else {
+      paymentSigner = await config.addressSource.secretManager.getSigner([
+        ...DEFAULT_PAYMENT_KEY_DERIVATION_PATH,
+        0
+      ]);
+      paymentCredential = {
+        type: 0 /* KeyHash */,
+        hash: await paymentSigner.getPublicKeyHash()
+      };
+    }
+    let stakeSigner = void 0;
+    let stakeCredential;
+    if (config.addressSource.type === "credentials" && config.addressSource.stakeCredential) {
+      if (config.addressSource.stakeCredential.type === "scriptHash") {
+        stakeCredential = {
+          type: 1 /* ScriptHash */,
+          hash: config.addressSource.stakeCredential.scriptHash
+        };
+      } else {
+        stakeSigner = config.addressSource.stakeCredential.signer;
+        stakeCredential = {
+          type: 0 /* KeyHash */,
+          hash: await stakeSigner.getPublicKeyHash()
+        };
+      }
+    } else if (config.addressSource.type === "secretManager") {
+      stakeSigner = await config.addressSource.secretManager.getSigner([
+        ...DEFAULT_STAKE_KEY_DERIVATION_PATH,
+        0
+      ]);
+      stakeCredential = {
+        type: 0 /* KeyHash */,
+        hash: await stakeSigner.getPublicKeyHash()
+      };
+    }
+    let drepSigner = void 0;
+    let drepCredential;
+    if (config.addressSource.type === "credentials" && config.addressSource.drepCredential) {
+      if (config.addressSource.drepCredential.type === "scriptHash") {
+        drepCredential = {
+          type: 1 /* ScriptHash */,
+          hash: config.addressSource.drepCredential.scriptHash
+        };
+      } else {
+        drepSigner = config.addressSource.drepCredential.signer;
+        drepCredential = {
+          type: 0 /* KeyHash */,
+          hash: await drepSigner.getPublicKeyHash()
+        };
+      }
+    } else if (config.addressSource.type === "secretManager") {
+      drepSigner = await config.addressSource.secretManager.getSigner([
+        ...DEFAULT_DREP_KEY_DERIVATION_PATH,
+        0
+      ]);
+      drepCredential = {
+        type: 0 /* KeyHash */,
+        hash: await drepSigner.getPublicKeyHash()
+      };
+    }
+    const networkId = config.networkId;
+    return new _AddressManager(
+      paymentCredential,
+      stakeCredential,
+      drepCredential,
+      paymentSigner,
+      networkId,
+      stakeSigner,
+      drepSigner
+    );
   }
-  let carry = 0;
-  let pos = 0;
-  const max = powers[from];
-  const mask = powers[to] - 1;
-  const res = [];
-  for (const n of data) {
-    anumber(n);
-    if (n >= max)
-      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
-    carry = carry << from | n;
-    if (pos + from > 32)
-      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
-    pos += from;
-    for (; pos >= to; pos -= to)
-      res.push((carry >> pos - to & mask) >>> 0);
-    const pow = powers[pos];
-    if (pow === void 0)
-      throw new Error("invalid carry");
-    carry &= pow - 1;
+  constructor(paymentCredential, stakeCredential, drepCredential, paymentSigner, networkId, stakeSigner, drepSigner) {
+    setInConwayEra3(true);
+    this.paymentCredential = paymentCredential;
+    this.stakeCredential = stakeCredential;
+    this.drepCredential = drepCredential;
+    this.paymentSigner = paymentSigner;
+    this.stakeSigner = stakeSigner;
+    this.drepSigner = drepSigner;
+    this.networkId = networkId;
+  }
+  async getNextAddress(addressType) {
+    return new CardanoAddress(
+      addressType,
+      this.networkId,
+      this.paymentCredential,
+      this.stakeCredential
+    );
+  }
+  async getChangeAddress(addressType) {
+    return new CardanoAddress(
+      addressType,
+      this.networkId,
+      this.paymentCredential,
+      this.stakeCredential
+    );
+  }
+  async getRewardAccount() {
+    return new CardanoAddress(
+      2 /* Reward */,
+      this.networkId,
+      this.paymentCredential,
+      this.stakeCredential
+    );
+  }
+  asyncGetAllUsedAddresses() {
+    return Promise.all([
+      this.getNextAddress(1 /* Base */),
+      this.getNextAddress(0 /* Enterprise */)
+    ]);
+  }
+  //TODO: Implement getDrepId
+  //async getDrepId(): Promise<string> {
+  //}
+  async getCredentialsSigners(pubkeyHashes) {
+    const signersMap = /* @__PURE__ */ new Map();
+    if (this.paymentCredential.type === 0 /* KeyHash */ && pubkeyHashes.has(this.paymentCredential.hash)) {
+      signersMap.set(this.paymentCredential.hash, this.paymentSigner);
+    }
+    if (this.stakeCredential && this.stakeCredential.type === 0 /* KeyHash */ && pubkeyHashes.has(this.stakeCredential.hash) && this.stakeSigner) {
+      signersMap.set(this.stakeCredential.hash, this.stakeSigner);
+    }
+    if (this.drepCredential && this.drepCredential.type === 0 /* KeyHash */ && pubkeyHashes.has(this.drepCredential.hash) && this.drepSigner) {
+      signersMap.set(this.drepCredential.hash, this.drepSigner);
+    }
+    return signersMap;
+  }
+};
+
+// src/cardano/signer/cardano-signer.ts
+import { Serialization as Serialization4, setInConwayEra as setInConwayEra4 } from "@cardano-sdk/core";
+import { Ed25519PublicKeyHex, Ed25519SignatureHex as Ed25519SignatureHex2 } from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob5 } from "@cardano-sdk/util";
+import {
+  CborBytes as CborBytes2,
+  CborMap as CborMap2,
+  CborNegInt as CborNegInt2,
+  CborText as CborText2,
+  CborUInt as CborUInt2
+} from "@harmoniclabs/cbor";
+
+// node_modules/@meshsdk/common/dist/index.js
+var import_bech32 = __toESM(require_dist(), 1);
+var import_blake2b = __toESM(require_blake2b2(), 1);
+var import_blakejs = __toESM(require_blakejs(), 1);
+var import_bip392 = __toESM(require_src(), 1);
+var stringToHex = (str) => Buffer.from(str, "utf8").toString("hex");
+var isHexString = (hex) => /^[0-9A-F]*$/i.test(hex);
+var SLOT_CONFIG_NETWORK = {
+  mainnet: {
+    zeroTime: 1596059091e3,
+    zeroSlot: 4492800,
+    slotLength: 1e3,
+    startEpoch: 208,
+    epochLength: 432e3
+  },
+  // Starting at Shelley era
+  preview: {
+    zeroTime: 1666656e6,
+    zeroSlot: 0,
+    slotLength: 1e3,
+    startEpoch: 0,
+    epochLength: 86400
+  },
+  // Starting at Shelley era
+  preprod: {
+    zeroTime: 16540416e5 + 1728e6,
+    zeroSlot: 86400,
+    slotLength: 1e3,
+    startEpoch: 4,
+    epochLength: 432e3
+  },
+  // Starting at Shelley era
+  /** Customizable slot config (Initialized with 0 values). */
+  testnet: {
+    zeroTime: 0,
+    zeroSlot: 0,
+    slotLength: 0,
+    startEpoch: 0,
+    epochLength: 0
   }
-  carry = carry << to - pos & mask;
-  if (!padding && pos >= from)
-    throw new Error("Excess padding");
-  if (!padding && carry > 0)
-    throw new Error(`Non-zero padding: ${carry}`);
-  if (padding && pos > 0)
-    res.push(carry >>> 0);
-  return res;
-}
-// @__NO_SIDE_EFFECTS__
-function radix2(bits, revPadding = false) {
-  anumber(bits);
-  if (bits <= 0 || bits > 32)
-    throw new Error("radix2: bits should be in (0..32]");
-  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
-    throw new Error("radix2: carry overflow");
-  return {
-    encode: (bytes) => {
-      if (!isBytes(bytes))
-        throw new Error("radix2.encode input should be Uint8Array");
-      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
-    },
-    decode: (digits) => {
-      anumArr("radix2.decode", digits);
-      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+};
+
+// src/cardano/signer/cip-8.ts
+var import_blakejs2 = __toESM(require_blakejs(), 1);
+import * as Crypto from "@cardano-sdk/crypto";
+import { HexBlob as HexBlob4 } from "@cardano-sdk/util";
+import {
+  Cbor,
+  CborArray,
+  CborBytes,
+  CborMap,
+  CborNegInt,
+  CborSimple,
+  CborText,
+  CborUInt,
+  isRawCborArray,
+  isRawCborMap
+} from "@harmoniclabs/cbor";
+import JSONBig from "json-bigint";
+var CoseSign1 = class _CoseSign1 {
+  constructor(payload) {
+    this.protectedMap = payload.protectedMap;
+    this.unProtectedMap = payload.unProtectedMap;
+    this.payload = payload.payload;
+    if (!this.unProtectedMap.map.find((value) => {
+      return JSONBig.stringify(value.k) === JSONBig.stringify(new CborText("hashed"));
+    })) {
+      this.unProtectedMap.map.push({
+        k: new CborText("hashed"),
+        v: new CborSimple(false)
+      });
     }
-  };
-}
-function unsafeWrapper(fn) {
-  afn(fn);
-  return function(...args) {
+    this.signature = payload.signature;
+  }
+  static fromCbor(cbor) {
+    const decoded = Cbor.parse(cbor);
+    if (!isRawCborArray(decoded.toRawObj()))
+      throw Error("Invalid CBOR");
+    if (decoded.array.length !== 4) throw Error("Invalid COSE_SIGN1");
+    let protectedMap;
+    const protectedSerialized = decoded.array[0];
     try {
-      return fn.apply(null, args);
-    } catch (e) {
+      protectedMap = Cbor.parse(protectedSerialized.bytes);
+      if (!isRawCborMap(protectedMap.toRawObj())) {
+        throw Error();
+      }
+    } catch (error) {
+      throw Error("Invalid protected");
     }
-  };
-}
-var BECH_ALPHABET = /* @__PURE__ */ chain(/* @__PURE__ */ alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), /* @__PURE__ */ join(""));
-var POLYMOD_GENERATORS = [996825010, 642813549, 513874426, 1027748829, 705979059];
-function bech32Polymod(pre) {
-  const b = pre >> 25;
-  let chk = (pre & 33554431) << 5;
-  for (let i = 0; i < POLYMOD_GENERATORS.length; i++) {
-    if ((b >> i & 1) === 1)
-      chk ^= POLYMOD_GENERATORS[i];
+    let unProtectedMap = decoded.array[1];
+    if (!isRawCborMap(unProtectedMap.toRawObj()))
+      throw Error("Invalid unprotected");
+    const payload = decoded.array[2];
+    const signature = decoded.array[3];
+    return new _CoseSign1({
+      protectedMap,
+      unProtectedMap,
+      payload,
+      signature
+    });
   }
-  return chk;
-}
-function bechChecksum(prefix, words, encodingConst = 1) {
-  const len = prefix.length;
-  let chk = 1;
-  for (let i = 0; i < len; i++) {
-    const c = prefix.charCodeAt(i);
-    if (c < 33 || c > 126)
-      throw new Error(`Invalid prefix (${prefix})`);
-    chk = bech32Polymod(chk) ^ c >> 5;
+  createSigStructure(externalAad = Buffer.alloc(0)) {
+    let protectedSerialized = new CborBytes(Buffer.alloc(0));
+    if (this.protectedMap.map.length !== 0) {
+      protectedSerialized = new CborBytes(
+        Cbor.encode(this.protectedMap).toBuffer()
+      );
+    }
+    if (!this.payload) throw Error("Invalid payload");
+    const structure = new CborArray([
+      new CborText("Signature1"),
+      protectedSerialized,
+      new CborBytes(externalAad),
+      this.payload
+    ]);
+    return Buffer.from(Cbor.encode(structure).toBuffer());
   }
-  chk = bech32Polymod(chk);
-  for (let i = 0; i < len; i++)
-    chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
-  for (let v of words)
-    chk = bech32Polymod(chk) ^ v;
-  for (let i = 0; i < 6; i++)
-    chk = bech32Polymod(chk);
-  chk ^= encodingConst;
-  return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
-}
-// @__NO_SIDE_EFFECTS__
-function genBech32(encoding) {
-  const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
-  const _words = /* @__PURE__ */ radix2(5);
-  const fromWords = _words.decode;
-  const toWords = _words.encode;
-  const fromWordsUnsafe = unsafeWrapper(fromWords);
-  function encode(prefix, words, limit = 90) {
-    astr("bech32.encode prefix", prefix);
-    if (isBytes(words))
-      words = Array.from(words);
-    anumArr("bech32.encode", words);
-    const plen = prefix.length;
-    if (plen === 0)
-      throw new TypeError(`Invalid prefix length ${plen}`);
-    const actualLength = plen + 7 + words.length;
-    if (limit !== false && actualLength > limit)
-      throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
-    const lowered = prefix.toLowerCase();
-    const sum = bechChecksum(lowered, words, ENCODING_CONST);
-    return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
+  buildMessage(signature) {
+    this.signature = new CborBytes(signature);
+    let protectedSerialized = new CborBytes(Buffer.alloc(0));
+    if (this.protectedMap.map.length !== 0) {
+      protectedSerialized = new CborBytes(
+        Cbor.encode(this.protectedMap).toBuffer()
+      );
+    }
+    if (!this.payload) throw Error("Invalid payload");
+    const coseSign1 = new CborArray([
+      protectedSerialized,
+      this.unProtectedMap,
+      this.payload,
+      this.signature
+    ]);
+    return Buffer.from(Cbor.encode(coseSign1).toBuffer());
   }
-  function decode(str, limit = 90) {
-    astr("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 prefix = lowered.slice(0, sepIndex);
-    const data = lowered.slice(sepIndex + 1);
-    if (data.length < 6)
-      throw new Error("Data must be at least 6 characters long");
-    const words = BECH_ALPHABET.decode(data).slice(0, -6);
-    const sum = bechChecksum(prefix, words, ENCODING_CONST);
-    if (!data.endsWith(sum))
-      throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
-    return { prefix, words };
+  verifySignature({
+    externalAad = Buffer.alloc(0),
+    publicKeyBuffer
+  } = {}) {
+    if (!publicKeyBuffer) {
+      publicKeyBuffer = this.getPublicKey();
+    }
+    if (!publicKeyBuffer) throw Error("Public key not found");
+    if (!this.signature) throw Error("Signature not found");
+    const publicKey = new Crypto.Ed25519PublicKey(publicKeyBuffer);
+    return publicKey.verify(
+      new Crypto.Ed25519Signature(this.signature.bytes),
+      HexBlob4(Buffer.from(this.createSigStructure(externalAad)).toString("hex"))
+    );
   }
-  const decodeUnsafe = unsafeWrapper(decode);
-  function decodeToBytes(str) {
-    const { prefix, words } = decode(str, false);
-    return { prefix, words, bytes: fromWords(words) };
+  hashPayload() {
+    if (!this.unProtectedMap) throw Error("Invalid unprotected map");
+    if (!this.payload) throw Error("Invalid payload");
+    const hashedIndex = this.unProtectedMap.map.findIndex((value) => {
+      return JSONBig.stringify(value.k) === JSONBig.stringify(new CborText("hashed"));
+    });
+    const hashed = this.unProtectedMap.map[hashedIndex];
+    if (hashed && JSONBig.stringify(hashed.v) === JSONBig.stringify(new CborSimple(true)))
+      throw Error("Payload already hashed");
+    if (hashed && JSONBig.stringify(hashed.v) === JSONBig.stringify(new CborSimple(true)) != false)
+      throw Error("Invalid unprotected map");
+    this.unProtectedMap.map.splice(hashedIndex, 1);
+    const hash = (0, import_blakejs2.blake2b)(this.payload.bytes, void 0, 24);
+    this.payload = new CborBytes(hash);
   }
-  function encodeFromBytes(prefix, bytes) {
-    return encode(prefix, toWords(bytes));
+  getAddress() {
+    const address = this.protectedMap.map.find((value) => {
+      return JSONBig.stringify(value.k) === JSONBig.stringify(new CborText("address"));
+    });
+    if (!address) throw Error("Address not found");
+    return Buffer.from(address.v.bytes);
   }
-  return {
-    encode,
-    decode,
-    encodeFromBytes,
-    decodeToBytes,
-    decodeUnsafe,
-    fromWords,
-    fromWordsUnsafe,
-    toWords
-  };
-}
-var bech32 = /* @__PURE__ */ genBech32("bech32");
-
-// src/bip32/in-memory-bip32.ts
-var import_bip39 = __toESM(require_src(), 1);
+  getPublicKey() {
+    const publicKey = this.protectedMap.map.find((value) => {
+      return JSONBig.stringify(value.k) === JSONBig.stringify(new CborUInt(4));
+    });
+    if (!publicKey) throw Error("Public key not found");
+    return Buffer.from(publicKey.v.bytes);
+  }
+  getSignature() {
+    return this.signature ? Buffer.from(this.signature.bytes) : void 0;
+  }
+  getPayload() {
+    return this.payload ? Buffer.from(this.payload.bytes) : null;
+  }
+};
+var getCoseKeyFromPublicKey = (cbor) => {
+  const coseKeyMap = [];
+  coseKeyMap.push({ k: new CborUInt(1), v: new CborUInt(1) });
+  coseKeyMap.push({ k: new CborUInt(3), v: new CborNegInt(-8) });
+  coseKeyMap.push({ k: new CborNegInt(-1), v: new CborUInt(6) });
+  coseKeyMap.push({
+    k: new CborNegInt(-2),
+    v: new CborBytes(Buffer.from(cbor, "hex"))
+  });
+  return Buffer.from(Cbor.encode(new CborMap(coseKeyMap)).toBuffer());
+};
 
-// src/utils/constants.ts
-var HARDENED_OFFSET = 2147483648;
-var DEFAULT_ACCOUNT_KEY_DERIVATION_PATH = [
-  1852 + HARDENED_OFFSET,
-  1815 + HARDENED_OFFSET,
-  0 + HARDENED_OFFSET
-];
-var DEFAULT_PAYMENT_KEY_DERIVATION_PATH = [
-  ...DEFAULT_ACCOUNT_KEY_DERIVATION_PATH,
-  0
-];
-var DEFAULT_STAKE_KEY_DERIVATION_PATH = [
-  ...DEFAULT_ACCOUNT_KEY_DERIVATION_PATH,
-  2
-];
-var DEFAULT_DREP_KEY_DERIVATION_PATH = [
-  ...DEFAULT_ACCOUNT_KEY_DERIVATION_PATH,
-  3
-];
+// src/cardano/signer/cardano-signer.ts
+var CardanoSigner = class {
+  constructor() {
+    setInConwayEra4(true);
+  }
+  static async signTx(tx, signers, returnFullTx = false) {
+    const cardanoTx = Serialization4.Transaction.fromCbor(
+      Serialization4.TxCBOR(tx)
+    );
+    const txHash = cardanoTx.body().hash();
+    const vkeyWitnesses = [];
+    for (const signer of signers) {
+      vkeyWitnesses.push([
+        Ed25519PublicKeyHex(await signer.getPublicKey()),
+        Ed25519SignatureHex2(await signer.sign(HexBlob5(txHash)))
+      ]);
+    }
+    if (returnFullTx) {
+      const txWitnessSet2 = cardanoTx.witnessSet();
+      let witnessSetVkeys = txWitnessSet2.vkeys();
+      let witnessSetVkeysValues = witnessSetVkeys ? [
+        ...witnessSetVkeys.values().map((vkw) => vkw.toCore()),
+        ...vkeyWitnesses
+      ] : vkeyWitnesses;
+      txWitnessSet2.setVkeys(
+        Serialization4.CborSet.fromCore(
+          witnessSetVkeysValues,
+          Serialization4.VkeyWitness.fromCore
+        )
+      );
+      return new Serialization4.Transaction(
+        cardanoTx.body(),
+        txWitnessSet2,
+        cardanoTx.auxiliaryData()
+      ).toCbor();
+    }
+    const txWitnessSet = new Serialization4.TransactionWitnessSet();
+    txWitnessSet.setVkeys(
+      Serialization4.CborSet.fromCore(
+        vkeyWitnesses,
+        Serialization4.VkeyWitness.fromCore
+      )
+    );
+    return txWitnessSet.toCbor();
+  }
+  static async signData(data, addressHex, signer) {
+    const hexData = isHexString(data) ? data : stringToHex(data);
+    const payload = Buffer.from(hexData, "hex");
+    const publicKey = Buffer.from(await signer.getPublicKey(), "hex");
+    const protectedMap = [];
+    protectedMap.push({ k: new CborUInt2(1), v: new CborNegInt2(-8) });
+    protectedMap.push({
+      k: new CborText2("address"),
+      v: new CborBytes2(Buffer.from(addressHex, "hex"))
+    });
+    const coseSign1Builder = new CoseSign1({
+      protectedMap: new CborMap2(protectedMap),
+      unProtectedMap: new CborMap2([]),
+      payload: new CborBytes2(payload)
+    });
+    const signature = await signer.sign(
+      HexBlob5(
+        Buffer.from(coseSign1Builder.createSigStructure()).toString("hex")
+      )
+    );
+    const coseSignature = coseSign1Builder.buildMessage(Buffer.from(signature, "hex")).toString("hex");
+    return {
+      key: getCoseKeyFromPublicKey(publicKey.toString("hex")).toString("hex"),
+      signature: coseSignature
+    };
+  }
+};
 
-// src/interfaces/secret-manager.ts
-var derivationPathVectorFromString = (path) => {
-  if (!/^m?\/\d+(\/\d+)*$/.test(path)) {
-    throw new Error(`Invalid derivation path: ${path}`);
+// src/cardano/utils/transaction-signers.ts
+import { Cardano as Cardano5 } from "@cardano-sdk/core";
+async function getRequiredSignersFromInputs(txBody, fetcher) {
+  const requiredSigners = /* @__PURE__ */ new Set();
+  let inputs = txBody.inputs().values();
+  if (txBody.collateral()) {
+    inputs = [...inputs, ...txBody.collateral().values()];
   }
-  let pathString = path;
-  if (pathString.startsWith("m/")) {
-    pathString = pathString.slice(2);
+  const transactionIds = /* @__PURE__ */ new Set();
+  for (const input of inputs) {
+    transactionIds.add(input.transactionId());
   }
-  return pathString.split("/").map((part) => {
-    if (part.endsWith("'")) {
-      return Number.parseInt(part.slice(0, -1)) + HARDENED_OFFSET;
+  let utxos = [];
+  for (const txId of transactionIds) {
+    const fetchedUtxos = await fetcher.fetchUTxOs(txId);
+    if (fetchedUtxos) {
+      utxos.push(...fetchedUtxos);
     } else {
-      return Number.parseInt(part);
+      throw new Error(
+        `[TransactionSigners] Transaction not found for transaction id: ${txId}`
+      );
     }
+  }
+  utxos = utxos.filter((utxo) => {
+    return inputs.some((input) => {
+      return input.transactionId() === utxo.input.txHash && input.index() === BigInt(utxo.input.outputIndex);
+    });
   });
-};
+  for (const utxo of utxos) {
+    const address = Cardano5.Address.fromBech32(utxo.output.address);
+    const addressProps = address.getProps();
+    if (addressProps.paymentPart) {
+      if (addressProps.paymentPart.type === 0 /* KeyHash */) {
+        requiredSigners.add(addressProps.paymentPart.hash);
+      }
+    }
+  }
+  return requiredSigners;
+}
+function getRequiredSignersFromCertificates(txBody) {
+  const requiredSigners = /* @__PURE__ */ new Set();
+  const certs = txBody.certs();
+  if (!certs) {
+    return requiredSigners;
+  }
+  const certsIter = certs.values();
+  for (const cert of certsIter) {
+    if (cert.asStakeRegistration()) {
+      const stakeReg = cert.asStakeRegistration();
+      if (stakeReg.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(stakeReg.stakeCredential().hash);
+      }
+    } else if (cert.asStakeDeregistration()) {
+      const stakeDereg = cert.asStakeDeregistration();
+      if (stakeDereg.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(stakeDereg.stakeCredential().hash);
+      }
+    } else if (cert.asStakeDelegation()) {
+      const stakeDeleg = cert.asStakeDelegation();
+      if (stakeDeleg.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(stakeDeleg.stakeCredential().hash);
+      }
+    } else if (cert.asPoolRegistration()) {
+      const poolReg = cert.asPoolRegistration();
+      const poolOwners = poolReg.poolParameters().poolOwners().values();
+      for (const owner of poolOwners) {
+        requiredSigners.add(owner.value());
+      }
+      const poolOperator = poolReg.poolParameters().operator();
+      requiredSigners.add(poolOperator);
+    } else if (cert.asPoolRetirement()) {
+      const poolRetire = cert.asPoolRetirement();
+      requiredSigners.add(poolRetire.poolKeyHash());
+    } else if (cert.asGenesisKeyDelegation()) {
+    } else if (cert.asMoveInstantaneousRewardsCert()) {
+    } else if (cert.asRegistrationCert()) {
+      const reg = cert.asRegistrationCert();
+      if (reg.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(reg.stakeCredential().hash);
+      }
+    } else if (cert.asUnregistrationCert()) {
+      const unreg = cert.asUnregistrationCert();
+      if (unreg.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(unreg.stakeCredential().hash);
+      }
+    } else if (cert.asVoteDelegationCert()) {
+      const voteDel = cert.asVoteDelegationCert();
+      if (voteDel.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(voteDel.stakeCredential().hash);
+      }
+    } else if (cert.asStakeVoteDelegationCert()) {
+      const stakeVoteDel = cert.asStakeVoteDelegationCert();
+      if (stakeVoteDel.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(stakeVoteDel.stakeCredential().hash);
+      }
+    } else if (cert.asStakeRegistrationDelegationCert()) {
+      const stakeRegDel = cert.asStakeRegistrationDelegationCert();
+      if (stakeRegDel.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(stakeRegDel.stakeCredential().hash);
+      }
+    } else if (cert.asVoteRegistrationDelegationCert()) {
+      const voteRegDel = cert.asVoteRegistrationDelegationCert();
+      if (voteRegDel.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(voteRegDel.stakeCredential().hash);
+      }
+    } else if (cert.asStakeVoteRegistrationDelegationCert()) {
+      const stakeVoteRegDel = cert.asStakeVoteRegistrationDelegationCert();
+      if (stakeVoteRegDel.stakeCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(stakeVoteRegDel.stakeCredential().hash);
+      }
+    } else if (cert.asAuthCommitteeHotCert()) {
+      const authCommHot = cert.asAuthCommitteeHotCert();
+      if (authCommHot.hotCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(authCommHot.hotCredential().hash);
+      }
+      if (authCommHot.coldCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(authCommHot.coldCredential().hash);
+      }
+    } else if (cert.asResignCommitteeColdCert()) {
+      const resignCommCold = cert.asResignCommitteeColdCert();
+      if (resignCommCold.coldCredential().type === 0 /* KeyHash */) {
+        requiredSigners.add(resignCommCold.coldCredential().hash);
+      }
+    } else if (cert.asRegisterDelegateRepresentativeCert()) {
+      const drepReg = cert.asRegisterDelegateRepresentativeCert();
+      if (drepReg.credential().type === 0 /* KeyHash */) {
+        requiredSigners.add(drepReg.credential().hash);
+      }
+    } else if (cert.asUnregisterDelegateRepresentativeCert()) {
+      const drepUnreg = cert.asUnregisterDelegateRepresentativeCert();
+      if (drepUnreg.credential().type === 0 /* KeyHash */) {
+        requiredSigners.add(drepUnreg.credential().hash);
+      }
+    } else if (cert.asUpdateDelegateRepresentativeCert()) {
+      const drepUpdate = cert.asUpdateDelegateRepresentativeCert();
+      if (drepUpdate.credential().type === 0 /* KeyHash */) {
+        requiredSigners.add(drepUpdate.credential().hash);
+      }
+    } else {
+      throw new Error(
+        "[TransactionSigners] Error parsing required signers: Unknown certificate type"
+      );
+    }
+  }
+  return requiredSigners;
+}
+function getRequiredSignersFromWithdrawals(txBody) {
+  const requiredSigners = /* @__PURE__ */ new Set();
+  const withdrawals = txBody.withdrawals();
+  if (withdrawals) {
+    for (const rewardAccount of withdrawals.keys()) {
+      requiredSigners.add(Cardano5.RewardAccount.toHash(rewardAccount));
+    }
+  }
+  return requiredSigners;
+}
+function getRequiredSignersFromRequiredSignersField(txBody) {
+  const requiredSigners = /* @__PURE__ */ new Set();
+  const reqSigners = txBody.requiredSigners();
+  if (reqSigners) {
+    const reqSignersIter = reqSigners.values();
+    for (const reqSigner of reqSignersIter) {
+      requiredSigners.add(reqSigner.value());
+    }
+  }
+  return requiredSigners;
+}
+function getRequiredSignersFromVotingProcedures(txBody) {
+  const requiredSigners = /* @__PURE__ */ new Set();
+  const votingProcedures = txBody.votingProcedures();
+  if (votingProcedures) {
+    const voters = votingProcedures.getVoters().values();
+    for (const voter of voters) {
+      if (voter.toDrepCred()) {
+        const drepCred = voter.toDrepCred();
+        if (drepCred.type === 0 /* KeyHash */) {
+          requiredSigners.add(drepCred.hash);
+        }
+      } else if (voter.toConstitutionalCommitteeHotCred()) {
+        const ccHotCred = voter.toConstitutionalCommitteeHotCred();
+        if (ccHotCred.type === 0 /* KeyHash */) {
+          requiredSigners.add(ccHotCred.hash);
+        }
+      } else if (voter.toStakingPoolKeyHash()) {
+        const poolKeyHash = voter.toStakingPoolKeyHash();
+        requiredSigners.add(poolKeyHash);
+      }
+    }
+  }
+  return requiredSigners;
+}
+async function getTransactionRequiredSigners(transaction, fetcher) {
+  const txBody = transaction.body();
+  const allRequiredSigners = /* @__PURE__ */ new Set();
+  const inputSigners = await getRequiredSignersFromInputs(txBody, fetcher);
+  const certSigners = getRequiredSignersFromCertificates(txBody);
+  const withdrawalSigners = getRequiredSignersFromWithdrawals(txBody);
+  const explicitSigners = getRequiredSignersFromRequiredSignersField(txBody);
+  const votingSigners = getRequiredSignersFromVotingProcedures(txBody);
+  for (const signer of inputSigners) allRequiredSigners.add(signer);
+  for (const signer of certSigners) allRequiredSigners.add(signer);
+  for (const signer of withdrawalSigners) allRequiredSigners.add(signer);
+  for (const signer of explicitSigners) allRequiredSigners.add(signer);
+  for (const signer of votingSigners) allRequiredSigners.add(signer);
+  return allRequiredSigners;
+}
 
-// src/signer/base-signer.ts
-import { setInConwayEra } from "@cardano-sdk/core";
-import {
-  Ed25519PrivateExtendedKeyHex,
-  Ed25519PrivateKey,
-  Ed25519PrivateNormalKeyHex,
-  Ed25519Signature,
-  Ed25519SignatureHex
-} from "@cardano-sdk/crypto";
-import { HexBlob } from "@cardano-sdk/util";
-var BaseSigner = class _BaseSigner {
-  constructor(ed25519PrivateKey) {
-    setInConwayEra(true);
-    this.ed25519PrivateKey = ed25519PrivateKey;
+// src/cardano/wallet/mesh/cardano-base-wallet.ts
+var CardanoHeadlessWallet = class _CardanoHeadlessWallet {
+  constructor(networkId, addressManager, walletAddressType, fetcher, submitter) {
+    setInConwayEra5(true);
+    this.networkId = networkId;
+    this.addressManager = addressManager;
+    this.fetcher = fetcher;
+    this.submitter = submitter;
+    this.walletAddressType = walletAddressType;
+  }
+  static async create(config) {
+    const addressManager = await AddressManager.create({
+      addressSource: config.addressSource,
+      networkId: config.networkId
+    });
+    return new _CardanoHeadlessWallet(
+      config.networkId,
+      addressManager,
+      config.walletAddressType,
+      config.fetcher,
+      config.submitter
+    );
   }
   /**
-   * Create a BaseSigner instance from an Ed25519 private key in extended hex format.
-   * @param keyHex Ed25519 private key in extended hex format
-   * @returns {BaseSigner} A BaseSigner instance
+   * Create a CardanoHeadlessWallet instance from a Bip32 root in Bech32 format.
+   * @param config The configuration object
+   * @returns {Promise<CardanoHeadlessWallet>} A promise that resolves to a CardanoHeadlessWallet instance
    */
-  static fromExtendedKeyHex(keyHex) {
-    return new _BaseSigner(
-      Ed25519PrivateKey.fromExtendedHex(Ed25519PrivateExtendedKeyHex(keyHex))
-    );
+  static async fromBip32Root(config) {
+    const bip32 = InMemoryBip32.fromBech32(config.bech32);
+    return _CardanoHeadlessWallet.create({
+      addressSource: { type: "secretManager", secretManager: bip32 },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
   }
   /**
-   * Create a BaseSigner instance from an Ed25519 private key in normal hex format.
-   * @param keyHex Ed25519 private key in normal hex format
-   * @returns {BaseSigner} A BaseSigner instance
+   * Create a CardanoHeadlessWallet instance from a Bip32 root in hex format.
+   * @param config The configuration object
+   * @returns {Promise<CardanoHeadlessWallet>} A promise that resolves to a CardanoHeadlessWallet instance
    */
-  static fromNormalKeyHex(keyHex) {
-    return new _BaseSigner(
-      Ed25519PrivateKey.fromNormalHex(Ed25519PrivateNormalKeyHex(keyHex))
+  static async fromBip32RootHex(config) {
+    const bip32 = InMemoryBip32.fromKeyHex(config.hex);
+    return _CardanoHeadlessWallet.create({
+      addressSource: { type: "secretManager", secretManager: bip32 },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
+  }
+  /**
+   * Create a CardanoHeadlessWallet instance from a mnemonic phrase.
+   * @param config The configuration object
+   * @returns {Promise<CardanoHeadlessWallet>} A promise that resolves to a CardanoHeadlessWallet instance
+   */
+  static async fromMnemonic(config) {
+    const bip32 = await InMemoryBip32.fromMnemonic(
+      config.mnemonic,
+      config.password
     );
+    return _CardanoHeadlessWallet.create({
+      addressSource: { type: "secretManager", secretManager: bip32 },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
   }
-  static fromKeyHex(keyHex) {
-    const hexLength = keyHex.length;
-    if (hexLength === 128) {
-      return this.fromExtendedKeyHex(keyHex);
-    } else if (hexLength === 64) {
-      return this.fromNormalKeyHex(keyHex);
-    } else {
-      throw new Error(
-        `Invalid key length: ${hexLength}. Expected 64 (normal key) or 128 (extended key) hex characters.`
-      );
-    }
+  static async fromCredentialSources(config) {
+    return _CardanoHeadlessWallet.create({
+      addressSource: {
+        type: "credentials",
+        paymentCredential: config.paymentCredentialSource,
+        stakeCredential: config.stakeCredentialSource,
+        drepCredential: config.drepCredentialSource
+      },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
   }
   /**
-   * Get the Ed25519 public key in hex format.
-   * @returns {Promise<string>} A promise that resolves to the public key in hex format.
+   * Submit a transaction to the network, using the submitter instance.
+   * @param tx The transaction in CBOR hex format
+   * @returns {Promise<string>} A promise that resolves to the transaction ID
    */
-  async getPublicKey() {
-    return this.ed25519PrivateKey.toPublic().hex();
+  async submitTx(tx) {
+    if (!this.submitter) {
+      throw new Error("[CardanoWallet] No submitter provided");
+    }
+    return await this.submitter.submitTx(tx);
   }
   /**
-   * Get the Ed25519 public key hash in hex format.
-   * @returns {Promise<string>} A promise that resolves to the public key hash in hex format.
+   * Get the network ID.
+   * @returns {number} The network ID
    */
-  async getPublicKeyHash() {
-    return this.ed25519PrivateKey.toPublic().hash().hex();
+  async getNetworkId() {
+    return this.networkId;
   }
   /**
-   * Sign data using the Ed25519 private key.
-   * @param data data to be signed in hex format
-   * @returns {Promise<string>} A promise that resolves to the signature in hex format.
+   * Get the UTxOs for the wallet.
+   *
+   * NOTE: This method is only an approximation to CIP-30 getUtxos, as this wallet is completely
+   * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+   * will be overlap between getUtxos() and getCollateral() results. This can result in the collateral being
+   * spent between transactions.
+   *
+   * The method also does not perform pagination, nor is there a coin selection mechanism.
+   * @returns {Promise<string[]>} A promise that resolves to an array of UTxOs in CBOR hex format
    */
-  async sign(data) {
-    return this.ed25519PrivateKey.sign(HexBlob(data)).hex();
+  async getUtxos() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
+    }
+    const utxos = await this.fetchAccountUtxos();
+    return utxos.map((utxo) => toTxUnspentOutput(utxo).toCbor());
   }
   /**
-   * Verify a signature using the Ed25519 public key.
-   * @param data The original data in hex format.
-   * @param signature The signature to verify in hex format.
-   * @returns {Promise<boolean>} A promise that resolves to true if the signature is valid, false otherwise.
+   * Get the collateral UTxOs for the wallet.
+   *
+   * NOTE: This method is only an approximation to CIP-30 getCollateral, as this wallet is completely
+   * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+   * will be overlap between getUtxos() and getCollateral() results.
+   *
+   * The basic strategy is to return the smallest pure ADA UTxO that is at least 5 ADA belonging to the wallet.
+   * @returns {Promise<string[]>} A promise that resolves to an array of UTxOs in CBOR hex format
    */
-  async verify(data, signature) {
-    return this.ed25519PrivateKey.toPublic().verify(
-      Ed25519Signature.fromHex(Ed25519SignatureHex(signature)),
-      HexBlob(data)
-    );
+  async getCollateral() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
+    }
+    const utxos = await this.fetchAccountUtxos();
+    const cardanoUtxos = utxos.map((utxo) => toTxUnspentOutput(utxo));
+    const pureAdaUtxos = cardanoUtxos.filter((utxo) => {
+      return utxo.output().amount().multiasset() === void 0;
+    });
+    pureAdaUtxos.sort((a, b) => {
+      return Number(a.output().amount().coin()) - Number(b.output().amount().coin());
+    });
+    for (const utxo of pureAdaUtxos) {
+      if (Number(utxo.output().amount().coin()) >= 5e6) {
+        return [utxo.toCbor()];
+      }
+    }
+    return [];
   }
-};
-
-// src/bip32/in-memory-bip32.ts
-var InMemoryBip32 = class _InMemoryBip32 {
-  constructor(privateKey) {
-    setInConwayEra2(true);
-    this.bip32PrivateKey = privateKey;
+  /**
+   * Get the balance of the wallet.
+   *
+   * NOTE: This method is only an approximation to CIP-30 getBalance, as this wallet is completely
+   * stateless and does not track which UTxOs are specifically set as collateral. Which means the balance
+   * returned includes all UTxOs, including those that may be used as collateral.
+   * @returns {Promise<string>} A promise that resolves to the balance in CBOR hex format
+   */
+  async getBalance() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
+    }
+    const utxos = await this.fetchAccountUtxos();
+    const cardanoUtxos = utxos.map((utxo) => toTxUnspentOutput(utxo));
+    let total = new Serialization6.Value(0n);
+    for (const utxo of cardanoUtxos) {
+      total = mergeValue(total, utxo.output().amount());
+    }
+    return total.toCbor();
   }
-  static async fromMnemonic(mnemonic, password) {
-    await ready();
-    const entropy = (0, import_bip39.mnemonicToEntropy)(mnemonic.join(" "));
-    const bip32PrivateKey = Bip32PrivateKey.fromBip39Entropy(
-      Buffer.from(entropy, "hex"),
-      password || ""
+  /**
+   * Get the used addresses for the wallet.
+   *
+   * NOTE: This method completely deviates from CIP-30 getUsedAddresses, as this wallet is stateless
+   * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @returns {Promise<string[]>} A promise that resolves to an array of used addresses in hex format
+   */
+  async getUsedAddresses() {
+    const address = await this.addressManager.getNextAddress(
+      this.walletAddressType
     );
-    return new _InMemoryBip32(bip32PrivateKey);
+    return [address.getAddressHex()];
   }
-  static async fromEntropy(entropy, password) {
-    await ready();
-    const bip32PrivateKey = Bip32PrivateKey.fromBip39Entropy(
-      Buffer.from(entropy, "hex"),
-      password || ""
+  /**
+   * Get the unused addresses for the wallet.
+   *
+   * NOTE: This method completely deviates from CIP-30 getUnusedAddresses, as this wallet is stateless
+   * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @returns {Promise<string[]>} A promise that resolves to an array of unused addresses in hex format
+   */
+  async getUnusedAddresses() {
+    const address = await this.addressManager.getNextAddress(
+      this.walletAddressType
     );
-    return new _InMemoryBip32(bip32PrivateKey);
+    return [address.getAddressHex()];
   }
-  static fromKeyHex(keyHex) {
-    const bip32PrivateKey = Bip32PrivateKey.fromHex(
-      keyHex
+  /**
+   * Get the change address for the wallet.
+   * NOTE: This method deviates from CIP-30 getChangeAddress, as this wallet is stateless
+   * it does not track which addresses has been previously used as change address. This method simply
+   * returns the wallet's main address.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @returns {Promise<string>} A promise that resolves to the change address in hex format
+   */
+  async getChangeAddress() {
+    const address = await this.addressManager.getChangeAddress(
+      this.walletAddressType
     );
-    return new _InMemoryBip32(bip32PrivateKey);
-  }
-  static fromBech32(bech322) {
-    const bech32DecodedBytes = bech32.decodeToBytes(bech322).bytes;
-    const bip32PrivateKey = Bip32PrivateKey.fromBytes(bech32DecodedBytes);
-    return new _InMemoryBip32(bip32PrivateKey);
+    return address.getAddressHex();
   }
   /**
-   * Get the Bip32 public key in hex format.
-   * @returns {Promise<string>} A promise that resolves to the public key in hex format.
+   * Get the reward address for the wallet.
+   *
+   * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in hex format
    */
-  async getPublicKey() {
-    await ready();
-    return this.bip32PrivateKey.toPublic().hex();
+  async getRewardAddresses() {
+    const rewardAddress = await this.addressManager.getRewardAccount();
+    return [rewardAddress.getAddressHex()];
   }
   /**
-   * Get an ISigner instance initialized with the current Bip32 private key.
-   * @returns {Promise<ISigner>} A promise that resolves to an ISigner instance initialized with the current Bip32 private key.
+   * Sign a transaction with the wallet.
+   *
+   * NOTE: This method requires a fetcher to resolve input UTxOs for determining required signers.
+   *
+   * It is also only an approximation to CIP-30 signTx, as this wallet is stateless and does not repeatedly
+   * derive keys, it is unable to sign for multiple derived key indexes.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @param tx The transaction in CBOR hex format
+   * @returns A promise that resolves to a witness set with the signatures in CBOR hex format
    */
-  async getSigner(derivationPath) {
-    const path = Array.isArray(derivationPath) ? derivationPath : derivationPathVectorFromString(derivationPath);
-    const bip32PrivateKey = this.bip32PrivateKey.derive(path);
-    return BaseSigner.fromExtendedKeyHex(bip32PrivateKey.toRawKey().hex());
-  }
-};
-
-// src/cardano/address/cardano-address.ts
-import { Cardano, setInConwayEra as setInConwayEra3 } from "@cardano-sdk/core";
-import { Hash28ByteBase16 } from "@cardano-sdk/crypto";
-var CredentialType = /* @__PURE__ */ ((CredentialType2) => {
-  CredentialType2[CredentialType2["KeyHash"] = 0] = "KeyHash";
-  CredentialType2[CredentialType2["ScriptHash"] = 1] = "ScriptHash";
-  return CredentialType2;
-})(CredentialType || {});
-var AddressType = /* @__PURE__ */ ((AddressType2) => {
-  AddressType2[AddressType2["Enterprise"] = 0] = "Enterprise";
-  AddressType2[AddressType2["Base"] = 1] = "Base";
-  AddressType2[AddressType2["Reward"] = 2] = "Reward";
-  return AddressType2;
-})(AddressType || {});
-var CardanoAddress = class {
-  constructor(addressType, networkId, paymentCredential, stakeCredential) {
-    setInConwayEra3(true);
-    if (addressType === 1 /* Base */ && !stakeCredential) {
-      throw new Error("No stake credential");
+  async signTx(tx, partialSign = false) {
+    if (!this.fetcher) {
+      throw new Error(
+        "[CardanoWallet] No fetcher provided, wallet sign tx does not behave correctly without a fetcher to resolve inputs. If you need to blindly sign a tx, use the CardanoSigner class directly."
+      );
     }
-    this.addressType = addressType;
-    this.networkId = networkId;
-    this.paymentCredential = paymentCredential;
-    this.stakeCredential = stakeCredential;
+    const transaction = Serialization6.Transaction.fromCbor(
+      Serialization6.TxCBOR(tx)
+    );
+    const requiredSigners = await getTransactionRequiredSigners(
+      transaction,
+      this.fetcher
+    );
+    const signersMap = await this.addressManager.getCredentialsSigners(
+      requiredSigners
+    );
+    if (!partialSign) {
+      if (requiredSigners.size !== signersMap.size) {
+        throw new Error("[CardanoWallet] Not all required signers found");
+      }
+    }
+    const signers = Array.from(signersMap.values());
+    return await CardanoSigner.signTx(tx, signers, false);
   }
-  getAddressBech32() {
-    if (this.addressType === 0 /* Enterprise */) {
-      return this.getEnterpriseAddressBech32();
-    } else if (this.addressType === 1 /* Base */) {
-      return this.getBaseAddressBech32();
-    } else if (this.addressType === 2 /* Reward */) {
-      return this.getRewardAddressBech32();
+  async signData(addressBech32, data) {
+    let targetAddressBech32 = addressBech32;
+    if (!targetAddressBech32) {
+      const address2 = await this.addressManager.getNextAddress(
+        this.walletAddressType
+      );
+      targetAddressBech32 = address2.getAddressBech32();
     }
-    throw new Error(`Invalid address type: ${this.addressType}`);
+    const address = Cardano6.Address.fromBech32(targetAddressBech32);
+    if (!address) {
+      throw new Error("[CardanoWallet] Invalid address");
+    }
+    const addressProps = address.getProps();
+    let credentialHash;
+    if (addressProps.type === Cardano6.AddressType.RewardKey && addressProps.delegationPart) {
+      credentialHash = addressProps.delegationPart.hash;
+    } else if (addressProps.paymentPart) {
+      credentialHash = addressProps.paymentPart.hash;
+    } else {
+      throw new Error("[CardanoWallet] No credential found in address");
+    }
+    const signersMap = await this.addressManager.getCredentialsSigners(
+      /* @__PURE__ */ new Set([credentialHash])
+    );
+    const signer = signersMap.get(credentialHash);
+    if (!signer) {
+      throw new Error(
+        `[CardanoWallet] No signer found for credential hash: ${credentialHash}`
+      );
+    }
+    return await CardanoSigner.signData(data, address.toBytes(), signer);
   }
-  getAddressHex() {
-    if (this.addressType === 0 /* Enterprise */) {
-      return this.getEnterpriseAddressHex();
-    } else if (this.addressType === 1 /* Base */) {
-      return this.getBaseAddressHex();
-    } else if (this.addressType === 2 /* Reward */) {
-      return this.getRewardAddressHex();
+  async fetchAccountUtxos() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
     }
-    throw new Error(`Invalid address type: ${this.addressType}`);
+    const addresses = (await this.addressManager.asyncGetAllUsedAddresses()).map((address) => address.getAddressBech32());
+    const utxos = [];
+    for (const addr of addresses) {
+      const fetchedUtxos = await this.fetcher.fetchAddressUTxOs(addr);
+      utxos.push(...fetchedUtxos);
+    }
+    return utxos;
   }
-  getEnterpriseAddressBech32() {
-    const enterpriseAddress = Cardano.EnterpriseAddress.fromCredentials(
-      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
-      {
-        hash: Hash28ByteBase16(this.paymentCredential.hash),
-        type: mapCredentialTypeToCredential(this.paymentCredential.type)
-      }
+};
+
+// src/cardano/wallet/mesh/mesh-wallet.ts
+import { Cardano as Cardano7, Serialization as Serialization7 } from "@cardano-sdk/core";
+import { HexBlob as HexBlob6 } from "@cardano-sdk/util";
+var MeshCardanoHeadlessWallet = class _MeshCardanoHeadlessWallet extends CardanoHeadlessWallet {
+  static async create(config) {
+    const addressManager = await AddressManager.create({
+      addressSource: config.addressSource,
+      networkId: config.networkId
+    });
+    return new _MeshCardanoHeadlessWallet(
+      config.networkId,
+      addressManager,
+      config.walletAddressType,
+      config.fetcher,
+      config.submitter
     );
-    return enterpriseAddress.toAddress().toBech32();
   }
-  getEnterpriseAddressHex() {
-    const enterpriseAddress = Cardano.EnterpriseAddress.fromCredentials(
-      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
-      {
-        hash: Hash28ByteBase16(this.paymentCredential.hash),
-        type: mapCredentialTypeToCredential(this.paymentCredential.type)
-      }
+  static async fromMnemonic(config) {
+    const bip32 = await InMemoryBip32.fromMnemonic(
+      config.mnemonic,
+      config.password
     );
-    return enterpriseAddress.toAddress().toBytes();
+    return _MeshCardanoHeadlessWallet.create({
+      addressSource: { type: "secretManager", secretManager: bip32 },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
   }
-  getBaseAddressBech32() {
-    if (!this.stakeCredential) throw new Error("No stake credential");
-    const baseAddress = Cardano.BaseAddress.fromCredentials(
-      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
-      {
-        hash: Hash28ByteBase16(this.paymentCredential.hash),
-        type: mapCredentialTypeToCredential(this.paymentCredential.type)
-      },
-      {
-        hash: Hash28ByteBase16(this.stakeCredential.hash),
-        type: mapCredentialTypeToCredential(this.stakeCredential.type)
-      }
-    );
-    return baseAddress.toAddress().toBech32();
+  static async fromBip32Root(config) {
+    const bip32 = InMemoryBip32.fromBech32(config.bech32);
+    return _MeshCardanoHeadlessWallet.create({
+      addressSource: { type: "secretManager", secretManager: bip32 },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
   }
-  getBaseAddressHex() {
-    if (!this.stakeCredential) throw new Error("No stake credential");
-    const baseAddress = Cardano.BaseAddress.fromCredentials(
-      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
-      {
-        hash: Hash28ByteBase16(this.paymentCredential.hash),
-        type: mapCredentialTypeToCredential(this.paymentCredential.type)
+  static async fromBip32RootHex(config) {
+    const bip32 = InMemoryBip32.fromKeyHex(config.hex);
+    return _MeshCardanoHeadlessWallet.create({
+      addressSource: { type: "secretManager", secretManager: bip32 },
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
+  }
+  static async fromCredentialSources(config) {
+    return _MeshCardanoHeadlessWallet.create({
+      addressSource: {
+        type: "credentials",
+        paymentCredential: config.paymentCredentialSource,
+        stakeCredential: config.stakeCredentialSource,
+        drepCredential: config.drepCredentialSource
       },
-      {
-        hash: Hash28ByteBase16(this.stakeCredential.hash),
-        type: this.stakeCredential.type
-      }
-    );
-    return baseAddress.toAddress().toBytes();
+      networkId: config.networkId,
+      walletAddressType: config.walletAddressType,
+      fetcher: config.fetcher,
+      submitter: config.submitter
+    });
   }
-  getRewardAddressBech32() {
-    if (!this.stakeCredential) throw new Error("No stake credential");
-    const rewardAddress = Cardano.RewardAddress.fromCredentials(
-      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
-      {
-        hash: Hash28ByteBase16(this.stakeCredential.hash),
-        type: this.stakeCredential.type
-      }
-    );
-    return rewardAddress.toAddress().toBech32();
+  /**
+   * Get the UTxOs for the wallet.
+   *
+   * NOTE: This method is only an approximation to CIP-30 getUtxos, as this wallet is completely
+   * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+   * will be overlap between getUtxos() and getCollateral() results. This can result in the collateral being
+   * spent between transactions.
+   *
+   * The method also does not perform pagination, nor is there a coin selection mechanism.
+   * @returns {Promise<UTxO[]>} A promise that resolves to an array of UTxOs in the Mesh UTxO format
+   */
+  async getUtxosMesh() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
+    }
+    return await this.fetchAccountUtxos();
   }
-  getRewardAddressHex() {
-    if (!this.stakeCredential) throw new Error("No stake credential");
-    const rewardAddress = Cardano.RewardAddress.fromCredentials(
-      this.networkId === 1 ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
-      {
-        hash: Hash28ByteBase16(this.stakeCredential.hash),
-        type: this.stakeCredential.type
+  /**
+   * Get the collateral UTxOs for the wallet.
+   *
+   * NOTE: This method is only an approximation to CIP-30 getCollateral, as this wallet is completely
+   * stateless and does not track which UTxOs are specifically set as collateral. Which means that there
+   * will be overlap between getUtxos() and getCollateral() results.
+   *
+   * The basic strategy is to return the smallest pure ADA UTxO that is at least 5 ADA belonging to the wallet.
+   * @returns {Promise<UTxO[]>} A promise that resolves to an array of UTxOs in the Mesh UTxO format
+   */
+  async getCollateralMesh() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
+    }
+    const utxos = await this.fetchAccountUtxos();
+    const getUtxoLovelaceValue = (utxo) => {
+      const value = utxo.output.amount;
+      let lovelace = 0;
+      for (const asset of value) {
+        if (asset.unit === "lovelace" || asset.unit === "") {
+          lovelace = parseInt(asset.quantity);
+        }
       }
+      return lovelace;
+    };
+    const sortedUtxos = utxos.sort(
+      (a, b) => getUtxoLovelaceValue(a) - getUtxoLovelaceValue(b)
     );
-    return rewardAddress.toAddress().toBytes();
+    for (const utxo of sortedUtxos) {
+      if (getUtxoLovelaceValue(utxo) >= 5e6) {
+        return [utxo];
+      }
+    }
+    return [];
   }
-};
-var mapCredentialTypeToCredential = (credentialType) => {
-  switch (credentialType) {
-    case 0 /* KeyHash */:
-      return Cardano.CredentialType.KeyHash;
-    case 1 /* ScriptHash */:
-      return Cardano.CredentialType.ScriptHash;
+  /**
+   * Get the balance of the wallet.
+   *
+   * NOTE: This method is only an approximation to CIP-30 getBalance, as this wallet is completely
+   * stateless and does not track which UTxOs are specifically set as collateral. Which means the balance
+   * returned includes all UTxOs, including those that may be used as collateral.
+   * @returns {Promise<Asset[]>} A promise that resolves to the balance in the Mesh Asset format
+   */
+  async getBalanceMesh() {
+    if (!this.fetcher) {
+      throw new Error("[CardanoWallet] No fetcher provided");
+    }
+    const utxos = await this.fetchAccountUtxos();
+    return utxos.map((utxo) => utxo.output.amount).flat();
+  }
+  /**
+   * Get the used addresses for the wallet.
+   *
+   * NOTE: This method completely deviates from CIP-30 getUsedAddresses, as this wallet is stateless
+   * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @returns {Promise<string[]>} A promise that resolves to an array of used addresses in Bech32 format
+   */
+  async getUsedAddressesBech32() {
+    const addresses = await this.getUsedAddresses();
+    return addresses.map((addr) => {
+      const cardanoAddr = Cardano7.Address.fromBytes(HexBlob6(addr));
+      return cardanoAddr.toBech32();
+    });
+  }
+  /**
+   * Get the unused addresses for the wallet.
+   *
+   * NOTE: This method completely deviates from CIP-30 getUnusedAddresses, as this wallet is stateless
+   * it is impossible to track which addresses have been used. This method simply returns the wallet's main address.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @returns {Promise<string[]>} A promise that resolves to an array of unused addresses in Bech32 format
+   */
+  async getUnusedAddressesBech32() {
+    const addresses = await this.getUnusedAddresses();
+    return addresses.map((addr) => {
+      const cardanoAddr = Cardano7.Address.fromBytes(HexBlob6(addr));
+      return cardanoAddr.toBech32();
+    });
+  }
+  /**
+   * Get the change address for the wallet.
+   * NOTE: This method deviates from CIP-30 getChangeAddress, as this wallet is stateless
+   * it does not track which addresses has been previously used as change address. This method simply
+   * returns the wallet's main address.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @returns {Promise<string>} A promise that resolves to the change address in Bech32 format
+   */
+  async getChangeAddressBech32() {
+    const address = await this.getChangeAddress();
+    const cardanoAddr = Cardano7.Address.fromBytes(HexBlob6(address));
+    return cardanoAddr.toBech32();
+  }
+  /**
+   * Get the reward address for the wallet.
+   * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in Bech32 format
+   */
+  async getRewardAddressesBech32() {
+    const addresses = await this.getRewardAddresses();
+    return addresses.map((addr) => {
+      const cardanoAddr = Cardano7.Address.fromBytes(HexBlob6(addr));
+      return cardanoAddr.toBech32();
+    });
+  }
+  /**
+   * Sign a transaction with the wallet.
+   *
+   * NOTE: This method requires a fetcher to resolve input UTxOs for determining required signers.
+   *
+   * It is also only an approximation to CIP-30 signTx, as this wallet is stateless and does not repeatedly
+   * derive keys, it is unable to sign for multiple derived key indexes.
+   *
+   * It will be effective to be used as a single address wallet.
+   *
+   * @param tx The transaction in CBOR hex format
+   * @returns A promise that resolves to a full transaction with extra vkey witnesses added from the wallet
+   * to the witness set in CBOR hex format
+   */
+  async signTxReturnFullTx(tx, partialSign = false) {
+    const witnessCbor = await this.signTx(tx, partialSign);
+    const addedWitnesses = Serialization7.TransactionWitnessSet.fromCbor(
+      HexBlob6(witnessCbor)
+    );
+    const transaction = Serialization7.Transaction.fromCbor(
+      Serialization7.TxCBOR(tx)
+    );
+    let witnessSet = transaction.witnessSet();
+    let witnessSetVkeys = witnessSet.vkeys();
+    let witnessSetVkeysValues = witnessSetVkeys ? [
+      ...witnessSetVkeys.values(),
+      ...addedWitnesses.vkeys()?.values() ?? []
+    ] : [...addedWitnesses.vkeys()?.values() ?? []];
+    witnessSet.setVkeys(
+      Serialization7.CborSet.fromCore(
+        witnessSetVkeysValues.map((vkw) => vkw.toCore()),
+        Serialization7.VkeyWitness.fromCore
+      )
+    );
+    const signedTx = new Serialization7.Transaction(
+      transaction.body(),
+      witnessSet,
+      transaction.auxiliaryData()
+    );
+    return signedTx.toCbor();
   }
 };
 export {
   AddressType,
   BaseSigner,
   CardanoAddress,
+  CardanoBrowserWallet,
+  CardanoHeadlessWallet,
   CredentialType,
-  InMemoryBip32
+  InMemoryBip32,
+  MeshCardanoBrowserWallet,
+  MeshCardanoHeadlessWallet
 };
 /*! Bundled license information: