@meshsdk/wallet 1.8.4 → 1.8.6

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,266 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/base32-encoding/index.js
+var require_base32_encoding = __commonJS({
+  "../../node_modules/base32-encoding/index.js"(exports2) {
+    "use strict";
+    var std = "23456789abcdefghijkmnpqrstuvwxyz";
+    exports2.stringify = function(buf, alphabet2) {
+      if (alphabet2 == null) alphabet2 = std;
+      return from(base322(buf), (b) => alphabet2[b]).join("");
+    };
+    exports2.parse = function(str, alphabet2) {
+      if (alphabet2 == null) alphabet2 = std;
+      return base256(str.split("").map((s) => alphabet2.indexOf(s)));
+    };
+    function from(buf, map) {
+      var a = new Array(buf.length);
+      for (var i = 0; i < a.length; i++) {
+        a[i] = map(buf[i]);
+      }
+      return a;
+    }
+    exports2.encode = base322;
+    function base322(buf, arr, offset) {
+      exports2.encode.bytes = Math.ceil(buf.length * 8 / 5);
+      if (arr == null) arr = Buffer.alloc(exports2.encode.bytes);
+      if (offset == null) offset = 0;
+      for (var i = 0, j = offset; i + 5 <= buf.length; i += 5, j += 8) {
+        arr[j + 0] = (buf[i + 0] & 248) >>> 3;
+        arr[j + 1] = (buf[i + 0] & 7) << 2 | (buf[i + 1] & 192) >>> 6;
+        arr[j + 2] = (buf[i + 1] & 62) >>> 1;
+        arr[j + 3] = (buf[i + 1] & 1) << 4 | (buf[i + 2] & 240) >>> 4;
+        arr[j + 4] = (buf[i + 2] & 15) << 1 | (buf[i + 3] & 128) >>> 7;
+        arr[j + 5] = (buf[i + 3] & 124) >>> 2;
+        arr[j + 6] = (buf[i + 3] & 3) << 3 | (buf[i + 4] & 224) >>> 5;
+        arr[j + 7] = buf[i + 4] & 31;
+      }
+      switch (buf.length - i) {
+        // No need for 5 since we work in batches of 5 above
+        case 4:
+          arr[j + 4] |= (buf[i + 3] & 128) >>> 7;
+          arr[j + 5] |= (buf[i + 3] & 124) >>> 2;
+          arr[j + 6] |= (buf[i + 3] & 3) << 3;
+        case 3:
+          arr[j + 3] |= (buf[i + 2] & 240) >>> 4;
+          arr[j + 4] |= (buf[i + 2] & 15) << 1;
+        case 2:
+          arr[j + 1] |= (buf[i + 1] & 192) >>> 6;
+          arr[j + 2] |= (buf[i + 1] & 62) >>> 1;
+          arr[j + 3] |= (buf[i + 1] & 1) << 4;
+        case 1:
+          arr[j + 0] |= (buf[i + 0] & 248) >>> 3;
+          arr[j + 1] |= (buf[i + 0] & 7) << 2;
+      }
+      return arr;
+    }
+    exports2.decode = base256;
+    function base256(buf, arr, offset) {
+      exports2.decode.bytes = Math.floor(buf.length * 5 / 8);
+      if (arr == null) arr = Buffer.alloc(exports2.decode.bytes);
+      if (offset == null) offset = 0;
+      for (var i = 0, j = offset; i + 8 <= buf.length; i += 8, j += 5) {
+        arr[j + 0] = buf[i + 0] << 3 & 255 | buf[i + 1] >>> 2 & 255;
+        arr[j + 1] = buf[i + 1] << 6 & 255 | buf[i + 2] << 1 & 255 | buf[i + 3] >>> 4 & 255;
+        arr[j + 2] = buf[i + 3] << 4 & 255 | buf[i + 4] >>> 1 & 255;
+        arr[j + 3] = buf[i + 4] << 7 & 255 | buf[i + 5] << 2 & 255 | buf[i + 6] >> 3 & 255;
+        arr[j + 4] = buf[i + 6] << 5 & 255 | buf[i + 7] & 255;
+      }
+      switch (buf.length - i) {
+        case 7:
+          arr[j + 3] |= buf[i + 6] >> 3 & 255;
+          arr[j + 4] |= buf[i + 6] << 5 & 255;
+        case 6:
+          arr[j + 3] |= buf[i + 5] << 2 & 255;
+        case 5:
+          arr[j + 2] |= buf[i + 4] >>> 1 & 255;
+          arr[j + 3] |= buf[i + 4] << 7 & 255;
+        case 4:
+          arr[j + 1] |= buf[i + 3] >>> 4 & 255;
+          arr[j + 2] |= buf[i + 3] << 4 & 255;
+        case 3:
+          arr[j + 1] |= buf[i + 2] << 1 & 255;
+        case 2:
+          arr[j + 0] |= buf[i + 1] >>> 2 & 255;
+          arr[j + 1] |= buf[i + 1] << 6 & 255;
+        case 1:
+          arr[j + 0] |= buf[i + 0] << 3 & 255;
+      }
+      return arr;
+    }
+    exports2.encodingLength = function(buf) {
+      return Math.ceil(buf.length * 8 / 5);
+    };
+  }
+});
+
+// ../../node_modules/bech32/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/bech32/dist/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.bech32m = exports2.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
+      };
+    }
+    exports2.bech32 = getLibraryFromEncoding("bech32");
+    exports2.bech32m = getLibraryFromEncoding("bech32m");
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -34,7 +297,10 @@ __export(index_exports, {
   BrowserWallet: () => BrowserWallet,
   EmbeddedWallet: () => EmbeddedWallet,
   MeshWallet: () => MeshWallet,
-  WalletStaticMethods: () => WalletStaticMethods
+  WalletStaticMethods: () => WalletStaticMethods,
+  connect: () => connect,
+  login: () => login,
+  register: () => register
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -303,8 +569,8 @@ var bech32 = /* @__PURE__ */ genBech32("bech32");
 var import_common = require("@meshsdk/common");
 var import_core_cst = require("@meshsdk/core-cst");
 var WalletStaticMethods = class {
-  static privateKeyToEntropy(bech322) {
-    const bech32DecodedBytes = bech32.decodeToBytes(bech322).bytes;
+  static privateKeyToEntropy(_bech32) {
+    const bech32DecodedBytes = bech32.decodeToBytes(_bech32).bytes;
     const bip32PrivateKey = import_core_cst.Bip32PrivateKey.fromBytes(bech32DecodedBytes);
     return (0, import_common.bytesToHex)(bip32PrivateKey.bytes());
   }
@@ -319,6 +585,10 @@ var WalletStaticMethods = class {
       stakeKey.startsWith("5820") ? stakeKey.slice(4) : stakeKey
     ];
   }
+  static bip32BytesToEntropy(bip32Bytes) {
+    const bip32PrivateKey = import_core_cst.Bip32PrivateKey.fromBytes(bip32Bytes);
+    return (0, import_common.bytesToHex)(bip32PrivateKey.bytes());
+  }
   static getAddresses(paymentKey, stakingKey, networkId = 0) {
     const baseAddress = (0, import_core_cst.buildBaseAddress)(
       networkId,
@@ -405,6 +675,11 @@ var EmbeddedWallet = class extends WalletStaticMethods {
           options.key.stake ?? "f0".repeat(32)
         );
         break;
+      case "bip32Bytes":
+        this._entropy = WalletStaticMethods.bip32BytesToEntropy(
+          options.key.bip32Bytes
+        );
+        break;
     }
   }
   getAccount(accountIndex = 0, keyIndex = 0) {
@@ -622,7 +897,7 @@ var AppWallet = class {
   }
 };
 
-// src/browser/index.ts
+// src/browser/browser-wallet.ts
 var import_common2 = require("@meshsdk/common");
 var import_core_csl = require("@meshsdk/core-csl");
 var import_core_cst3 = require("@meshsdk/core-cst");
@@ -665,7 +940,7 @@ async function checkIfMetamaskInstalled(network = "preprod") {
   }
 }
 
-// src/browser/index.ts
+// src/browser/browser-wallet.ts
 var BrowserWallet = class _BrowserWallet {
   constructor(_walletInstance, _walletName) {
     this._walletInstance = _walletInstance;
@@ -1158,10 +1433,170 @@ var BrowserWallet = class _BrowserWallet {
   }
 };
 
+// src/browser/webauthn/cardano/build-wallet-from-passkey.ts
+var import_base32_encoding = __toESM(require_base32_encoding(), 1);
+var import_bech32 = __toESM(require_dist(), 1);
+var import_core_cst4 = require("@meshsdk/core-cst");
+async function buildWalletFromPasskey(rawId, password, appSalt = "appSalt") {
+  const entropy = await createEntropy(rawId, appSalt);
+  return buildKey(Buffer.from(entropy), password);
+}
+function buildKey(entropy, password) {
+  const bip32Key = import_core_cst4.Crypto.Bip32PrivateKey.fromBip39Entropy(entropy, password);
+  const bytes = import_base32_encoding.default.encode(bip32Key.bytes());
+  const bech32PrivateKey = import_bech32.bech32.encode("xprv", bytes, 1023);
+  return {
+    bech32PrivateKey
+  };
+}
+async function createEntropy(rawId, appSalt) {
+  const rawIdBytes = new Uint8Array(new TextEncoder().encode(rawId));
+  const saltBytes = new TextEncoder().encode(appSalt);
+  const entropyBuffer = new Uint8Array([...rawIdBytes, ...saltBytes]);
+  const entropy = await crypto.subtle.digest("SHA-256", entropyBuffer);
+  return entropy;
+}
+
+// src/browser/webauthn/common/error-codes/index.ts
+var ERRORCODES = {
+  USEREXISTS: 1
+};
+
+// src/browser/webauthn/auth/login.ts
+var import_browser = require("@simplewebauthn/browser");
+async function login({
+  serverUrl,
+  username
+}) {
+  const initAuthRes = await fetch(`${serverUrl}/init-auth`, {
+    credentials: "include",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      username
+    })
+  });
+  const initAuth = await initAuthRes.json();
+  if (!initAuth.success) {
+    return {
+      success: false,
+      error: initAuth.error,
+      errorCode: initAuth.errorCode
+    };
+  }
+  const optionsJSON = initAuth.optionsJSON;
+  const authJSON = await (0, import_browser.startAuthentication)({ optionsJSON });
+  const verifyAuthRes = await fetch(`${serverUrl}/verify-auth`, {
+    credentials: "include",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(authJSON)
+  });
+  const verifyAuth = await verifyAuthRes.json();
+  if (!verifyAuthRes.ok) {
+    return { success: false, error: verifyAuth.error };
+  }
+  if (verifyAuth.verified) {
+    return { success: true, authJSON };
+  } else {
+    return { success: false, error: "Failed to log in" };
+  }
+}
+
+// src/browser/webauthn/auth/register.ts
+var import_browser2 = require("@simplewebauthn/browser");
+async function register({
+  serverUrl,
+  username
+}) {
+  const initRegisterRes = await fetch(`${serverUrl}/init-register`, {
+    credentials: "include",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      username
+    })
+  });
+  const initRegister = await initRegisterRes.json();
+  if (!initRegister.success) {
+    return {
+      success: false,
+      error: initRegister.error,
+      errorCode: initRegister.errorCode
+    };
+  }
+  const optionsJSON = initRegister.optionsJSON;
+  const registrationJSON = await (0, import_browser2.startRegistration)({ optionsJSON });
+  const verifyResponse = await fetch(`${serverUrl}/verify-register`, {
+    credentials: "include",
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(registrationJSON)
+  });
+  const verifyData = await verifyResponse.json();
+  if (!verifyResponse.ok) {
+    console.error(verifyData.error);
+    return {
+      success: false,
+      error: verifyData.error,
+      errorCode: verifyData.errorCode
+    };
+  }
+  if (verifyData.verified) {
+    console.log(`Successfully registered ${username}`);
+    return { success: true };
+  } else {
+    console.error(`Failed to register`);
+    return { success: false, error: "Failed to register", errorCode: 1 };
+  }
+}
+
+// src/browser/webauthn/auth/connect.ts
+async function connect({
+  username,
+  password,
+  serverUrl
+}) {
+  const responseRegister = await register({ serverUrl, username });
+  if (responseRegister.success || responseRegister.errorCode == ERRORCODES.USEREXISTS) {
+    const loginRes = await handleLogin({ serverUrl, username });
+    if (loginRes.success && loginRes.authJSON) {
+      const wallet = await buildWalletFromPasskey(
+        loginRes.authJSON.rawId,
+        password
+      );
+      return { success: true, wallet };
+    }
+  } else {
+    return { success: false, error: responseRegister.error };
+  }
+  return { success: false, error: "Fail to connect" };
+}
+async function handleLogin({
+  serverUrl,
+  username
+}) {
+  const responseLogin = await login({ serverUrl, username });
+  if (responseLogin.success && responseLogin.authJSON) {
+    const authJSON = responseLogin.authJSON;
+    return { success: true, authJSON };
+  } else {
+    return { success: false, error: responseLogin.error };
+  }
+}
+
 // src/mesh/index.ts
