quantumcoin 6.14.2 → 6.14.5

package/src.ts/wallet/wallet.ts

@@ -1,139 +1,138 @@
-import { SigningKey } from "../crypto/index.js";
-import { assertArgument,hexlify } from "../utils/index.js";
-
-import { BaseWallet } from "./base-wallet.js";
-
-//import { decryptCrowdsaleJson, isCrowdsaleJson  } from "./json-crowdsale.js";
-import {
-    decryptKeystoreJsonSync,
-    encryptKeystoreJsonSync,
-    isKeystoreJson
-} from "./json-keystore.js";
-//import { Mnemonic } from "./mnemonic.js";
-import qcsdk = require('quantum-coin-js-sdk');
-
-import type { Provider } from "../providers/index.js";
-
-import type { KeystoreAccount } from "./json-keystore.js";
-//import {newWallet} from "quantum-coin-js-sdk";
-
-/**
- *  A **Wallet** manages a single private key which is used to sign
- *  transactions, messages and other common payloads.
- *
- *  This class is generally the main entry point for developers
- *  that wish to use a private key directly, as it can create
- *  instances from a large variety of common sources, including
- *  raw private key, [[link-bip-39]] mnemonics and encrypte JSON
- *  wallets.
- */
-export class Wallet extends BaseWallet {
-
-    /**
-     *  Create a new wallet for the private %%key%%, optionally connected
-     *  to %%provider%%.
-     */
-    constructor(key: string | SigningKey, provider?: null | Provider) {
-        if (typeof(key) === "string" && !key.startsWith("0x")) {
-            key = "0x" + key;
-        }
-
-        let signingKey = (typeof(key) === "string") ? new SigningKey(key): key;
-        super(signingKey, provider);
-    }
-
-    connect(provider: null | Provider): Wallet {
-        return new Wallet(this.signingKey, provider);
-    }
-
-    /**
-     *  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with
-     *  %%password%%.
-     *
-     *  If %%progressCallback%% is specified, it will receive periodic
-     *  updates as the encryption process progreses.
-     */
-    async encrypt(password: Uint8Array | string): Promise<string> {
-        const account = { address: this.address, privateKey: this.privateKey };
-        return encryptKeystoreJsonSync(account, password);
-    }
-
-    /**
-     *  Returns a [JSON Keystore Wallet](json-wallets) encryped with
-     *  %%password%%.
-     *
-     *  It is preferred to use the [async version](encrypt) instead,
-     *  which allows a [[ProgressCallback]] to keep the user informed.
-     *
-     *  This method will block the event loop (freezing all UI) until
-     *  it is complete, which may be a non-trivial duration.
-     */
-    encryptSync(password: Uint8Array | string): string {
-        const account = { address: this.address, privateKey: this.privateKey };
-        return encryptKeystoreJsonSync(account, password);
-    }
-
-    static #fromAccount(account: null | KeystoreAccount): Wallet {
-        assertArgument(account, "invalid JSON wallet", "json", "[ REDACTED ]");
-
-        const wallet = new Wallet(account.privateKey);
-
-        assertArgument(wallet.address === account.address,
-            "address/privateKey mismatch", "json", "[ REDACTED ]");
-
-        return wallet;
-    }
-
-    /**
-     *  Creates (asynchronously) a **Wallet** by decrypting the %%json%%
-     *  with %%password%%.
-     */
-    static async fromEncryptedJson(json: string, password: Uint8Array | string): Promise<Wallet> {
-        let account: null | KeystoreAccount = null;
-        if (isKeystoreJson(json)) {
-            account = decryptKeystoreJsonSync(json, password);
-
-        }
-
-        return Wallet.#fromAccount(account);
-    }
-
-    /**
-     *  Creates a **Wallet** by decrypting the %%json%% with %%password%%.
-     *
-     *  The [[fromEncryptedJson]] method is preferred, as this method
-     *  will lock up and freeze the UI during decryption, which may take
-     *  some time.
-     */
-    static fromEncryptedJsonSync(json: string, password: Uint8Array | string): Wallet {
-        let account: null | KeystoreAccount = null;
-        if (isKeystoreJson(json)) {
-            account = decryptKeystoreJsonSync(json, password);
-        } else {
-            assertArgument(false, "invalid JSON wallet", "json", "[ REDACTED ]");
-        }
-
-        return Wallet.#fromAccount(account);
-    }
-
-    /**
-     *  Creates a new random [[Wallet]] using the available
-     *  [cryptographic random source](randomBytes).
-     *
-     *  If there is no crytographic random source, this will throw.
-     */
-    static createRandom(provider?: null | Provider): Wallet {
-        let wal = qcsdk.newWallet();
-        let privKey: any = wal.privateKey;
-        return new Wallet(hexlify(privKey));
-    }
-
-    /**
-     *  Creates a [[HDNodeWallet]] for %%phrase%%.
-     *//*
-    static fromPhrase(phrase: string, provider?: Provider): HDNodeWallet {
-        const wallet = HDNodeWallet.fromPhrase(phrase);
-        if (provider) { return wallet.connect(provider); }
-        return wallet;
-    }*/
-}
+import { SigningKey } from "../crypto/index.js";
+import { assertArgument,hexlify } from "../utils/index.js";
+
+import { BaseWallet } from "./base-wallet.js";
+
+//import { decryptCrowdsaleJson, isCrowdsaleJson  } from "./json-crowdsale.js";
+import {
+    decryptKeystoreJsonSync,
+    encryptKeystoreJsonSync,
+    isKeystoreJson
+} from "./json-keystore.js";
+//import { Mnemonic } from "./mnemonic.js";
+import {newWallet} from "quantum-coin-js-sdk";
+import type { Provider } from "../providers/index.js";
+
+import type { KeystoreAccount } from "./json-keystore.js";
+//import {newWallet} from "quantum-coin-js-sdk";
+
+/**
+ *  A **Wallet** manages a single private key which is used to sign
+ *  transactions, messages and other common payloads.
+ *
+ *  This class is generally the main entry point for developers
+ *  that wish to use a private key directly, as it can create
+ *  instances from a large variety of common sources, including
+ *  raw private key, [[link-bip-39]] mnemonics and encrypte JSON
+ *  wallets.
+ */
+export class Wallet extends BaseWallet {
+
+    /**
+     *  Create a new wallet for the private %%key%%, optionally connected
+     *  to %%provider%%.
+     */
+    constructor(key: string | SigningKey, provider?: null | Provider) {
+        if (typeof(key) === "string" && !key.startsWith("0x")) {
+            key = "0x" + key;
+        }
+
+        let signingKey = (typeof(key) === "string") ? new SigningKey(key): key;
+        super(signingKey, provider);
+    }
+
+    connect(provider: null | Provider): Wallet {
+        return new Wallet(this.signingKey, provider);
+    }
+
+    /**
+     *  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with
+     *  %%password%%.
+     *
+     *  If %%progressCallback%% is specified, it will receive periodic
+     *  updates as the encryption process progreses.
+     */
+    async encrypt(password: Uint8Array | string): Promise<string> {
+        const account = { address: this.address, privateKey: this.privateKey };
+        return encryptKeystoreJsonSync(account, password);
+    }
+
+    /**
+     *  Returns a [JSON Keystore Wallet](json-wallets) encryped with
+     *  %%password%%.
+     *
+     *  It is preferred to use the [async version](encrypt) instead,
+     *  which allows a [[ProgressCallback]] to keep the user informed.
+     *
+     *  This method will block the event loop (freezing all UI) until
+     *  it is complete, which may be a non-trivial duration.
+     */
+    encryptSync(password: Uint8Array | string): string {
+        const account = { address: this.address, privateKey: this.privateKey };
+        return encryptKeystoreJsonSync(account, password);
+    }
+
+    static #fromAccount(account: null | KeystoreAccount): Wallet {
+        assertArgument(account, "invalid JSON wallet", "json", "[ REDACTED ]");
+
+        const wallet = new Wallet(account.privateKey);
+
+        assertArgument(wallet.address === account.address,
+            "address/privateKey mismatch", "json", "[ REDACTED ]");
+
+        return wallet;
+    }
+
+    /**
+     *  Creates (asynchronously) a **Wallet** by decrypting the %%json%%
+     *  with %%password%%.
+     */
+    static async fromEncryptedJson(json: string, password: Uint8Array | string): Promise<Wallet> {
+        let account: null | KeystoreAccount = null;
+        if (isKeystoreJson(json)) {
+            account = decryptKeystoreJsonSync(json, password);
+
+        }
+
+        return Wallet.#fromAccount(account);
+    }
+
+    /**
+     *  Creates a **Wallet** by decrypting the %%json%% with %%password%%.
+     *
+     *  The [[fromEncryptedJson]] method is preferred, as this method
+     *  will lock up and freeze the UI during decryption, which may take
+     *  some time.
+     */
+    static fromEncryptedJsonSync(json: string, password: Uint8Array | string): Wallet {
+        let account: null | KeystoreAccount = null;
+        if (isKeystoreJson(json)) {
+            account = decryptKeystoreJsonSync(json, password);
+        } else {
+            assertArgument(false, "invalid JSON wallet", "json", "[ REDACTED ]");
+        }
+
+        return Wallet.#fromAccount(account);
+    }
+
+    /**
+     *  Creates a new random [[Wallet]] using the available
+     *  [cryptographic random source](randomBytes).
+     *
+     *  If there is no crytographic random source, this will throw.
+     */
+    static createRandom(provider?: null | Provider): Wallet {
+        let wal = newWallet();
+        let privKey: any = wal.privateKey;
+        return new Wallet(hexlify(privKey));
+    }
+
+    /**
+     *  Creates a [[HDNodeWallet]] for %%phrase%%.
+     *//*
+    static fromPhrase(phrase: string, provider?: Provider): HDNodeWallet {
+        const wallet = HDNodeWallet.fromPhrase(phrase);
+        if (provider) { return wallet.connect(provider); }
+        return wallet;
+    }*/
+}

