quantumcoin 6.14.5 → 7.0.2

package/src.ts/wallet/base-wallet.ts

@@ -1,160 +0,0 @@
-import { getAddress, resolveAddress } from "../address/index.js";
-import {
-    hashAuthorization, hashMessage, TypedDataEncoder
-} from "../hash/index.js";
-import { AbstractSigner, copyRequest } from "../providers/index.js";
-import { computeAddress, Transaction } from "../transaction/index.js";
-import {
-    defineProperties, getBigInt, resolveProperties, assert, assertArgument
-} from "../utils/index.js";
-
-import type { SigningKey } from "../crypto/index.js";
-import type {
-    AuthorizationRequest, TypedDataDomain, TypedDataField
-} from "../hash/index.js";
-import type { Provider, TransactionRequest } from "../providers/index.js";
-import type { Authorization, TransactionLike } from "../transaction/index.js";
-
-
-/**
- *  The **BaseWallet** is a stream-lined implementation of a
- *  [[Signer]] that operates with a private key.
- *
- *  It is preferred to use the [[Wallet]] class, as it offers
- *  additional functionality and simplifies loading a variety
- *  of JSON formats, Mnemonic Phrases, etc.
- *
- *  This class may be of use for those attempting to implement
- *  a minimal Signer.
- */
-export class BaseWallet extends AbstractSigner {
-    /**
-     *  The wallet address.
-     */
-    readonly address!: string;
-
-    readonly #signingKey: SigningKey;
-
-    /**
-     *  Creates a new BaseWallet for %%privateKey%%, optionally
-     *  connected to %%provider%%.
-     *
-     *  If %%provider%% is not specified, only offline methods can
-     *  be used.
-     */
-    constructor(privateKey: SigningKey, provider?: null | Provider) {
-        super(provider);
-
-        assertArgument(privateKey && typeof(privateKey.sign) === "function", "invalid private key", "privateKey", "[ REDACTED ]");
-
-        this.#signingKey = privateKey;
-
-        const address = computeAddress(this.signingKey.publicKey);
-        defineProperties<BaseWallet>(this, { address });
-    }
-
-    // Store private values behind getters to reduce visibility
-    // in console.log
-
-    /**
-     *  The [[SigningKey]] used for signing payloads.
-     */
-    get signingKey(): SigningKey { return this.#signingKey; }
-
-    /**
-     *  The private key for this wallet.
-     */
-    get privateKey(): string { return this.signingKey.privateKey; }
-
-    async getAddress(): Promise<string> { return this.address; }
-
-    connect(provider: null | Provider): BaseWallet {
-        return new BaseWallet(this.#signingKey, provider);
-    }
-
-    async signTransaction(tx: TransactionRequest): Promise<string> {
-        tx = copyRequest(tx);
-
-        // Replace any Addressable or ENS name with an address
-        const { to, from } = await resolveProperties({
-            to: (tx.to ? resolveAddress(tx.to, this): undefined),
-            from: (tx.from ? resolveAddress(tx.from, this): undefined)
-        });
-
-        if (to != null) { tx.to = to; }
-        if (from != null) { tx.from = from; }
-
-        if (tx.from != null) {
-            assertArgument(getAddress(<string>(tx.from)) === this.address,
-                "transaction from address mismatch", "tx.from", tx.from);
-            delete tx.from;
-        }
-
-        // Build the transaction
-        const btx = Transaction.from(<TransactionLike<string>>tx);
-        btx.signature = this.signingKey.sign(btx.unsignedHash);
-
-        return btx.serialized;
-    }
-
-    async signMessage(message: string | Uint8Array): Promise<string> {
-        return this.signMessageSync(message);
-    }
-
-    // @TODO: Add a secialized signTx and signTyped sync that enforces
-    // all parameters are known?
-    /**
-     *  Returns the signature for %%message%% signed with this wallet.
-     */
-    signMessageSync(message: string | Uint8Array): string {
-        return this.signingKey.sign(hashMessage(message)).serialized;
-    }
-
-    /**
-     *  Returns the Authorization for %%auth%%.
-     */
-    authorizeSync(auth: AuthorizationRequest): Authorization {
-        assertArgument(typeof(auth.address) === "string",
-          "invalid address for authorizeSync", "auth.address", auth);
-
-        const signature = this.signingKey.sign(hashAuthorization(auth));
-        return Object.assign({ }, {
-            address: getAddress(auth.address),
-            nonce: getBigInt(auth.nonce || 0),
-            chainId: getBigInt(auth.chainId || 0),
-        }, { signature });
-    }
-
-    /**
-     *  Resolves to the Authorization for %%auth%%.
-     */
-    async authorize(auth: AuthorizationRequest): Promise<Authorization> {
-        auth = Object.assign({ }, auth, {
-            address: await resolveAddress(auth.address, this)
-        });
-        return this.authorizeSync(await this.populateAuthorization(auth));
-    }
-
-    async signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string> {
-
-        // Populate any ENS names
-        const populated = await TypedDataEncoder.resolveNames(domain, types, value, async (name: string) => {
-            // @TODO: this should use resolveName; addresses don't
-            //        need a provider
-
-            assert(this.provider != null, "cannot resolve ENS names without a provider", "UNSUPPORTED_OPERATION", {
-                operation: "resolveName",
-                info: { name }
-            });
-
-            const address = await this.provider.resolveName(name);
-            assert(address != null, "unconfigured ENS name", "UNCONFIGURED_NAME", {
-                value: name
-            });
-
-            return address;
-        });
-
-        return this.signingKey.sign(TypedDataEncoder.hash(populated.domain, types, populated.value)).serialized;
-    }
-}

package/src.ts/wallet/index.ts

@@ -1,32 +0,0 @@
-/**
- *  When interacting with Ethereum, it is necessary to use a private
- *  key authenticate actions by signing a payload.
- *
- *  Wallets are the simplest way to expose the concept of an
- *  //Externally Owner Account// (EOA) as it wraps a private key
- *  and supports high-level methods to sign common types of interaction
- *  and send transactions.
- *
- *  The class most developers will want to use is [[Wallet]], which
- *  can load a private key directly or from any common wallet format.
- *
- *  The [[HDNodeWallet]] can be used when it is necessary to access
- *  low-level details of how an HD wallets are derived, exported
- *  or imported.
- *
- *  @_section: api/wallet:Wallets  [about-wallets]
- */
-
-export { BaseWallet } from "./base-wallet.js";
-
-export {
-    isKeystoreJson,
-    decryptKeystoreJsonSync, encryptKeystoreJsonSync
-} from "./json-keystore.js";
-
-export { Wallet } from "./wallet.js";
-
-
-export type {
-    KeystoreAccount
-} from "./json-keystore.js"

package/src.ts/wallet/json-keystore.ts

@@ -1,108 +0,0 @@
-/**
- *  The JSON Wallet formats allow a simple way to store the private
- *  keys needed in Ethereum along with related information and allows
- *  for extensible forms of encryption.
- *
- *  These utilities facilitate decrypting and encrypting the most common
- *  JSON Wallet formats.
- *
- *  @_subsection: api/wallet:JSON Wallets  [json-wallets]
- */
-
-//import { CTR } from "aes-js";
-
-//import { getAddress } from "../address/index.js";
-//randomBytes, scrypt, scryptSync, uuidV4
-//import { keccak256  } from "../crypto/index.js";
-//import { computeAddress } from "../transaction/index.js";
-//concat, assert, assertArgument,
-import {
-    getBytes, hexlify, toUtf8String
-} from "../utils/index.js";
-
-import {SigningKey} from "../crypto/signing-key.js"
-
-//zpad
-//import { spelunk } from "./utils.js";
-
-//import type { ProgressCallback } from "../crypto/index.js";
-//import {Wallet} from "quantum-coin-js-sdk";
-//import type { BytesLike } from "../utils/index.js";
-import {Wallet, deserializeEncryptedWallet, serializeEncryptedWallet} from "quantum-coin-js-sdk";
-
-
-
-//import { version } from "../_version.js";
-
-
-//const defaultPath = "m/44'/60'/0'/0/0";
-
-/**
- *  The contents of a JSON Keystore Wallet.
- */
-export type KeystoreAccount = {
-    address: string;
-    privateKey: string;
-};
-
-/**
- *  Returns true if %%json%% is a valid JSON Keystore Wallet.
- */
-export function isKeystoreJson(json: string): boolean {
-    try {
-        const data = JSON.parse(json);
-        const version = ((data.version != null) ? parseInt(data.version): 0);
-        if (version === 3) { return true; }
-    } catch (error) { }
-    return false;
-}
-
-/**
- *  Resolves to the decrypted JSON Keystore Wallet %%json%% using the
- *  %%password%%.
- *
- *  If provided, %%progress%% will be called periodically during the
- *  decrpytion to provide feedback, and if the function returns
- *  ``false`` will halt decryption.
- */
-export function decryptKeystoreJsonSync(json: string, _password: string | Uint8Array): KeystoreAccount {
-    let pass: string;
-    if (typeof _password === 'string') {
-        pass = _password;
-    } else {
-        pass =  toUtf8String(_password);
-    }
-
-    let wal = deserializeEncryptedWallet(json, pass);
-    let privKey: any = wal.privateKey;
-
-    let ks: KeystoreAccount = {
-        address: wal.address,
-        privateKey: hexlify(privKey)
-    };
-
-    return ks;
-}
-
-/**
- *  Resolved to the JSON Keystore Wallet for %%account%% encrypted
- *  with %%password%%.
- *
- *  The %%options%% can be used to tune the password-based key
- *  derivation function parameters, explicitly set the random values
- *  used.
- */
-export function encryptKeystoreJsonSync(account: KeystoreAccount, password: Uint8Array | string): string {
-    const signingKey: SigningKey = new SigningKey(account.privateKey);
-    const privateKey: any = getBytes(signingKey.privateKey);
-    const publicKey: any = getBytes(signingKey.publicKey);
-    const wal = new Wallet(account.address, privateKey, publicKey);
-
-    if (typeof password === 'string') {
-        return serializeEncryptedWallet(wal, password);
-    } else {
-        let passPhrase = toUtf8String(password);
-        return serializeEncryptedWallet(wal, passPhrase);
-    }
-}
-

package/src.ts/wallet/utils.ts

@@ -1,147 +0,0 @@
-/**
- *  @_ignore
- */
-
-import {
-    getBytesCopy, assertArgument, toUtf8Bytes
-} from "../utils/index.js";
-
-export function looseArrayify(hexString: string): Uint8Array {
-    if (typeof(hexString) === "string" && !hexString.startsWith("0x")) {
-        hexString = "0x" + hexString;
-    }
-    return getBytesCopy(hexString);
-}
-
-export function zpad(value: String | number, length: number): String {
-    value = String(value);
-    while (value.length < length) { value = '0' + value; }
-    return value;
-}
-
-export function getPassword(password: string | Uint8Array): Uint8Array {
-    if (typeof(password) === 'string') {
-        return toUtf8Bytes(password, "NFKC");
-    }
-    return getBytesCopy(password);
-}
-
-export function spelunk<T>(object: any, _path: string): T {
-
-    const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);
-    assertArgument(match != null, "invalid path", "path", _path);
-
-    const path = match[1];
-    const type = match[3];
-    const reqd = (match[4] === "!");
-
-    let cur = object;
-    for (const comp of path.toLowerCase().split('.')) {
-
-        // Search for a child object with a case-insensitive matching key
-        if (Array.isArray(cur)) {
-            if (!comp.match(/^[0-9]+$/)) { break; }
-            cur = cur[parseInt(comp)];
-
-        } else if (typeof(cur) === "object") {
-            let found: any = null;
-            for (const key in cur) {
-                 if (key.toLowerCase() === comp) {
-                     found = cur[key];
-                     break;
-                 }
-            }
-            cur = found;
-
-        } else {
-            cur = null;
-        }
-
-        if (cur == null) { break; }
-    }
-
-    assertArgument(!reqd || cur != null, "missing required value", "path", path);
-
-    if (type && cur != null) {
-        if (type === "int") {
-            if (typeof(cur) === "string" && cur.match(/^-?[0-9]+$/)) {
-                return <T><unknown>parseInt(cur);
-            } else if (Number.isSafeInteger(cur)) {
-                return cur;
-            }
-        }
-
-        if (type === "number") {
-            if (typeof(cur) === "string" && cur.match(/^-?[0-9.]*$/)) {
-                return <T><unknown>parseFloat(cur);
-            }
-        }
-
-        if (type === "data") {
-            if (typeof(cur) === "string") { return <T><unknown>looseArrayify(cur); }
-        }
-
-        if (type === "array" && Array.isArray(cur)) { return <T><unknown>cur; }
-        if (type === typeof(cur)) { return cur; }
-
-        assertArgument(false, `wrong type found for ${ type } `, "path", path);
-    }
-
-    return cur;
-}
-/*
-export function follow(object: any, path: string): null | string {
-    let currentChild = object;
-
-    for (const comp of path.toLowerCase().split('/')) {
-
-        // Search for a child object with a case-insensitive matching key
-        let matchingChild = null;
-        for (const key in currentChild) {
-             if (key.toLowerCase() === comp) {
-                 matchingChild = currentChild[key];
-                 break;
-             }
-        }
-
-        if (matchingChild === null) { return null; }
-
-        currentChild = matchingChild;
-    }
-
-    return currentChild;
-}
-
-// "path/to/something:type!"
-export function followRequired(data: any, path: string): string {
-    const value = follow(data, path);
-    if (value != null) { return value; }
-    return logger.throwArgumentError("invalid value", `data:${ path }`,
-    JSON.stringify(data));
-}
-*/
-// See: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)
-/*
-export function uuidV4(randomBytes: BytesLike): string {
-    const bytes = getBytes(randomBytes, "randomBytes");
-
-    // Section: 4.1.3:
-    // - time_hi_and_version[12:16] = 0b0100
-    bytes[6] = (bytes[6] & 0x0f) | 0x40;
-
-    // Section 4.4
-    // - clock_seq_hi_and_reserved[6] = 0b0
-    // - clock_seq_hi_and_reserved[7] = 0b1
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
-
-    const value = hexlify(bytes);
-
-    return [
-       value.substring(2, 10),
-       value.substring(10, 14),
-       value.substring(14, 18),
-       value.substring(18, 22),
-       value.substring(22, 34),
-    ].join("-");
-}
-*/

package/src.ts/wallet/wallet.ts

@@ -1,138 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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));
-}