@talismn/keyring 1.0.12 → 2.0.0

package/dist/index.js

@@ -1,501 +1,409 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _talismn_crypto = require("@talismn/crypto");
+//#region src/types/utils.ts
+const isAccountOfType = (account, type) => {
+	return account?.type === type;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+const isAccountInTypes = (account, types) => {
+	return !!account && types.includes(account.type);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Keyring: () => Keyring,
-  getAccountGenesisHash: () => getAccountGenesisHash,
-  getAccountPlatform: () => getAccountPlatform,
-  getAccountSignetUrl: () => getAccountSignetUrl,
-  isAccountAddressEthereum: () => isAccountAddressEthereum,
-  isAccountAddressSs58: () => isAccountAddressSs58,
-  isAccountBitcoin: () => isAccountBitcoin,
-  isAccountExternal: () => isAccountExternal,
-  isAccountInTypes: () => isAccountInTypes,
-  isAccountLedgerPolkadot: () => isAccountLedgerPolkadot,
-  isAccountLedgerPolkadotGeneric: () => isAccountLedgerPolkadotGeneric,
-  isAccountLedgerPolkadotLegacy: () => isAccountLedgerPolkadotLegacy,
-  isAccountNotContact: () => isAccountNotContact,
-  isAccountOfType: () => isAccountOfType,
-  isAccountOwned: () => isAccountOwned,
-  isAccountPlatformEthereum: () => isAccountPlatformEthereum,
-  isAccountPlatformPolkadot: () => isAccountPlatformPolkadot,
-  isAccountPlatformSolana: () => isAccountPlatformSolana,
-  isAccountPortfolio: () => isAccountPortfolio
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/keyring/Keyring.ts
-var import_crypto3 = require("@talismn/crypto");
-
-// src/types/utils.ts
-var import_crypto = require("@talismn/crypto");
-var isAccountOfType = (account, type) => {
-  return account?.type === type;
-};
-var isAccountInTypes = (account, types) => {
-  return !!account && types.includes(account.type);
-};
-var ACCOUNT_TYPES_OWNED = [
-  "keypair",
-  "ledger-ethereum",
-  "ledger-polkadot",
-  "ledger-solana",
-  "polkadot-vault"
+const ACCOUNT_TYPES_OWNED = [
+	"keypair",
+	"ledger-ethereum",
+	"ledger-polkadot",
+	"ledger-solana",
+	"polkadot-vault"
 ];
-var ACCOUNT_TYPES_EXTERNAL = [
-  "contact",
-  "watch-only",
-  "ledger-ethereum",
-  "ledger-polkadot",
-  "ledger-solana",
-  "polkadot-vault",
-  "signet"
+const ACCOUNT_TYPES_EXTERNAL = [
+	"contact",
+	"watch-only",
+	"ledger-ethereum",
+	"ledger-polkadot",
+	"ledger-solana",
+	"polkadot-vault",
+	"signet"
 ];
-var isAccountExternal = (account) => {
-  return isAccountInTypes(account, ACCOUNT_TYPES_EXTERNAL);
+const isAccountExternal = (account) => {
+	return isAccountInTypes(account, ACCOUNT_TYPES_EXTERNAL);
 };
-var isAccountOwned = (account) => {
-  return isAccountInTypes(account, ACCOUNT_TYPES_OWNED);
+const isAccountOwned = (account) => {
+	return isAccountInTypes(account, ACCOUNT_TYPES_OWNED);
 };
-var isAccountPortfolio = (account) => {
-  return isAccountOwned(account) || isAccountOfType(account, "watch-only") && account.isPortfolio;
+const isAccountPortfolio = (account) => {
+	return isAccountOwned(account) || isAccountOfType(account, "watch-only") && account.isPortfolio;
 };
-var isAccountNotContact = (acc) => acc.type !== "contact";
-var isAccountAddressEthereum = (account) => {
-  return !!account && (0, import_crypto.isEthereumAddress)(account.address);
+const isAccountNotContact = (acc) => acc.type !== "contact";
+const isAccountAddressEthereum = (account) => {
+	return !!account && (0, _talismn_crypto.isEthereumAddress)(account.address);
 };
-var isAccountPlatformEthereum = (account) => {
-  return !!account && account.type !== "ledger-polkadot" && (0, import_crypto.isEthereumAddress)(account.address);
+const isAccountPlatformEthereum = (account) => {
+	return !!account && account.type !== "ledger-polkadot" && (0, _talismn_crypto.isEthereumAddress)(account.address);
 };
-var isAccountPlatformSolana = (account) => {
-  return !!account && (0, import_crypto.isSolanaAddress)(account.address);
+const isAccountPlatformSolana = (account) => {
+	return !!account && (0, _talismn_crypto.isSolanaAddress)(account.address);
 };
-var isAccountPlatformPolkadot = (account) => {
-  return !!account && account.type !== "ledger-ethereum" && (isAccountAddressEthereum(account) || isAccountAddressSs58(account));
+const isAccountPlatformPolkadot = (account) => {
+	return !!account && account.type !== "ledger-ethereum" && (isAccountAddressEthereum(account) || isAccountAddressSs58(account));
 };
-var isAccountAddressSs58 = (account) => {
-  return !!account && (0, import_crypto.detectAddressEncoding)(account.address) === "ss58";
+const isAccountAddressSs58 = (account) => {
+	return !!account && (0, _talismn_crypto.detectAddressEncoding)(account.address) === "ss58";
 };
-var isAccountLedgerPolkadot = (account) => {
-  return isAccountOfType(account, "ledger-polkadot");
+const isAccountLedgerPolkadot = (account) => {
+	return isAccountOfType(account, "ledger-polkadot");
 };
-var isAccountLedgerPolkadotGeneric = (account) => {
-  return isAccountOfType(account, "ledger-polkadot") && !account.genesisHash;
+const isAccountLedgerPolkadotGeneric = (account) => {
+	return isAccountOfType(account, "ledger-polkadot") && !account.genesisHash;
 };
-var isAccountLedgerPolkadotLegacy = (account) => {
-  return isAccountOfType(account, "ledger-polkadot") && !!account.genesisHash;
+const isAccountLedgerPolkadotLegacy = (account) => {
+	return isAccountOfType(account, "ledger-polkadot") && !!account.genesisHash;
 };
-var isAccountBitcoin = (account) => {
-  return !!account && (0, import_crypto.isBitcoinAddress)(account.address);
+const isAccountBitcoin = (account) => {
+	return !!account && (0, _talismn_crypto.isBitcoinAddress)(account.address);
 };
-var getAccountGenesisHash = (account) => {
-  if (!account) return void 0;
-  return "genesisHash" in account ? account.genesisHash || void 0 : void 0;
+const getAccountGenesisHash = (account) => {
+	if (!account) return void 0;
+	return "genesisHash" in account ? account.genesisHash || void 0 : void 0;
 };
-var getAccountSignetUrl = (account) => {
-  return isAccountOfType(account, "signet") ? account.url : void 0;
+const getAccountSignetUrl = (account) => {
+	return isAccountOfType(account, "signet") ? account.url : void 0;
 };
-var getAccountPlatform = (account) => {
-  if (!account) return void 0;
-  return "curve" in account ? (0, import_crypto.getAccountPlatformFromCurve)(account.curve) : (0, import_crypto.getAccountPlatformFromAddress)(account.address);
+const getAccountPlatform = (account) => {
+	if (!account) return void 0;
+	return "curve" in account ? (0, _talismn_crypto.getAccountPlatformFromCurve)(account.curve) : (0, _talismn_crypto.getAccountPlatformFromAddress)(account.address);
 };
-
-// src/keyring/encryption.ts
-var import_crypto2 = require("@talismn/crypto");
-var deriveKey = async (password, salt) => (
-  // Deriving 32-byte key using PBKDF2 with 100,000 iterations and SHA-256
-  await crypto.subtle.importKey(
-    "raw",
-    await (0, import_crypto2.pbkdf2)(
-      "SHA-256",
-      new TextEncoder().encode(password),
-      salt,
-      1e5,
-      // 100,000 iterations
-      32
-      // 32 bytes (32 * 8 == 256 bits)
-    ),
-    { name: "AES-GCM", length: 256 },
-    false,
-    ["encrypt", "decrypt"]
-  )
-);
-var encryptData = async (data, password) => {
-  try {
-    const salt = crypto.getRandomValues(new Uint8Array(16));
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const key = await deriveKey(password, salt);
-    const encryptedSeed = await crypto.subtle.encrypt(
-      { name: "AES-GCM", iv },
-      key,
-      data
-    );
-    const combined = new Uint8Array(salt.length + iv.length + encryptedSeed.byteLength);
-    combined.set(salt, 0);
-    combined.set(iv, salt.length);
-    combined.set(new Uint8Array(encryptedSeed), salt.length + iv.length);
-    return btoa(String.fromCharCode(...combined));
-  } catch (cause) {
-    throw new Error("Failed to encrypt data", { cause });
-  }
+//#endregion
+//#region src/keyring/encryption.ts
+const deriveKey = async (password, salt) => await crypto.subtle.importKey("raw", await (0, _talismn_crypto.pbkdf2)("SHA-256", new TextEncoder().encode(password), salt, 1e5, 32), {
+	name: "AES-GCM",
+	length: 256
+}, false, ["encrypt", "decrypt"]);
+const encryptData = async (data, password) => {
+	try {
+		const salt = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+		const iv = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(12));
+		const key = await deriveKey(password, salt);
+		const encryptedSeed = await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv
+		}, key, data);
+		const combined = new Uint8Array(salt.length + iv.length + encryptedSeed.byteLength);
+		combined.set(salt, 0);
+		combined.set(iv, salt.length);
+		combined.set(new Uint8Array(encryptedSeed), salt.length + iv.length);
+		return btoa(String.fromCharCode(...combined));
+	} catch (cause) {
+		throw new Error("Failed to encrypt data", { cause });
+	}
 };
-var decryptData = async (encryptedData, password) => {
-  try {
-    const combined = Uint8Array.from(atob(encryptedData), (c) => c.charCodeAt(0));
-    const salt = combined.slice(0, 16);
-    const iv = combined.slice(16, 28);
-    const encryptedSeed = combined.slice(28);
-    const key = await deriveKey(password, salt);
-    const decryptedSeed = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, encryptedSeed);
-    return new Uint8Array(decryptedSeed);
-  } catch (cause) {
-    throw new Error("Failed to decrypt data", { cause });
-  }
+const decryptData = async (encryptedData, password) => {
+	try {
+		const combined = Uint8Array.from(atob(encryptedData), (c) => c.charCodeAt(0));
+		const salt = combined.slice(0, 16);
+		const iv = combined.slice(16, 28);
+		const encryptedSeed = combined.slice(28);
+		const key = await deriveKey(password, salt);
+		const decryptedSeed = await crypto.subtle.decrypt({
+			name: "AES-GCM",
+			iv
+		}, key, encryptedSeed);
+		return new Uint8Array(decryptedSeed);
+	} catch (cause) {
+		throw new Error("Failed to decrypt data", { cause });
+	}
 };
-var changeEncryptedDataPassword = async (encryptedData, oldPassword, newPassword) => {
-  try {
-    const decrypted = await decryptData(encryptedData, oldPassword);
-    return await encryptData(decrypted, newPassword);
-  } catch (cause) {
-    throw new Error("Failed to change password on encrypted data", { cause });
-  }
+const changeEncryptedDataPassword = async (encryptedData, oldPassword, newPassword) => {
+	try {
+		const decrypted = await decryptData(encryptedData, oldPassword);
+		return await encryptData(decrypted, newPassword);
+	} catch (cause) {
+		throw new Error("Failed to change password on encrypted data", { cause });
+	}
 };
-
-// src/keyring/utils.ts
-var REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
-var isHexString = (value) => {
-  return typeof value === "string" && REGEX_HEX_STRING.test(value);
+//#endregion
+//#region src/keyring/utils.ts
+const REGEX_HEX_STRING = /^0x[0-9a-fA-F]*$/;
+const isHexString = (value) => {
+	return typeof value === "string" && REGEX_HEX_STRING.test(value);
 };
-
-// src/keyring/Keyring.ts
-var Keyring = class _Keyring {
-  #data;
-  constructor(data) {
-    this.#data = structuredClone(data);
-  }
-  static create() {
-    return new _Keyring({
-      passwordCheck: null,
-      // well-known data encrypted using the password, used to ensure all secrets of the keyring are encrypted with the same password
-      mnemonics: [],
-      accounts: []
-    });
-  }
-  static load(data) {
-    if (!data.accounts || !data.mnemonics) throw new Error("Invalid data");
-    for (const account of data.accounts) {
-      if (account.type === "ledger-polkadot" && !account.curve) account.curve = "ed25519";
-    }
-    return new _Keyring(data);
-  }
-  async checkPassword(password, reset = false) {
-    if (typeof password !== "string" || !password) throw new Error("password is required");
-    const passwordHash = oneWayHash(password);
-    const PASSWORD_CHECK_PHRASE = "PASSWORD_CHECK_PHRASE";
-    if (!this.#data.passwordCheck || reset) {
-      const bytes = import_crypto3.utf8.decode(PASSWORD_CHECK_PHRASE);
-      this.#data.passwordCheck = await encryptData(bytes, passwordHash);
-    } else {
-      try {
-        const bytes = await decryptData(this.#data.passwordCheck, passwordHash);
-        const text = import_crypto3.utf8.encode(bytes);
-        if (text !== PASSWORD_CHECK_PHRASE) throw new Error("Invalid password");
-      } catch {
-        throw new Error("Invalid password");
-      }
-    }
-  }
-  /** Returns true if a password has been set on this keyring. */
-  hasPassword() {
-    return this.#data.passwordCheck !== null;
-  }
-  /**
-   * Verify a password against the keyring's passwordCheck blob.
-   * Returns true on success, false on wrong password.
-   * Throws if no password has been set (caller should check hasPassword() first).
-   */
-  async verifyPassword(password) {
-    if (!this.#data.passwordCheck) {
-      throw new Error("No password set \u2014 call hasPassword() before verifyPassword()");
-    }
-    try {
-      await this.checkPassword(password);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Initialize the password on a fresh keyring that has no password set.
-   * Throws if a password is already set (use changePassword flow instead).
-   */
-  async initializePassword(password) {
-    if (this.#data.passwordCheck !== null) {
-      throw new Error("Password already set \u2014 cannot re-initialize");
-    }
-    await this.checkPassword(password, true);
-  }
-  toJson() {
-    return structuredClone(this.#data);
-  }
-  async export(password, jsonPassword) {
-    const keyring = new _Keyring(structuredClone(this.#data));
-    for (const mnemonic of keyring.#data.mnemonics)
-      mnemonic.entropy = await changeEncryptedDataPassword(mnemonic.entropy, password, jsonPassword);
-    for (const account of keyring.#data.accounts)
-      if (account.type === "keypair")
-        account.secretKey = await changeEncryptedDataPassword(
-          account.secretKey,
-          password,
-          jsonPassword
-        );
-    await keyring.checkPassword(jsonPassword, true);
-    return keyring.toJson();
-  }
-  getMnemonics() {
-    return this.#data.mnemonics.map(mnemonicFromStorage);
-  }
-  async addMnemonic({ name, mnemonic, confirmed }, password) {
-    if (typeof name !== "string" || !name) throw new Error("name is required");
-    if (typeof mnemonic !== "string") throw new Error("mnemonic is required");
-    if (typeof confirmed !== "boolean") throw new Error("confirmed is required");
-    if (!(0, import_crypto3.isValidMnemonic)(mnemonic)) throw new Error("Invalid mnemonic");
-    await this.checkPassword(password);
-    const entropy = (0, import_crypto3.mnemonicToEntropy)(mnemonic);
-    const id = oneWayHash(entropy);
-    if (this.#data.mnemonics.find((s) => s.id === id)) throw new Error("Mnemonic already exists");
-    const storage = {
-      id,
-      name,
-      entropy: await encryptData(entropy, password),
-      confirmed,
-      createdAt: Date.now()
-    };
-    this.#data.mnemonics.push(storage);
-    return mnemonicFromStorage(storage);
-  }
-  getMnemonic(id) {
-    const mnemonic = this.#data.mnemonics.find((s) => s.id === id);
-    return mnemonic ? mnemonicFromStorage(mnemonic) : null;
-  }
-  updateMnemonic(id, { name, confirmed }) {
-    const mnemonic = this.#data.mnemonics.find((s) => s.id === id);
-    if (!mnemonic) throw new Error("Mnemonic not found");
-    if (name !== void 0) {
-      if (typeof name !== "string" || !name) throw new Error("name must be a string");
-      mnemonic.name = name;
-    }
-    if (confirmed !== void 0) {
-      if (typeof confirmed !== "boolean") throw new Error("confirmed must be a boolean");
-      mnemonic.confirmed = confirmed;
-    }
-    return mnemonicFromStorage(mnemonic);
-  }
-  removeMnemonic(id) {
-    const index = this.#data.mnemonics.findIndex((mnemonic) => mnemonic.id === id);
-    if (index === -1) throw new Error("Mnemonic not found");
-    this.#data.mnemonics.splice(index, 1);
-  }
-  async getMnemonicText(id, password) {
-    const mnemonic = this.#data.mnemonics.find((s) => s.id === id);
-    if (!mnemonic) throw new Error("Mnemonic not found");
-    const entropy = await decryptData(mnemonic.entropy, password);
-    return (0, import_crypto3.entropyToMnemonic)(entropy);
-  }
-  getExistingMnemonicId(mnemonic) {
-    const entropy = (0, import_crypto3.mnemonicToEntropy)(mnemonic);
-    const mnemonicId = oneWayHash(entropy);
-    return this.#data.mnemonics.some((s) => s.id === mnemonicId) ? mnemonicId : null;
-  }
-  getAccounts() {
-    return this.#data.accounts.map(accountFromStorage);
-  }
-  getAccount(address) {
-    const account = this.#data.accounts.find((s) => (0, import_crypto3.isAddressEqual)(s.address, address));
-    return account ? accountFromStorage(account) : null;
-  }
-  updateAccount(address, { name, isPortfolio, genesisHash }) {
-    const account = this.#data.accounts.find((s) => s.address === address);
-    if (!account) throw new Error("Account not found");
-    if (name) {
-      if (typeof name !== "string" || !name) throw new Error("name is required");
-      account.name = name;
-    }
-    if (account.type === "watch-only" && isPortfolio !== void 0) {
-      if (typeof isPortfolio !== "boolean") throw new Error("isPortfolio must be a boolean");
-      account.isPortfolio = isPortfolio;
-    }
-    if (account.type === "contact") {
-      if (genesisHash) {
-        if (!isHexString(genesisHash)) throw new Error("genesisHash must be a hex string");
-        account.genesisHash = genesisHash;
-      } else delete account.genesisHash;
-    }
-    return accountFromStorage(account);
-  }
-  removeAccount(address) {
-    const index = this.#data.accounts.findIndex((s) => (0, import_crypto3.isAddressEqual)(s.address, address));
-    if (index === -1) throw new Error("Account not found");
-    this.#data.accounts.splice(index, 1);
-  }
-  addAccountExternal(options) {
-    const address = (0, import_crypto3.normalizeAddress)(options.address);
-    if (this.getAccount(address)) throw new Error("Account already exists");
-    const account = {
-      ...options,
-      address,
-      createdAt: Date.now()
-    };
-    if (!isAccountExternal(account)) throw new Error("Invalid account type");
-    this.#data.accounts.push(account);
-    return accountFromStorage(account);
-  }
-  /**
-   * Needs to be called before deriving an account from a mnemonic.
-   *
-   * This will ensure that it is present (or add it if possible) in the keyring before actually creating the account.
-   *
-   * @param options
-   * @param password
-   * @returns the id of the mnemonic
-   */
-  async ensureMnemonic(options, password) {
-    await this.checkPassword(password);
-    switch (options.type) {
-      case "new-mnemonic": {
-        const { mnemonic, mnemonicName: name, confirmed } = options;
-        if (typeof name !== "string" || !name) throw new Error("mnemonicName is required");
-        if (typeof confirmed !== "boolean") throw new Error("confirmed is required");
-        const mnemonicId = this.getExistingMnemonicId(mnemonic);
-        if (mnemonicId) return mnemonicId;
-        const { id } = await this.addMnemonic(
-          {
-            name,
-            mnemonic,
-            confirmed
-          },
-          password
-        );
-        return id;
-      }
-      case "existing-mnemonic": {
-        if (typeof options.mnemonicId !== "string" || !options.mnemonicId)
-          throw new Error("mnemonicId must be a string");
-        return options.mnemonicId;
-      }
-    }
-  }
-  async addAccountDerive(options, password) {
-    await this.checkPassword(password);
-    const { curve, derivationPath, name } = options;
-    const mnemonicId = await this.ensureMnemonic(options, password);
-    const mnemonic = this.#data.mnemonics.find((s) => s.id === mnemonicId);
-    if (!mnemonic) throw new Error("Mnemonic not found");
-    const entropy = await decryptData(mnemonic.entropy, password);
-    const seed = await (0, import_crypto3.entropyToSeed)(entropy, curve);
-    const pair = (0, import_crypto3.deriveKeypair)(seed, derivationPath, curve);
-    if (this.getAccount(pair.address)) throw new Error("Account already exists");
-    const account = {
-      type: "keypair",
-      curve,
-      name,
-      address: (0, import_crypto3.normalizeAddress)(pair.address),
-      secretKey: await encryptData(pair.secretKey, password),
-      mnemonicId,
-      derivationPath,
-      createdAt: Date.now()
-    };
-    this.#data.accounts.push(account);
-    return accountFromStorage(account);
-  }
-  async addAccountKeypair({ curve, name, secretKey }, password) {
-    await this.checkPassword(password);
-    const publicKey = (0, import_crypto3.getPublicKeyFromSecret)(secretKey, curve);
-    const encoding = (0, import_crypto3.addressEncodingFromCurve)(curve);
-    const address = (0, import_crypto3.addressFromPublicKey)(publicKey, encoding);
-    if (this.getAccount(address)) throw new Error("Account already exists");
-    const account = {
-      type: "keypair",
-      curve,
-      name,
-      address: (0, import_crypto3.normalizeAddress)(address),
-      secretKey: await encryptData(secretKey, password),
-      createdAt: Date.now()
-    };
-    this.#data.accounts.push(account);
-    return accountFromStorage(account);
-  }
-  getAccountSecretKey(address, password) {
-    if (typeof address !== "string" || !address) throw new Error("address is required");
-    if (typeof password !== "string" || !password) throw new Error("password is required");
-    const account = this.#data.accounts.find((a) => a.address === (0, import_crypto3.normalizeAddress)(address));
-    if (!account) throw new Error("Account not found");
-    if (account.type !== "keypair") throw new Error("Secret key unavailable");
-    return decryptData(account.secretKey, password);
-  }
-  async getDerivedAddress(mnemonicId, derivationPath, curve, password) {
-    if (typeof mnemonicId !== "string" || !mnemonicId) throw new Error("mnemonicId is required");
-    if (typeof password !== "string" || !password) throw new Error("password is required");
-    const mnemonic = this.#data.mnemonics.find((s) => s.id === mnemonicId);
-    if (!mnemonic) throw new Error("Mnemonic not found");
-    const entropy = await decryptData(mnemonic.entropy, password);
-    const seed = await (0, import_crypto3.entropyToSeed)(entropy, curve);
-    const pair = (0, import_crypto3.deriveKeypair)(seed, derivationPath, curve);
-    return pair.address;
-  }
+//#endregion
+//#region src/keyring/Keyring.ts
+var Keyring = class Keyring {
+	#data;
+	constructor(data) {
+		this.#data = structuredClone(data);
+	}
+	static create() {
+		return new Keyring({
+			passwordCheck: null,
+			mnemonics: [],
+			accounts: []
+		});
+	}
+	static load(data) {
+		if (!data.accounts || !data.mnemonics) throw new Error("Invalid data");
+		for (const account of data.accounts) if (account.type === "ledger-polkadot" && !account.curve) account.curve = "ed25519";
+		return new Keyring(data);
+	}
+	async checkPassword(password, reset = false) {
+		if (typeof password !== "string" || !password) throw new Error("password is required");
+		const passwordHash = oneWayHash(password);
+		const PASSWORD_CHECK_PHRASE = "PASSWORD_CHECK_PHRASE";
+		if (!this.#data.passwordCheck || reset) {
+			const bytes = _talismn_crypto.utf8.decode(PASSWORD_CHECK_PHRASE);
+			this.#data.passwordCheck = await encryptData(bytes, passwordHash);
+		} else try {
+			const bytes = await decryptData(this.#data.passwordCheck, passwordHash);
+			if (_talismn_crypto.utf8.encode(bytes) !== PASSWORD_CHECK_PHRASE) throw new Error("Invalid password");
+		} catch {
+			throw new Error("Invalid password");
+		}
+	}
+	/** Returns true if a password has been set on this keyring. */
+	hasPassword() {
+		return this.#data.passwordCheck !== null;
+	}
+	/**
+	* Verify a password against the keyring's passwordCheck blob.
+	* Returns true on success, false on wrong password.
+	* Throws if no password has been set (caller should check hasPassword() first).
+	*/
+	async verifyPassword(password) {
+		if (!this.#data.passwordCheck) throw new Error("No password set — call hasPassword() before verifyPassword()");
+		try {
+			await this.checkPassword(password);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Initialize the password on a fresh keyring that has no password set.
+	* Throws if a password is already set (use changePassword flow instead).
+	*/
+	async initializePassword(password) {
+		if (this.#data.passwordCheck !== null) throw new Error("Password already set — cannot re-initialize");
+		await this.checkPassword(password, true);
+	}
+	toJson() {
+		return structuredClone(this.#data);
+	}
+	async export(password, jsonPassword) {
+		const keyring = new Keyring(structuredClone(this.#data));
+		for (const mnemonic of keyring.#data.mnemonics) mnemonic.entropy = await changeEncryptedDataPassword(mnemonic.entropy, password, jsonPassword);
+		for (const account of keyring.#data.accounts) if (account.type === "keypair") account.secretKey = await changeEncryptedDataPassword(account.secretKey, password, jsonPassword);
+		await keyring.checkPassword(jsonPassword, true);
+		return keyring.toJson();
+	}
+	getMnemonics() {
+		return this.#data.mnemonics.map(mnemonicFromStorage);
+	}
+	async addMnemonic({ name, mnemonic, confirmed }, password) {
+		if (typeof name !== "string" || !name) throw new Error("name is required");
+		if (typeof mnemonic !== "string") throw new Error("mnemonic is required");
+		if (typeof confirmed !== "boolean") throw new Error("confirmed is required");
+		if (!(0, _talismn_crypto.isValidMnemonic)(mnemonic)) throw new Error("Invalid mnemonic");
+		await this.checkPassword(password);
+		const entropy = (0, _talismn_crypto.mnemonicToEntropy)(mnemonic);
+		const id = oneWayHash(entropy);
+		if (this.#data.mnemonics.find((s) => s.id === id)) throw new Error("Mnemonic already exists");
+		const storage = {
+			id,
+			name,
+			entropy: await encryptData(entropy, password),
+			confirmed,
+			createdAt: Date.now()
+		};
+		this.#data.mnemonics.push(storage);
+		return mnemonicFromStorage(storage);
+	}
+	getMnemonic(id) {
+		const mnemonic = this.#data.mnemonics.find((s) => s.id === id);
+		return mnemonic ? mnemonicFromStorage(mnemonic) : null;
+	}
+	updateMnemonic(id, { name, confirmed }) {
+		const mnemonic = this.#data.mnemonics.find((s) => s.id === id);
+		if (!mnemonic) throw new Error("Mnemonic not found");
+		if (name !== void 0) {
+			if (typeof name !== "string" || !name) throw new Error("name must be a string");
+			mnemonic.name = name;
+		}
+		if (confirmed !== void 0) {
+			if (typeof confirmed !== "boolean") throw new Error("confirmed must be a boolean");
+			mnemonic.confirmed = confirmed;
+		}
+		return mnemonicFromStorage(mnemonic);
+	}
+	removeMnemonic(id) {
+		const index = this.#data.mnemonics.findIndex((mnemonic) => mnemonic.id === id);
+		if (index === -1) throw new Error("Mnemonic not found");
+		this.#data.mnemonics.splice(index, 1);
+	}
+	async getMnemonicText(id, password) {
+		const mnemonic = this.#data.mnemonics.find((s) => s.id === id);
+		if (!mnemonic) throw new Error("Mnemonic not found");
+		return (0, _talismn_crypto.entropyToMnemonic)(await decryptData(mnemonic.entropy, password));
+	}
+	getExistingMnemonicId(mnemonic) {
+		const entropy = (0, _talismn_crypto.mnemonicToEntropy)(mnemonic);
+		const mnemonicId = oneWayHash(entropy);
+		return this.#data.mnemonics.some((s) => s.id === mnemonicId) ? mnemonicId : null;
+	}
+	getAccounts() {
+		return this.#data.accounts.map(accountFromStorage);
+	}
+	getAccount(address) {
+		const account = this.#data.accounts.find((s) => (0, _talismn_crypto.isAddressEqual)(s.address, address));
+		return account ? accountFromStorage(account) : null;
+	}
+	updateAccount(address, { name, isPortfolio, genesisHash }) {
+		const account = this.#data.accounts.find((s) => s.address === address);
+		if (!account) throw new Error("Account not found");
+		if (name) {
+			if (typeof name !== "string" || !name) throw new Error("name is required");
+			account.name = name;
+		}
+		if (account.type === "watch-only" && isPortfolio !== void 0) {
+			if (typeof isPortfolio !== "boolean") throw new Error("isPortfolio must be a boolean");
+			account.isPortfolio = isPortfolio;
+		}
+		if (account.type === "contact") if (genesisHash) {
+			if (!isHexString(genesisHash)) throw new Error("genesisHash must be a hex string");
+			account.genesisHash = genesisHash;
+		} else delete account.genesisHash;
+		return accountFromStorage(account);
+	}
+	removeAccount(address) {
+		const index = this.#data.accounts.findIndex((s) => (0, _talismn_crypto.isAddressEqual)(s.address, address));
+		if (index === -1) throw new Error("Account not found");
+		this.#data.accounts.splice(index, 1);
+	}
+	addAccountExternal(options) {
+		const address = (0, _talismn_crypto.normalizeAddress)(options.address);
+		if (this.getAccount(address)) throw new Error("Account already exists");
+		const account = {
+			...options,
+			address,
+			createdAt: Date.now()
+		};
+		if (!isAccountExternal(account)) throw new Error("Invalid account type");
+		this.#data.accounts.push(account);
+		return accountFromStorage(account);
+	}
+	/**
+	* Needs to be called before deriving an account from a mnemonic.
+	*
+	* This will ensure that it is present (or add it if possible) in the keyring before actually creating the account.
+	*
+	* @param options
+	* @param password
+	* @returns the id of the mnemonic
+	*/
+	async ensureMnemonic(options, password) {
+		await this.checkPassword(password);
+		switch (options.type) {
+			case "new-mnemonic": {
+				const { mnemonic, mnemonicName: name, confirmed } = options;
+				if (typeof name !== "string" || !name) throw new Error("mnemonicName is required");
+				if (typeof confirmed !== "boolean") throw new Error("confirmed is required");
+				const mnemonicId = this.getExistingMnemonicId(mnemonic);
+				if (mnemonicId) return mnemonicId;
+				const { id } = await this.addMnemonic({
+					name,
+					mnemonic,
+					confirmed
+				}, password);
+				return id;
+			}
+			case "existing-mnemonic":
+				if (typeof options.mnemonicId !== "string" || !options.mnemonicId) throw new Error("mnemonicId must be a string");
+				return options.mnemonicId;
+		}
+	}
+	async addAccountDerive(options, password) {
+		await this.checkPassword(password);
+		const { curve, derivationPath, name } = options;
+		const mnemonicId = await this.ensureMnemonic(options, password);
+		const mnemonic = this.#data.mnemonics.find((s) => s.id === mnemonicId);
+		if (!mnemonic) throw new Error("Mnemonic not found");
+		const pair = (0, _talismn_crypto.deriveKeypair)(await (0, _talismn_crypto.entropyToSeed)(await decryptData(mnemonic.entropy, password), curve), derivationPath, curve);
+		if (this.getAccount(pair.address)) throw new Error("Account already exists");
+		const account = {
+			type: "keypair",
+			curve,
+			name,
+			address: (0, _talismn_crypto.normalizeAddress)(pair.address),
+			secretKey: await encryptData(pair.secretKey, password),
+			mnemonicId,
+			derivationPath,
+			createdAt: Date.now()
+		};
+		this.#data.accounts.push(account);
+		return accountFromStorage(account);
+	}
+	async addAccountKeypair({ curve, name, secretKey }, password) {
+		await this.checkPassword(password);
+		const address = (0, _talismn_crypto.addressFromPublicKey)((0, _talismn_crypto.getPublicKeyFromSecret)(secretKey, curve), (0, _talismn_crypto.addressEncodingFromCurve)(curve));
+		if (this.getAccount(address)) throw new Error("Account already exists");
+		const account = {
+			type: "keypair",
+			curve,
+			name,
+			address: (0, _talismn_crypto.normalizeAddress)(address),
+			secretKey: await encryptData(secretKey, password),
+			createdAt: Date.now()
+		};
+		this.#data.accounts.push(account);
+		return accountFromStorage(account);
+	}
+	getAccountSecretKey(address, password) {
+		if (typeof address !== "string" || !address) throw new Error("address is required");
+		if (typeof password !== "string" || !password) throw new Error("password is required");
+		const account = this.#data.accounts.find((a) => a.address === (0, _talismn_crypto.normalizeAddress)(address));
+		if (!account) throw new Error("Account not found");
+		if (account.type !== "keypair") throw new Error("Secret key unavailable");
+		return decryptData(account.secretKey, password);
+	}
+	async getDerivedAddress(mnemonicId, derivationPath, curve, password) {
+		if (typeof mnemonicId !== "string" || !mnemonicId) throw new Error("mnemonicId is required");
+		if (typeof password !== "string" || !password) throw new Error("password is required");
+		const mnemonic = this.#data.mnemonics.find((s) => s.id === mnemonicId);
+		if (!mnemonic) throw new Error("Mnemonic not found");
+		return (0, _talismn_crypto.deriveKeypair)(await (0, _talismn_crypto.entropyToSeed)(await decryptData(mnemonic.entropy, password), curve), derivationPath, curve).address;
+	}
 };
-var oneWayHash = (bytes) => {
-  if (typeof bytes === "string") bytes = import_crypto3.utf8.decode(bytes);
-  return import_crypto3.base58.encode((0, import_crypto3.blake3)(bytes));
+const oneWayHash = (bytes) => {
+	if (typeof bytes === "string") bytes = _talismn_crypto.utf8.decode(bytes);
+	return _talismn_crypto.base58.encode((0, _talismn_crypto.blake3)(bytes));
 };
-var mnemonicFromStorage = (data) => {
-  const copy = structuredClone(data);
-  if ("entropy" in copy) delete copy.entropy;
-  return Object.freeze(copy);
+const mnemonicFromStorage = (data) => {
+	const copy = structuredClone(data);
+	if ("entropy" in copy) delete copy.entropy;
+	return Object.freeze(copy);
 };
-var accountFromStorage = (data) => {
-  const copy = structuredClone(data);
-  if ("secretKey" in copy) delete copy.secretKey;
-  return Object.freeze(copy);
+const accountFromStorage = (data) => {
+	const copy = structuredClone(data);
+	if ("secretKey" in copy) delete copy.secretKey;
+	return Object.freeze(copy);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Keyring,
-  getAccountGenesisHash,
-  getAccountPlatform,
-  getAccountSignetUrl,
-  isAccountAddressEthereum,
-  isAccountAddressSs58,
-  isAccountBitcoin,
-  isAccountExternal,
-  isAccountInTypes,
-  isAccountLedgerPolkadot,
-  isAccountLedgerPolkadotGeneric,
-  isAccountLedgerPolkadotLegacy,
-  isAccountNotContact,
-  isAccountOfType,
-  isAccountOwned,
-  isAccountPlatformEthereum,
-  isAccountPlatformPolkadot,
-  isAccountPlatformSolana,
-  isAccountPortfolio
-});
+//#endregion
+exports.Keyring = Keyring;
+exports.getAccountGenesisHash = getAccountGenesisHash;
+exports.getAccountPlatform = getAccountPlatform;
+exports.getAccountSignetUrl = getAccountSignetUrl;
+exports.isAccountAddressEthereum = isAccountAddressEthereum;
+exports.isAccountAddressSs58 = isAccountAddressSs58;
+exports.isAccountBitcoin = isAccountBitcoin;
+exports.isAccountExternal = isAccountExternal;
+exports.isAccountInTypes = isAccountInTypes;
+exports.isAccountLedgerPolkadot = isAccountLedgerPolkadot;
+exports.isAccountLedgerPolkadotGeneric = isAccountLedgerPolkadotGeneric;
+exports.isAccountLedgerPolkadotLegacy = isAccountLedgerPolkadotLegacy;
+exports.isAccountNotContact = isAccountNotContact;
+exports.isAccountOfType = isAccountOfType;
+exports.isAccountOwned = isAccountOwned;
+exports.isAccountPlatformEthereum = isAccountPlatformEthereum;
+exports.isAccountPlatformPolkadot = isAccountPlatformPolkadot;
+exports.isAccountPlatformSolana = isAccountPlatformSolana;
+exports.isAccountPortfolio = isAccountPortfolio;
+
 //# sourceMappingURL=index.js.map