package/src.ts/wordlists/bit-reader.ts

@@ -1,35 +1,35 @@
-const Base64 = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
-
-/**
- *  @_ignore
- */
-export function decodeBits(width: number, data: string): Array<number> {
-    const maxValue = (1 << width) - 1;
-    const result: Array<number> = [ ];
-    let accum = 0, bits = 0, flood = 0;
-    for (let i = 0; i < data.length; i++) {
-
-        // Accumulate 6 bits of data
-        accum = ((accum << 6) | Base64.indexOf(data[i]));
-        bits += 6;
-
-        // While we have enough for a word...
-        while (bits >= width) {
-            // ...read the word
-            const value = (accum >> (bits - width));
-            accum &= (1 << (bits - width)) - 1;
-            bits -= width;
-
-            // A value of 0 indicates we exceeded maxValue, it
-            // floods over into the next value
-            if (value === 0) {
-                flood += maxValue;
-            } else {
-                result.push(value + flood);
-                flood = 0;
-            }
-        }
-    }
-
-    return result;
-}
+const Base64 = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
+
+/**
+ *  @_ignore
+ */
+export function decodeBits(width: number, data: string): Array<number> {
+    const maxValue = (1 << width) - 1;
+    const result: Array<number> = [ ];
+    let accum = 0, bits = 0, flood = 0;
+    for (let i = 0; i < data.length; i++) {
+
+        // Accumulate 6 bits of data
+        accum = ((accum << 6) | Base64.indexOf(data[i]));
+        bits += 6;
+
+        // While we have enough for a word...
+        while (bits >= width) {
+            // ...read the word
+            const value = (accum >> (bits - width));
+            accum &= (1 << (bits - width)) - 1;
+            bits -= width;
+
+            // A value of 0 indicates we exceeded maxValue, it
+            // floods over into the next value
+            if (value === 0) {
+                flood += maxValue;
+            } else {
+                result.push(value + flood);
+                flood = 0;
+            }
+        }
+    }
+
+    return result;
+}

