@xyo-network/bip39 2.63.7

package/dist/esm/wordlists/traditional-chinese.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traditional-chinese.js","sourceRoot":"","sources":["../../../src/wordlists/traditional-chinese.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,MAAM,CAAC,MAAM,QAAQ,GAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+/DhC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+ * @param wordlist imported wordlist for specific language
+ * @param strength mnemonic strength 128-256 bits
+ * @example
+ * generateMnemonic(wordlist, 128)
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export declare function generateMnemonic(wordlist: string[], strength?: number): string;
+/**
+ * Reversible: Converts mnemonic string to raw entropy in form of byte array.
+ * @param mnemonic 12-24 words
+ * @param wordlist imported wordlist for specific language
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToEntropy(mnem, wordlist)
+ * // Produces
+ * new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ])
+ */
+export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
+/**
+ * Reversible: Converts raw entropy in form of byte array to mnemonic string.
+ * @param entropy byte array
+ * @param wordlist imported wordlist for specific language
+ * @returns 12-24 words
+ * @example
+ * const ent = new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ]);
+ * entropyToMnemonic(ent, wordlist);
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
+/**
+ * Validates mnemonic for being 12-24 words contained in `wordlist`.
+ */
+export declare function validateMnemonic(mnemonic: string, wordlist: string[]): boolean;
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * await mnemonicToSeed(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export declare function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAgCA;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,QAAQ,SAAM,GAAG,MAAM,CAI3E;AAmBD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAO9E;AAID;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/types/wordlists/czech.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=czech.d.ts.map

package/dist/types/wordlists/czech.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"czech.d.ts","sourceRoot":"","sources":["../../../src/wordlists/czech.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/DZ,CAAA"}

package/dist/types/wordlists/english.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=english.d.ts.map

package/dist/types/wordlists/english.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"english.d.ts","sourceRoot":"","sources":["../../../src/wordlists/english.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/Db,CAAA"}

package/dist/types/wordlists/french.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=french.d.ts.map

package/dist/types/wordlists/french.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"french.d.ts","sourceRoot":"","sources":["../../../src/wordlists/french.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/DR,CAAA"}

package/dist/types/wordlists/italian.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=italian.d.ts.map

package/dist/types/wordlists/italian.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"italian.d.ts","sourceRoot":"","sources":["../../../src/wordlists/italian.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/DX,CAAA"}

package/dist/types/wordlists/japanese.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=japanese.d.ts.map

package/dist/types/wordlists/japanese.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"japanese.d.ts","sourceRoot":"","sources":["../../../src/wordlists/japanese.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/Db,CAAA"}

package/dist/types/wordlists/korean.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=korean.d.ts.map

package/dist/types/wordlists/korean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"korean.d.ts","sourceRoot":"","sources":["../../../src/wordlists/korean.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/DV,CAAA"}

package/dist/types/wordlists/simplified-chinese.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=simplified-chinese.d.ts.map

package/dist/types/wordlists/simplified-chinese.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplified-chinese.d.ts","sourceRoot":"","sources":["../../../src/wordlists/simplified-chinese.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/Df,CAAA"}

package/dist/types/wordlists/spanish.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=spanish.d.ts.map

package/dist/types/wordlists/spanish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanish.d.ts","sourceRoot":"","sources":["../../../src/wordlists/spanish.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/DX,CAAA"}

package/dist/types/wordlists/traditional-chinese.d.ts

@@ -0,0 +1,2 @@
+export declare const wordlist: string[];
+//# sourceMappingURL=traditional-chinese.d.ts.map

package/dist/types/wordlists/traditional-chinese.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traditional-chinese.d.ts","sourceRoot":"","sources":["../../../src/wordlists/traditional-chinese.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,QAAQ,EAAE,MAAM,EA+/Df,CAAA"}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@xyo-network/bip39",
+  "author": {
+    "email": "support@xyo.network",
+    "name": "XYO Development Team",
+    "url": "https://xyo.network"
+  },
+  "bugs": {
+    "email": "support@xyo.network",
+    "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues"
+  },
+  "dependencies": {
+    "@noble/hashes": "~1.3.0",
+    "@scure/base": "~1.1.0"
+  },
+  "description": "Primary SDK for using XYO Protocol 2.0",
+  "devDependencies": {
+    "@xylabs/ts-scripts-yarn3": "^2.17.17",
+    "@xylabs/tsconfig": "^2.17.17",
+    "typescript": "^5.1.3"
+  },
+  "browser": "dist/esm/index.js",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "docs": "dist/docs.json",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
+      },
+      "browser": {
+        "import": "./dist/esm/index.js",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/esm/index.js"
+    },
+    "./dist/docs.json": {
+      "default": "./dist/docs.json"
+    },
+    "./package.json": "./package.json"
+  },
+  "homepage": "https://xyo.network",
+  "license": "LGPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
+  },
+  "sideEffects": false,
+  "types": "dist/types/index.d.ts",
+  "version": "2.63.7"
+}

package/src/index.ts

@@ -0,0 +1,143 @@
+/* eslint-disable import/no-named-as-default-member */
+/* eslint-disable import/no-internal-modules */
+/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+import assert from '@noble/hashes/_assert'
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'
+import { sha256 } from '@noble/hashes/sha256'
+import { sha512 } from '@noble/hashes/sha512'
+import { randomBytes } from '@noble/hashes/utils'
+import { utils as baseUtils } from '@scure/base'
+
+// Japanese wordlist
+const isJapanese = (wordlist: string[]) => wordlist[0] === '\u3042\u3044\u3053\u304f\u3057\u3093'
+
+// Normalization replaces equivalent sequences of characters
+// so that any two texts that are equivalent will be reduced
+// to the same sequence of code points, called the normal form of the original text.
+function nfkd(str: string) {
+  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)
+  return str.normalize('NFKD')
+}
+
+function normalize(str: string) {
+  const norm = nfkd(str)
+  const words = norm.split(' ')
+  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')
+  return { nfkd: norm, words }
+}
+
+function assertEntropy(entropy: Uint8Array) {
+  assert.bytes(entropy, 16, 20, 24, 28, 32)
+}
+
+/**
+ * Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+ * @param wordlist imported wordlist for specific language
+ * @param strength mnemonic strength 128-256 bits
+ * @example
+ * generateMnemonic(wordlist, 128)
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export function generateMnemonic(wordlist: string[], strength = 128): string {
+  assert.number(strength)
+  if (strength % 32 !== 0 || strength > 256) throw new TypeError('Invalid entropy')
+  return entropyToMnemonic(randomBytes(strength / 8), wordlist)
+}
+
+const calcChecksum = (entropy: Uint8Array) => {
+  // Checksum is ent.length/4 bits long
+  const bitsLeft = 8 - entropy.length / 4
+  // Zero rightmost "bitsLeft" bits in byte
+  // For example: bitsLeft=4 val=10111101 -> 10110000
+  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])
+}
+
+function getCoder(wordlist: string[]) {
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')
+    throw new Error('Worlist: expected array of 2048 strings')
+  wordlist.forEach((i) => {
+    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)
+  })
+  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))
+}
+
+/**
+ * Reversible: Converts mnemonic string to raw entropy in form of byte array.
+ * @param mnemonic 12-24 words
+ * @param wordlist imported wordlist for specific language
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToEntropy(mnem, wordlist)
+ * // Produces
+ * new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ])
+ */
+export function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {
+  const { words } = normalize(mnemonic)
+  const entropy = getCoder(wordlist).decode(words)
+  assertEntropy(entropy)
+  return entropy
+}
+
+/**
+ * Reversible: Converts raw entropy in form of byte array to mnemonic string.
+ * @param entropy byte array
+ * @param wordlist imported wordlist for specific language
+ * @returns 12-24 words
+ * @example
+ * const ent = new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ]);
+ * entropyToMnemonic(ent, wordlist);
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {
+  assertEntropy(entropy)
+  const words = getCoder(wordlist).encode(entropy)
+  return words.join(isJapanese(wordlist) ? '\u3000' : ' ')
+}
+
+/**
+ * Validates mnemonic for being 12-24 words contained in `wordlist`.
+ */
+export function validateMnemonic(mnemonic: string, wordlist: string[]): boolean {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist)
+  } catch (e) {
+    return false
+  }
+  return true
+}
+
+const salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)
+
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * await mnemonicToSeed(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export function mnemonicToSeed(mnemonic: string, passphrase = '') {
+  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })
+}
+
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export function mnemonicToSeedSync(mnemonic: string, passphrase = '') {
+  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })
+}