quantumcoin 6.14.1 → 6.14.2

package/src.ts/crypto/signature.ts

@@ -1,21 +1,21 @@
 
 import { ZeroHash } from "../constants/index.js";
 import {
-    concat, dataLength, getBigInt, getBytes, getNumber, hexlify,
-    toBeArray, isHexString, zeroPadValue,
+    //isHexString,     toBeArray, zeroPadValue,
+    concat, getBigInt, getBytes, getNumber, hexlify,
     assertArgument, assertPrivate
 } from "../utils/index.js";
 
 import type {
-    BigNumberish, BytesLike, Numeric
+    //Numeric
+    BigNumberish, BytesLike,
 } from "../utils/index.js";
 
 
 // Constants
 const BN_0 = BigInt(0);
-const BN_1 = BigInt(1);
+//const BN_1 = BigInt(1);
 const BN_2 = BigInt(2);
-const BN_27 = BigInt(27);
 const BN_28 = BigInt(28);
 const BN_35 = BigInt(35);
 
@@ -33,25 +33,19 @@ export type SignatureLike = Signature | string | {
     r: string;
     s: string;
     v: BigNumberish;
-    yParity?: 0 | 1;
-    yParityAndS?: string;
 } | {
     r: string;
-    yParityAndS: string;
-    yParity?: 0 | 1;
     s?: string;
     v?: number;
 } | {
     r: string;
     s: string;
-    yParity: 0 | 1;
     v?: BigNumberish;
-    yParityAndS?: string;
 };