package/src.ts/wordlists/decode-owl.ts

@@ -1,58 +1,58 @@
-import { assertArgument } from "../utils/index.js";
-
-
-const subsChrs = " !#$%&'()*+,-./<=>?@[]^_`{|}~";
-const Word = /^[a-z]*$/i;
-
-function unfold(words: Array<string>, sep: string): Array<string> {
-    let initial = 97;
-    return words.reduce((accum, word) => {
-        if (word === sep) {
-            initial++;
-        } else if (word.match(Word)) {
-            accum.push(String.fromCharCode(initial) + word);
-        } else {
-            initial = 97;
-            accum.push(word);
-        }
-        return accum;
-    }, <Array<string>>[]);
-}
-
-/**
- *  @_ignore
- */
-export function decode(data: string, subs: string): Array<string> {
-
-    // Replace all the substitutions with their expanded form
-    for (let i = subsChrs.length - 1; i >= 0; i--) {
-        data = data.split(subsChrs[i]).join(subs.substring(2 * i, 2 * i + 2));
-    }
-
-    // Get all tle clumps; each suffix, first-increment and second-increment
-    const clumps: Array<string> = [ ];
-    const leftover = data.replace(/(:|([0-9])|([A-Z][a-z]*))/g, (all, item, semi, word) => {
-        if (semi) {
-            for (let i = parseInt(semi); i >= 0; i--) { clumps.push(";"); }
-        } else {
-            clumps.push(item.toLowerCase());
-        }
-        return "";
-    });
-    /* c8 ignore start */
-    if (leftover) { throw new Error(`leftovers: ${ JSON.stringify(leftover) }`); }
-    /* c8 ignore stop */
-
-    return unfold(unfold(clumps, ";"), ":");
-}
-
-/**
- *  @_ignore
- */
-export function decodeOwl(data: string): Array<string> {
-    assertArgument(data[0] === "0", "unsupported auwl data", "data", data);
-
-    return decode(
-        data.substring(1 + 2 * subsChrs.length),
-        data.substring(1, 1 + 2 * subsChrs.length));
-}
+import { assertArgument } from "../utils/index.js";
+
+
+const subsChrs = " !#$%&'()*+,-./<=>?@[]^_`{|}~";
+const Word = /^[a-z]*$/i;
+
+function unfold(words: Array<string>, sep: string): Array<string> {
+    let initial = 97;
+    return words.reduce((accum, word) => {
+        if (word === sep) {
+            initial++;
+        } else if (word.match(Word)) {
+            accum.push(String.fromCharCode(initial) + word);
+        } else {
+            initial = 97;
+            accum.push(word);
+        }
+        return accum;
+    }, <Array<string>>[]);
+}
+
+/**
+ *  @_ignore
+ */
+export function decode(data: string, subs: string): Array<string> {
+
+    // Replace all the substitutions with their expanded form
+    for (let i = subsChrs.length - 1; i >= 0; i--) {
+        data = data.split(subsChrs[i]).join(subs.substring(2 * i, 2 * i + 2));
+    }
+
+    // Get all tle clumps; each suffix, first-increment and second-increment
+    const clumps: Array<string> = [ ];
+    const leftover = data.replace(/(:|([0-9])|([A-Z][a-z]*))/g, (all, item, semi, word) => {
+        if (semi) {
+            for (let i = parseInt(semi); i >= 0; i--) { clumps.push(";"); }
+        } else {
+            clumps.push(item.toLowerCase());
+        }
+        return "";
+    });
+    /* c8 ignore start */
+    if (leftover) { throw new Error(`leftovers: ${ JSON.stringify(leftover) }`); }
+    /* c8 ignore stop */
+
+    return unfold(unfold(clumps, ";"), ":");
+}
+
+/**
+ *  @_ignore
+ */
+export function decodeOwl(data: string): Array<string> {
+    assertArgument(data[0] === "0", "unsupported auwl data", "data", data);
+
+    return decode(
+        data.substring(1 + 2 * subsChrs.length),
+        data.substring(1, 1 + 2 * subsChrs.length));
+}

package/src.ts/wordlists/decode-owla.ts

@@ -1,33 +1,33 @@
-import { assertArgument } from "../utils/index.js";
-
-import { decodeBits } from "./bit-reader.js";
-import { decodeOwl } from "./decode-owl.js";
-
-/**
- *  @_ignore
- */
-export function decodeOwlA(data: string, accents: string): Array<string> {
-    let words = decodeOwl(data).join(",");
-
-    // Inject the accents
-    accents.split(/,/g).forEach((accent) => {
-
-        const match = accent.match(/^([a-z]*)([0-9]+)([0-9])(.*)$/);
-        assertArgument(match !== null, "internal error parsing accents", "accents", accents);
-
-        let posOffset = 0;
-        const positions = decodeBits(parseInt(match[3]), match[4]);
-        const charCode = parseInt(match[2]);
-        const regex = new RegExp(`([${ match[1] }])`, "g");
-        words = words.replace(regex, (all, letter) => {
-            const rem = --positions[posOffset];
-            if (rem === 0) {
-                letter = String.fromCharCode(letter.charCodeAt(0), charCode);
-                posOffset++;
-            }
-            return letter;
-        });
-    });
-
-    return words.split(",");
-}
+import { assertArgument } from "../utils/index.js";
+
+import { decodeBits } from "./bit-reader.js";
+import { decodeOwl } from "./decode-owl.js";
+
+/**
+ *  @_ignore
+ */
+export function decodeOwlA(data: string, accents: string): Array<string> {
+    let words = decodeOwl(data).join(",");
+
+    // Inject the accents
+    accents.split(/,/g).forEach((accent) => {
+
+        const match = accent.match(/^([a-z]*)([0-9]+)([0-9])(.*)$/);
+        assertArgument(match !== null, "internal error parsing accents", "accents", accents);
+
+        let posOffset = 0;
+        const positions = decodeBits(parseInt(match[3]), match[4]);
+        const charCode = parseInt(match[2]);
+        const regex = new RegExp(`([${ match[1] }])`, "g");
+        words = words.replace(regex, (all, letter) => {
+            const rem = --positions[posOffset];
+            if (rem === 0) {
+                letter = String.fromCharCode(letter.charCodeAt(0), charCode);
+                posOffset++;
+            }
+            return letter;
+        });
+    });
+
+    return words.split(",");
+}