quantumcoin 6.14.1 → 6.14.2

package/src.ts/wallet/wallet.ts

@@ -1,26 +1,21 @@
 import { SigningKey } from "../crypto/index.js";
-import { assertArgument } from "../utils/index.js";
+import { assertArgument,hexlify } from "../utils/index.js";
 
 import { BaseWallet } from "./base-wallet.js";
-import { HDNodeWallet } from "./hdwallet.js";
-import { decryptCrowdsaleJson, isCrowdsaleJson  } from "./json-crowdsale.js";
+
+//import { decryptCrowdsaleJson, isCrowdsaleJson  } from "./json-crowdsale.js";
 import {
-    decryptKeystoreJson, decryptKeystoreJsonSync,
-    encryptKeystoreJson, encryptKeystoreJsonSync,
+    decryptKeystoreJsonSync,
+    encryptKeystoreJsonSync,
     isKeystoreJson
 } from "./json-keystore.js";
-import { Mnemonic } from "./mnemonic.js";
+//import { Mnemonic } from "./mnemonic.js";
+import qcsdk = require('quantum-coin-js-sdk');
 
-import type { ProgressCallback } from "../crypto/index.js";
 import type { Provider } from "../providers/index.js";
 
-import type { CrowdsaleAccount } from "./json-crowdsale.js";
 import type { KeystoreAccount } from "./json-keystore.js";
-
-
-function stall(duration: number): Promise<void> {
-    return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); });
-}
+//import {newWallet} from "quantum-coin-js-sdk";
 
 /**
  *  A **Wallet** manages a single private key which is used to sign
@@ -58,9 +53,9 @@ export class Wallet extends BaseWallet {
      *  If %%progressCallback%% is specified, it will receive periodic
      *  updates as the encryption process progreses.
      */