-
+/*
 function toUint256(value: BigNumberish): string {
     return zeroPadValue(toBeArray(value), 32);
-}
+}*/
 
 /**
  *  A Signature  @TODO
@@ -62,7 +56,7 @@ function toUint256(value: BigNumberish): string {
 export class Signature {
     #r: string;
     #s: string;
-    #v: 27 | 28;
+    #v: 28;
     #networkV: null | bigint;
 
     /**
@@ -73,7 +67,6 @@ export class Signature {
      */
     get r(): string { return this.#r; }
     set r(value: BytesLike) {
-        assertArgument(dataLength(value) === 32, "invalid r", "value", value);
         this.#r = hexlify(value);
     }
 
@@ -82,9 +75,7 @@ export class Signature {
      */
     get s(): string { return this.#s; }
     set s(_value: BytesLike) {
-        assertArgument(dataLength(_value) === 32, "invalid s", "value", _value);
         const value = hexlify(_value);
-        assertArgument(parseInt(value.substring(0, 3)) < 8, "non-canonical s", "value", value);
         this.#s = value;
     }
 
@@ -95,13 +86,13 @@ export class Signature {
      *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
      *  values to use.
      *
-     *  It is normalized to the values ``27`` or ``28`` for legacy
+     *  It is normalized to the values ``28`` or ``28`` for legacy
      *  purposes.
      */
-    get v(): 27 | 28 { return this.#v; }
+    get v(): 28 | 28 { return this.#v; }
     set v(value: BigNumberish) {
         const v = getNumber(value, "value");
-        assertArgument(v === 27 || v === 28, "invalid v", "v", value);
+        assertArgument(v === 28, "invalid v", "v", value);
         this.#v = v;
     }
 
@@ -127,7 +118,7 @@ export class Signature {
      *  See ``v`` for more details on how this value is used.
      */
     get yParity(): 0 | 1 {
-        return (this.v === 27) ? 0: 1;
+        return (this.v === 28) ? 0: 1;
     }
 
     /**
@@ -158,7 +149,7 @@ export class Signature {
     /**
      *  @private
      */
-    constructor(guard: any, r: string, s: string, v: 27 | 28) {
+    constructor(guard: any, r: string, s: string, v: 28) {
         assertPrivate(guard, _guard, "Signature");
         this.#r = r;
         this.#s = s;
@@ -205,7 +196,7 @@ export class Signature {
         const bv = getBigInt(v, "v");
 
         // The v is not an EIP-155 v, so it is the unspecified chain ID
-        if ((bv == BN_27) || (bv == BN_28)) { return BN_0; }
+        if ((bv == BN_28) || (bv == BN_28)) { return BN_0; }
 
         // Bad value for an EIP-155 v
         assertArgument(bv >= BN_35, "invalid EIP-155 v", "v", v);
@@ -220,15 +211,13 @@ export class Signature {
      *  property to include the chain ID.
      *
      *  @example:
-     *    Signature.getChainIdV(5, 27)
-     *    //_result:
      *
      *    Signature.getChainIdV(5, 28)
      *    //_result:
      *
      */
-    static getChainIdV(chainId: BigNumberish, v: 27 | 28): bigint {
-        return (getBigInt(chainId) * BN_2) + BigInt(35 + v - 27);
+    static getChainIdV(chainId: BigNumberish, v: 28): bigint {
+        return (getBigInt(chainId) * BN_2) + BigInt(35 + v - 28);
     }
 
     /**
@@ -240,10 +229,6 @@ export class Signature {
      *    Signature.getNormalizedV(0)
      *    //_result:
      *
-     *    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
-     *    Signature.getNormalizedV(27)
-     *    //_result:
-     *
      *    // Legacy EIP-155 transaction (i.e. >= 35)
      *    Signature.getNormalizedV(46)
      *    //_result:
@@ -252,17 +237,16 @@ export class Signature {
      *    Signature.getNormalizedV(5)
      *    //_error:
      */
-    static getNormalizedV(v: BigNumberish): 27 | 28 {
+    /*static getNormalizedV(v: BigNumberish): 28 {
         const bv = getBigInt(v);
 
-        if (bv === BN_0 || bv === BN_27) { return 27; }
         if (bv === BN_1 || bv === BN_28) { return 28; }
 
         assertArgument(bv >= BN_35, "invalid v", "v", v);
 
-        // Otherwise, EIP-155 v means odd is 27 and even is 28
-        return (bv & BN_1) ? 27: 28;
-    }
+        // Otherwise, EIP-155 v means odd is 28 and even is 28
+        return (bv & BN_1) ? 28: 28;
+    }*/
 
     /**
      *  Creates a new [[Signature]].
@@ -278,15 +262,15 @@ export class Signature {
         };
 
         if (sig == null) {
-            return new Signature(_guard, ZeroHash, ZeroHash, 27);
+            return new Signature(_guard, ZeroHash, ZeroHash, 28);
         }
 
         if (typeof(sig) === "string") {
-            const bytes = getBytes(sig, "signature");
+            /*const bytes = getBytes(sig, "signature");
             if (bytes.length === 64) {
                 const r = hexlify(bytes.slice(0, 32));
                 const s = bytes.slice(32, 64);
-                const v = (s[0] & 0x80) ? 28: 27;
+                const v = (s[0] & 0x80) ? 28: 28;
                 s[0] &= 0x7f;
                 return new Signature(_guard, r, hexlify(s), v);
             }
@@ -297,14 +281,16 @@ export class Signature {
                 assertError((s[0] & 0x80) === 0, "non-canonical s");
                 const v = Signature.getNormalizedV(bytes[64]);
                 return new Signature(_guard, r, hexlify(s), v);
-            }
+            }*/
 
             assertError(false, "invalid raw signature length");
         }
 
         if (sig instanceof Signature) { return sig.clone(); }
 
-        // Get r
+        return new Signature(_guard, ZeroHash, ZeroHash, 28); //todo
+
+        /*// Get r
         const _r = sig.r;
         assertError(_r != null, "missing r");
         const r = toUint256(_r);
@@ -325,7 +311,7 @@ export class Signature {
         assertError((getBytes(s)[0] & 0x80) == 0, "non-canonical s");
 
         // Get v; by any means necessary (we check consistency below)
-        const { networkV, v } = (function(_v?: BigNumberish, yParityAndS?: string, yParity?: Numeric): { networkV?: bigint, v: 27 | 28 } {
+        const { networkV, v } = (function(_v?: BigNumberish, yParityAndS?: string, yParity?: Numeric): { networkV?: bigint, v: 28 | 28 } {
             if (_v != null) {
                 const v = getBigInt(_v);
                 return {
@@ -336,12 +322,12 @@ export class Signature {
 
             if (yParityAndS != null) {
                 assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-                return { v: ((getBytes(yParityAndS)[0] & 0x80) ? 28: 27) };
+                return { v: ((getBytes(yParityAndS)[0] & 0x80) ? 28: 28) };
             }
 
             if (yParity != null) {
                 switch (getNumber(yParity, "sig.yParity")) {
-                    case 0: return { v: 27 };
+                    case 0: return { v: 28 };
                     case 1: return { v: 28 };
                 }
                 assertError(false, "invalid yParity");
@@ -357,7 +343,7 @@ export class Signature {
         assertError(sig.yParity == null || getNumber(sig.yParity, "sig.yParity") === result.yParity, "yParity mismatch");
         assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, "yParityAndS mismatch");
 
-        return result;
+        return result;*/
     }
 }
 

package/src.ts/crypto/signing-key.ts

@@ -4,10 +4,12 @@
  *  @_subsection: api/crypto:Signing  [about-signing]
  */
 
-import { secp256k1 } from "@noble/curves/secp256k1";
+import pqc = require('quantum-coin-pqc-js-sdk');
+import qcsdk = require('quantum-coin-js-sdk');
 
 import {
-    concat, dataLength, getBytes, getBytesCopy, hexlify, toBeHex,
+    getBytes,
+    dataLength, getBytesCopy, hexlify,
     assertArgument
 } from "../utils/index.js";
 
@@ -17,10 +19,12 @@ import type { BytesLike } from "../utils/index.js";
 
 import type { SignatureLike } from "./index.js";
 
+const CRYPTO_MESSAGE_LENGTH = 32;
+const CRYPTO_SECRETKEY_BYTES = 64 + 2560 + 1312 + 128;
+//const CRYPTO_PUBLICKEY_BYTES = 32 + 1312 + 64;
 
 /**
- *  A **SigningKey** provides high-level access to the elliptic curve
- *  cryptography (ECC) operations and key management.
+ *  A **SigningKey** provides high-level access to cryptography operations and key management.
  */
 export class SigningKey {
     #privateKey: string;
@@ -29,7 +33,7 @@ export class SigningKey {
      *  Creates a new **SigningKey** for %%privateKey%%.
      */
     constructor(privateKey: BytesLike) {
-        assertArgument(dataLength(privateKey) === 32, "invalid private key", "privateKey", "[REDACTED]");
+        assertArgument(dataLength(privateKey) === CRYPTO_SECRETKEY_BYTES, "invalid private key", "privateKey", "[REDACTED]");
         this.#privateKey = hexlify(privateKey);
     }
 
@@ -39,110 +43,46 @@ export class SigningKey {
     get privateKey(): string { return this.#privateKey; }
 
     /**
-     *  The uncompressed public key.
+     *  The public key.
      *
-     * This will always begin with the prefix ``0x04`` and be 132
-     * characters long (the ``0x`` prefix and 130 hexadecimal nibbles).
      */
     get publicKey(): string { return SigningKey.computePublicKey(this.#privateKey); }
 
-    /**
-     *  The compressed public key.
-     *
-     *  This will always begin with either the prefix ``0x02`` or ``0x03``
-     *  and be 68 characters long (the ``0x`` prefix and 33 hexadecimal
-     *  nibbles)
-     */
-    get compressedPublicKey(): string { return SigningKey.computePublicKey(this.#privateKey, true); }
-
     /**
      *  Return the signature of the signed %%digest%%.
      */
     sign(digest: BytesLike): Signature {
-        assertArgument(dataLength(digest) === 32, "invalid digest length", "digest", digest);
+        assertArgument(dataLength(digest) === CRYPTO_MESSAGE_LENGTH, "invalid digest length", "digest", digest);
 
-        const sig = secp256k1.sign(getBytesCopy(digest), getBytesCopy(this.#privateKey), {
-            lowS: true
-        });
+        const sig: any = pqc.cryptoSign(getBytesCopy(digest), getBytesCopy(this.#privateKey));
+        const pubBytes: any = getBytes(this.publicKey);
+        const combinedSig = qcsdk.combinePublicKeySignature(pubBytes, sig);
 
         return Signature.from({
-            r: toBeHex(sig.r, 32),
-            s: toBeHex(sig.s, 32),
-            v: (sig.recovery ? 0x1c: 0x1b)
+            r: this.publicKey,
+            s: combinedSig,
+            v: 0x1
         });
     }
 
     /**
-     *  Returns the [[link-wiki-ecdh]] shared secret between this
-     *  private key and the %%other%% key.
-     *
-     *  The %%other%% key may be any type of key, a raw public key,
-     *  a compressed/uncompressed pubic key or aprivate key.
-     *
-     *  Best practice is usually to use a cryptographic hash on the
-     *  returned value before using it as a symetric secret.
-     *
-     *  @example:
-     *    sign1 = new SigningKey(id("some-secret-1"))
-     *    sign2 = new SigningKey(id("some-secret-2"))
-     *
-     *    // Notice that privA.computeSharedSecret(pubB)...
-     *    sign1.computeSharedSecret(sign2.publicKey)
-     *    //_result:
-     *
-     *    // ...is equal to privB.computeSharedSecret(pubA).
-     *    sign2.computeSharedSecret(sign1.publicKey)
-     *    //_result:
-     */
-    computeSharedSecret(other: BytesLike): string {
-        const pubKey = SigningKey.computePublicKey(other);
-        return hexlify(secp256k1.getSharedSecret(getBytesCopy(this.#privateKey), getBytes(pubKey), false));
-    }
-
-    /**
-     *  Compute the public key for %%key%%, optionally %%compressed%%.
+     *  Compute the public key for a private %%key%%.
      *
-     *  The %%key%% may be any type of key, a raw public key, a
-     *  compressed/uncompressed public key or private key.
      *
      *  @example:
      *    sign = new SigningKey(id("some-secret"));
      *
-     *    // Compute the uncompressed public key for a private key
+     *    // Compute the public key for a private key
      *    SigningKey.computePublicKey(sign.privateKey)
      *    //_result:
-     *
-     *    // Compute the compressed public key for a private key
-     *    SigningKey.computePublicKey(sign.privateKey, true)
-     *    //_result:
-     *
-     *    // Compute the uncompressed public key
-     *    SigningKey.computePublicKey(sign.publicKey, false);
-     *    //_result:
-     *
-     *    // Compute the Compressed a public key
-     *    SigningKey.computePublicKey(sign.publicKey, true);
-     *    //_result:
      */
-    static computePublicKey(key: BytesLike, compressed?: boolean): string {
-        let bytes = getBytes(key, "key");
-
-        // private key
-        if (bytes.length === 32) {
-            const pubKey = secp256k1.getPublicKey(bytes, !!compressed);
-            return hexlify(pubKey);
-        }
-
-        // raw public key; use uncompressed key with 0x04 prefix
-        if (bytes.length === 64) {
-            const pub = new Uint8Array(65);
-            pub[0] = 0x04;
-            pub.set(bytes, 1);
-            bytes = pub;
-        }
-
-        const point = secp256k1.ProjectivePoint.fromHex(bytes);
-        return hexlify(point.toRawBytes(compressed));
+    static computePublicKey(key: BytesLike): string {
+        assertArgument(dataLength(key) === CRYPTO_SECRETKEY_BYTES, "invalid private key", "privateKey", "[REDACTED]");
+        let priBytes: any = getBytes(key, "key");
+
+        let pubKey = qcsdk.publicKeyFromPrivateKey(priBytes);
+
+        return pubKey;
     }
 
     /**
@@ -164,33 +104,15 @@ export class SigningKey {
      *
      */
     static recoverPublicKey(digest: BytesLike, signature: SignatureLike): string {
-        assertArgument(dataLength(digest) === 32, "invalid digest length", "digest", digest);
+        assertArgument(dataLength(digest) === CRYPTO_MESSAGE_LENGTH, "invalid digest length", "digest", digest);
 
         const sig = Signature.from(signature);
+        let sigBytes: any = getBytes(sig.s);
+        let digestBytes: any = digest;
 
-        let secpSig = secp256k1.Signature.fromCompact(getBytesCopy(concat([ sig.r, sig.s ])));
-        secpSig = secpSig.addRecoveryBit(sig.yParity);
-
-        const pubKey = secpSig.recoverPublicKey(getBytesCopy(digest));
-        assertArgument(pubKey != null, "invalid signature for digest", "signature", signature);
-
-        return "0x" + pubKey.toHex(false);
-    }
+        let publicKey = qcsdk.publicKeyFromSignature(digestBytes, sigBytes);
 
-    /**
-     *  Returns the point resulting from adding the ellipic curve points
-     *  %%p0%% and %%p1%%.
-     *
-     *  This is not a common function most developers should require, but
-     *  can be useful for certain privacy-specific techniques.
-     *
-     *  For example, it is used by [[HDNodeWallet]] to compute child
-     *  addresses from parent public keys and chain codes.
-     */
-    static addPoints(p0: BytesLike, p1: BytesLike, compressed?: boolean): string {
-        const pub0 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p0).substring(2));
-        const pub1 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p1).substring(2));
-        return "0x" + pub0.add(pub1).toHex(!!compressed)
+        return publicKey;
     }
 }
 

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

@@ -1,16 +1,6 @@
 
 import { assert } from "../utils/index.js";
 
-import { AnkrProvider } from "./provider-ankr.js";
-import { AlchemyProvider } from "./provider-alchemy.js";
-//import { BlockscoutProvider } from "./provider-blockscout.js";
-import { ChainstackProvider } from "./provider-chainstack.js";
-import { CloudflareProvider } from "./provider-cloudflare.js";
-import { EtherscanProvider } from "./provider-etherscan.js";
-import { InfuraProvider } from "./provider-infura.js";
-//import { PocketProvider } from "./provider-pocket.js";
-import { QuickNodeProvider } from "./provider-quicknode.js";
-
 import { FallbackProvider } from "./provider-fallback.js";
 import { JsonRpcProvider } from "./provider-jsonrpc.js";
 import { Network } from "./network.js";
@@ -47,14 +37,6 @@ const Testnets = "goerli kovan sepolia classicKotti optimism-goerli arbitrum-goe
  *  will whitelist **only** those backends.
  *
  *  Current backend strings supported are:
- *  - ``"alchemy"``
- *  - ``"ankr"``
- *  - ``"cloudflare"``
- *  - ``"chainstack"``
- *  - ``"etherscan"``
- *  - ``"infura"``
- *  - ``"publicPolygon"``
- *  - ``"quicknode"``
  *
  *  @example:
  *    // Connect to a local Geth node
@@ -74,17 +56,6 @@ const Testnets = "goerli kovan sepolia classicKotti optimism-goerli arbitrum-goe
 export function getDefaultProvider(network?: string | Networkish | WebSocketLike, options?: any): AbstractProvider {
     if (options == null) { options = { }; }
 
-    const allowService = (name: string) => {
-        if (options[name] === "-") { return false; }
-        if (typeof(options.exclusive) === "string") {
-            return (name === options.exclusive);
-        }
-        if (Array.isArray(options.exclusive)) {
-            return (options.exclusive.indexOf(name) !== -1);
-        }
-        return true;
-    };
-
     if (typeof(network) === "string" && network.match(/^https?:/)) {
         return new JsonRpcProvider(network);
     }
@@ -102,83 +73,6 @@ export function getDefaultProvider(network?: string | Networkish | WebSocketLike
 
     const providers: Array<AbstractProvider> = [ ];
 
-    if (allowService("publicPolygon") && staticNetwork) {
-        if (staticNetwork.name === "matic") {
-            providers.push(new JsonRpcProvider("https:/\/polygon-rpc.com/", staticNetwork, { staticNetwork }));
-        } else if (staticNetwork.name === "matic-amoy") {
-            providers.push(new JsonRpcProvider("https:/\/rpc-amoy.polygon.technology/", staticNetwork, { staticNetwork }));
-        }
-    }
-
-    if (allowService("alchemy")) {
-        try {
-            providers.push(new AlchemyProvider(network, options.alchemy));
-        } catch (error) { }
-    }
-
-    if (allowService("ankr") && options.ankr != null) {
-        try {
-            providers.push(new AnkrProvider(network, options.ankr));
-        } catch (error) { }
-    }
-/* Temporarily remove until custom error issue is fixed
-    if (allowService("blockscout")) {
-        try {
-            providers.push(new BlockscoutProvider(network, options.blockscout));
-        } catch (error) { }
-    }
-*/
-    if (allowService("chainstack")) {
-        try {
-            providers.push(new ChainstackProvider(network, options.chainstack));
-        } catch (error) { }
-    }
-
-    if (allowService("cloudflare")) {
-        try {
-            providers.push(new CloudflareProvider(network));
-        } catch (error) { }
-    }
-
-    if (allowService("etherscan")) {
-        try {
-            providers.push(new EtherscanProvider(network, options.etherscan));
-        } catch (error) { }
-    }
-
-    if (allowService("infura")) {
-        try {
-            let projectId = options.infura;
-            let projectSecret: undefined | string = undefined;
-            if (typeof(projectId) === "object") {
-                projectSecret = projectId.projectSecret;
-                projectId = projectId.projectId;
-            }
-            providers.push(new InfuraProvider(network, projectId, projectSecret));
-        } catch (error) { }
-    }
-/*
-    if (options.pocket !== "-") {
-        try {
-            let appId = options.pocket;
-            let secretKey: undefined | string = undefined;
-            let loadBalancer: undefined | boolean = undefined;
-            if (typeof(appId) === "object") {
-                loadBalancer = !!appId.loadBalancer;
-                secretKey = appId.secretKey;
-                appId = appId.appId;
-            }
-            providers.push(new PocketProvider(network, appId, secretKey, loadBalancer));
-        } catch (error) { console.log(error); }
-    }
-*/
-    if (allowService("quicknode")) {
-        try {
-            let token = options.quicknode;
-            providers.push(new QuickNodeProvider(network, token));
-        } catch (error) { }
-    }
-
     assert(providers.length, "unsupported default network", "UNSUPPORTED_OPERATION", {
         operation: "getDefaultProvider"
     });

package/src.ts/providers/index.ts

@@ -59,16 +59,6 @@ export { JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner } from "./provider-j
 
 export { BrowserProvider } from "./provider-browser.js";
 
-export { AlchemyProvider } from "./provider-alchemy.js";
-export { BlockscoutProvider } from "./provider-blockscout.js";
-export { AnkrProvider } from "./provider-ankr.js";
-export { CloudflareProvider } from "./provider-cloudflare.js";
-export { ChainstackProvider } from "./provider-chainstack.js";
-export { EtherscanProvider, EtherscanPlugin } from "./provider-etherscan.js";
-export { InfuraProvider, InfuraWebSocketProvider } from "./provider-infura.js";
-export { PocketProvider } from "./provider-pocket.js";
-export { QuickNodeProvider } from "./provider-quicknode.js";
-
 import { IpcSocketProvider } from "./provider-ipcsocket.js"; /*-browser*/
 export { IpcSocketProvider };
 export { SocketProvider } from "./provider-socket.js";