-var import_common3 = require("@meshsdk/common");
+var import_common4 = require("@meshsdk/common");
 var import_core_csl2 = require("@meshsdk/core-csl");
-var import_core_cst4 = require("@meshsdk/core-cst");
+var import_core_cst5 = require("@meshsdk/core-cst");
 var import_transaction = require("@meshsdk/transaction");
 var MeshWallet = class {
   _wallet;
@@ -1209,12 +1644,29 @@ var MeshWallet = class {
         });
         this.getAddressesFromWallet(this._wallet);
         break;
+      case "bip32Bytes":
+        this._wallet = new EmbeddedWallet({
+          networkId: options.networkId,
+          key: {
+            type: "bip32Bytes",
+            bip32Bytes: options.key.bip32Bytes
+          }
+        });
+        this.getAddressesFromWallet(this._wallet);
+        break;
       case "address":
         this._wallet = null;
         this.buildAddressFromBech32Address(options.key.address);
         break;
     }
   }
+  /**
+   * Returns all derived addresses from the wallet.
+   * @returns a list of addresses
+   */
+  getAddresses() {
+    return this.addresses;
+  }
   /**
    * Returns a list of assets in the wallet. This API will return every assets in the wallet. Each asset is an object with the following properties:
    * - A unit is provided to display asset's name on the user interface.
@@ -1226,7 +1678,7 @@ var MeshWallet = class {
     const utxos = await this.getUnspentOutputs();
     const assets = /* @__PURE__ */ new Map();
     utxos.map((utxo) => {
-      const _utxo = (0, import_core_cst4.fromTxUnspentOutput)(utxo);
+      const _utxo = (0, import_core_cst5.fromTxUnspentOutput)(utxo);
       _utxo.output.amount.map((asset) => {
         const assetId = asset.unit;
         const amount = Number(asset.quantity);
@@ -1263,7 +1715,7 @@ var MeshWallet = class {
   async getCollateral(addressType = "payment") {
     const utxos = await this.getCollateralUnspentOutput(addressType);
     return utxos.map((utxo, i) => {
-      return (0, import_core_cst4.fromTxUnspentOutput)(utxo);
+      return (0, import_core_cst5.fromTxUnspentOutput)(utxo);
     });
   }
   /**
@@ -1358,7 +1810,7 @@ var MeshWallet = class {
    */
   async getUtxos(addressType = "payment") {
     const utxos = await this.getUsedUTxOs(addressType);
-    return utxos.map((c) => (0, import_core_cst4.fromTxUnspentOutput)(c));
+    return utxos.map((c) => (0, import_core_cst5.fromTxUnspentOutput)(c));
   }
   /**
    * This endpoint utilizes the [CIP-8 - Message Signing](https://cips.cardano.org/cips/cip8/) to sign arbitrary data, to verify the data was signed by the owner of the private key.
@@ -1396,7 +1848,7 @@ var MeshWallet = class {
         "[MeshWallet] Read only wallet does not support signing data."
       );
     }
-    const tx = (0, import_core_cst4.deserializeTx)(unsignedTx);
+    const tx = (0, import_core_cst5.deserializeTx)(unsignedTx);
     if (!partialSign && tx.witnessSet().vkeys() !== void 0 && tx.witnessSet().vkeys().size() !== 0)
       throw new Error(
         "Signatures already exist in the transaction in a non partial sign call"
@@ -1455,9 +1907,9 @@ var MeshWallet = class {
    */
   getUsedAddress(addressType = "payment") {
     if (this.addresses.baseAddressBech32 && addressType === "payment") {
-      return (0, import_core_cst4.toAddress)(this.addresses.baseAddressBech32);
+      return (0, import_core_cst5.toAddress)(this.addresses.baseAddressBech32);
     } else {
-      return (0, import_core_cst4.toAddress)(this.addresses.enterpriseAddressBech32);
+      return (0, import_core_cst5.toAddress)(this.addresses.enterpriseAddressBech32);
     }
   }
   /**
@@ -1477,7 +1929,7 @@ var MeshWallet = class {
     const utxos = await this._fetcher.fetchAddressUTxOs(
       this.addresses.baseAddressBech32 && addressType == "payment" ? this.addresses.baseAddressBech32 : this.addresses.enterpriseAddressBech32
     );
-    return utxos.map((utxo) => (0, import_core_cst4.toTxUnspentOutput)(utxo));
+    return utxos.map((utxo) => (0, import_core_cst5.toTxUnspentOutput)(utxo));
   }
   /**
    * A helper function to get the assets in the wallet.
@@ -1487,13 +1939,13 @@ var MeshWallet = class {
   async getAssets() {
     const balance = await this.getBalance();
     return balance.filter((v) => v.unit !== "lovelace").map((v) => {
-      const policyId = v.unit.slice(0, import_common3.POLICY_ID_LENGTH);
-      const assetName = v.unit.slice(import_common3.POLICY_ID_LENGTH);
-      const fingerprint = (0, import_common3.resolveFingerprint)(policyId, assetName);
+      const policyId = v.unit.slice(0, import_common4.POLICY_ID_LENGTH);
+      const assetName = v.unit.slice(import_common4.POLICY_ID_LENGTH);
+      const fingerprint = (0, import_common4.resolveFingerprint)(policyId, assetName);
       return {
         unit: v.unit,
         policyId,
-        assetName: (0, import_common3.toUTF8)(assetName),
+        assetName: (0, import_common4.toUTF8)(assetName),
         fingerprint,
         quantity: v.quantity
       };
@@ -1527,7 +1979,7 @@ var MeshWallet = class {
   async getPolicyIds() {
     const balance = await this.getBalance();
     return Array.from(
-      new Set(balance.map((v) => v.unit.slice(0, import_common3.POLICY_ID_LENGTH)))
+      new Set(balance.map((v) => v.unit.slice(0, import_common4.POLICY_ID_LENGTH)))
     ).filter((p) => p !== "lovelace");
   }
   async getRegisteredPubStakeKeys() {
@@ -1588,40 +2040,40 @@ var MeshWallet = class {
   buildAddressFromBech32Address(address) {
     let pubKeyHash = void 0;
     let stakeKeyHash = void 0;
-    const baseAddress = import_core_cst4.Address.fromBech32(address).asBase();
+    const baseAddress = import_core_cst5.Address.fromBech32(address).asBase();
     if (baseAddress) {
       pubKeyHash = baseAddress.getPaymentCredential().hash;
       stakeKeyHash = baseAddress.getStakeCredential().hash;
     }
-    const enterpriseAddress = import_core_cst4.Address.fromBech32(address).asEnterprise();
+    const enterpriseAddress = import_core_cst5.Address.fromBech32(address).asEnterprise();
     if (enterpriseAddress) {
       pubKeyHash = enterpriseAddress.getPaymentCredential().hash;
     }
-    const rewardAddress = import_core_cst4.Address.fromBech32(address).asReward();
+    const rewardAddress = import_core_cst5.Address.fromBech32(address).asReward();
     if (rewardAddress) {
       stakeKeyHash = rewardAddress.getPaymentCredential().hash;
     }
     if (pubKeyHash && stakeKeyHash) {
-      this.addresses.baseAddress = (0, import_core_cst4.buildBaseAddress)(
+      this.addresses.baseAddress = (0, import_core_cst5.buildBaseAddress)(
         this._networkId,
-        import_core_cst4.Hash28ByteBase16.fromEd25519KeyHashHex((0, import_core_cst4.Ed25519KeyHashHex)(pubKeyHash)),
-        import_core_cst4.Hash28ByteBase16.fromEd25519KeyHashHex(
-          (0, import_core_cst4.Ed25519KeyHashHex)((0, import_core_cst4.Ed25519KeyHashHex)(stakeKeyHash))
+        import_core_cst5.Hash28ByteBase16.fromEd25519KeyHashHex((0, import_core_cst5.Ed25519KeyHashHex)(pubKeyHash)),
+        import_core_cst5.Hash28ByteBase16.fromEd25519KeyHashHex(
+          (0, import_core_cst5.Ed25519KeyHashHex)((0, import_core_cst5.Ed25519KeyHashHex)(stakeKeyHash))
         )
       ).toAddress();
       this.addresses.baseAddressBech32 = this.addresses.baseAddress.toBech32();
     }
     if (pubKeyHash) {
-      this.addresses.enterpriseAddress = (0, import_core_cst4.buildEnterpriseAddress)(
+      this.addresses.enterpriseAddress = (0, import_core_cst5.buildEnterpriseAddress)(
         this._networkId,
-        import_core_cst4.Hash28ByteBase16.fromEd25519KeyHashHex((0, import_core_cst4.Ed25519KeyHashHex)(pubKeyHash))
+        import_core_cst5.Hash28ByteBase16.fromEd25519KeyHashHex((0, import_core_cst5.Ed25519KeyHashHex)(pubKeyHash))
       ).toAddress();
       this.addresses.enterpriseAddressBech32 = this.addresses.enterpriseAddress.toBech32();
     }
     if (stakeKeyHash) {
-      this.addresses.rewardAddress = (0, import_core_cst4.buildRewardAddress)(
+      this.addresses.rewardAddress = (0, import_core_cst5.buildRewardAddress)(
         this._networkId,
-        import_core_cst4.Hash28ByteBase16.fromEd25519KeyHashHex((0, import_core_cst4.Ed25519KeyHashHex)(stakeKeyHash))
+        import_core_cst5.Hash28ByteBase16.fromEd25519KeyHashHex((0, import_core_cst5.Ed25519KeyHashHex)(stakeKeyHash))
       ).toAddress();
       this.addresses.rewardAddressBech32 = this.addresses.rewardAddress.toBech32();
     }
@@ -1633,7 +2085,10 @@ var MeshWallet = class {
   BrowserWallet,
   EmbeddedWallet,
   MeshWallet,
-  WalletStaticMethods
+  WalletStaticMethods,
+  connect,
+  login,
+  register
 });
 /*! Bundled license information: