@talismn/crypto 0.1.1 → 0.1.3

package/dist/declarations/src/address/encoding/addressEncodingFromCurve.d.ts

@@ -1,2 +1,3 @@
 import type { AddressEncoding, KeypairCurve } from "../../types";
+/** NOTE: Try not to use this too much, it will need to change */
 export declare const addressEncodingFromCurve: (curve: KeypairCurve) => AddressEncoding;

package/dist/declarations/src/address/encoding/bitcoin.d.ts

@@ -0,0 +1,37 @@
+export declare const isBitcoinAddress: (address: string) => boolean;
+export declare function isBech32mAddress(address: string): boolean;
+export declare function isBech32Address(address: string): boolean;
+export declare function isBase58CheckAddress(address: string): boolean;
+/**
+ * Converts a Bech32m encoded address to its corresponding data representation.
+ * @param address - The Bech32m encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+export declare function fromBech32m(address: string): {
+    version: number;
+    prefix: string;
+    data: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Converts a Bech32 encoded address to its corresponding data representation.
+ * @param address - The Bech32 encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+export declare function fromBech32(address: string): {
+    version: number;
+    prefix: string;
+    data: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Decodes a base58check encoded Bitcoin address and returns the version and hash.
+ *
+ * @param address - The base58check encoded Bitcoin address to decode.
+ * @returns An object containing the version and hash of the decoded address.
+ * @throws {TypeError} If the address is too short or too long.
+ */
+export declare function fromBase58Check(address: string): {
+    version: number;
+    hash: Uint8Array<ArrayBuffer>;
+};

package/dist/declarations/src/address/encoding/index.d.ts

@@ -1,5 +1,6 @@
+export * from "./addressEncodingFromCurve";
 export * from "./base58";
+export * from "./bitcoin";
+export * from "./detectAddressEncoding";
 export * from "./ethereum";
 export * from "./ss58";
-export * from "./addressEncodingFromCurve";
-export * from "./detectAddressEncoding";

package/dist/declarations/src/derivation/common.d.ts

@@ -1,5 +1,5 @@
 type DerivationDescriptor = [type: "hard" | "soft", code: string];
 export declare const parseSubstrateDerivations: (derivationsStr: string) => DerivationDescriptor[];
-export declare const createChainCode: (code: string) => Uint8Array;
-export declare const deriveSubstrateSecretKey: (seed: Uint8Array, derivationPath: string, prefix: string) => Uint8Array;
+export declare const createChainCode: (code: string) => Uint8Array<ArrayBuffer>;
+export declare const deriveSubstrateSecretKey: (seed: Uint8Array, derivationPath: string, prefix: string) => Uint8Array<ArrayBufferLike>;
 export {};

package/dist/declarations/src/derivation/deriveEcdsa.d.ts

@@ -1,3 +1,3 @@
 import type { Keypair } from "../types";
 export declare const deriveEcdsa: (seed: Uint8Array, derivationPath: string) => Keypair;
