@leocuvee/turtlecoin-utils 0.0.14

package/src/Types/ED25519.ts

@@ -0,0 +1,187 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {Common} from '../Common';
+import {TurtleCoinCrypto} from '../Types';
+import {Mnemonics} from 'turtlecoin-mnemonics';
+
+/** @ignore */
+const Config = require('../../config.json');
+
+/** @ignore */
+const SecureRandomString = require('secure-random-string');
+
+export namespace ED25519 {
+    /**
+     * Represents a ED25519 Key Pair (private & public) and provides a few methods
+     * for generating new key pairs including deterministic methods.
+     */
+    export class KeyPair {
+        private m_privateKey?: string;
+        private m_publicKey?: string;
+
+        /**
+         * Constructs a new KeyPair object
+         * @param publicKey
+         * @param privateKey
+         * @param entropy
+         * @param iterations
+         */
+        constructor(publicKey?: string, privateKey?: string, entropy?: string, iterations?: number) {
+            if (!publicKey && !privateKey && !entropy && !iterations) {
+                return;
+            }
+
+            if (publicKey && TurtleCoinCrypto.checkKey(publicKey)) {
+                this.m_publicKey = publicKey;
+            }
+
+            if (privateKey && TurtleCoinCrypto.checkScalar(privateKey)) {
+                this.m_privateKey = privateKey;
+            }
+
+            if (!publicKey && !privateKey) {
+                /* If no entropy was supplied, we'll go find our own */
+                entropy = entropy || SecureRandomString({length: 256});
+
+                this.privateKey = simpleKdf(
+                    entropy + rand32(), iterations || Config.keccakIterations);
+            }
+
+            if (this.m_privateKey && !this.m_publicKey) {
+                /* If we supplied a private key but no public key, and we said 1 iteration
+                we are probably looking to generate the deterministic view key for the
+                specified private spend key */
+                if (iterations && iterations === 1) {
+                    this.privateKey = TurtleCoinCrypto.cn_fast_hash(this.m_privateKey);
+                }
+
+                this.m_publicKey = TurtleCoinCrypto.secretKeyToPublicKey(this.m_privateKey);
+            }
+        }
+
+        /**
+         * Returns the private key
+         */
+        public get privateKey(): string {
+            return (this.m_privateKey) ? this.m_privateKey : '';
+        }
+
+        /**
+         * Sets the private key or reduces the value to a private key
+         * @param key
+         */
+        public set privateKey(key: string) {
+            this.m_privateKey = (TurtleCoinCrypto.checkScalar(key)) ?
+                key : TurtleCoinCrypto.scReduce32(key);
+        }
+
+        /**
+         * Returns the public key
+         */
+        public get publicKey(): string {
+            return (this.m_publicKey) ? this.m_publicKey : '';
+        }
+
+        /**
+         * Sets the public key
+         * @param key
+         */
+        public set publicKey(key: string) {
+            if (TurtleCoinCrypto.checkKey(key)) {
+                this.m_publicKey = key;
+            } else {
+                throw new Error('Not a public key');
+            }
+        }
+
+        /**
+         * Returns if the public key belongs to the private key
+         */
+        public get isPaired(): boolean {
+            if (this.publicKey.length === 0 || this.privateKey.length === 0) {
+                return false;
+            }
+
+            return (TurtleCoinCrypto.secretKeyToPublicKey(this.privateKey) === this.publicKey);
+        }
+    }
+
+    /**
+     * Represents a set of ED25519 key pairs (view and spend) used by TurtleCoin wallets
+     */
+    export class Keys {
+        private m_spendKeys: KeyPair = new KeyPair();
+        private m_viewKeys: KeyPair = new KeyPair();
+
+        /**
+         * Creates a new instance of a set of Keys
+         * @param spendKeys the spend key pair
+         * @param viewKeys the view key pair
+         */
+        constructor(spendKeys?: KeyPair, viewKeys?: KeyPair) {
+            if (spendKeys) {
+                this.m_spendKeys = spendKeys;
+            }
+
+            if (viewKeys) {
+                this.m_viewKeys = viewKeys;
+            }
+
+            if (!spendKeys && !viewKeys) {
+                this.m_spendKeys = new KeyPair();
+                this.m_viewKeys = new KeyPair(undefined, this.m_spendKeys.privateKey, undefined, 1);
+            }
+        }
+
+        /**
+         * Returns the spend keys
+         */
+        public get spend(): KeyPair {
+            return this.m_spendKeys;
+        }
+
+        /**
+         * Sets the spend keys
+         * @param keys
+         */
+        public set spend(keys: KeyPair) {
+            this.m_spendKeys = keys;
+        }
+
+        /**
+         * Returns the view keys
+         */
+        public get view(): KeyPair {
+            return this.m_viewKeys;
+        }
+
+        /**
+         * Sets the view keys
+         * @param keys
+         */
+        public set view(keys: KeyPair) {
+            this.m_viewKeys = keys;
+        }
+    }
+}
+
+/** @ignore */
+function rand32(): string {
+    try {
+        return Mnemonics.random(256);
+    } catch (error) {
+        throw new Error('Could not retrieve 32-bytes of random data: ' + error.toString());
+    }
+}
+
+/** @ignore */
+function simpleKdf(value: string, iterations: number): string {
+    /** This is a very simple implementation of a pseudo PBKDF2 function */
+    let hex = Common.bin2hex(Common.str2bin(value));
+    for (let i = 0; i < iterations; i++) {
+        hex = TurtleCoinCrypto.cn_fast_hash(hex);
+    }
+    return hex;
+}

