@meshsdk/wallet 2.0.0-beta.4 → 2.0.0-beta.5

package/dist/index.js

@@ -4,13 +4,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -30,14 +24,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/@noble/hashes/cryptoNode.js
-var require_cryptoNode = __commonJS({
-  "node_modules/@noble/hashes/cryptoNode.js"(exports) {
+// node_modules/@noble/hashes/crypto.js
+var require_crypto = __commonJS({
+  "node_modules/@noble/hashes/crypto.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.crypto = void 0;
-    var nc = __require("crypto");
-    exports.crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
+    exports.crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
   }
 });
 
@@ -74,7 +67,7 @@ var require_utils = __commonJS({
     exports.createOptHasher = createOptHasher;
     exports.createXOFer = createXOFer;
     exports.randomBytes = randomBytes;
-    var crypto_1 = require_cryptoNode();
+    var crypto_1 = require_crypto();
     function isBytes2(a) {
       return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
     }
@@ -22185,122 +22178,682 @@ var require_nanoassert = __commonJS({
   }
 });
 
-// node_modules/b4a/index.js
-var require_b4a = __commonJS({
-  "node_modules/b4a/index.js"(exports, module) {
+// node_modules/b4a/lib/ascii.js
+var require_ascii = __commonJS({
+  "node_modules/b4a/lib/ascii.js"(exports, module) {
+    function byteLength(string) {
+      return string.length;
+    }
+    function toString(buffer) {
+      const len = buffer.byteLength;
+      let result = "";
+      for (let i = 0; i < len; i++) {
+        result += String.fromCharCode(buffer[i]);
+      }
+      return result;
+    }
+    function write(buffer, string) {
+      const len = buffer.byteLength;
+      for (let i = 0; i < len; i++) {
+        buffer[i] = string.charCodeAt(i);
+      }
+      return len;
+    }
+    module.exports = {
+      byteLength,
+      toString,
+      write
+    };
+  }
+});
+
+// node_modules/b4a/lib/base64.js
+var require_base64 = __commonJS({
+  "node_modules/b4a/lib/base64.js"(exports, module) {
+    var alphabet2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var codes = new Uint8Array(256);
+    for (let i = 0; i < alphabet2.length; i++) {
+      codes[alphabet2.charCodeAt(i)] = i;
+    }
+    codes[
+      /* - */
+      45
+    ] = 62;
+    codes[
+      /* _ */
+      95
+    ] = 63;
+    function byteLength(string) {
+      let len = string.length;
+      if (string.charCodeAt(len - 1) === 61) len--;
+      if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
+      return len * 3 >>> 2;
+    }
+    function toString(buffer) {
+      const len = buffer.byteLength;
+      let result = "";
+      for (let i = 0; i < len; i += 3) {
+        result += alphabet2[buffer[i] >> 2] + alphabet2[(buffer[i] & 3) << 4 | buffer[i + 1] >> 4] + alphabet2[(buffer[i + 1] & 15) << 2 | buffer[i + 2] >> 6] + alphabet2[buffer[i + 2] & 63];
+      }
+      if (len % 3 === 2) {
+        result = result.substring(0, result.length - 1) + "=";
+      } else if (len % 3 === 1) {
+        result = result.substring(0, result.length - 2) + "==";
+      }
+      return result;
+    }
+    function write(buffer, string) {
+      const len = buffer.byteLength;
+      for (let i = 0, j = 0; j < len; i += 4) {
+        const a = codes[string.charCodeAt(i)];
+        const b = codes[string.charCodeAt(i + 1)];
+        const c = codes[string.charCodeAt(i + 2)];
+        const d = codes[string.charCodeAt(i + 3)];
+        buffer[j++] = a << 2 | b >> 4;
+        buffer[j++] = (b & 15) << 4 | c >> 2;
+        buffer[j++] = (c & 3) << 6 | d & 63;
+      }
+      return len;
+    }
+    module.exports = {
+      byteLength,
+      toString,
+      write
+    };
+  }
+});
+
+// node_modules/b4a/lib/hex.js
+var require_hex = __commonJS({
+  "node_modules/b4a/lib/hex.js"(exports, module) {
+    function byteLength(string) {
+      return string.length >>> 1;
+    }
+    function toString(buffer) {
+      const len = buffer.byteLength;
+      buffer = new DataView(buffer.buffer, buffer.byteOffset, len);
+      let result = "";
+      let i = 0;
+      for (let n = len - len % 4; i < n; i += 4) {
+        result += buffer.getUint32(i).toString(16).padStart(8, "0");
+      }
+      for (; i < len; i++) {
+        result += buffer.getUint8(i).toString(16).padStart(2, "0");
+      }
+      return result;
+    }
+    function write(buffer, string) {
+      const len = buffer.byteLength;
+      for (let i = 0; i < len; i++) {
+        const a = hexValue(string.charCodeAt(i * 2));
+        const b = hexValue(string.charCodeAt(i * 2 + 1));
+        if (a === void 0 || b === void 0) {
+          return buffer.subarray(0, i);
+        }
+        buffer[i] = a << 4 | b;
+      }
+      return len;
+    }
+    module.exports = {
+      byteLength,
+      toString,
+      write
+    };
+    function hexValue(char) {
+      if (char >= 48 && char <= 57) return char - 48;
+      if (char >= 65 && char <= 70) return char - 65 + 10;
+      if (char >= 97 && char <= 102) return char - 97 + 10;
+    }
+  }
+});
+
+// node_modules/b4a/lib/utf8.js
+var require_utf8 = __commonJS({
+  "node_modules/b4a/lib/utf8.js"(exports, module) {
+    function byteLength(string) {
+      let length = 0;
+      for (let i = 0, n = string.length; i < n; i++) {
+        const code = string.charCodeAt(i);
+        if (code >= 55296 && code <= 56319 && i + 1 < n) {
+          const code2 = string.charCodeAt(i + 1);
+          if (code2 >= 56320 && code2 <= 57343) {
+            length += 4;
+            i++;
+            continue;
+          }
+        }
+        if (code <= 127) length += 1;
+        else if (code <= 2047) length += 2;
+        else length += 3;
+      }
+      return length;
+    }
+    var toString;
+    if (typeof TextDecoder !== "undefined") {
+      const decoder = new TextDecoder();
+      toString = function toString2(buffer) {
+        return decoder.decode(buffer);
+      };
+    } else {
+      toString = function toString2(buffer) {
+        const len = buffer.byteLength;
+        let output = "";
+        let i = 0;
+        while (i < len) {
+          let byte = buffer[i];
+          if (byte <= 127) {
+            output += String.fromCharCode(byte);
+            i++;
+            continue;
+          }
+          let bytesNeeded = 0;
+          let codePoint = 0;
+          if (byte <= 223) {
+            bytesNeeded = 1;
+            codePoint = byte & 31;
+          } else if (byte <= 239) {
+            bytesNeeded = 2;
+            codePoint = byte & 15;
+          } else if (byte <= 244) {
+            bytesNeeded = 3;
+            codePoint = byte & 7;
+          }
+          if (len - i - bytesNeeded > 0) {
+            let k = 0;
+            while (k < bytesNeeded) {
+              byte = buffer[i + k + 1];
+              codePoint = codePoint << 6 | byte & 63;
+              k += 1;
+            }
+          } else {
+            codePoint = 65533;
+            bytesNeeded = len - i;
+          }
+          output += String.fromCodePoint(codePoint);
+          i += bytesNeeded + 1;
+        }
+        return output;
+      };
+    }
+    var write;
+    if (typeof TextEncoder !== "undefined") {
+      const encoder = new TextEncoder();
+      write = function write2(buffer, string) {
+        return encoder.encodeInto(string, buffer).written;
+      };
+    } else {
+      write = function write2(buffer, string) {
+        const len = buffer.byteLength;
+        let i = 0;
+        let j = 0;
+        while (i < string.length) {
+          const code = string.codePointAt(i);
+          if (code <= 127) {
+            buffer[j++] = code;
+            i++;
+            continue;
+          }
+          let count = 0;
+          let bits = 0;
+          if (code <= 2047) {
+            count = 6;
+            bits = 192;
+          } else if (code <= 65535) {
+            count = 12;
+            bits = 224;
+          } else if (code <= 2097151) {
+            count = 18;
+            bits = 240;
+          }
+          buffer[j++] = bits | code >> count;
+          count -= 6;
+          while (count >= 0) {
+            buffer[j++] = 128 | code >> count & 63;
+            count -= 6;
+          }
+          i += code >= 65536 ? 2 : 1;
+        }
+        return len;
+      };
+    }
+    module.exports = {
+      byteLength,
+      toString,
+      write
+    };
+  }
+});
+
+// node_modules/b4a/lib/utf16le.js
+var require_utf16le = __commonJS({
+  "node_modules/b4a/lib/utf16le.js"(exports, module) {
+    function byteLength(string) {
+      return string.length * 2;
+    }
+    function toString(buffer) {
+      const len = buffer.byteLength;
+      let result = "";
+      for (let i = 0; i < len - 1; i += 2) {
+        result += String.fromCharCode(buffer[i] + buffer[i + 1] * 256);
+      }
+      return result;
+    }
+    function write(buffer, string) {
+      const len = buffer.byteLength;
+      let units = len;
+      for (let i = 0; i < string.length; ++i) {
+        if ((units -= 2) < 0) break;
+        const c = string.charCodeAt(i);
+        const hi = c >> 8;
+        const lo = c % 256;
+        buffer[i * 2] = lo;
+        buffer[i * 2 + 1] = hi;
+      }
+      return len;
+    }
+    module.exports = {
+      byteLength,
+      toString,
+      write
+    };
+  }
+});
+
+// node_modules/b4a/browser.js
+var require_browser = __commonJS({
+  "node_modules/b4a/browser.js"(exports, module) {
+    var ascii = require_ascii();
+    var base64 = require_base64();
+    var hex = require_hex();
+    var utf8 = require_utf8();
+    var utf16le = require_utf16le();
+    var LE = new Uint8Array(Uint16Array.of(255).buffer)[0] === 255;
+    function codecFor(encoding) {
+      switch (encoding) {
+        case "ascii":
+          return ascii;
+        case "base64":
+          return base64;
+        case "hex":
+          return hex;
+        case "utf8":
+        case "utf-8":
+        case void 0:
+        case null:
+          return utf8;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return utf16le;
+        default:
+          throw new Error(`Unknown encoding '${encoding}'`);
+      }
+    }
     function isBuffer(value) {
-      return Buffer.isBuffer(value) || value instanceof Uint8Array;
+      return value instanceof Uint8Array;
     }
     function isEncoding(encoding) {
-      return Buffer.isEncoding(encoding);
+      try {
+        codecFor(encoding);
+        return true;
+      } catch {
+        return false;
+      }
     }
     function alloc(size, fill2, encoding) {
-      return Buffer.alloc(size, fill2, encoding);
+      const buffer = new Uint8Array(size);
+      if (fill2 !== void 0) {
+        exports.fill(buffer, fill2, 0, buffer.byteLength, encoding);
+      }
+      return buffer;
     }
     function allocUnsafe(size) {
-      return Buffer.allocUnsafe(size);
+      return new Uint8Array(size);
     }
     function allocUnsafeSlow(size) {
-      return Buffer.allocUnsafeSlow(size);
+      return new Uint8Array(size);
     }
     function byteLength(string, encoding) {
-      return Buffer.byteLength(string, encoding);
+      return codecFor(encoding).byteLength(string);
     }
     function compare(a, b) {
-      return Buffer.compare(a, b);
+      if (a === b) return 0;
+      const len = Math.min(a.byteLength, b.byteLength);
+      a = new DataView(a.buffer, a.byteOffset, a.byteLength);
+      b = new DataView(b.buffer, b.byteOffset, b.byteLength);
+      let i = 0;
+      for (let n = len - len % 4; i < n; i += 4) {
+        const x = a.getUint32(i, LE);
+        const y = b.getUint32(i, LE);
+        if (x !== y) break;
+      }
+      for (; i < len; i++) {
+        const x = a.getUint8(i);
+        const y = b.getUint8(i);
+        if (x < y) return -1;
+        if (x > y) return 1;
+      }
+      return a.byteLength > b.byteLength ? 1 : a.byteLength < b.byteLength ? -1 : 0;
     }
-    function concat(buffers, totalLength) {
-      return Buffer.concat(buffers, totalLength);
+    function concat(buffers, length) {
+      if (length === void 0) {
+        length = buffers.reduce((len, buffer) => len + buffer.byteLength, 0);
+      }
+      const result = new Uint8Array(length);
+      let offset = 0;
+      for (const buffer of buffers) {
+        if (offset + buffer.byteLength > result.byteLength) {
+          result.set(buffer.subarray(0, result.byteLength - offset), offset);
+          return result;
+        }
+        result.set(buffer, offset);
+        offset += buffer.byteLength;
+      }
+      return result;
     }
-    function copy(source, target, targetStart, start, end) {
-      return toBuffer(source).copy(target, targetStart, start, end);
+    function copy(source, target, targetStart = 0, sourceStart = 0, sourceEnd = source.byteLength) {
+      if (targetStart < 0) targetStart = 0;
+      if (targetStart >= target.byteLength) return 0;
+      const targetLength = target.byteLength - targetStart;
+      if (sourceStart < 0) sourceStart = 0;
+      if (sourceStart >= source.byteLength) return 0;
+      if (sourceEnd <= sourceStart) return 0;
+      if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
+      if (sourceEnd - sourceStart > targetLength) {
+        sourceEnd = sourceStart + targetLength;
+      }
+      const sourceLength = sourceEnd - sourceStart;
+      if (source === target) {
+        target.copyWithin(targetStart, sourceStart, sourceEnd);
+      } else {
+        if (sourceStart !== 0 || sourceEnd !== source.byteLength) {
+          source = source.subarray(sourceStart, sourceEnd);
+        }
+        target.set(source, targetStart);
+      }
+      return sourceLength;
     }
     function equals(a, b) {
-      return toBuffer(a).equals(b);
+      if (a === b) return true;
+      if (a.byteLength !== b.byteLength) return false;
+      return compare(a, b) === 0;
     }
-    function fill(buffer, value, offset, end, encoding) {
-      return toBuffer(buffer).fill(value, offset, end, encoding);
+    function fill(buffer, value, offset = 0, end = buffer.byteLength, encoding = "utf8") {
+      if (typeof value === "string") {
+        if (typeof offset === "string") {
+          encoding = offset;
+          offset = 0;
+          end = buffer.byteLength;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = buffer.byteLength;
+        }
+      } else if (typeof value === "number") {
+        value = value & 255;
+      } else if (typeof value === "boolean") {
+        value = +value;
+      }
+      if (offset < 0) offset = 0;
+      if (offset >= buffer.byteLength) return buffer;
+      if (end <= offset) return buffer;
+      if (end > buffer.byteLength) end = buffer.byteLength;
+      if (typeof value === "number") return buffer.fill(value, offset, end);
+      if (typeof value === "string") value = exports.from(value, encoding);
+      const len = value.byteLength;
+      for (let i = 0, n = end - offset; i < n; ++i) {
+        buffer[i + offset] = value[i % len];
+      }
+      return buffer;
     }
     function from(value, encodingOrOffset, length) {
-      return Buffer.from(value, encodingOrOffset, length);
+      if (typeof value === "string") return fromString(value, encodingOrOffset);
+      if (Array.isArray(value)) return fromArray(value);
+      if (ArrayBuffer.isView(value)) return fromBuffer(value);
+      return fromArrayBuffer(value, encodingOrOffset, length);
+    }
+    function fromString(string, encoding) {
+      const codec = codecFor(encoding);
+      const buffer = new Uint8Array(codec.byteLength(string));
+      codec.write(buffer, string);
+      return buffer;
+    }
+    function fromArray(array) {
+      const buffer = new Uint8Array(array.length);
+      buffer.set(array);
+      return buffer;
+    }
+    function fromBuffer(buffer) {
+      const copy2 = new Uint8Array(buffer.byteLength);
+      copy2.set(buffer);
+      return copy2;
+    }
+    function fromArrayBuffer(arrayBuffer, byteOffset, length) {
+      return new Uint8Array(arrayBuffer, byteOffset, length);
     }
     function includes(buffer, value, byteOffset, encoding) {
-      return toBuffer(buffer).includes(value, byteOffset, encoding);
+      return indexOf(buffer, value, byteOffset, encoding) !== -1;
     }
-    function indexOf(buffer, value, byfeOffset, encoding) {
-      return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
+    function indexOf(buffer, value, byteOffset, encoding) {
+      return bidirectionalIndexOf(
+        buffer,
+        value,
+        byteOffset,
+        encoding,
+        true
+        /* first */
+      );
     }
     function lastIndexOf(buffer, value, byteOffset, encoding) {
-      return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
+      return bidirectionalIndexOf(
+        buffer,
+        value,
+        byteOffset,
+        encoding,
+        false
+        /* last */
+      );
+    }
+    function bidirectionalIndexOf(buffer, value, byteOffset, encoding, first) {
+      if (buffer.byteLength === 0) return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset === void 0) {
+        byteOffset = first ? 0 : buffer.length - 1;
+      } else if (byteOffset < 0) {
+        byteOffset += buffer.byteLength;
+      }
+      if (byteOffset >= buffer.byteLength) {
+        if (first) return -1;
+        else byteOffset = buffer.byteLength - 1;
+      } else if (byteOffset < 0) {
+        if (first) byteOffset = 0;
+        else return -1;
+      }
+      if (typeof value === "string") {
+        value = from(value, encoding);
+      } else if (typeof value === "number") {
+        value = value & 255;
+        if (first) {
+          return buffer.indexOf(value, byteOffset);
+        } else {
+          return buffer.lastIndexOf(value, byteOffset);
+        }
+      }
+      if (value.byteLength === 0) return -1;
+      if (first) {
+        let foundIndex = -1;
+        for (let i = byteOffset; i < buffer.byteLength; i++) {
+          if (buffer[i] === value[foundIndex === -1 ? 0 : i - foundIndex]) {
+            if (foundIndex === -1) foundIndex = i;
+            if (i - foundIndex + 1 === value.byteLength) return foundIndex;
+          } else {
+            if (foundIndex !== -1) i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + value.byteLength > buffer.byteLength) {
+          byteOffset = buffer.byteLength - value.byteLength;
+        }
+        for (let i = byteOffset; i >= 0; i--) {
+          let found = true;
+          for (let j = 0; j < value.byteLength; j++) {
+            if (buffer[i + j] !== value[j]) {
+              found = false;
+              break;
+            }
+          }
+          if (found) return i;
+        }
+      }
+      return -1;
+    }
+    function swap(buffer, n, m) {
+      const i = buffer[n];
+      buffer[n] = buffer[m];
+      buffer[m] = i;
     }
     function swap16(buffer) {
-      return toBuffer(buffer).swap16();
+      const len = buffer.byteLength;
+      if (len % 2 !== 0)
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      for (let i = 0; i < len; i += 2) swap(buffer, i, i + 1);
+      return buffer;
     }
     function swap32(buffer) {
-      return toBuffer(buffer).swap32();
+      const len = buffer.byteLength;
+      if (len % 4 !== 0)
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      for (let i = 0; i < len; i += 4) {
+        swap(buffer, i, i + 3);
+        swap(buffer, i + 1, i + 2);
+      }
+      return buffer;
     }
     function swap64(buffer) {
-      return toBuffer(buffer).swap64();
+      const len = buffer.byteLength;
+      if (len % 8 !== 0)
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      for (let i = 0; i < len; i += 8) {
+        swap(buffer, i, i + 7);
+        swap(buffer, i + 1, i + 6);
+        swap(buffer, i + 2, i + 5);
+        swap(buffer, i + 3, i + 4);
+      }
+      return buffer;
     }
     function toBuffer(buffer) {
-      if (Buffer.isBuffer(buffer)) return buffer;
-      return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return buffer;
     }
-    function toString(buffer, encoding, start, end) {
-      return toBuffer(buffer).toString(encoding, start, end);
+    function toString(buffer, encoding = "utf8", start = 0, end = buffer.byteLength) {
+      if (arguments.length === 1) return utf8.toString(buffer);
+      if (arguments.length === 2) return codecFor(encoding).toString(buffer);
+      if (start < 0) start = 0;
+      if (start >= buffer.byteLength) return "";
+      if (end <= start) return "";
+      if (end > buffer.byteLength) end = buffer.byteLength;
+      if (start !== 0 || end !== buffer.byteLength) {
+        buffer = buffer.subarray(start, end);
+      }
+      return codecFor(encoding).toString(buffer);
     }
     function write(buffer, string, offset, length, encoding) {
-      return toBuffer(buffer).write(string, offset, length, encoding);
+      if (arguments.length === 2) return utf8.write(buffer, string);
+      if (typeof offset === "string") {
+        encoding = offset;
+        offset = 0;
+        length = buffer.byteLength;
+      } else if (typeof length === "string") {
+        encoding = length;
+        length = buffer.byteLength - offset;
+      }
+      length = Math.min(length, exports.byteLength(string, encoding));
+      let start = offset;
+      if (start < 0) start = 0;
+      if (start >= buffer.byteLength) return 0;
+      let end = offset + length;
+      if (end <= start) return 0;
+      if (end > buffer.byteLength) end = buffer.byteLength;
+      if (start !== 0 || end !== buffer.byteLength) {
+        buffer = buffer.subarray(start, end);
+      }
+      return codecFor(encoding).write(buffer, string);
     }
-    function readDoubleBE(buffer, offset) {
-      return toBuffer(buffer).readDoubleBE(offset);
+    function readDoubleBE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getFloat64(offset, false);
     }
-    function readDoubleLE(buffer, offset) {
-      return toBuffer(buffer).readDoubleLE(offset);
+    function readDoubleLE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getFloat64(offset, true);
     }
-    function readFloatBE(buffer, offset) {
-      return toBuffer(buffer).readFloatBE(offset);
+    function readFloatBE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getFloat32(offset, false);
     }
-    function readFloatLE(buffer, offset) {
-      return toBuffer(buffer).readFloatLE(offset);
+    function readFloatLE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getFloat32(offset, true);
     }
-    function readInt32BE(buffer, offset) {
-      return toBuffer(buffer).readInt32BE(offset);
+    function readInt32BE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getInt32(offset, false);
     }
-    function readInt32LE(buffer, offset) {
-      return toBuffer(buffer).readInt32LE(offset);
+    function readInt32LE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getInt32(offset, true);
     }
-    function readUInt32BE(buffer, offset) {
-      return toBuffer(buffer).readUInt32BE(offset);
+    function readUInt32BE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getUint32(offset, false);
     }
-    function readUInt32LE(buffer, offset) {
-      return toBuffer(buffer).readUInt32LE(offset);
+    function readUInt32LE(buffer, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      return view.getUint32(offset, true);
     }
-    function writeDoubleBE(buffer, value, offset) {
-      return toBuffer(buffer).writeDoubleBE(value, offset);
+    function writeDoubleBE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setFloat64(offset, value, false);
+      return offset + 8;
     }
-    function writeDoubleLE(buffer, value, offset) {
-      return toBuffer(buffer).writeDoubleLE(value, offset);
+    function writeDoubleLE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setFloat64(offset, value, true);
+      return offset + 8;
     }
-    function writeFloatBE(buffer, value, offset) {
-      return toBuffer(buffer).writeFloatBE(value, offset);
+    function writeFloatBE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setFloat32(offset, value, false);
+      return offset + 4;
     }
-    function writeFloatLE(buffer, value, offset) {
-      return toBuffer(buffer).writeFloatLE(value, offset);
+    function writeFloatLE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setFloat32(offset, value, true);
+      return offset + 4;
     }
-    function writeInt32BE(buffer, value, offset) {
-      return toBuffer(buffer).writeInt32BE(value, offset);
+    function writeInt32BE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setInt32(offset, value, false);
+      return offset + 4;
     }
-    function writeInt32LE(buffer, value, offset) {
-      return toBuffer(buffer).writeInt32LE(value, offset);
+    function writeInt32LE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setInt32(offset, value, true);
+      return offset + 4;
     }
-    function writeUInt32BE(buffer, value, offset) {
-      return toBuffer(buffer).writeUInt32BE(value, offset);
+    function writeUInt32BE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setUint32(offset, value, false);
+      return offset + 4;
     }
-    function writeUInt32LE(buffer, value, offset) {
-      return toBuffer(buffer).writeUInt32LE(value, offset);
+    function writeUInt32LE(buffer, value, offset = 0) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      view.setUint32(offset, value, true);
+      return offset + 4;
     }
-    module.exports = {
+    module.exports = exports = {
       isBuffer,
       isEncoding,
       alloc,
@@ -22345,7 +22898,7 @@ var require_b4a = __commonJS({
 // node_modules/blake2b-wasm/blake2b.js
 var require_blake2b = __commonJS({
   "node_modules/blake2b-wasm/blake2b.js"(exports, module) {
-    var __commonJS2 = (cb, mod) => function __require2() {
+    var __commonJS2 = (cb, mod) => function __require() {
       return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
     };
     var __toBinary = /* @__PURE__ */ (() => {
@@ -22382,7 +22935,7 @@ var require_blake2b = __commonJS({
 var require_blake2b_wasm = __commonJS({
   "node_modules/blake2b-wasm/index.js"(exports, module) {
     var assert = require_nanoassert();
-    var b4a = require_b4a();
+    var b4a = require_browser();
     var wasm = null;
     var wasmPromise = typeof WebAssembly !== "undefined" && require_blake2b()().then((mod) => {
       wasm = mod;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meshsdk/wallet",
-  "version": "2.0.0-beta.4",
+  "version": "2.0.0-beta.5",
   "description": "Wallets - https://meshjs.dev/apis/wallets",
   "main": "./dist/index.cjs",
   "browser": "./dist/index.js",
@@ -18,7 +18,7 @@
     "dist/**"
   ],
   "scripts": {
-    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "build": "tsup",
     "build:demo": "tsup demo/src/main.ts --format esm --outDir demo/dist --clean",
     "dev:demo": "tsup demo/src/main.ts --format esm --outDir demo/dist --watch",
     "preview:demo": "npx serve demo -p 5173",

package/dist/index.d.cts

@@ -1,518 +0,0 @@
-import { DataSignature, Extension as Extension$1, UTxO, Asset, IFetcher, ISubmitter } from '@meshsdk/common';
-
-interface ISigner {
-    getPublicKey(): Promise<string>;
-    getPublicKeyHash(): Promise<string>;
-    sign(data: string): Promise<string>;
-    verify(data: string, signature: string): Promise<boolean>;
-}
-
-type DerivationPath = number[] | string;
-interface ISecretManager {
-    getPublicKey(derivationPath: DerivationPath): Promise<string>;
-    getSigner(derivationPath: DerivationPath): Promise<ISigner>;
-}
-
-declare class InMemoryBip32 implements ISecretManager {
-    private bip32PrivateKey;
-    private constructor();
-    static fromMnemonic(mnemonic: string[], password?: string): Promise<InMemoryBip32>;
-    static fromEntropy(entropy: string, password?: string): Promise<InMemoryBip32>;
-    static fromKeyHex(keyHex: string): InMemoryBip32;
-    static fromBech32(bech32: string): InMemoryBip32;
-    /**
-     * Get the Bip32 public key in hex format.
-     * @returns {Promise<string>} A promise that resolves to the public key in hex format.
-     */
-    getPublicKey(): Promise<string>;
-    /**
-     * 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.
-     */
-    getSigner(derivationPath: DerivationPath): Promise<ISigner>;
-}
-
-/**
- * BaseSigner provides functionalities to sign and verify data using Ed25519 keys.
- * It supports construction from both extended and normal private key hex formats.
- */
-declare class BaseSigner implements ISigner {
-    private ed25519PrivateKey;
-    private constructor();
-    /**
-     * 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: string): BaseSigner;
-    /**
-     * 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: string): BaseSigner;
-    static fromKeyHex(keyHex: string): BaseSigner;
-    /**
-     * Get the Ed25519 public key in hex format.
-     * @returns {Promise<string>} A promise that resolves to the public key in hex format.
-     */
-    getPublicKey(): Promise<string>;
-    /**
-     * Get the Ed25519 public key hash in hex format.
-     * @returns {Promise<string>} A promise that resolves to the public key hash in hex format.
-     */
-    getPublicKeyHash(): Promise<string>;
-    /**
-     * 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.
-     */
-    sign(data: string): Promise<string>;
-    /**
-     * 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.
-     */
-    verify(data: string, signature: string): Promise<boolean>;
-}
-
-declare enum CredentialType {
-    KeyHash = 0,
-    ScriptHash = 1
-}
-type Credential = {
-    type: CredentialType;
-    hash: string;
-};
-declare enum AddressType {
-    Enterprise = 0,
-    Base = 1,
-    Reward = 2
-}
-declare class CardanoAddress {
-    addressType: AddressType;
-    networkId: number;
-    paymentCredential: Credential;
-    stakeCredential?: Credential;
-    constructor(addressType: AddressType, networkId: number, paymentCredential: Credential, stakeCredential?: Credential);
-    getAddressBech32(): string;
-    getAddressHex(): string;
-    private getEnterpriseAddressBech32;
-    private getEnterpriseAddressHex;
-    private getBaseAddressBech32;
-    private getBaseAddressHex;
-    private getRewardAddressBech32;
-    private getRewardAddressHex;
-}
-
-interface ICardanoWallet {
-    getExtensions(): Promise<{
-        cip: number;
-    }[]>;
-    getNetworkId(): Promise<number>;
-    getUtxos(): Promise<string[]>;
-    getCollateral(): Promise<string[]>;
-    getBalance(): Promise<string>;
-    getUsedAddresses(): Promise<string[]>;
-    getUnusedAddresses(): Promise<string[]>;
-    getRewardAddresses(): Promise<string[]>;
-    getChangeAddress(): Promise<string>;
-    signTx(data: string, partialSign: boolean): Promise<string>;
-    signData(addressHex: string, data: string): Promise<DataSignature>;
-    submitTx(tx: string): Promise<string>;
-}
-
-type Wallet = {
-    id: string;
-    name: string;
-    icon: string;
-    version: string;
-};
-type Cardano = {
-    [key: string]: {
-        name: string;
-        icon: string;
-        apiVersion: string;
-        enable: (extensions?: {
-            extensions: {
-                cip: number;
-            }[];
-        }) => Promise<ICardanoWallet>;
-        supportedExtensions?: {
-            cip: number;
-        }[];
-    };
-};
-type Extension = {
-    cip: number;
-};
-declare class CardanoBrowserWallet implements ICardanoWallet {
-    walletInstance: ICardanoWallet;
-    constructor(walletInstance: ICardanoWallet);
-    getExtensions(): Promise<{
-        cip: number;
-    }[]>;
-    getNetworkId(): Promise<number>;
-    getUtxos(): Promise<string[]>;
-    getCollateral(): Promise<string[]>;
-    getBalance(): Promise<string>;
-    getUsedAddresses(): Promise<string[]>;
-    getUnusedAddresses(): Promise<string[]>;
-    getRewardAddresses(): Promise<string[]>;
-    getChangeAddress(): Promise<string>;
-    signTx(data: string, partialSign: boolean): Promise<string>;
-    signData(addressBech32: string, data: string): Promise<DataSignature>;
-    submitTx(tx: string): Promise<string>;
-    /**
-     * 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(): Wallet[];
-    /**
-     * 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 enable(walletName: string, extensions?: Extension[]): Promise<ICardanoWallet>;
-}
-
-declare class MeshCardanoBrowserWallet extends CardanoBrowserWallet {
-    constructor(walletInstance: ICardanoWallet);
-    static enable(walletName: string, extensions?: Extension$1[]): Promise<MeshCardanoBrowserWallet>;
-    getUtxosMesh(): Promise<UTxO[]>;
-    getCollateralMesh(): Promise<UTxO[]>;
-    getBalanceMesh(): Promise<Asset[]>;
-    getUsedAddressesBech32(): Promise<string[]>;
-    getUnusedAddressesBech32(): Promise<string[]>;
-    getChangeAddressBech32(): Promise<string>;
-    getRewardAddressesBech32(): Promise<string[]>;
-    signTxReturnFullTx(tx: string, partialSign?: boolean): Promise<string>;
-}
-
-type CredentialSource = {
-    type: "signer";
-    signer: ISigner;
-} | {
-    type: "scriptHash";
-    scriptHash: string;
-};
-interface AddressManagerConfig {
-    addressSource: AddressSource;
-    networkId: number;
-}
-type AddressSource = {
-    type: "secretManager";
-    secretManager: ISecretManager;
-} | {
-    type: "credentials";
-    paymentCredential: CredentialSource;
-    stakeCredential?: CredentialSource;
-    drepCredential?: CredentialSource;
-};
-declare class AddressManager {
-    private readonly paymentCredential;
-    private readonly stakeCredential;
-    private readonly drepCredential;
-    private readonly paymentSigner;
-    private readonly stakeSigner?;
-    private readonly drepSigner?;
-    private readonly networkId;
-    static create(config: AddressManagerConfig): Promise<AddressManager>;
-    private constructor();
-    getNextAddress(addressType: AddressType): Promise<CardanoAddress>;
-    getChangeAddress(addressType: AddressType): Promise<CardanoAddress>;
-    getRewardAccount(): Promise<CardanoAddress>;
-    asyncGetAllUsedAddresses(): Promise<CardanoAddress[]>;
-    getCredentialsSigners(pubkeyHashes: Set<string>): Promise<Map<string, ISigner>>;
-}
-
-type WalletAddressType = AddressType.Base | AddressType.Enterprise;
-/**
- * Configuration for creating a CardanoHeadlessWallet instance.
- */
-interface CardanoHeadlessWalletConfig {
-    /**
-     * The source for wallet's signing keys and addresses. Could either be a secret manager or explicit credentials.
-     */
-    addressSource: AddressSource;
-    /**
-     * The network ID (0 for testnet, 1 for mainnet).
-     */
-    networkId: number;
-    /**
-     * The type of wallet address to use (Base or Enterprise).
-     * Base addresses include staking capabilities, while Enterprise addresses do not.
-     */
-    walletAddressType: WalletAddressType;
-    /**
-     * Optional fetcher instance for querying blockchain data (UTxOs, protocol parameters, etc.).
-     */
-    fetcher?: IFetcher;
-    /**
-     * Optional submitter instance for submitting transactions to the blockchain.
-     */
-    submitter?: ISubmitter;
-}
-declare class CardanoHeadlessWallet implements ICardanoWallet {
-    protected networkId: number;
-    protected addressManager: AddressManager;
-    protected fetcher?: IFetcher;
-    protected submitter?: ISubmitter;
-    protected walletAddressType: WalletAddressType;
-    protected constructor(networkId: number, addressManager: AddressManager, walletAddressType: WalletAddressType, fetcher?: IFetcher, submitter?: ISubmitter);
-    static create(config: CardanoHeadlessWalletConfig): Promise<CardanoHeadlessWallet>;
-    /**
-     * 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 fromBip32Root(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        bech32: string;
-    }): Promise<CardanoHeadlessWallet>;
-    /**
-     * 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 fromBip32RootHex(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        hex: string;
-    }): Promise<CardanoHeadlessWallet>;
-    /**
-     * 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 fromMnemonic(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        mnemonic: string[];
-        password?: string;
-    }): Promise<CardanoHeadlessWallet>;
-    static fromCredentialSources(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        paymentCredentialSource: CredentialSource;
-        stakeCredentialSource?: CredentialSource;
-        drepCredentialSource?: CredentialSource;
-    }): Promise<CardanoHeadlessWallet>;
-    /**
-     * 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
-     */
-    submitTx(tx: string): Promise<string>;
-    /**
-     * Get the list of extensions enabled for this wallet.
-     * @returns {Promise<{ cip: number }[]>} A promise that resolves to an array of enabled extensions
-     */
-    getExtensions(): Promise<{
-        cip: number;
-    }[]>;
-    /**
-     * Get the network ID.
-     * @returns {number} The network ID
-     */
-    getNetworkId(): Promise<number>;
-    /**
-     * 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
-     */
-    getUtxos(): Promise<string[]>;
-    /**
-     * 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
-     */
-    getCollateral(): Promise<string[]>;
-    /**
-     * 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
-     */
-    getBalance(): Promise<string>;
-    /**
-     * 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
-     */
-    getUsedAddresses(): Promise<string[]>;
-    /**
-     * 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
-     */
-    getUnusedAddresses(): Promise<string[]>;
-    /**
-     * 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
-     */
-    getChangeAddress(): Promise<string>;
-    /**
-     * Get the reward address for the wallet.
-     *
-     * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in hex format
-     */
-    getRewardAddresses(): Promise<string[]>;
-    /**
-     * 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
-     */
-    signTx(tx: string, partialSign?: boolean): Promise<string>;
-    signData(addressBech32: string, data: string): Promise<DataSignature>;
-    fetchAccountUtxos(): Promise<UTxO[]>;
-}
-
-/**
- * MeshCardanoHeadlessWallet provides additional convenience methods on top of CardanoHeadlessWallet,
- * such as returning results in Mesh-compatible formats and Bech32 addresses.
- */
-declare class MeshCardanoHeadlessWallet extends CardanoHeadlessWallet {
-    static create(config: CardanoHeadlessWalletConfig): Promise<MeshCardanoHeadlessWallet>;
-    static fromMnemonic(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        mnemonic: string[];
-        password?: string;
-    }): Promise<MeshCardanoHeadlessWallet>;
-    static fromBip32Root(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        bech32: string;
-    }): Promise<MeshCardanoHeadlessWallet>;
-    static fromBip32RootHex(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        hex: string;
-    }): Promise<MeshCardanoHeadlessWallet>;
-    static fromCredentialSources(config: Omit<CardanoHeadlessWalletConfig, "addressSource"> & {
-        paymentCredentialSource: CredentialSource;
-        stakeCredentialSource?: CredentialSource;
-        drepCredentialSource?: CredentialSource;
-    }): Promise<MeshCardanoHeadlessWallet>;
-    /**
-     * 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
-     */
-    getUtxosMesh(): Promise<UTxO[]>;
-    /**
-     * 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
-     */
-    getCollateralMesh(): Promise<UTxO[]>;
-    /**
-     * 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
-     */
-    getBalanceMesh(): Promise<Asset[]>;
-    /**
-     * 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
-     */
-    getUsedAddressesBech32(): Promise<string[]>;
-    /**
-     * 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
-     */
-    getUnusedAddressesBech32(): Promise<string[]>;
-    /**
-     * 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
-     */
-    getChangeAddressBech32(): Promise<string>;
-    /**
-     * Get the reward address for the wallet.
-     * @returns {Promise<string[]>} A promise that resolves an array of reward addresses in Bech32 format
-     */
-    getRewardAddressesBech32(): Promise<string[]>;
-    /**
-     * 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
-     */
-    signTxReturnFullTx(tx: string, partialSign?: boolean): Promise<string>;
-}
-
-export { AddressType, BaseSigner, type Cardano, CardanoAddress, CardanoBrowserWallet, CardanoHeadlessWallet, type CardanoHeadlessWalletConfig, type Credential, type CredentialSource, CredentialType, type ICardanoWallet, InMemoryBip32, MeshCardanoBrowserWallet, MeshCardanoHeadlessWallet, type WalletAddressType };