quantumcoin 6.14.2 → 6.14.5

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

@@ -1,118 +1,126 @@
-/**
- *  Add details about signing here.
- *
- *  @_subsection: api/crypto:Signing  [about-signing]
- */
-
-import pqc = require('quantum-coin-pqc-js-sdk');
-import qcsdk = require('quantum-coin-js-sdk');
-
-import {
-    getBytes,
-    dataLength, getBytesCopy, hexlify,
-    assertArgument
-} from "../utils/index.js";
-
-import { Signature } from "./signature.js";
-
-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 cryptography operations and key management.
- */
-export class SigningKey {
-    #privateKey: string;
-
-    /**
-     *  Creates a new **SigningKey** for %%privateKey%%.
-     */
-    constructor(privateKey: BytesLike) {
-        assertArgument(dataLength(privateKey) === CRYPTO_SECRETKEY_BYTES, "invalid private key", "privateKey", "[REDACTED]");
-        this.#privateKey = hexlify(privateKey);
-    }
-
-    /**
-     *  The private key.
-     */
-    get privateKey(): string { return this.#privateKey; }
-
-    /**
-     *  The public key.
-     *
-     */
-    get publicKey(): string { return SigningKey.computePublicKey(this.#privateKey); }
-
-    /**
-     *  Return the signature of the signed %%digest%%.
-     */
-    sign(digest: BytesLike): Signature {
-        assertArgument(dataLength(digest) === CRYPTO_MESSAGE_LENGTH, "invalid digest length", "digest", digest);
-
-        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: this.publicKey,
-            s: combinedSig,
-            v: 0x1
-        });
-    }
-
-    /**
-     *  Compute the public key for a private %%key%%.
-     *
-     *
-     *  @example:
-     *    sign = new SigningKey(id("some-secret"));
-     *
-     *    // Compute the public key for a private key
-     *    SigningKey.computePublicKey(sign.privateKey)
-     *    //_result:
-     */
-    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;
-    }
-
-    /**
-     *  Returns the public key for the private key which produced the
-     *  %%signature%% for the given %%digest%%.
-     *
-     *  @example:
-     *    key = new SigningKey(id("some-secret"))
-     *    digest = id("hello world")
-     *    sig = key.sign(digest)
-     *
-     *    // Notice the signer public key...
-     *    key.publicKey
-     *    //_result:
-     *
-     *    // ...is equal to the recovered public key
-     *    SigningKey.recoverPublicKey(digest, sig)
-     *    //_result:
-     *
-     */
-    static recoverPublicKey(digest: BytesLike, signature: SignatureLike): string {
-        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 publicKey = qcsdk.publicKeyFromSignature(digestBytes, sigBytes);
-
-        return publicKey;
-    }
-}
-
+/**
+ *  Add details about signing here.
+ *
+ *  @_subsection: api/crypto:Signing  [about-signing]
+ */
+
+import {combinePublicKeySignature, publicKeyFromPrivateKey, publicKeyFromSignature} from "quantum-coin-js-sdk";
+import {cryptoSign} from "quantum-coin-pqc-js-sdk";
+
+import {
+    getBytes,
+    dataLength, getBytesCopy, hexlify,
+    assertArgument,
+} from "../utils/index.js";
+
+import { Signature } from "./signature.js";
+
+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 cryptography operations and key management.
+ */
+export class SigningKey {
+    #privateKey: string;
+
+    /**
+     *  Creates a new **SigningKey** for %%privateKey%%.
+     */
+    constructor(privateKey: BytesLike) {
+        assertArgument(dataLength(privateKey) === CRYPTO_SECRETKEY_BYTES, "invalid private key", "privateKey", "[REDACTED]");
+        this.#privateKey = hexlify(privateKey);
+    }
+
+    /**
+     *  The private key.
+     */
+    get privateKey(): string { return this.#privateKey; }
+
+    /**
+     *  The public key.
+     *
+     */
+    get publicKey(): string { return SigningKey.computePublicKey(this.#privateKey); }
+
+    /**
+     *  Return the signature of the signed %%digest%%.
+     */
+    sign(digest: BytesLike): Signature {
+        assertArgument(dataLength(digest) === CRYPTO_MESSAGE_LENGTH, "invalid digest length", "digest", digest);
+
+        const sig: any = cryptoSign(getBytesCopy(digest), getBytesCopy(this.#privateKey));
+        const pubBytes: any = getBytes(this.publicKey);
+        let combinedSig = combinePublicKeySignature(pubBytes, sig);
+        combinedSig = "0x" + combinedSig;
+
+        return Signature.from({
+            r: this.publicKey,
+            s: combinedSig,
+            v: 0x1
+        });
+    }
+
+    /**
+     *  Compute the public key for a private %%key%%. If a publicKey is passed, it is returned as is. for backward compatibility.
+     *
+     *
+     *  @example:
+     *    sign = new SigningKey(id("some-secret"));
+     *
+     *    // Compute the public key for a private key
+     *    SigningKey.computePublicKey(sign.privateKey)
+     *    //_result:
+     */
+    static computePublicKey(key: BytesLike): string {
+        let keyBytes: any = getBytes(key, "key");
+        let pubKey: any;
+
+        if (keyBytes.length == CRYPTO_SECRETKEY_BYTES) {
+            pubKey = publicKeyFromPrivateKey(keyBytes);
+            assertArgument(pubKey !== null && pubKey !== undefined, "invalid key", "key", "[REDACTED]");
+            pubKey = '0x' + pubKey;
+        } else if(keyBytes.length == CRYPTO_PUBLICKEY_BYTES) {
+            pubKey = keyBytes;
+        }
+
+        assertArgument(pubKey !== null && pubKey !== undefined, "invalid key", "key", "[REDACTED]");
+        return pubKey;
+    }
+
+    /**
+     *  Returns the public key for the private key which produced the
+     *  %%signature%% for the given %%digest%%.
+     *
+     *  @example:
+     *    key = new SigningKey(id("some-secret"))
+     *    digest = id("hello world")
+     *    sig = key.sign(digest)
+     *
+     *    // Notice the signer public key...
+     *    key.publicKey
+     *    //_result:
+     *
+     *    // ...is equal to the recovered public key
+     *    SigningKey.recoverPublicKey(digest, sig)
+     *    //_result:
+     *
+     */
+    static recoverPublicKey(digest: BytesLike, signature: SignatureLike): string {
+        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 publicKey = publicKeyFromSignature(digestBytes, sigBytes);
+
+        return publicKey;
+    }
+}
+

package/src.ts/hash/authorization.ts

@@ -1,38 +1,38 @@
-import { getAddress } from "../address/index.js";
-import { keccak256 } from "../crypto/index.js";
-import { recoverAddress } from "../transaction/index.js";
-import {
-    assertArgument, concat, encodeRlp, toBeArray
-} from "../utils/index.js";
-
-import type { Addressable } from "../address/index.js";
-import type { SignatureLike } from "../crypto/index.js";
-import type { BigNumberish, Numeric } from "../utils/index.js";
-
-export interface AuthorizationRequest {
-    address: string | Addressable;
-    nonce?: Numeric;
-    chainId?: BigNumberish;
-}
-
-/**
- *  Computes the [[link-eip-7702]] authorization digest to sign.
- */
-export function hashAuthorization(auth: AuthorizationRequest): string {
-    assertArgument(typeof(auth.address) === "string", "invalid address for hashAuthorization", "auth.address", auth);
-    return keccak256(concat([
-        "0x05", encodeRlp([
-            (auth.chainId != null) ? toBeArray(auth.chainId): "0x",
-            getAddress(auth.address),
-            (auth.nonce != null) ? toBeArray(auth.nonce): "0x",
-        ])
-    ]));
-}
-
-/**
- *  Return the address of the private key that produced
- *  the signature %%sig%% during signing for %%message%%.
- */
-export function verifyAuthorization(auth: AuthorizationRequest, sig: SignatureLike): string {
-    return recoverAddress(hashAuthorization(auth), sig);
-}
+import { getAddress } from "../address/index.js";
+import { keccak256 } from "../crypto/index.js";
+import { recoverAddress } from "../transaction/index.js";
+import {
+    assertArgument, concat, encodeRlp, toBeArray
+} from "../utils/index.js";
+
+import type { Addressable } from "../address/index.js";
+import type { SignatureLike } from "../crypto/index.js";
+import type { BigNumberish, Numeric } from "../utils/index.js";
+
+export interface AuthorizationRequest {
+    address: string | Addressable;
+    nonce?: Numeric;
+    chainId?: BigNumberish;
+}
+
+/**
+ *  Computes the [[link-eip-7702]] authorization digest to sign.
+ */
+export function hashAuthorization(auth: AuthorizationRequest): string {
+    assertArgument(typeof(auth.address) === "string", "invalid address for hashAuthorization", "auth.address", auth);
+    return keccak256(concat([
+        "0x05", encodeRlp([
+            (auth.chainId != null) ? toBeArray(auth.chainId): "0x",
+            getAddress(auth.address),
+            (auth.nonce != null) ? toBeArray(auth.nonce): "0x",
+        ])
+    ]));
+}
+
+/**
+ *  Return the address of the private key that produced
+ *  the signature %%sig%% during signing for %%message%%.
+ */
+export function verifyAuthorization(auth: AuthorizationRequest, sig: SignatureLike): string {
+    return recoverAddress(hashAuthorization(auth), sig);
+}

package/src.ts/hash/id.ts

@@ -1,17 +1,17 @@
-import { keccak256 } from "../crypto/index.js";
-import { toUtf8Bytes } from "../utils/index.js";
-
-/**
- *  A simple hashing function which operates on UTF-8 strings to
- *  compute an 32-byte identifier.
- *
- *  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes
- *  the [[keccak256]].
- *
- *  @example:
- *    id("hello world")
- *    //_result:
- */
-export function id(value: string): string {
-    return keccak256(toUtf8Bytes(value));
-}
+import { keccak256 } from "../crypto/index.js";
+import { toUtf8Bytes } from "../utils/index.js";
+
+/**
+ *  A simple hashing function which operates on UTF-8 strings to
+ *  compute an 32-byte identifier.
+ *
+ *  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes
+ *  the [[keccak256]].
+ *
+ *  @example:
+ *    id("hello world")
+ *    //_result:
+ */
+export function id(value: string): string {
+    return keccak256(toUtf8Bytes(value));
+}

package/src.ts/hash/index.ts

@@ -1,18 +1,18 @@
-/**
- *  Utilities for common tasks involving hashing. Also see
- *  [cryptographic hashing](about-crypto-hashing).
- *
- *  @_section: api/hashing:Hashing Utilities  [about-hashing]
- */
-
-export { hashAuthorization, verifyAuthorization } from "./authorization.js";
-export { id } from "./id.js"
-export { ensNormalize, isValidName, namehash, dnsEncode } from "./namehash.js";
-export { hashMessage, verifyMessage } from "./message.js";
-export {
-    solidityPacked, solidityPackedKeccak256, solidityPackedSha256
-} from "./solidity.js";
-export { TypedDataEncoder, verifyTypedData } from "./typed-data.js";
-
-export type { AuthorizationRequest } from "./authorization.js";
-export type { TypedDataDomain, TypedDataField } from "./typed-data.js";
+/**
+ *  Utilities for common tasks involving hashing. Also see
+ *  [cryptographic hashing](about-crypto-hashing).
+ *
+ *  @_section: api/hashing:Hashing Utilities  [about-hashing]
+ */
+
+export { hashAuthorization, verifyAuthorization } from "./authorization.js";
+export { id } from "./id.js"
+export { ensNormalize, isValidName, namehash, dnsEncode } from "./namehash.js";
+export { hashMessage, verifyMessage } from "./message.js";
+export {
+    solidityPacked, solidityPackedKeccak256, solidityPackedSha256
+} from "./solidity.js";
+export { TypedDataEncoder, verifyTypedData } from "./typed-data.js";
+
+export type { AuthorizationRequest } from "./authorization.js";
+export type { TypedDataDomain, TypedDataField } from "./typed-data.js";

package/src.ts/hash/message.ts

@@ -1,51 +1,51 @@
-import { keccak256 } from "../crypto/index.js";
-import { MessagePrefix } from "../constants/index.js";
-import { recoverAddress } from "../transaction/index.js";
-import { concat, toUtf8Bytes } from "../utils/index.js";
-
-import type { SignatureLike } from "../crypto/index.js";
-/**
- *  Computes the [[link-eip-191]] personal-sign message digest to sign.
- *
- *  This prefixes the message with [[MessagePrefix]] and the decimal length
- *  of %%message%% and computes the [[keccak256]] digest.
- *
- *  If %%message%% is a string, it is converted to its UTF-8 bytes
- *  first. To compute the digest of a [[DataHexString]], it must be converted
- *  to [bytes](getBytes).
- *
- *  @example:
- *    hashMessage("Hello World")
- *    //_result:
- *
- *    // Hashes the SIX (6) string characters, i.e.
- *    // [ "0", "x", "4", "2", "4", "3" ]
- *    hashMessage("0x4243")
- *    //_result:
- *
- *    // Hashes the TWO (2) bytes [ 0x42, 0x43 ]...
- *    hashMessage(getBytes("0x4243"))
- *    //_result:
- *
- *    // ...which is equal to using data
- *    hashMessage(new Uint8Array([ 0x42, 0x43 ]))
- *    //_result:
- *
- */
-export function hashMessage(message: Uint8Array | string): string {
-    if (typeof(message) === "string") { message = toUtf8Bytes(message); }
-    return keccak256(concat([
-        toUtf8Bytes(MessagePrefix),
-        toUtf8Bytes(String(message.length)),
-        message
-    ]));
-}
-
-/**
- *  Return the address of the private key that produced
- *  the signature %%sig%% during signing for %%message%%.
- */
-export function verifyMessage(message: Uint8Array | string, sig: SignatureLike): string {
-    const digest = hashMessage(message);
-    return recoverAddress(digest, sig);
-}
+import { keccak256 } from "../crypto/index.js";
+import { MessagePrefix } from "../constants/index.js";
+import { recoverAddress } from "../transaction/index.js";
+import { concat, toUtf8Bytes } from "../utils/index.js";
+
+import type { SignatureLike } from "../crypto/index.js";
+/**
+ *  Computes the [[link-eip-191]] personal-sign message digest to sign.
+ *
+ *  This prefixes the message with [[MessagePrefix]] and the decimal length
+ *  of %%message%% and computes the [[keccak256]] digest.
+ *
+ *  If %%message%% is a string, it is converted to its UTF-8 bytes
+ *  first. To compute the digest of a [[DataHexString]], it must be converted
+ *  to [bytes](getBytes).
+ *
+ *  @example:
+ *    hashMessage("Hello World")
+ *    //_result:
+ *
+ *    // Hashes the SIX (6) string characters, i.e.
+ *    // [ "0", "x", "4", "2", "4", "3" ]
+ *    hashMessage("0x4243")
+ *    //_result:
+ *
+ *    // Hashes the TWO (2) bytes [ 0x42, 0x43 ]...
+ *    hashMessage(getBytes("0x4243"))
+ *    //_result:
+ *
+ *    // ...which is equal to using data
+ *    hashMessage(new Uint8Array([ 0x42, 0x43 ]))
+ *    //_result:
+ *
+ */
+export function hashMessage(message: Uint8Array | string): string {
+    if (typeof(message) === "string") { message = toUtf8Bytes(message); }
+    return keccak256(concat([
+        toUtf8Bytes(MessagePrefix),
+        toUtf8Bytes(String(message.length)),
+        message
+    ]));
+}
+
+/**
+ *  Return the address of the private key that produced
+ *  the signature %%sig%% during signing for %%message%%.
+ */
+export function verifyMessage(message: Uint8Array | string, sig: SignatureLike): string {
+    const digest = hashMessage(message);
+    return recoverAddress(digest, sig);
+}