xpi-ts 0.2.0

package/dist/lib/bitcore/mnemonic/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const MnemonicError: Function;
+export interface MnemonicErrorType {
+    InvalidEntropy: new (entropy: string) => Error;
+    UnknownWordlist: new (mnemonic: string) => Error;
+    InvalidMnemonic: new (mnemonic: string) => Error;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/bitcore/mnemonic/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/mnemonic/errors.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,aAAa,UAAyC,CAAA;AAGnE,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE,KAAK,OAAO,EAAE,MAAM,KAAK,KAAK,CAAA;IAC9C,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,KAAK,CAAA;IAChD,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,KAAK,KAAK,CAAA;CACjD"}

package/dist/lib/bitcore/mnemonic/errors.js

@@ -0,0 +1,20 @@
+import { BitcoreError } from '../errors.js';
+const mnemonicErrorSpec = {
+    name: 'Mnemonic',
+    message: 'Internal Error on bitcore-mnemonic module {0}',
+    errors: [
+        {
+            name: 'InvalidEntropy',
+            message: 'Entropy length must be an even multiple of 11 bits: {0}',
+        },
+        {
+            name: 'UnknownWordlist',
+            message: 'Could not detect the used word list: {0}',
+        },
+        {
+            name: 'InvalidMnemonic',
+            message: 'Mnemonic string is invalid: {0}',
+        },
+    ],
+};
+export const MnemonicError = BitcoreError.extend(mnemonicErrorSpec);

package/dist/lib/bitcore/mnemonic/index.d.ts

@@ -0,0 +1,5 @@
+export { Mnemonic, default } from './mnemonic.js';
+export { MnemonicError } from './errors.js';
+export { pbkdf2 } from './pbkdf2.js';
+export { Words } from './words/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/bitcore/mnemonic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/mnemonic/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/lib/bitcore/mnemonic/index.js

@@ -0,0 +1,4 @@
+export { Mnemonic, default } from './mnemonic.js';
+export { MnemonicError } from './errors.js';
+export { pbkdf2 } from './pbkdf2.js';
+export { Words } from './words/index.js';

package/dist/lib/bitcore/mnemonic/mnemonic.d.ts

@@ -0,0 +1,23 @@
+import { HDPrivateKey } from '../hdprivatekey.js';
+import { Network } from '../networks.js';
+export declare class Mnemonic {
+    readonly wordlist: string[];
+    readonly phrase: string;
+    constructor(data?: Buffer | string | number | string[], wordlist?: string[]);
+    static Words: {
+        ENGLISH: string[];
+    };
+    static isValid(mnemonic: string, wordlist?: string[]): boolean;
+    static _belongsToWordlist(mnemonic: string, wordlist: string[]): boolean;
+    static _getDictionary(mnemonic?: string): string[] | undefined;
+    toSeed(passphrase?: string): Buffer;
+    static fromSeed(seed: Buffer, wordlist?: string[]): Mnemonic;
+    toHDPrivateKey(passphrase?: string, network?: string | Network): HDPrivateKey;
+    toString(): string;
+    inspect(): string;
+    static _mnemonic(ENT: number, wordlist: string[]): string;
+    static _entropy2mnemonic(entropy: Buffer, wordlist: string[]): string;
+    static _entropyChecksum(entropy: Buffer): string;
+}
+export default Mnemonic;
+//# sourceMappingURL=mnemonic.d.ts.map

package/dist/lib/bitcore/mnemonic/mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonic.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/mnemonic/mnemonic.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAoCxC,qBAAa,QAAQ;IACnB,SAAgB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClC,SAAgB,MAAM,EAAE,MAAM,CAAA;gBAElB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE;IAuD3E,MAAM,CAAC,KAAK;;MAAQ;IAcpB,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO;IAmC9D,MAAM,CAAC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO;IAexE,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS;IAoB9D,MAAM,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM;IAiBnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,QAAQ;IAoB5D,cAAc,CACZ,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,GACzB,YAAY;IAUf,QAAQ,IAAI,MAAM;IASlB,OAAO,IAAI,MAAM;IAWjB,MAAM,CAAC,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM;IAYzD,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM;IAiCrE,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAiBjD;AAED,eAAe,QAAQ,CAAA"}

package/dist/lib/bitcore/mnemonic/mnemonic.js

@@ -0,0 +1,164 @@
+import { BN } from '../crypto/bn.js';
+import { Hash } from '../crypto/hash.js';
+import { Random } from '../crypto/random.js';
+import { Preconditions } from '../util/preconditions.js';
+import { HDPrivateKey } from '../hdprivatekey.js';
+import { pbkdf2 } from './pbkdf2.js';
+import { Words } from './words/index.js';
+function normalizeUnicode(str) {
+    return str.normalize('NFKD');
+}
+export class Mnemonic {
+    wordlist;
+    phrase;
+    constructor(data, wordlist) {
+        if (Array.isArray(data)) {
+            wordlist = data;
+            data = undefined;
+        }
+        let ent;
+        let phrase;
+        let seed;
+        if (Buffer.isBuffer(data)) {
+            seed = data;
+            ent = seed.length * 8;
+        }
+        else if (typeof data === 'string') {
+            phrase = normalizeUnicode(data);
+        }
+        else if (typeof data === 'number') {
+            ent = data;
+        }
+        else if (data) {
+            throw new Error('Invalid data: Must be a Buffer, a string or an integer');
+        }
+        ent = ent || 128;
+        const detectedWordlist = Mnemonic._getDictionary(phrase);
+        wordlist = wordlist || detectedWordlist || Words.ENGLISH;
+        if (phrase && !detectedWordlist) {
+            throw new Error(`Could not detect the used word list: ${phrase}`);
+        }
+        if (seed) {
+            phrase = Mnemonic._entropy2mnemonic(seed, wordlist);
+        }
+        if (phrase && !Mnemonic.isValid(phrase, wordlist)) {
+            throw new Error(`Mnemonic string is invalid: ${phrase}`);
+        }
+        if (!seed && ent && (ent % 32 !== 0 || ent < 128 || ent > 256)) {
+            throw new Error('Values must be ENT > 128 and ENT < 256 and ENT % 32 == 0');
+        }
+        phrase = phrase || Mnemonic._mnemonic(ent, wordlist);
+        phrase = normalizeUnicode(phrase);
+        this.wordlist = wordlist;
+        this.phrase = phrase;
+    }
+    static Words = Words;
+    static isValid(mnemonic, wordlist) {
+        mnemonic = normalizeUnicode(mnemonic);
+        const detectedWordlist = Mnemonic._getDictionary(mnemonic);
+        wordlist = wordlist || detectedWordlist;
+        if (!wordlist) {
+            return false;
+        }
+        const words = mnemonic.split(' ');
+        let bin = '';
+        for (let i = 0; i < words.length; i++) {
+            const ind = wordlist.indexOf(words[i]);
+            if (ind < 0)
+                return false;
+            bin = bin + ('00000000000' + ind.toString(2)).slice(-11);
+        }
+        const cs = bin.length / 33;
+        const hash_bits = bin.slice(-cs);
+        const nonhash_bits = bin.slice(0, bin.length - cs);
+        const buf = Buffer.alloc(nonhash_bits.length / 8);
+        for (let i = 0; i < nonhash_bits.length / 8; i++) {
+            buf.writeUInt8(parseInt(bin.slice(i * 8, (i + 1) * 8), 2), i);
+        }
+        const expected_hash_bits = Mnemonic._entropyChecksum(buf);
+        return expected_hash_bits === hash_bits;
+    }
+    static _belongsToWordlist(mnemonic, wordlist) {
+        const words = normalizeUnicode(mnemonic).split(' ');
+        for (let i = 0; i < words.length; i++) {
+            const ind = wordlist.indexOf(words[i]);
+            if (ind < 0)
+                return false;
+        }
+        return true;
+    }
+    static _getDictionary(mnemonic) {
+        if (!mnemonic)
+            return undefined;
+        const dicts = Object.keys(Words);
+        for (let i = 0; i < dicts.length; i++) {
+            const key = dicts[i];
+            const wordlist = Words[key];
+            if (Mnemonic._belongsToWordlist(mnemonic, wordlist)) {
+                return wordlist;
+            }
+        }
+        return undefined;
+    }
+    toSeed(passphrase) {
+        passphrase = passphrase || '';
+        return pbkdf2(normalizeUnicode(this.phrase), normalizeUnicode('mnemonic' + passphrase), 2048, 64);
+    }
+    static fromSeed(seed, wordlist) {
+        Preconditions.checkArgument(Buffer.isBuffer(seed), 'seed must be a Buffer.');
+        if (wordlist !== undefined) {
+            Preconditions.checkArgument(Array.isArray(wordlist) || typeof wordlist === 'string', 'wordlist must be a string or an array.');
+        }
+        return new Mnemonic(seed, wordlist);
+    }
+    toHDPrivateKey(passphrase, network) {
+        const seed = this.toSeed(passphrase);
+        return HDPrivateKey.fromSeed(seed, network);
+    }
+    toString() {
+        return this.phrase;
+    }
+    inspect() {
+        return '<Mnemonic: ' + this.toString() + ' >';
+    }
+    static _mnemonic(ENT, wordlist) {
+        const buf = Random.getRandomBuffer(ENT / 8);
+        return Mnemonic._entropy2mnemonic(buf, wordlist);
+    }
+    static _entropy2mnemonic(entropy, wordlist) {
+        let bin = '';
+        for (let i = 0; i < entropy.length; i++) {
+            bin = bin + ('00000000' + entropy[i].toString(2)).slice(-8);
+        }
+        bin = bin + Mnemonic._entropyChecksum(entropy);
+        if (bin.length % 11 !== 0) {
+            throw new Error(`Entropy length must be an even multiple of 11 bits: ${bin}`);
+        }
+        const mnemonic = [];
+        for (let i = 0; i < bin.length / 11; i++) {
+            const wi = parseInt(bin.slice(i * 11, (i + 1) * 11), 2);
+            mnemonic.push(wordlist[wi]);
+        }
+        let ret;
+        if (wordlist === Words.ENGLISH) {
+            ret = mnemonic.join(' ');
+        }
+        else {
+            ret = mnemonic.join(' ');
+        }
+        return ret;
+    }
+    static _entropyChecksum(entropy) {
+        const hash = Hash.sha256(entropy);
+        const bits = entropy.length * 8;
+        const cs = bits / 32;
+        const hashbits = new BN(hash.toString('hex'), 16).toString(2);
+        let paddedHashbits = hashbits;
+        while (paddedHashbits.length % 256 !== 0) {
+            paddedHashbits = '0' + paddedHashbits;
+        }
+        const checksum = paddedHashbits.slice(0, cs);
+        return checksum;
+    }
+}
+export default Mnemonic;

package/dist/lib/bitcore/mnemonic/pbkdf2.d.ts

@@ -0,0 +1,2 @@
+export declare function pbkdf2(key: string | Buffer, salt: string | Buffer, iterations: number, dkLen: number): Buffer;
+//# sourceMappingURL=pbkdf2.d.ts.map

package/dist/lib/bitcore/mnemonic/pbkdf2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pbkdf2.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/mnemonic/pbkdf2.ts"],"names":[],"mappings":"AAiBA,wBAAgB,MAAM,CACpB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,GACZ,MAAM,CA+BR"}

package/dist/lib/bitcore/mnemonic/pbkdf2.js

@@ -0,0 +1,25 @@
+import { pbkdf2 as noblePbkdf2 } from '@noble/hashes/pbkdf2';
+import { sha512 } from '@noble/hashes/sha512';
+export function pbkdf2(key, salt, iterations, dkLen) {
+    const hLen = 64;
+    if (dkLen > (Math.pow(2, 32) - 1) * hLen) {
+        throw new Error('Requested key length too long');
+    }
+    if (typeof key !== 'string' && !Buffer.isBuffer(key)) {
+        throw new TypeError('key must a string or Buffer');
+    }
+    if (typeof salt !== 'string' && !Buffer.isBuffer(salt)) {
+        throw new TypeError('salt must a string or Buffer');
+    }
+    const keyBytes = typeof key === 'string'
+        ? new TextEncoder().encode(key)
+        : new Uint8Array(key);
+    const saltBytes = typeof salt === 'string'
+        ? new TextEncoder().encode(salt)
+        : new Uint8Array(salt);
+    const result = noblePbkdf2(sha512, keyBytes, saltBytes, {
+        c: iterations,
+        dkLen: dkLen,
+    });
+    return Buffer.from(result);
+}

package/dist/lib/bitcore/mnemonic/words/english.d.ts

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

package/dist/lib/bitcore/mnemonic/words/english.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"english.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/mnemonic/words/english.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,OAAO,UAigEnB,CAAA"}