-    async encrypt(password: Uint8Array | string, progressCallback?: ProgressCallback): Promise<string> {
+    async encrypt(password: Uint8Array | string): Promise<string> {
         const account = { address: this.address, privateKey: this.privateKey };
-        return await encryptKeystoreJson(account, password, { progressCallback });
+        return encryptKeystoreJsonSync(account, password);
     }
 
     /**
@@ -78,18 +73,9 @@ export class Wallet extends BaseWallet {
         return encryptKeystoreJsonSync(account, password);
     }
 
-    static #fromAccount(account: null | CrowdsaleAccount | KeystoreAccount): HDNodeWallet | Wallet {
+    static #fromAccount(account: null | KeystoreAccount): Wallet {
         assertArgument(account, "invalid JSON wallet", "json", "[ REDACTED ]");
 
-        if ("mnemonic" in account && account.mnemonic && account.mnemonic.locale === "en") {
-            const mnemonic = Mnemonic.fromEntropy(account.mnemonic.entropy);
-            const wallet = HDNodeWallet.fromMnemonic(mnemonic, account.mnemonic.path);
-            if (wallet.address === account.address && wallet.privateKey === account.privateKey) {
-                return wallet;
-            }
-            console.log("WARNING: JSON mismatch address/privateKey != mnemonic; fallback onto private key");
-        }
-
         const wallet = new Wallet(account.privateKey);
 
         assertArgument(wallet.address === account.address,
@@ -101,19 +87,11 @@ export class Wallet extends BaseWallet {
     /**
      *  Creates (asynchronously) a **Wallet** by decrypting the %%json%%
      *  with %%password%%.
-     *
-     *  If %%progress%% is provided, it is called periodically during
-     *  decryption so that any UI can be updated.
      */
-    static async fromEncryptedJson(json: string, password: Uint8Array | string, progress?: ProgressCallback): Promise<HDNodeWallet | Wallet> {
-        let account: null | CrowdsaleAccount | KeystoreAccount = null;
+    static async fromEncryptedJson(json: string, password: Uint8Array | string): Promise<Wallet> {
+        let account: null | KeystoreAccount = null;
         if (isKeystoreJson(json)) {
-            account = await decryptKeystoreJson(json, password, progress);
-
-        } else if (isCrowdsaleJson(json)) {
-            if (progress) { progress(0); await stall(0); }
-            account = decryptCrowdsaleJson(json, password);
-            if (progress) { progress(1); await stall(0); }
+            account = decryptKeystoreJsonSync(json, password);
 
         }
 
@@ -127,12 +105,10 @@ export class Wallet extends BaseWallet {
      *  will lock up and freeze the UI during decryption, which may take
      *  some time.
      */
-    static fromEncryptedJsonSync(json: string, password: Uint8Array | string): HDNodeWallet | Wallet {
-        let account: null | CrowdsaleAccount | KeystoreAccount = null;
+    static fromEncryptedJsonSync(json: string, password: Uint8Array | string): Wallet {
+        let account: null | KeystoreAccount = null;
         if (isKeystoreJson(json)) {
             account = decryptKeystoreJsonSync(json, password);
-        } else if (isCrowdsaleJson(json)) {
-            account = decryptCrowdsaleJson(json, password);
         } else {
             assertArgument(false, "invalid JSON wallet", "json", "[ REDACTED ]");
         }
@@ -141,23 +117,23 @@ export class Wallet extends BaseWallet {
     }
 
     /**
-     *  Creates a new random [[HDNodeWallet]] using the available
+     *  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): HDNodeWallet {
-        const wallet = HDNodeWallet.createRandom();
-        if (provider) { return wallet.connect(provider); }
-        return wallet;
+    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;
-    }
+    }*/
 }

package/src.ts/providers/provider-alchemy.ts

@@ -1,166 +0,0 @@
-/**
- *  [[link-alchemy]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Arbitrum (``arbitrum``)
- *  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
- *  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
- *  - Base (``base``)
- *  - Base Goerlia Testnet (``base-goerli``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *  - Polygon Amoy Testnet (``matic-amoy``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *
- *  @_subsection: api/providers/thirdparty:Alchemy  [providers-alchemy]
- */
-
-import {
-    defineProperties, resolveProperties, assert, assertArgument,
-    FetchRequest
-} from "../utils/index.js";
-
-import { showThrottleMessage } from "./community.js";
-import { Network } from "./network.js";
-import { JsonRpcProvider } from "./provider-jsonrpc.js";
-
-import type { AbstractProvider, PerformActionRequest } from "./abstract-provider.js";
-import type { CommunityResourcable } from "./community.js";
-import type { Networkish } from "./network.js";
-
-
-const defaultApiKey = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC"
-
-function getHost(name: string): string {
-    switch(name) {
-        case "mainnet":
-            return "eth-mainnet.alchemyapi.io";
-        case "goerli":
-            return "eth-goerli.g.alchemy.com";
-        case "sepolia":
-            return "eth-sepolia.g.alchemy.com";
-
-        case "arbitrum":
-            return "arb-mainnet.g.alchemy.com";
-        case "arbitrum-goerli":
-            return "arb-goerli.g.alchemy.com";
-        case "arbitrum-sepolia":
-            return "arb-sepolia.g.alchemy.com";
-        case "base":
-            return "base-mainnet.g.alchemy.com";
-        case "base-goerli":
-            return "base-goerli.g.alchemy.com";
-        case "base-sepolia":
-            return "base-sepolia.g.alchemy.com";
-        case "matic":
-            return "polygon-mainnet.g.alchemy.com";
-        case "matic-amoy":
-            return "polygon-amoy.g.alchemy.com";
-        case "matic-mumbai":
-            return "polygon-mumbai.g.alchemy.com";
-        case "optimism":
-            return "opt-mainnet.g.alchemy.com";
-        case "optimism-goerli":
-            return "opt-goerli.g.alchemy.com";
-        case "optimism-sepolia":
-            return "opt-sepolia.g.alchemy.com";
-    }
-
-    assertArgument(false, "unsupported network", "network", name);
-}
-
-/**
- *  The **AlchemyProvider** connects to the [[link-alchemy]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-alchemy-signup).
- *
- *  @_docloc: api/providers/thirdparty
- */
-export class AlchemyProvider extends JsonRpcProvider implements CommunityResourcable {
-    readonly apiKey!: string;
-
-    constructor(_network?: Networkish, apiKey?: null | string) {
-        if (_network == null) { _network = "mainnet"; }
-        const network = Network.from(_network);
-        if (apiKey == null) { apiKey = defaultApiKey; }
-
-        const request = AlchemyProvider.getRequest(network, apiKey);
-        super(request, network, { staticNetwork: network });
-
-        defineProperties<AlchemyProvider>(this, { apiKey });
-    }
-
-    _getProvider(chainId: number): AbstractProvider {
-        try {
-            return new AlchemyProvider(chainId, this.apiKey);
-        } catch (error) { }
-        return super._getProvider(chainId);
-    }
-
-    async _perform(req: PerformActionRequest): Promise<any> {
-
-        // https://docs.alchemy.com/reference/trace-transaction
-        if (req.method === "getTransactionResult") {
-            const { trace, tx } = await resolveProperties({
-                trace: this.send("trace_transaction", [ req.hash ]),
-                tx: this.getTransaction(req.hash)
-            });
-            if (trace == null || tx == null) { return null; }
-
-            let data: undefined | string;
-            let error = false;
-            try {
-                data = trace[0].result.output;
-                error = (trace[0].error === "Reverted");
-            } catch (error) { }
-
-            if (data) {
-                assert(!error, "an error occurred during transaction executions", "CALL_EXCEPTION", {
-                    action: "getTransactionResult",
-                    data,
-                    reason: null,
-                    transaction: tx,
-                    invocation: null,
-                    revert: null // @TODO
-                });
-                return data;
-            }
-
-            assert(false, "could not parse trace result", "BAD_DATA", { value: trace });
-        }
-
-        return await super._perform(req);
-    }
-
-    isCommunityResource(): boolean {
-        return (this.apiKey === defaultApiKey);
-    }
-
-    static getRequest(network: Network, apiKey?: string): FetchRequest {
-        if (apiKey == null) { apiKey = defaultApiKey; }
-
-        const request = new FetchRequest(`https:/\/${ getHost(network.name) }/v2/${ apiKey }`);
-        request.allowGzip = true;
-
-        if (apiKey === defaultApiKey) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("alchemy");
-                return true;
-            }
-        }
-
-        return request;
-    }
-}

package/src.ts/providers/provider-ankr.ts

@@ -1,153 +0,0 @@
-/**
- *  [[link-ankr]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Arbitrum (``arbitrum``)
- *  - Base (``base``)
- *  - Base Goerlia Testnet (``base-goerli``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - BNB (``bnb``)
- *  - BNB Testnet (``bnbt``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *
- *  @_subsection: api/providers/thirdparty:Ankr  [providers-ankr]
- */
-import {
-    defineProperties, FetchRequest, assertArgument
-} from "../utils/index.js";
-
-import { AbstractProvider } from "./abstract-provider.js";
-import { showThrottleMessage } from "./community.js";
-import { Network } from "./network.js";
-import { JsonRpcProvider } from "./provider-jsonrpc.js";
-
-import type { CommunityResourcable } from "./community.js";
-import type { Networkish } from "./network.js";
-import type { JsonRpcError, JsonRpcPayload } from "./provider-jsonrpc.js";
-
-
-const defaultApiKey = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972";
-
-function getHost(name: string): string {
-    switch (name) {
-        case "mainnet":
-            return "rpc.ankr.com/eth";
-        case "goerli":
-            return "rpc.ankr.com/eth_goerli";
-        case "sepolia":
-            return "rpc.ankr.com/eth_sepolia";
-
-        case "arbitrum":
-            return "rpc.ankr.com/arbitrum";
-        case "base":
-            return "rpc.ankr.com/base";
-        case "base-goerli":
-            return "rpc.ankr.com/base_goerli";
-        case "base-sepolia":
-            return "rpc.ankr.com/base_sepolia";
-        case "bnb":
-            return "rpc.ankr.com/bsc";
-        case "bnbt":
-            return "rpc.ankr.com/bsc_testnet_chapel";
-        case "matic":
-            return "rpc.ankr.com/polygon";
-        case "matic-mumbai":
-            return "rpc.ankr.com/polygon_mumbai";
-        case "optimism":
-            return "rpc.ankr.com/optimism";
-        case "optimism-goerli":
-            return "rpc.ankr.com/optimism_testnet";
-        case "optimism-sepolia":
-            return "rpc.ankr.com/optimism_sepolia";
-    }
-
-    assertArgument(false, "unsupported network", "network", name);
-}
-
-
-/**
- *  The **AnkrProvider** connects to the [[link-ankr]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-ankr-signup).
- */
-export class AnkrProvider extends JsonRpcProvider implements CommunityResourcable {
-
-    /**
-     *  The API key for the Ankr connection.
-     */
-    readonly apiKey!: string;
-
-    /**
-     *  Create a new **AnkrProvider**.
-     *
-     *  By default connecting to ``mainnet`` with a highly throttled
-     *  API key.
-     */
-    constructor(_network?: Networkish, apiKey?: null | string) {
-        if (_network == null) { _network = "mainnet"; }
-        const network = Network.from(_network);
-        if (apiKey == null) { apiKey = defaultApiKey; }
-
-        // Ankr does not support filterId, so we force polling
-        const options = { polling: true, staticNetwork: network };
-
-        const request = AnkrProvider.getRequest(network, apiKey);
-        super(request, network, options);
-
-        defineProperties<AnkrProvider>(this, { apiKey });
-    }
-
-    _getProvider(chainId: number): AbstractProvider {
-        try {
-            return new AnkrProvider(chainId, this.apiKey);
-        } catch (error) { }
-        return super._getProvider(chainId);
-    }
-
-    /**
-     *  Returns a prepared request for connecting to %%network%% with
-     *  %%apiKey%%.
-     */
-    static getRequest(network: Network, apiKey?: null | string): FetchRequest {
-        if (apiKey == null) { apiKey = defaultApiKey; }
-
-        const request = new FetchRequest(`https:/\/${ getHost(network.name) }/${ apiKey }`);
-        request.allowGzip = true;
-
-        if (apiKey === defaultApiKey) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("AnkrProvider");
-                return true;
-            };
-        }
-
-        return request;
-    }
-
-    getRpcError(payload: JsonRpcPayload, error: JsonRpcError): Error {
-        if (payload.method === "eth_sendRawTransaction") {
-            if (error && error.error && error.error.message === "INTERNAL_ERROR: could not replace existing tx") {
-                error.error.message = "replacement transaction underpriced";
-            }
-        }
-
-        return super.getRpcError(payload, error);
-    }
-
-    isCommunityResource(): boolean {
-        return (this.apiKey === defaultApiKey);
-    }
-}

package/src.ts/providers/provider-blockscout.ts

@@ -1,167 +0,0 @@
-
-/**
- *  [[link-blockscout]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Holesky Testnet (``holesky``)
- *  - Ethereum Classic (``classic``)
- *  - Arbitrum (``arbitrum``)
- *  - Base (``base``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - Gnosis (``xdai``)
- *  - Optimism (``optimism``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *
- *  @_subsection: api/providers/thirdparty:Blockscout  [providers-blockscout]
- */
-import {
-    assertArgument, defineProperties, FetchRequest, isHexString
-} from "../utils/index.js";
-
-import { Network } from "./network.js";
-import { JsonRpcProvider } from "./provider-jsonrpc.js";
-
-import type { AbstractProvider, PerformActionRequest } from "./abstract-provider.js";
-import type { CommunityResourcable } from "./community.js";
-import type { Networkish } from "./network.js";
-import type { JsonRpcPayload, JsonRpcError } from "./provider-jsonrpc.js";
-
-
-function getUrl(name: string): string {
-    switch(name) {
-        case "mainnet":
-            return "https:/\/eth.blockscout.com/api/eth-rpc";
-        case "sepolia":
-            return "https:/\/eth-sepolia.blockscout.com/api/eth-rpc";
-        case "holesky":
-            return "https:/\/eth-holesky.blockscout.com/api/eth-rpc";
-
-        case "classic":
-            return "https:/\/etc.blockscout.com/api/eth-rpc";
-
-        case "arbitrum":
-            return "https:/\/arbitrum.blockscout.com/api/eth-rpc";
-
-        case "base":
-            return "https:/\/base.blockscout.com/api/eth-rpc";
-        case "base-sepolia":
-            return "https:/\/base-sepolia.blockscout.com/api/eth-rpc";
-
-        case "matic":
-            return "https:/\/polygon.blockscout.com/api/eth-rpc";
-
-        case "optimism":
-            return "https:/\/optimism.blockscout.com/api/eth-rpc";
-        case "optimism-sepolia":
-            return "https:/\/optimism-sepolia.blockscout.com/api/eth-rpc";
-
-        case "xdai":
-            return "https:/\/gnosis.blockscout.com/api/eth-rpc";
-    }
-
-    assertArgument(false, "unsupported network", "network", name);
-}
-
-
-/**
- *  The **BlockscoutProvider** connects to the [[link-blockscout]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-blockscout).
- */
-export class BlockscoutProvider extends JsonRpcProvider implements CommunityResourcable {
-    /**
-     *  The API key.
-     */
-    readonly apiKey!: null | string;
-
-    /**
-     *  Creates a new **BlockscoutProvider**.
-     */
-    constructor(_network?: Networkish, apiKey?: null | string) {
-        if (_network == null) { _network = "mainnet"; }
-        const network = Network.from(_network);
-
-        if (apiKey == null) { apiKey = null; }
-
-        const request = BlockscoutProvider.getRequest(network);
-        super(request, network, { staticNetwork: network });
-
-        defineProperties<BlockscoutProvider>(this, { apiKey });
-    }
-
-    _getProvider(chainId: number): AbstractProvider {
-        try {
-            return new BlockscoutProvider(chainId, this.apiKey);
-        } catch (error) { }
-        return super._getProvider(chainId);
-    }
-
-    isCommunityResource(): boolean {
-        return (this.apiKey === null);
-    }
-
-    getRpcRequest(req: PerformActionRequest): null | { method: string, args: Array<any> } {
-        // Blockscout enforces the TAG argument for estimateGas
-        const resp = super.getRpcRequest(req);
-        if (resp && resp.method === "eth_estimateGas" && resp.args.length == 1) {
-            resp.args = resp.args.slice();
-            resp.args.push("latest");
-        }
-        return resp;
-    }
-
-    getRpcError(payload: JsonRpcPayload, _error: JsonRpcError): Error {
-        const error = _error ? _error.error: null;
-
-        // Blockscout currently drops the VM result and replaces it with a
-        // human-readable string, so we need to make it machine-readable.
-        if (error && error.code === -32015 && !isHexString(error.data || "", true)) {
-            const panicCodes = <Record<string, string>>{
-                "assert(false)": "01",
-                "arithmetic underflow or overflow": "11",
-                "division or modulo by zero": "12",
-                "out-of-bounds array access; popping on an empty array": "31",
-                "out-of-bounds access of an array or bytesN": "32"
-            };
-
-            let panicCode = "";
-            if (error.message === "VM execution error.") {
-                // eth_call passes this message
-                panicCode = panicCodes[error.data] || "";
-            } else if (panicCodes[error.message || ""]) {
-                panicCode = panicCodes[error.message || ""];
-            }
-
-            if (panicCode) {
-                error.message += ` (reverted: ${ error.data })`;
-                error.data = "0x4e487b7100000000000000000000000000000000000000000000000000000000000000" + panicCode;
-            }
-
-        } else if (error && error.code === -32000) {
-            if (error.message === "wrong transaction nonce") {
-                error.message += " (nonce too low)";
-            }
-        }
-
-        return super.getRpcError(payload, _error);
-    }
-
-    /**
-     *  Returns a prepared request for connecting to %%network%%
-     *  with %%apiKey%%.
-     */
-    static getRequest(network: Network): FetchRequest {
-        const request = new FetchRequest(getUrl(network.name));
-        request.allowGzip = true;
-        return request;
-    }
-}