package/src/Types/IExtraNonce.ts

@@ -0,0 +1,225 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {Reader, Writer} from 'bytestream-helper';
+import {Common} from '../Common';
+
+/** @ignore */
+enum SIZES {
+    KEY = 32,
+}
+
+export namespace ExtraNonceTag {
+    /**
+     * Nonce subtag types
+     */
+    export enum NonceTagType {
+        PAYMENT_ID = 0,
+        EXTRA_DATA = 127,
+    }
+
+    /**
+     * Abstract interface for structured Extra Nonce Field Values
+     */
+    export abstract class IExtraNonce {
+        /**
+         * Returns the size of the nonce field in bytes including it's tag
+         */
+        abstract get size(): number;
+
+        /**
+         * Returns the Extra Nonce Field tag
+         */
+        abstract get tag(): NonceTagType;
+
+        /**
+         * Returns the Extra Nonce as a Buffer
+         * @returns the Buffer representation of the object
+         */
+        public abstract toBuffer(): Buffer;
+
+        /**
+         * Returns the Extra Nonce as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public abstract toString(): string;
+    }
+
+    /**
+     * Represents arbitrary extra data included in the nonce by the user
+     */
+    export class ExtraNonceData implements IExtraNonce {
+
+        /**
+         * The tag type of the field
+         */
+        public get tag(): NonceTagType {
+            return this.m_tag;
+        }
+
+        /**
+         * The size of the field in bytes including the tag
+         */
+        public get size(): number {
+            return this.toBuffer().length;
+        }
+
+        /**
+         * The arbitrary data included in the field
+         */
+        public get data(): Buffer {
+            return this.m_data;
+        }
+
+        /**
+         * Creates a new instance of the field using a Buffer or Blob copy of
+         * field created through other means
+         * @param data the data that makes up the nonce field
+         * @returns the new object
+         */
+        public static from(data: Buffer | string): ExtraNonceData {
+            const reader = new Reader(data);
+
+            if (reader.varint().toJSNumber() !== NonceTagType.EXTRA_DATA) {
+                throw new Error('Not an extra data field');
+            }
+
+            try {
+                reader.varint(true);
+            } catch {
+                throw new Error('Cannot read required field data');
+            }
+
+            const length = reader.varint().toJSNumber();
+
+            if (reader.unreadBytes !== length) {
+                throw new RangeError('Not enough data available for reading');
+            }
+
+            const dataLength = reader.bytes(length);
+
+            return new ExtraNonceData(dataLength);
+        }
+        private readonly m_tag: NonceTagType = NonceTagType.EXTRA_DATA;
+        private readonly m_data: Buffer = Buffer.alloc(0);
+
+        /**
+         * Creates a new instance of the field from just the extra data to be included
+         * @param data the arbitrary data to be included in the field
+         */
+        constructor(data: Buffer) {
+            this.m_data = data;
+        }
+
+        /**
+         * Represents the field as a Buffer
+         * @returns the Buffer representation of the object
+         */
+        public toBuffer(): Buffer {
+            const writer = new Writer();
+
+            writer.varint(this.tag);
+
+            writer.varint(this.data.length);
+
+            writer.write(this.data);
+
+            return writer.buffer;
+        }
+
+        /**
+         * Represents the field as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public toString(): string {
+            return this.toBuffer().toString('hex');
+        }
+    }
+
+    /**
+     * Represents a payment ID included in the Extra Nonce field
+     */
+    export class ExtraNoncePaymentId implements IExtraNonce {
+
+        /**
+         * The tag type of the field
+         */
+        public get tag(): NonceTagType {
+            return this.m_tag;
+        }
+
+        /**
+         * The size of the field in bytes including the tag
+         */
+        public get size(): number {
+            return this.toBuffer().length;
+        }
+
+        /**
+         * The payment ID contained in the field
+         */
+        public get paymentId(): string {
+            return this.m_paymentId;
+        }
+
+        /**
+         * Creates a new instance of the field using a Buffer or Blob copy of
+         * field created through other means
+         * @param data the data that makes up the nonce field
+         * @returns the new object
+         */
+        public static from(data: Buffer | string): ExtraNoncePaymentId {
+            const reader = new Reader(data);
+
+            if (reader.varint().toJSNumber() !== NonceTagType.PAYMENT_ID) {
+                throw new Error('Not a payment ID field');
+            }
+
+            if (reader.unreadBytes !== SIZES.KEY) {
+                throw new RangeError('Not enough data available for reading');
+            }
+
+            const paymentId = reader.hash();
+
+            return new ExtraNoncePaymentId(paymentId);
+        }
+
+        private readonly m_tag: NonceTagType = NonceTagType.PAYMENT_ID;
+        private readonly m_paymentId: string = '';
+
+        /**
+         * Constructs a new instance of the field using the supplied payment ID
+         * @param paymentId
+         */
+        constructor(paymentId: string) {
+            if (!Common.isHex64(paymentId)) {
+                throw new Error('paymentId must be 64 hexadecimal characters');
+            }
+
+            this.m_paymentId = paymentId;
+        }
+
+        /**
+         * Represents the field as a Buffer
+         * @returns the Buffer representation of the object
+         */
+        public toBuffer(): Buffer {
+            const writer = new Writer();
+
+            writer.varint(this.tag);
+
+            writer.hash(this.paymentId);
+
+            return writer.buffer;
+        }
+
+        /**
+         * Represents the field as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public toString(): string {
+            return this.toBuffer().toString('hex');
+        }
+    }
+}