-export declare const getPublicKeyEcdsa: (secretKey: Uint8Array) => Uint8Array;
+export declare const getPublicKeyEcdsa: (secretKey: Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/declarations/src/derivation/deriveEd25519.d.ts

@@ -1,3 +1,3 @@
 import type { Keypair } from "../types";
 export declare const deriveEd25519: (seed: Uint8Array, derivationPath: string) => Keypair;
-export declare const getPublicKeyEd25519: (secretKey: Uint8Array) => Uint8Array;
+export declare const getPublicKeyEd25519: (secretKey: Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/declarations/src/derivation/deriveEthereum.d.ts

@@ -1,3 +1,3 @@
 import type { Keypair } from "../types";
 export declare const deriveEthereum: (seed: Uint8Array, derivationPath: string) => Keypair;
-export declare const getPublicKeyEthereum: (secretKey: Uint8Array) => Uint8Array;
+export declare const getPublicKeyEthereum: (secretKey: Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/declarations/src/derivation/deriveSolana.d.ts

@@ -1,3 +1,3 @@
 import type { Keypair } from "../types";
 export declare const deriveSolana: (seed: Uint8Array, derivationPath: string) => Keypair;
-export declare const getPublicKeySolana: (secretKey: Uint8Array) => Uint8Array;
+export declare const getPublicKeySolana: (secretKey: Uint8Array) => Uint8Array<ArrayBufferLike>;

package/dist/declarations/src/derivation/utils.d.ts

@@ -1,7 +1,7 @@
 import { KeypairCurve } from "../types";
 export declare const deriveKeypair: (seed: Uint8Array, derivationPath: string, curve: KeypairCurve) => import("../types").Keypair;
 export declare const getPublicKeyFromSecret: (secretKey: Uint8Array, curve: KeypairCurve) => Uint8Array;
-export declare const addressFromSuri: (suri: string, type: KeypairCurve) => string;
+export declare const addressFromSuri: (suri: string, type: KeypairCurve) => Promise<string>;
 /**
  * @dev we only expect suri to contain a mnemonic and derivation path.
  * for other cases see https://polkadot.js.org/docs/keyring/start/suri/
@@ -12,5 +12,5 @@ export declare const parseSuri: (suri: string) => {
     password: string | undefined;
 };
 export declare const removeHexPrefix: (secretKey: string) => string;
-export declare const parseSecretKey: (secretKey: string, curve: KeypairCurve) => Uint8Array;
-export declare const isValidDerivationPath: (derivationPath: string, curve: KeypairCurve) => boolean;
+export declare const parseSecretKey: (secretKey: string, curve: KeypairCurve) => Uint8Array<ArrayBufferLike>;
+export declare const isValidDerivationPath: (derivationPath: string, curve: KeypairCurve) => Promise<boolean>;

package/dist/declarations/src/hashing/index.d.ts

@@ -4,6 +4,6 @@ export declare const blake3: {
     blockLen: number;
     create(opts: Object): import("@noble/hashes/utils").HashXOF<import("@noble/hashes/utils").HashXOF<import("@noble/hashes/utils").HashXOF<any>>>;
 };
-export declare const blake2b256: (msg: Uint8Array) => Uint8Array;
-export declare const blake2b512: (msg: Uint8Array) => Uint8Array;
+export declare const blake2b256: (msg: Uint8Array) => Uint8Array<ArrayBufferLike>;
+export declare const blake2b512: (msg: Uint8Array) => Uint8Array<ArrayBufferLike>;
 export declare const getSafeHash: (bytes: Uint8Array) => string;

package/dist/declarations/src/mnemonic/index.d.ts

@@ -1,9 +1,9 @@
 import type { KeypairCurve } from "../types";
-export declare const mnemonicToEntropy: (mnemonic: string) => Uint8Array;
+export declare const mnemonicToEntropy: (mnemonic: string) => Uint8Array<ArrayBufferLike>;
 export declare const entropyToMnemonic: (entropy: Uint8Array) => string;
-export declare const entropyToSeed: (entropy: Uint8Array, curve: KeypairCurve, password?: string) => Uint8Array;
+export declare const entropyToSeed: (entropy: Uint8Array, curve: KeypairCurve, password?: string) => Promise<Uint8Array<ArrayBuffer>>;
 export declare const isValidMnemonic: (mnemonic: string) => boolean;
 export declare const generateMnemonic: (words: 12 | 24) => string;
 export declare const DEV_MNEMONIC_POLKADOT = "bottom drive obey lake curtain smoke basket hold race lonely fit walk";
 export declare const DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test test junk";
-export declare const getDevSeed: (curve: KeypairCurve) => Uint8Array;
+export declare const getDevSeed: (curve: KeypairCurve) => Promise<Uint8Array<ArrayBufferLike>>;

package/dist/declarations/src/types/index.d.ts

@@ -1,9 +1,9 @@
-export type KeypairCurve = "ecdsa" | "ed25519" | "sr25519" | "ethereum" | "solana";
-export type AddressEncoding = "ss58" | "ethereum" | "base58";
+export type KeypairCurve = "ecdsa" | "ed25519" | "sr25519" | "ethereum" | "bitcoin-ed25519" | "bitcoin-ecdsa" | "solana";
+export type AddressEncoding = "ss58" | "ethereum" | "bech32m" | "bech32" | "base58check" | "base58";
 export type Keypair = {
     type: KeypairCurve;
     secretKey: Uint8Array;
     publicKey: Uint8Array;
     address: string;
 };
-export type Platform = "ethereum" | "polkadot" | "solana";
+export type Platform = "ethereum" | "polkadot" | "bitcoin" | "solana";

package/dist/declarations/src/utils/index.d.ts

@@ -1 +1,2 @@
 export * from "./exports";
+export * from "./pbkdf2";

package/dist/declarations/src/utils/pbkdf2.d.ts

@@ -0,0 +1 @@
+export declare const pbkdf2: (hash: "SHA-256" | "SHA-512", entropy: Uint8Array, salt: Uint8Array, iterations: number, outputLenBytes: number) => Promise<Uint8Array<ArrayBuffer>>;

package/dist/talismn-crypto.cjs.dev.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var pbkdf2 = require('@noble/hashes/pbkdf2');
-var sha512 = require('@noble/hashes/sha512');
 var bip39 = require('@scure/bip39');
 var english = require('@scure/bip39/wordlists/english');
 var base = require('@scure/base');
+var bech32 = require('bech32');
+var bs58check = require('bs58check');
 var sha3 = require('@noble/hashes/sha3');
 var utils = require('@noble/hashes/utils');
 var blake2b = require('@noble/hashes/blake2b');
@@ -14,30 +14,45 @@ var scaleTs = require('scale-ts');
 var ed25519 = require('@noble/curves/ed25519');
 var bip32 = require('@scure/bip32');
 var hmac = require('@noble/hashes/hmac');
+var sha512 = require('@noble/hashes/sha512');
 var microSr25519 = require('micro-sr25519');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58check__default = /*#__PURE__*/_interopDefault(bs58check);
+
+const pbkdf2 = async (hash, entropy, salt, iterations, outputLenBytes) => {
+  // NOTE: react-native-quick-crypto (our `global.crypto` polyfill on Talisman Mobile) doesn't support `crypto.subtle.deriveKey`.
+  // But, we can work around this by using `crypto.subtle.deriveBits` and `crypto.subtle.importKey`, which when used together
+  // can provide the same functionality as `crypto.subtle.deriveKey`.
+  const keyMaterial = await crypto.subtle.importKey("raw", entropy, "PBKDF2", false, ["deriveBits"]);
+  const derivedBits = await crypto.subtle.deriveBits({
+    name: "PBKDF2",
+    salt,
+    iterations,
+    hash
+  }, keyMaterial, outputLenBytes * 8);
+  return new Uint8Array(derivedBits);
+};
+
 const mnemonicToEntropy = mnemonic => {
   return bip39.mnemonicToEntropy(mnemonic, english.wordlist);
 };
 const entropyToMnemonic = entropy => {
   return bip39.entropyToMnemonic(entropy, english.wordlist);
 };
-const salt = password => {
-  return new TextEncoder().encode(`mnemonic${password.normalize("NFKD")}`);
-};
-const entropyToSeedSubstrate = (entropy, password) => {
-  return pbkdf2.pbkdf2(sha512.sha512, entropy, salt(password ?? ""), {
-    c: 2048,
-    dkLen: 32
-  });
-};
-const entropyToSeedClassic = (entropy, password) => {
-  const mnemonic = entropyToMnemonic(entropy);
-  return pbkdf2.pbkdf2(sha512.sha512, mnemonic.normalize("NFKD"), salt(password ?? ""), {
-    c: 2048,
-    dkLen: 64
-  });
-};
+const entropyToSeedSubstrate = async (entropy, password) => await pbkdf2("SHA-512", entropy, mnemonicPasswordToSalt(password ?? ""), 2048,
+// 2048 iterations
+32 // 32 bytes (32 * 8 == 256 bits)
+);
+const entropyToSeedClassic = async (entropy, password) => await pbkdf2("SHA-512", encodeNormalized(entropyToMnemonic(entropy)), mnemonicPasswordToSalt(password ?? ""), 2048,
+// 2048 iterations
+64 // 64 bytes (64 * 8 == 512 bits)
+);
+const mnemonicPasswordToSalt = password => encodeNormalized(`mnemonic${password}`);
+
+/** Normalizes a UTF-8 string using `NFKD` form, then encodes it into bytes */
+const encodeNormalized = utf8 => new TextEncoder().encode(utf8.normalize("NFKD"));
 const getSeedDerivationType = curve => {
   switch (curve) {
     case "sr25519":
@@ -47,18 +62,21 @@ const getSeedDerivationType = curve => {
     case "ethereum":
     case "solana":
       return "classic";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("seed derivation is not implemented for Bitcoin");
   }
 };
 
 // when deriving keys from a mnemonic, we usually dont want a password here.
 // a password provided here would be used as a 25th mnemonic word.
-const entropyToSeed = (entropy, curve, password) => {
+const entropyToSeed = async (entropy, curve, password) => {
   const type = getSeedDerivationType(curve);
   switch (type) {
     case "classic":
-      return entropyToSeedClassic(entropy, password);
+      return await entropyToSeedClassic(entropy, password);
     case "substrate":
-      return entropyToSeedSubstrate(entropy, password);
+      return await entropyToSeedSubstrate(entropy, password);
   }
 };
 const isValidMnemonic = mnemonic => {
@@ -81,21 +99,21 @@ const DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test
 
 // keep dev seeds in cache as we will reuse them to validate multiple derivation paths
 const DEV_SEED_CACHE = new Map();
-const getDevSeed = curve => {
+const getDevSeed = async curve => {
   const type = getSeedDerivationType(curve);
   if (!DEV_SEED_CACHE.has(type)) {
     switch (type) {
       case "classic":
         {
           const entropy = mnemonicToEntropy(DEV_MNEMONIC_ETHEREUM);
-          const seed = entropyToSeedClassic(entropy); // 80ms
+          const seed = await entropyToSeedClassic(entropy); // 80ms
           DEV_SEED_CACHE.set(type, seed);
           break;
         }
       case "substrate":
         {
           const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT);
-          const seed = entropyToSeedSubstrate(entropy); // 80ms
+          const seed = await entropyToSeedSubstrate(entropy); // 80ms
           DEV_SEED_CACHE.set(type, seed);
           break;
         }
@@ -106,6 +124,26 @@ const getDevSeed = curve => {
   return DEV_SEED_CACHE.get(type);
 };
 
+/** NOTE: Try not to use this too much, it will need to change */
+const addressEncodingFromCurve = curve => {
+  switch (curve) {
+    case "sr25519":
+    case "ed25519":
+    case "ecdsa":
+      return "ss58";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      // NOTE: Bitcoin has multiple address formats, so this isn't necessarily correct
+      // The format MAY be bech32m, but it might also be bech32 or base58check.
+      // bech32m is the most recent format.
+      return "bech32m";
+    case "ethereum":
+      return "ethereum";
+    case "solana":
+      return "base58";
+  }
+};
+
 const encodeAddressBase58 = publicKey => {
   return base.base58.encode(publicKey);
 };
@@ -119,6 +157,94 @@ function isBase58Address(address) {
   }
 }
 
+const isBitcoinAddress = address => isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address);
+function isBech32mAddress(address) {
+  try {
+    fromBech32m(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBech32Address(address) {
+  try {
+    fromBech32(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBase58CheckAddress(address) {
+  try {
+    fromBase58Check(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Converts a Bech32m encoded address to its corresponding data representation.
+ * @param address - The Bech32m encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32m(address) {
+  const result = bech32.bech32m.decode(address);
+  const version = result.words[0];
+  if (version === 0) throw new TypeError(address + " uses wrong encoding");
+  const data = bech32.bech32m.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data)
+  };
+}
+
+/**
+ * Converts a Bech32 encoded address to its corresponding data representation.
+ * @param address - The Bech32 encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32(address) {
+  const result = bech32.bech32.decode(address);
+  const version = result.words[0];
+  if (version !== 0) throw new TypeError(address + " uses wrong encoding");
+  const data = bech32.bech32.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data)
+  };
+}
+
+/**
+ * Decodes a base58check encoded Bitcoin address and returns the version and hash.
+ *
+ * @param address - The base58check encoded Bitcoin address to decode.
+ * @returns An object containing the version and hash of the decoded address.
+ * @throws {TypeError} If the address is too short or too long.
+ */
+function fromBase58Check(address) {
+  const payload = bs58check__default.default.decode(address);
+  if (payload.length < 21) throw new TypeError(address + " is too short");
+  if (payload.length > 21) throw new TypeError(address + " is too long");
+  function readUInt8(buffer, offset) {
+    if (offset + 1 > buffer.length) {
+      throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    const buf = Buffer.from(buffer);
+    return buf.readUInt8(offset);
+  }
+  const version = readUInt8(payload, 0);
+  const hash = payload.slice(1);
+  return {
+    version,
+    hash
+  };
+}
+
 /**
  * Encodes a public key using H160 encoding with Ethereum checksum.
  */
@@ -206,23 +332,13 @@ function isSs58Address(address) {
   }
 }
 
-const addressEncodingFromCurve = curve => {
-  switch (curve) {
-    case "sr25519":
-    case "ed25519":
-    case "ecdsa":
-      return "ss58";
-    case "ethereum":
-      return "ethereum";
-    case "solana":
-      return "base58";
-  }
-};
-
 const CACHE$1 = new Map();
 const detectAddressEncodingInner = address => {
   if (isEthereumAddress(address)) return "ethereum";
   if (isSs58Address(address)) return "ss58";
+  if (isBech32mAddress(address)) return "bech32m";
+  if (isBech32Address(address)) return "bech32";
+  if (isBase58CheckAddress(address)) return "base58check";
   if (isBase58Address(address)) return "base58";
   throw new Error(`Unknown address encoding`);
 };
@@ -237,6 +353,10 @@ const addressFromPublicKey = (publicKey, encoding, options) => {
       return encodeAddressSs58(publicKey, options?.ss58Prefix);
     case "ethereum":
       return encodeAddressEthereum(publicKey);
+    case "bech32m":
+    case "bech32":
+    case "base58check":
+      throw new Error("addressFromPublicKey is not implemented for Bitcoin");
     case "base58":
       return encodeAddressBase58(publicKey);
   }
@@ -259,6 +379,9 @@ const normalizeAnyAddress = address => {
   switch (detectAddressEncoding(address)) {
     case "ethereum":
       return checksumEthereumAddress(address);
+    case "bech32m":
+    case "bech32":
+    case "base58check":
     case "base58":
       return address;
     case "ss58":
@@ -439,6 +562,9 @@ const deriveKeypair = (seed, derivationPath, curve) => {
       return deriveEd25519(seed, derivationPath);
     case "ecdsa":
       return deriveEcdsa(seed, derivationPath);
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("deriveKeypair is not implemented for Bitcoin");
     case "ethereum":
       return deriveEthereum(seed, derivationPath);
     case "solana":
@@ -455,18 +581,21 @@ const getPublicKeyFromSecret = (secretKey, curve) => {
       return getPublicKeySr25519(secretKey);
     case "ed25519":
       return getPublicKeyEd25519(secretKey);
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("getPublicKeyFromSecret is not implemented for Bitcoin");
     case "solana":
       return getPublicKeySolana(secretKey);
   }
 };
-const addressFromSuri = (suri, type) => {
+const addressFromSuri = async (suri, type) => {
   const {
     mnemonic,
     derivationPath,
     password
   } = parseSuri(suri);
   const entropy = mnemonicToEntropy(mnemonic);
-  const seed = entropyToSeed(entropy, type, password); // ~80ms
+  const seed = await entropyToSeed(entropy, type, password); // ~80ms
   const {
     secretKey
   } = deriveKeypair(seed, derivationPath, type);
@@ -510,15 +639,17 @@ const parseSecretKey = (secretKey, curve) => {
     case "ed25519":
     case "sr25519":
     case "ecdsa":
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
     case "solana":
       throw new Error("Not implemented");
   }
 };
 
 // @dev: didn't find a reliable source of information on which characters are valid => assume it s valid if a keypair can be generated from it
-const isValidDerivationPath = (derivationPath, curve) => {
+const isValidDerivationPath = async (derivationPath, curve) => {
   try {
-    deriveKeypair(getDevSeed(curve), derivationPath, curve);
+    deriveKeypair(await getDevSeed(curve), derivationPath, curve);
     return true;
   } catch (err) {
     return false;
@@ -533,6 +664,9 @@ const platformFromCurve = curve => {
       return "polkadot";
     case "ethereum":
       return "ethereum";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      return "bitcoin";
     case "solana":
       return "solana";
   }
@@ -543,6 +677,10 @@ const platformFromEncoding = encoding => {
       return "polkadot";
     case "ethereum":
       return "ethereum";
+    case "bech32m":
+    case "bech32":
+    case "base58check":
+      return "bitcoin";
     case "base58":
       return "solana";
   }
@@ -577,12 +715,19 @@ exports.encodeAddressEthereum = encodeAddressEthereum;
 exports.encodeAddressSs58 = encodeAddressSs58;
 exports.entropyToMnemonic = entropyToMnemonic;
 exports.entropyToSeed = entropyToSeed;
+exports.fromBase58Check = fromBase58Check;
+exports.fromBech32 = fromBech32;
+exports.fromBech32m = fromBech32m;
 exports.generateMnemonic = generateMnemonic;
 exports.getDevSeed = getDevSeed;
 exports.getPublicKeyFromSecret = getPublicKeyFromSecret;
 exports.getSafeHash = getSafeHash;
 exports.isAddressEqual = isAddressEqual;
 exports.isBase58Address = isBase58Address;
+exports.isBase58CheckAddress = isBase58CheckAddress;
+exports.isBech32Address = isBech32Address;
+exports.isBech32mAddress = isBech32mAddress;
+exports.isBitcoinAddress = isBitcoinAddress;
 exports.isEthereumAddress = isEthereumAddress;
 exports.isSs58Address = isSs58Address;
 exports.isValidDerivationPath = isValidDerivationPath;
@@ -591,6 +736,7 @@ exports.mnemonicToEntropy = mnemonicToEntropy;
 exports.normalizeAddress = normalizeAddress;
 exports.parseSecretKey = parseSecretKey;
 exports.parseSuri = parseSuri;
+exports.pbkdf2 = pbkdf2;
 exports.platformFromAddress = platformFromAddress;
 exports.platformFromCurve = platformFromCurve;
 exports.platformFromEncoding = platformFromEncoding;

package/dist/talismn-crypto.cjs.prod.js

@@ -1,10 +1,10 @@
 'use strict';
 
-var pbkdf2 = require('@noble/hashes/pbkdf2');
-var sha512 = require('@noble/hashes/sha512');
 var bip39 = require('@scure/bip39');
 var english = require('@scure/bip39/wordlists/english');
 var base = require('@scure/base');
+var bech32 = require('bech32');
+var bs58check = require('bs58check');
 var sha3 = require('@noble/hashes/sha3');
 var utils = require('@noble/hashes/utils');
 var blake2b = require('@noble/hashes/blake2b');
@@ -14,30 +14,45 @@ var scaleTs = require('scale-ts');
 var ed25519 = require('@noble/curves/ed25519');
 var bip32 = require('@scure/bip32');
 var hmac = require('@noble/hashes/hmac');
+var sha512 = require('@noble/hashes/sha512');
 var microSr25519 = require('micro-sr25519');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bs58check__default = /*#__PURE__*/_interopDefault(bs58check);
+
+const pbkdf2 = async (hash, entropy, salt, iterations, outputLenBytes) => {
+  // NOTE: react-native-quick-crypto (our `global.crypto` polyfill on Talisman Mobile) doesn't support `crypto.subtle.deriveKey`.
+  // But, we can work around this by using `crypto.subtle.deriveBits` and `crypto.subtle.importKey`, which when used together
+  // can provide the same functionality as `crypto.subtle.deriveKey`.
+  const keyMaterial = await crypto.subtle.importKey("raw", entropy, "PBKDF2", false, ["deriveBits"]);
+  const derivedBits = await crypto.subtle.deriveBits({
+    name: "PBKDF2",
+    salt,
+    iterations,
+    hash
+  }, keyMaterial, outputLenBytes * 8);
+  return new Uint8Array(derivedBits);
+};
+
 const mnemonicToEntropy = mnemonic => {
   return bip39.mnemonicToEntropy(mnemonic, english.wordlist);
 };
 const entropyToMnemonic = entropy => {
   return bip39.entropyToMnemonic(entropy, english.wordlist);
 };
-const salt = password => {
-  return new TextEncoder().encode(`mnemonic${password.normalize("NFKD")}`);
-};
-const entropyToSeedSubstrate = (entropy, password) => {
-  return pbkdf2.pbkdf2(sha512.sha512, entropy, salt(password ?? ""), {
-    c: 2048,
-    dkLen: 32
-  });
-};
-const entropyToSeedClassic = (entropy, password) => {
-  const mnemonic = entropyToMnemonic(entropy);
-  return pbkdf2.pbkdf2(sha512.sha512, mnemonic.normalize("NFKD"), salt(password ?? ""), {
-    c: 2048,
-    dkLen: 64
-  });
-};
+const entropyToSeedSubstrate = async (entropy, password) => await pbkdf2("SHA-512", entropy, mnemonicPasswordToSalt(password ?? ""), 2048,
+// 2048 iterations
+32 // 32 bytes (32 * 8 == 256 bits)
+);
+const entropyToSeedClassic = async (entropy, password) => await pbkdf2("SHA-512", encodeNormalized(entropyToMnemonic(entropy)), mnemonicPasswordToSalt(password ?? ""), 2048,
+// 2048 iterations
+64 // 64 bytes (64 * 8 == 512 bits)
+);
+const mnemonicPasswordToSalt = password => encodeNormalized(`mnemonic${password}`);
+
+/** Normalizes a UTF-8 string using `NFKD` form, then encodes it into bytes */
+const encodeNormalized = utf8 => new TextEncoder().encode(utf8.normalize("NFKD"));
 const getSeedDerivationType = curve => {
   switch (curve) {
     case "sr25519":
@@ -47,18 +62,21 @@ const getSeedDerivationType = curve => {
     case "ethereum":
     case "solana":
       return "classic";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("seed derivation is not implemented for Bitcoin");
   }
 };
 
 // when deriving keys from a mnemonic, we usually dont want a password here.
 // a password provided here would be used as a 25th mnemonic word.
-const entropyToSeed = (entropy, curve, password) => {
+const entropyToSeed = async (entropy, curve, password) => {
   const type = getSeedDerivationType(curve);
   switch (type) {
     case "classic":
-      return entropyToSeedClassic(entropy, password);
+      return await entropyToSeedClassic(entropy, password);
     case "substrate":
-      return entropyToSeedSubstrate(entropy, password);
+      return await entropyToSeedSubstrate(entropy, password);
   }
 };
 const isValidMnemonic = mnemonic => {
@@ -81,21 +99,21 @@ const DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test
 
 // keep dev seeds in cache as we will reuse them to validate multiple derivation paths
 const DEV_SEED_CACHE = new Map();
-const getDevSeed = curve => {
+const getDevSeed = async curve => {
   const type = getSeedDerivationType(curve);
   if (!DEV_SEED_CACHE.has(type)) {
     switch (type) {
       case "classic":
         {
           const entropy = mnemonicToEntropy(DEV_MNEMONIC_ETHEREUM);
-          const seed = entropyToSeedClassic(entropy); // 80ms
+          const seed = await entropyToSeedClassic(entropy); // 80ms
           DEV_SEED_CACHE.set(type, seed);
           break;
         }
       case "substrate":
         {
           const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT);
-          const seed = entropyToSeedSubstrate(entropy); // 80ms
+          const seed = await entropyToSeedSubstrate(entropy); // 80ms
           DEV_SEED_CACHE.set(type, seed);
           break;
         }
@@ -106,6 +124,26 @@ const getDevSeed = curve => {
   return DEV_SEED_CACHE.get(type);
 };
 
+/** NOTE: Try not to use this too much, it will need to change */
+const addressEncodingFromCurve = curve => {
+  switch (curve) {
+    case "sr25519":
+    case "ed25519":
+    case "ecdsa":
+      return "ss58";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      // NOTE: Bitcoin has multiple address formats, so this isn't necessarily correct
+      // The format MAY be bech32m, but it might also be bech32 or base58check.
+      // bech32m is the most recent format.
+      return "bech32m";
+    case "ethereum":
+      return "ethereum";
+    case "solana":
+      return "base58";
+  }
+};
+
 const encodeAddressBase58 = publicKey => {
   return base.base58.encode(publicKey);
 };
@@ -119,6 +157,94 @@ function isBase58Address(address) {
   }
 }
 
+const isBitcoinAddress = address => isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address);
+function isBech32mAddress(address) {
+  try {
+    fromBech32m(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBech32Address(address) {
+  try {
+    fromBech32(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBase58CheckAddress(address) {
+  try {
+    fromBase58Check(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Converts a Bech32m encoded address to its corresponding data representation.
+ * @param address - The Bech32m encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32m(address) {
+  const result = bech32.bech32m.decode(address);
+  const version = result.words[0];
+  if (version === 0) throw new TypeError(address + " uses wrong encoding");
+  const data = bech32.bech32m.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data)
+  };
+}
+
+/**
+ * Converts a Bech32 encoded address to its corresponding data representation.
+ * @param address - The Bech32 encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32(address) {
+  const result = bech32.bech32.decode(address);
+  const version = result.words[0];
+  if (version !== 0) throw new TypeError(address + " uses wrong encoding");
+  const data = bech32.bech32.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data)
+  };
+}
+
+/**
+ * Decodes a base58check encoded Bitcoin address and returns the version and hash.
+ *
+ * @param address - The base58check encoded Bitcoin address to decode.
+ * @returns An object containing the version and hash of the decoded address.
+ * @throws {TypeError} If the address is too short or too long.
+ */
+function fromBase58Check(address) {
+  const payload = bs58check__default.default.decode(address);
+  if (payload.length < 21) throw new TypeError(address + " is too short");
+  if (payload.length > 21) throw new TypeError(address + " is too long");
+  function readUInt8(buffer, offset) {
+    if (offset + 1 > buffer.length) {
+      throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    const buf = Buffer.from(buffer);
+    return buf.readUInt8(offset);
+  }
+  const version = readUInt8(payload, 0);
+  const hash = payload.slice(1);
+  return {
+    version,
+    hash
+  };
+}
+
 /**
  * Encodes a public key using H160 encoding with Ethereum checksum.
  */
@@ -206,23 +332,13 @@ function isSs58Address(address) {
   }
 }
 
-const addressEncodingFromCurve = curve => {
-  switch (curve) {
-    case "sr25519":
-    case "ed25519":
-    case "ecdsa":
-      return "ss58";
-    case "ethereum":
-      return "ethereum";
-    case "solana":
-      return "base58";
-  }
-};
-
 const CACHE$1 = new Map();
 const detectAddressEncodingInner = address => {
   if (isEthereumAddress(address)) return "ethereum";
   if (isSs58Address(address)) return "ss58";
+  if (isBech32mAddress(address)) return "bech32m";
+  if (isBech32Address(address)) return "bech32";
+  if (isBase58CheckAddress(address)) return "base58check";
   if (isBase58Address(address)) return "base58";
   throw new Error(`Unknown address encoding`);
 };
@@ -237,6 +353,10 @@ const addressFromPublicKey = (publicKey, encoding, options) => {
       return encodeAddressSs58(publicKey, options?.ss58Prefix);
     case "ethereum":
       return encodeAddressEthereum(publicKey);
+    case "bech32m":
+    case "bech32":
+    case "base58check":
+      throw new Error("addressFromPublicKey is not implemented for Bitcoin");
     case "base58":
       return encodeAddressBase58(publicKey);
   }
@@ -259,6 +379,9 @@ const normalizeAnyAddress = address => {
   switch (detectAddressEncoding(address)) {
     case "ethereum":
       return checksumEthereumAddress(address);
+    case "bech32m":
+    case "bech32":
+    case "base58check":
     case "base58":
       return address;
     case "ss58":
@@ -439,6 +562,9 @@ const deriveKeypair = (seed, derivationPath, curve) => {
       return deriveEd25519(seed, derivationPath);
     case "ecdsa":
       return deriveEcdsa(seed, derivationPath);
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("deriveKeypair is not implemented for Bitcoin");
     case "ethereum":
       return deriveEthereum(seed, derivationPath);
     case "solana":
@@ -455,18 +581,21 @@ const getPublicKeyFromSecret = (secretKey, curve) => {
       return getPublicKeySr25519(secretKey);
     case "ed25519":
       return getPublicKeyEd25519(secretKey);
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("getPublicKeyFromSecret is not implemented for Bitcoin");
     case "solana":
       return getPublicKeySolana(secretKey);
   }
 };
-const addressFromSuri = (suri, type) => {
+const addressFromSuri = async (suri, type) => {
   const {
     mnemonic,
     derivationPath,
     password
   } = parseSuri(suri);
   const entropy = mnemonicToEntropy(mnemonic);
-  const seed = entropyToSeed(entropy, type, password); // ~80ms
+  const seed = await entropyToSeed(entropy, type, password); // ~80ms
   const {
     secretKey
   } = deriveKeypair(seed, derivationPath, type);
@@ -510,15 +639,17 @@ const parseSecretKey = (secretKey, curve) => {
     case "ed25519":
     case "sr25519":
     case "ecdsa":
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
     case "solana":
       throw new Error("Not implemented");
   }
 };
 
 // @dev: didn't find a reliable source of information on which characters are valid => assume it s valid if a keypair can be generated from it
-const isValidDerivationPath = (derivationPath, curve) => {
+const isValidDerivationPath = async (derivationPath, curve) => {
   try {
-    deriveKeypair(getDevSeed(curve), derivationPath, curve);
+    deriveKeypair(await getDevSeed(curve), derivationPath, curve);
     return true;
   } catch (err) {
     return false;
@@ -533,6 +664,9 @@ const platformFromCurve = curve => {
       return "polkadot";
     case "ethereum":
       return "ethereum";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      return "bitcoin";
     case "solana":
       return "solana";
   }
@@ -543,6 +677,10 @@ const platformFromEncoding = encoding => {
       return "polkadot";
     case "ethereum":
       return "ethereum";
+    case "bech32m":
+    case "bech32":
+    case "base58check":
+      return "bitcoin";
     case "base58":
       return "solana";
   }
@@ -577,12 +715,19 @@ exports.encodeAddressEthereum = encodeAddressEthereum;
 exports.encodeAddressSs58 = encodeAddressSs58;
 exports.entropyToMnemonic = entropyToMnemonic;
 exports.entropyToSeed = entropyToSeed;
+exports.fromBase58Check = fromBase58Check;
+exports.fromBech32 = fromBech32;
+exports.fromBech32m = fromBech32m;
 exports.generateMnemonic = generateMnemonic;
 exports.getDevSeed = getDevSeed;
 exports.getPublicKeyFromSecret = getPublicKeyFromSecret;
 exports.getSafeHash = getSafeHash;
 exports.isAddressEqual = isAddressEqual;
 exports.isBase58Address = isBase58Address;
+exports.isBase58CheckAddress = isBase58CheckAddress;
+exports.isBech32Address = isBech32Address;
+exports.isBech32mAddress = isBech32mAddress;
+exports.isBitcoinAddress = isBitcoinAddress;
 exports.isEthereumAddress = isEthereumAddress;
 exports.isSs58Address = isSs58Address;
 exports.isValidDerivationPath = isValidDerivationPath;
@@ -591,6 +736,7 @@ exports.mnemonicToEntropy = mnemonicToEntropy;
 exports.normalizeAddress = normalizeAddress;
 exports.parseSecretKey = parseSecretKey;
 exports.parseSuri = parseSuri;
+exports.pbkdf2 = pbkdf2;
 exports.platformFromAddress = platformFromAddress;
 exports.platformFromCurve = platformFromCurve;
 exports.platformFromEncoding = platformFromEncoding;

package/dist/talismn-crypto.esm.js

@@ -1,9 +1,9 @@
-import { pbkdf2 } from '@noble/hashes/pbkdf2';
-import { sha512 } from '@noble/hashes/sha512';
 import { mnemonicToEntropy as mnemonicToEntropy$1, entropyToMnemonic as entropyToMnemonic$1, validateMnemonic, generateMnemonic as generateMnemonic$1 } from '@scure/bip39';
 import { wordlist } from '@scure/bip39/wordlists/english';
 import { base58, bytesToString, stringToBytes } from '@scure/base';
 export { bytesToString, stringToBytes } from '@scure/base';
+import { bech32m, bech32 } from 'bech32';
+import bs58check from 'bs58check';
 import { keccak_256 } from '@noble/hashes/sha3';
 import { bytesToHex, randomBytes } from '@noble/hashes/utils';
 import { blake2b } from '@noble/hashes/blake2b';
@@ -13,7 +13,22 @@ import { Tuple, str, Bytes, u32 } from 'scale-ts';
 import { ed25519 } from '@noble/curves/ed25519';
 import { HDKey } from '@scure/bip32';
 import { hmac } from '@noble/hashes/hmac';
-import { HDKD, secretFromSeed, getPublicKey } from 'micro-sr25519';
+import { sha512 } from '@noble/hashes/sha512';
+import { getPublicKey, HDKD, secretFromSeed } from 'micro-sr25519';
+
+const pbkdf2 = async (hash, entropy, salt, iterations, outputLenBytes) => {
+  // NOTE: react-native-quick-crypto (our `global.crypto` polyfill on Talisman Mobile) doesn't support `crypto.subtle.deriveKey`.
+  // But, we can work around this by using `crypto.subtle.deriveBits` and `crypto.subtle.importKey`, which when used together
+  // can provide the same functionality as `crypto.subtle.deriveKey`.
+  const keyMaterial = await crypto.subtle.importKey("raw", entropy, "PBKDF2", false, ["deriveBits"]);
+  const derivedBits = await crypto.subtle.deriveBits({
+    name: "PBKDF2",
+    salt,
+    iterations,
+    hash
+  }, keyMaterial, outputLenBytes * 8);
+  return new Uint8Array(derivedBits);
+};
 
 const mnemonicToEntropy = mnemonic => {
   return mnemonicToEntropy$1(mnemonic, wordlist);
@@ -21,22 +36,18 @@ const mnemonicToEntropy = mnemonic => {
 const entropyToMnemonic = entropy => {
   return entropyToMnemonic$1(entropy, wordlist);
 };
-const salt = password => {
-  return new TextEncoder().encode(`mnemonic${password.normalize("NFKD")}`);
-};
-const entropyToSeedSubstrate = (entropy, password) => {
-  return pbkdf2(sha512, entropy, salt(password ?? ""), {
-    c: 2048,
-    dkLen: 32
-  });
-};
-const entropyToSeedClassic = (entropy, password) => {
-  const mnemonic = entropyToMnemonic(entropy);
-  return pbkdf2(sha512, mnemonic.normalize("NFKD"), salt(password ?? ""), {
-    c: 2048,
-    dkLen: 64
-  });
-};
+const entropyToSeedSubstrate = async (entropy, password) => await pbkdf2("SHA-512", entropy, mnemonicPasswordToSalt(password ?? ""), 2048,
+// 2048 iterations
+32 // 32 bytes (32 * 8 == 256 bits)
+);
+const entropyToSeedClassic = async (entropy, password) => await pbkdf2("SHA-512", encodeNormalized(entropyToMnemonic(entropy)), mnemonicPasswordToSalt(password ?? ""), 2048,
+// 2048 iterations
+64 // 64 bytes (64 * 8 == 512 bits)
+);
+const mnemonicPasswordToSalt = password => encodeNormalized(`mnemonic${password}`);
+
+/** Normalizes a UTF-8 string using `NFKD` form, then encodes it into bytes */
+const encodeNormalized = utf8 => new TextEncoder().encode(utf8.normalize("NFKD"));
 const getSeedDerivationType = curve => {
   switch (curve) {
     case "sr25519":
@@ -46,18 +57,21 @@ const getSeedDerivationType = curve => {
     case "ethereum":
     case "solana":
       return "classic";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("seed derivation is not implemented for Bitcoin");
   }
 };
 
 // when deriving keys from a mnemonic, we usually dont want a password here.
 // a password provided here would be used as a 25th mnemonic word.
-const entropyToSeed = (entropy, curve, password) => {
+const entropyToSeed = async (entropy, curve, password) => {
   const type = getSeedDerivationType(curve);
   switch (type) {
     case "classic":
-      return entropyToSeedClassic(entropy, password);
+      return await entropyToSeedClassic(entropy, password);
     case "substrate":
-      return entropyToSeedSubstrate(entropy, password);
+      return await entropyToSeedSubstrate(entropy, password);
   }
 };
 const isValidMnemonic = mnemonic => {
@@ -80,21 +94,21 @@ const DEV_MNEMONIC_ETHEREUM = "test test test test test test test test test test
 
 // keep dev seeds in cache as we will reuse them to validate multiple derivation paths
 const DEV_SEED_CACHE = new Map();
-const getDevSeed = curve => {
+const getDevSeed = async curve => {
   const type = getSeedDerivationType(curve);
   if (!DEV_SEED_CACHE.has(type)) {
     switch (type) {
       case "classic":
         {
           const entropy = mnemonicToEntropy(DEV_MNEMONIC_ETHEREUM);
-          const seed = entropyToSeedClassic(entropy); // 80ms
+          const seed = await entropyToSeedClassic(entropy); // 80ms
           DEV_SEED_CACHE.set(type, seed);
           break;
         }
       case "substrate":
         {
           const entropy = mnemonicToEntropy(DEV_MNEMONIC_POLKADOT);
-          const seed = entropyToSeedSubstrate(entropy); // 80ms
+          const seed = await entropyToSeedSubstrate(entropy); // 80ms
           DEV_SEED_CACHE.set(type, seed);
           break;
         }
@@ -105,6 +119,26 @@ const getDevSeed = curve => {
   return DEV_SEED_CACHE.get(type);
 };
 
+/** NOTE: Try not to use this too much, it will need to change */
+const addressEncodingFromCurve = curve => {
+  switch (curve) {
+    case "sr25519":
+    case "ed25519":
+    case "ecdsa":
+      return "ss58";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      // NOTE: Bitcoin has multiple address formats, so this isn't necessarily correct
+      // The format MAY be bech32m, but it might also be bech32 or base58check.
+      // bech32m is the most recent format.
+      return "bech32m";
+    case "ethereum":
+      return "ethereum";
+    case "solana":
+      return "base58";
+  }
+};
+
 const encodeAddressBase58 = publicKey => {
   return base58.encode(publicKey);
 };
@@ -118,6 +152,94 @@ function isBase58Address(address) {
   }
 }
 
+const isBitcoinAddress = address => isBech32mAddress(address) || isBech32Address(address) || isBase58CheckAddress(address);
+function isBech32mAddress(address) {
+  try {
+    fromBech32m(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBech32Address(address) {
+  try {
+    fromBech32(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+function isBase58CheckAddress(address) {
+  try {
+    fromBase58Check(address);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Converts a Bech32m encoded address to its corresponding data representation.
+ * @param address - The Bech32m encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32m(address) {
+  const result = bech32m.decode(address);
+  const version = result.words[0];
+  if (version === 0) throw new TypeError(address + " uses wrong encoding");
+  const data = bech32m.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data)
+  };
+}
+
+/**
+ * Converts a Bech32 encoded address to its corresponding data representation.
+ * @param address - The Bech32 encoded address.
+ * @returns An object containing the version, prefix, and data of the address.
+ * @throws {TypeError} If the address uses the wrong encoding.
+ */
+function fromBech32(address) {
+  const result = bech32.decode(address);
+  const version = result.words[0];
+  if (version !== 0) throw new TypeError(address + " uses wrong encoding");
+  const data = bech32.fromWords(result.words.slice(1));
+  return {
+    version,
+    prefix: result.prefix,
+    data: Uint8Array.from(data)
+  };
+}
+
+/**
+ * Decodes a base58check encoded Bitcoin address and returns the version and hash.
+ *
+ * @param address - The base58check encoded Bitcoin address to decode.
+ * @returns An object containing the version and hash of the decoded address.
+ * @throws {TypeError} If the address is too short or too long.
+ */
+function fromBase58Check(address) {
+  const payload = bs58check.decode(address);
+  if (payload.length < 21) throw new TypeError(address + " is too short");
+  if (payload.length > 21) throw new TypeError(address + " is too long");
+  function readUInt8(buffer, offset) {
+    if (offset + 1 > buffer.length) {
+      throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    const buf = Buffer.from(buffer);
+    return buf.readUInt8(offset);
+  }
+  const version = readUInt8(payload, 0);
+  const hash = payload.slice(1);
+  return {
+    version,
+    hash
+  };
+}
+
 /**
  * Encodes a public key using H160 encoding with Ethereum checksum.
  */
@@ -205,23 +327,13 @@ function isSs58Address(address) {
   }
 }
 
-const addressEncodingFromCurve = curve => {
-  switch (curve) {
-    case "sr25519":
-    case "ed25519":
-    case "ecdsa":
-      return "ss58";
-    case "ethereum":
-      return "ethereum";
-    case "solana":
-      return "base58";
-  }
-};
-
 const CACHE$1 = new Map();
 const detectAddressEncodingInner = address => {
   if (isEthereumAddress(address)) return "ethereum";
   if (isSs58Address(address)) return "ss58";
+  if (isBech32mAddress(address)) return "bech32m";
+  if (isBech32Address(address)) return "bech32";
+  if (isBase58CheckAddress(address)) return "base58check";
   if (isBase58Address(address)) return "base58";
   throw new Error(`Unknown address encoding`);
 };
@@ -236,6 +348,10 @@ const addressFromPublicKey = (publicKey, encoding, options) => {
       return encodeAddressSs58(publicKey, options?.ss58Prefix);
     case "ethereum":
       return encodeAddressEthereum(publicKey);
+    case "bech32m":
+    case "bech32":
+    case "base58check":
+      throw new Error("addressFromPublicKey is not implemented for Bitcoin");
     case "base58":
       return encodeAddressBase58(publicKey);
   }
@@ -258,6 +374,9 @@ const normalizeAnyAddress = address => {
   switch (detectAddressEncoding(address)) {
     case "ethereum":
       return checksumEthereumAddress(address);
+    case "bech32m":
+    case "bech32":
+    case "base58check":
     case "base58":
       return address;
     case "ss58":
@@ -438,6 +557,9 @@ const deriveKeypair = (seed, derivationPath, curve) => {
       return deriveEd25519(seed, derivationPath);
     case "ecdsa":
       return deriveEcdsa(seed, derivationPath);
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("deriveKeypair is not implemented for Bitcoin");
     case "ethereum":
       return deriveEthereum(seed, derivationPath);
     case "solana":
@@ -454,18 +576,21 @@ const getPublicKeyFromSecret = (secretKey, curve) => {
       return getPublicKeySr25519(secretKey);
     case "ed25519":
       return getPublicKeyEd25519(secretKey);
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      throw new Error("getPublicKeyFromSecret is not implemented for Bitcoin");
     case "solana":
       return getPublicKeySolana(secretKey);
   }
 };
-const addressFromSuri = (suri, type) => {
+const addressFromSuri = async (suri, type) => {
   const {
     mnemonic,
     derivationPath,
     password
   } = parseSuri(suri);
   const entropy = mnemonicToEntropy(mnemonic);
-  const seed = entropyToSeed(entropy, type, password); // ~80ms
+  const seed = await entropyToSeed(entropy, type, password); // ~80ms
   const {
     secretKey
   } = deriveKeypair(seed, derivationPath, type);
@@ -509,15 +634,17 @@ const parseSecretKey = (secretKey, curve) => {
     case "ed25519":
     case "sr25519":
     case "ecdsa":
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
     case "solana":
       throw new Error("Not implemented");
   }
 };
 
 // @dev: didn't find a reliable source of information on which characters are valid => assume it s valid if a keypair can be generated from it
-const isValidDerivationPath = (derivationPath, curve) => {
+const isValidDerivationPath = async (derivationPath, curve) => {
   try {
-    deriveKeypair(getDevSeed(curve), derivationPath, curve);
+    deriveKeypair(await getDevSeed(curve), derivationPath, curve);
     return true;
   } catch (err) {
     return false;
@@ -532,6 +659,9 @@ const platformFromCurve = curve => {
       return "polkadot";
     case "ethereum":
       return "ethereum";
+    case "bitcoin-ecdsa":
+    case "bitcoin-ed25519":
+      return "bitcoin";
     case "solana":
       return "solana";
   }
@@ -542,6 +672,10 @@ const platformFromEncoding = encoding => {
       return "polkadot";
     case "ethereum":
       return "ethereum";
+    case "bech32m":
+    case "bech32":
+    case "base58check":
+      return "bitcoin";
     case "base58":
       return "solana";
   }
@@ -551,4 +685,4 @@ const platformFromAddress = address => {
   return platformFromEncoding(encoding);
 };
 
-export { DEV_MNEMONIC_ETHEREUM, DEV_MNEMONIC_POLKADOT, addressEncodingFromCurve, addressFromPublicKey, addressFromSuri, blake2b256, blake2b512, blake3, checksumEthereumAddress, decodeSs58Address, deriveKeypair, detectAddressEncoding, encodeAddressBase58, encodeAddressEthereum, encodeAddressSs58, entropyToMnemonic, entropyToSeed, generateMnemonic, getDevSeed, getPublicKeyFromSecret, getSafeHash, isAddressEqual, isBase58Address, isEthereumAddress, isSs58Address, isValidDerivationPath, isValidMnemonic, mnemonicToEntropy, normalizeAddress, parseSecretKey, parseSuri, platformFromAddress, platformFromCurve, platformFromEncoding, removeHexPrefix };
+export { DEV_MNEMONIC_ETHEREUM, DEV_MNEMONIC_POLKADOT, addressEncodingFromCurve, addressFromPublicKey, addressFromSuri, blake2b256, blake2b512, blake3, checksumEthereumAddress, decodeSs58Address, deriveKeypair, detectAddressEncoding, encodeAddressBase58, encodeAddressEthereum, encodeAddressSs58, entropyToMnemonic, entropyToSeed, fromBase58Check, fromBech32, fromBech32m, generateMnemonic, getDevSeed, getPublicKeyFromSecret, getSafeHash, isAddressEqual, isBase58Address, isBase58CheckAddress, isBech32Address, isBech32mAddress, isBitcoinAddress, isEthereumAddress, isSs58Address, isValidDerivationPath, isValidMnemonic, mnemonicToEntropy, normalizeAddress, parseSecretKey, parseSuri, pbkdf2, platformFromAddress, platformFromCurve, platformFromEncoding, removeHexPrefix };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@talismn/crypto",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "author": "Talisman",
   "homepage": "https://talisman.xyz",
   "license": "GPL-3.0-or-later",
@@ -27,6 +27,8 @@
     "@scure/base": "1.2.4",
     "@scure/bip32": "1.6.2",
     "@scure/bip39": "1.5.4",
+    "bech32": "2.0.0",
+    "bs58check": "4.0.0",
     "micro-sr25519": "0.1.3",
     "scale-ts": "1.6.1"
   },
@@ -36,8 +38,8 @@
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.6.3",
-    "@talismn/tsconfig": "0.0.2",
-    "@talismn/eslint-config": "0.0.3"
+    "@talismn/eslint-config": "0.0.3",
+    "@talismn/tsconfig": "0.0.2"
   },
   "preconstruct": {
     "entrypoints": [