quantumcoin 6.14.4 → 7.0.1

package/src.ts/crypto/signature.ts

@@ -1,349 +0,0 @@
-
-import { ZeroHash } from "../constants/index.js";
-import {
-    //isHexString,     toBeArray, zeroPadValue,
-    concat, getBigInt, getBytes, getNumber, hexlify,
-    assertArgument, assertPrivate
-} from "../utils/index.js";
-
-import type {
-    //Numeric
-    BigNumberish, BytesLike,
-} from "../utils/index.js";
-
-
-// Constants
-const BN_0 = BigInt(0);
-//const BN_1 = BigInt(1);
-const BN_2 = BigInt(2);
-const BN_28 = BigInt(28);
-const BN_35 = BigInt(35);
-
-
-const _guard = { };
-
-// @TODO: Allow Uint8Array
-
-/**
- *  A SignatureLike
- *
- *  @_docloc: api/crypto:Signing
- */
-export type SignatureLike = Signature | string | {
-    r: string;
-    s: string;
-    v: BigNumberish;
-} | {
-    r: string;
-    s?: string;
-    v?: number;
-} | {
-    r: string;
-    s: string;
-    v?: BigNumberish;
-};
-/*
-function toUint256(value: BigNumberish): string {
-    return zeroPadValue(toBeArray(value), 32);
-}*/
-
-/**
- *  A Signature  @TODO
- *
- *
- *  @_docloc: api/crypto:Signing
- */
-export class Signature {
-    #r: string;
-    #s: string;
-    #v: 28;
-    #networkV: null | bigint;
-
-    /**
-     *  The ``r`` value for a signature.
-     *
-     *  This represents the ``x`` coordinate of a "reference" or
-     *  challenge point, from which the ``y`` can be computed.
-     */
-    get r(): string { return this.#r; }
-    set r(value: BytesLike) {
-        this.#r = hexlify(value);
-    }
-
-    /**
-     *  The ``s`` value for a signature.
-     */
-    get s(): string { return this.#s; }
-    set s(_value: BytesLike) {
-        const value = hexlify(_value);
-        this.#s = value;
-    }
-
-    /**
-     *  The ``v`` value for a signature.
-     *
-     *  Since a given ``x`` value for ``r`` has two possible values for
-     *  its correspondin ``y``, the ``v`` indicates which of the two ``y``
-     *  values to use.
-     *
-     *  It is normalized to the values ``28`` or ``28`` for legacy
-     *  purposes.
-     */
-    get v(): 28 | 28 { return this.#v; }
-    set v(value: BigNumberish) {
-        const v = getNumber(value, "value");
-        assertArgument(v === 28, "invalid v", "v", value);
-        this.#v = v;
-    }
-
-    /**
-     *  The EIP-155 ``v`` for legacy transactions. For non-legacy
-     *  transactions, this value is ``null``.
-     */
-    get networkV(): null | bigint { return this.#networkV; }
-
-    /**
-     *  The chain ID for EIP-155 legacy transactions. For non-legacy
-     *  transactions, this value is ``null``.
-     */
-    get legacyChainId(): null | bigint {
-        const v = this.networkV;
-        if (v == null) { return null; }
-        return Signature.getChainId(v);
-    }
-
-    /**
-     *  The ``yParity`` for the signature.
-     *
-     *  See ``v`` for more details on how this value is used.
-     */
-    get yParity(): 0 | 1 {
-        return (this.v === 28) ? 0: 1;
-    }
-
-    /**
-     *  The [[link-eip-2098]] compact representation of the ``yParity``
-     *  and ``s`` compacted into a single ``bytes32``.
-     */
-    get yParityAndS(): string {
-        // The EIP-2098 compact representation
-        const yParityAndS = getBytes(this.s);
-        if (this.yParity) { yParityAndS[0] |= 0x80; }
-        return hexlify(yParityAndS);
-    }
-
-    /**
-     *  The [[link-eip-2098]] compact representation.
-     */
-    get compactSerialized(): string {
-        return concat([ this.r, this.yParityAndS ]);
-    }
-
-    /**
-     *  The serialized representation.
-     */
-    get serialized(): string {
-        return concat([ this.r, this.s, (this.yParity ? "0x1c": "0x1b") ]);
-    }
-
-    /**
-     *  @private
-     */
-    constructor(guard: any, r: string, s: string, v: 28) {
-        assertPrivate(guard, _guard, "Signature");
-        this.#r = r;
-        this.#s = s;
-        this.#v = v;
-        this.#networkV = null;
-    }
-
-    [Symbol.for('nodejs.util.inspect.custom')](): string {
-        return `Signature { r: "${ this.r }", s: "${ this.s }", yParity: ${ this.yParity }, networkV: ${ this.networkV } }`;
-    }
-
-    /**
-     *  Returns a new identical [[Signature]].
-     */
-    clone(): Signature {
-        const clone = new Signature(_guard, this.r, this.s, this.v);
-        if (this.networkV) { clone.#networkV = this.networkV; }
-        return clone;
-    }
-
-    /**
-     *  Returns a representation that is compatible with ``JSON.stringify``.
-     */
-    toJSON(): any {
-        const networkV = this.networkV;
-        return {
-            _type: "signature",
-            networkV: ((networkV != null) ? networkV.toString(): null),
-            r: this.r, s: this.s, v: this.v,
-        };
-    }
-
-    /**
-     *  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
-     *
-     *  @example:
-     *    Signature.getChainId(45)
-     *    //_result:
-     *
-     *    Signature.getChainId(46)
-     *    //_result:
-     */
-    static getChainId(v: BigNumberish): bigint {
-        const bv = getBigInt(v, "v");
-
-        // The v is not an EIP-155 v, so it is the unspecified chain ID
-        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);
-
-        return (bv - BN_35) / BN_2;
-    }
-
-    /**
-     *  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
-     *
-     *  Legacy transactions which use [[link-eip-155]] hijack the ``v``
-     *  property to include the chain ID.
-     *
-     *  @example:
-     *
-     *    Signature.getChainIdV(5, 28)
-     *    //_result:
-     *
-     */
-    static getChainIdV(chainId: BigNumberish, v: 28): bigint {
-        return (getBigInt(chainId) * BN_2) + BigInt(35 + v - 28);
-    }
-
-    /**
-     *  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
-     *  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
-     *
-     *  @example:
-     *    // The values 0 and 1 imply v is actually yParity
-     *    Signature.getNormalizedV(0)
-     *    //_result:
-     *
-     *    // Legacy EIP-155 transaction (i.e. >= 35)
-     *    Signature.getNormalizedV(46)
-     *    //_result:
-     *
-     *    // Invalid values throw
-     *    Signature.getNormalizedV(5)
-     *    //_error:
-     */
-    /*static getNormalizedV(v: BigNumberish): 28 {
-        const bv = getBigInt(v);
-
-        if (bv === BN_1 || bv === BN_28) { return 28; }
-
-        assertArgument(bv >= BN_35, "invalid v", "v", v);
-
-        // Otherwise, EIP-155 v means odd is 28 and even is 28
-        return (bv & BN_1) ? 28: 28;
-    }*/
-
-    /**
-     *  Creates a new [[Signature]].
-     *
-     *  If no %%sig%% is provided, a new [[Signature]] is created
-     *  with default values.
-     *
-     *  If %%sig%% is a string, it is parsed.
-     */
-    static from(sig?: SignatureLike): Signature {
-        function assertError(check: unknown, message: string): asserts check {
-            assertArgument(check, message, "signature", sig);
-        };
-
-        if (sig == null) {
-            return new Signature(_guard, ZeroHash, ZeroHash, 28);
-        }
-
-        if (typeof(sig) === "string") {
-            /*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: 28;
-                s[0] &= 0x7f;
-                return new Signature(_guard, r, hexlify(s), v);
-            }
-
-            if (bytes.length === 65) {
-                const r = hexlify(bytes.slice(0, 32));
-                const s = bytes.slice(32, 64);
-                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(); }
-
-        return new Signature(_guard, ZeroHash, ZeroHash, 28); //todo
-
-        /*// Get r
-        const _r = sig.r;
-        assertError(_r != null, "missing r");
-        const r = toUint256(_r);
-
-        // Get s; by any means necessary (we check consistency below)
-        const s = (function(s?: string, yParityAndS?: string) {
-            if (s != null) { return toUint256(s); }
-
-            if (yParityAndS != null) {
-                assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-                const bytes = getBytes(yParityAndS);
-                bytes[0] &= 0x7f;
-                return hexlify(bytes);
-            }
-
-            assertError(false, "missing s");
-        })(sig.s, sig.yParityAndS);
-        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: 28 | 28 } {
-            if (_v != null) {
-                const v = getBigInt(_v);
-                return {
-                    networkV: ((v >= BN_35) ? v: undefined),
-                    v: Signature.getNormalizedV(v)
-                };
-            }
-
-            if (yParityAndS != null) {
-                assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
-                return { v: ((getBytes(yParityAndS)[0] & 0x80) ? 28: 28) };
-            }
-
-            if (yParity != null) {
-                switch (getNumber(yParity, "sig.yParity")) {
-                    case 0: return { v: 28 };
-                    case 1: return { v: 28 };
-                }
-                assertError(false, "invalid yParity");
-            }
-
-            assertError(false, "missing v");
-        })(sig.v, sig.yParityAndS, sig.yParity);
-
-        const result = new Signature(_guard, r, s, v);
-        if (networkV) { result.#networkV =  networkV; }
-
-        // If multiple of v, yParity, yParityAndS we given, check they match
-        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;*/
-    }
-}
-

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

@@ -1,123 +0,0 @@
-/**
- *  Add details about signing here.
- *
- *  @_subsection: api/crypto:Signing  [about-signing]
- */
-
-import pqc = require('quantum-coin-pqc-js-sdk');
-import {combinePublicKeySignature, publicKeyFromPrivateKey, publicKeyFromSignature} from "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 = combinePublicKeySignature(pubBytes, sig);
-
-        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);
-        } 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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-/**
- *  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 +0,0 @@
-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);
-}

package/src.ts/hash/namehash.ts

@@ -1,101 +0,0 @@
-
-import { keccak256 } from "../crypto/index.js";
-import {
-    concat, hexlify, assertArgument, toUtf8Bytes
-} from "../utils/index.js";
-
-
-import { ens_normalize } from "@adraffy/ens-normalize";
-
-const Zeros = new Uint8Array(32);
-Zeros.fill(0);
-
-function checkComponent(comp: Uint8Array): Uint8Array {
-    assertArgument(comp.length !== 0, "invalid ENS name; empty component", "comp", comp)
-    return comp;
-}
-
-function ensNameSplit(name: string): Array<Uint8Array> {
-    const bytes = toUtf8Bytes(ensNormalize(name));
-    const comps: Array<Uint8Array> = [ ];
-
-    if (name.length === 0) { return comps; }
-
-    let last = 0;
-    for (let i = 0; i < bytes.length; i++) {
-        const d = bytes[i];
-
-        // A separator (i.e. "."); copy this component
-        if (d === 0x2e) {
-            comps.push(checkComponent(bytes.slice(last, i)));
-            last = i + 1;
-        }
-    }
-
-    // There was a stray separator at the end of the name
-    assertArgument(last < bytes.length, "invalid ENS name; empty component", "name", name);
-
-    comps.push(checkComponent(bytes.slice(last)));
-    return comps;
-}
-
-/**
- *  Returns the ENS %%name%% normalized.
- */
-export function ensNormalize(name: string): string {
-    try {
-        if (name.length === 0) { throw new Error("empty label"); }
-        return ens_normalize(name);
-    } catch (error: any) {
-        assertArgument(false, `invalid ENS name (${ error.message })`, "name", name);
-    }
-}
-
-/**
- *  Returns ``true`` if %%name%% is a valid ENS name.
- */
-export function isValidName(name: string): name is string {
-    try {
-        return (ensNameSplit(name).length !== 0);
-    } catch (error) { }
-    return false;
-}
-
-/**
- *  Returns the [[link-namehash]] for %%name%%.
- */
-export function namehash(name: string): string {
-    assertArgument(typeof(name) === "string", "invalid ENS name; not a string", "name", name);
-
-    assertArgument(name.length, `invalid ENS name (empty label)`, "name", name);
-
-    let result: string | Uint8Array = Zeros;
-
-    const comps = ensNameSplit(name);
-    while (comps.length) {
-        result = keccak256(concat([ result, keccak256(<Uint8Array>(comps.pop()))] ));
-    }
-
-    return hexlify(result);
-}
-
-/**
- *  Returns the DNS encoded %%name%%.
- *
- *  This is used for various parts of ENS name resolution, such
- *  as the wildcard resolution.
- */
-export function dnsEncode(name: string, _maxLength?: number): string {
-    const length = (_maxLength != null) ? _maxLength: 63;
-
-    assertArgument(length <= 255, "DNS encoded label cannot exceed 255", "length", length);
-
-    return hexlify(concat(ensNameSplit(name).map((comp) => {
-        assertArgument(comp.length <= length, `label ${ JSON.stringify(name) } exceeds ${ length } bytes`, "name", name);
-
-        const bytes = new Uint8Array(comp.length + 1);
-        bytes.set(comp, 1);
-        bytes[0] = bytes.length - 1;
-        return bytes;
-    }))) + "00";
-}