@leocuvee/turtlecoin-utils 0.0.14

package/src/Types/ITransaction.ts

@@ -0,0 +1,230 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {Transaction} from '../Transaction';
+import {Address} from '../Address';
+import {ED25519} from './ED25519';
+
+export namespace Interfaces {
+
+    /**
+     * Represents a transaction recipient
+     */
+    export interface TransactionRecipient {
+        /**
+         * The recipient public wallet address
+         */
+        address: string;
+        /**
+         * The amount sent to the recipient
+         */
+        amount: number;
+    }
+
+    /**
+     * Represents a prepared transaction
+     */
+    export interface PreparedTransaction {
+        /**
+         * The prepared transaction as a hexadecimal string (blob) -- this should be the prefix only (no signatures)
+         */
+        transaction: Transaction;
+        /**
+         * The transaction one-time private key.
+         * We need this value along with the list of addresses that funds are being sent to
+         * to ensure that funds are going where we believe the funds are going.
+         */
+        transactionPrivateKey: string;
+        /**
+         * The list of recipient addresses where funds are being sent to in the transaction.
+         * This is provided so that other participants can check the outputs to determine what
+         * amounts are going to which addresses so that they can verify that funds are going
+         * where they believe them to be going.
+         */
+        transactionRecipients: TransactionRecipient[];
+        /**
+         * The list of prepared ring signatures (incomplete) that are later used
+         * when we generate our partial signing key for the prepared transaction
+         */
+        signatureMeta: PreparedRingSignature[];
+    }
+
+    /**
+     * Represents a prepared ring signature for a given input of a prepared transaction
+     */
+    export interface PreparedRingSignature {
+        /**
+         * The index of the input in the transaction in which these prepared ring signatures belong
+         */
+        index: number;
+        /**
+         * The index in the list of prepared ring signatures that is our real input.
+         * Although this can sometimes be deduced based on the last 32-bytes being all 0s,
+         * it is safer to make sure that this value is transferred with the prepared
+         * ring signatures
+         */
+        realOutputIndex: number;
+        /**
+         * The randomly generated scalar value that was created in preparing the ring signatures
+         * This value is required for when we restore the ring signatures will all of the required
+         * partial signing keys.
+         */
+        key: string;
+        /**
+         * The prepared ring signatures
+         */
+        signatures?: string[];
+        /**
+         * The public keys used in the signature preparation (random + real)
+         */
+        inputKeys?: string[];
+        /**
+         * The output information used to create this input
+         */
+        input: {
+            derivation: string;
+            outputIndex: number;
+        };
+    }
+
+    /**
+     * Represents a Generated Output (destination)
+     */
+    export interface GeneratedOutput {
+        /**
+         * The amount of the output
+         */
+        amount: number;
+        /**
+         * The destination of the output
+         */
+        destination: Address;
+    }
+
+    /**
+     * Represents a transaction output to external applications
+     */
+    export interface Output {
+        /**
+         * The output key
+         */
+        key: string;
+        /**
+         * The output index (position) in the transaction
+         */
+        index: number;
+        /**
+         * The output global index
+         */
+        globalIndex: number;
+        /**
+         * The output amount
+         */
+        amount: number;
+        /**
+         * The output type
+         */
+        type?: number;
+        /**
+         * The output key image
+         */
+        keyImage?: string;
+        /**
+         * The GeneratedInput of the output (if it belongs to us)
+         */
+        input?: GeneratedInput;
+        /**
+         * Defines whether this is a partial key image
+         */
+        isPartialKeyImage?: boolean;
+    }
+
+    /**
+     * Represents a random output
+     */
+    export interface RandomOutput {
+        /**
+         * The output key
+         */
+        key: string;
+        /**
+         * The output global index
+         */
+        globalIndex: number;
+    }
+
+    /**
+     * Represents a generated input if the output belongs to us
+     */
+    export interface GeneratedInput {
+        /**
+         * The derived transaction keys
+         */
+        transactionKeys: InputKeys;
+        /**
+         * The public ephemeral of the input
+         */
+        publicEphemeral: string;
+        /**
+         * the private ephemeral of the input
+         */
+        privateEphemeral?: string;
+    }
+
+    /**
+     * The derived input transaction keys
+     */
+    export interface InputKeys {
+        /**
+         * The derived public key
+         */
+        publicKey: string;
+        /**
+         * The key derivation
+         */
+        derivedKey: string;
+        /**
+         * The output index
+         */
+        outputIndex: number;
+    }
+
+    /** @ignore */
+    export interface PreparedInput {
+        amount: number;
+        realOutputIndex: number;
+        keyImage: string;
+        input: GeneratedInput;
+        outputs: PreparedInputOutputs[];
+    }
+
+    /** @ignore */
+    export interface PreparedInputOutputs {
+        key: string;
+        index: number;
+    }
+
+    /** @ignore */
+    export interface PreparedOutput {
+        amount: number;
+        key: string;
+    }
+
+    /** @ignore */
+    export interface PreparedOutputs {
+        transactionKeys: ED25519.KeyPair;
+        outputs: PreparedOutput[];
+    }
+
+    /** @ignore */
+    export interface GeneratedRingSignatures {
+        signatures: string[];
+        index: number;
+    }
+
+    export interface IPreparedTransaction {
+        transaction: Transaction;
+        inputs: PreparedInput[];
+    }
+}

package/src/Types/ITransactionInput.ts

@@ -0,0 +1,190 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+/** @ignore */
+import {Writer} from 'bytestream-helper';
+import {BigInteger} from '../Types';
+
+export namespace TransactionInputs {
+
+    /**
+     * Transaction Input Types
+     */
+    export enum InputType {
+        KEY = 0x02,
+        COINBASE = 0xff,
+    }
+
+    /**
+     * Abstract interface for structured transaction inputs
+     */
+    export abstract class ITransactionInput {
+        /**
+         * The input type
+         */
+        public abstract get type(): InputType;
+
+        /**
+         * Returns the input as a buffer
+         * @returns the Buffer representation of the object
+         */
+        public abstract toBuffer(): Buffer;
+
+        /**
+         * Returns the input as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public abstract toString(): string;
+    }
+
+    /**
+     * Represents a Coinbase input (block reward)
+     */
+    export class CoinbaseInput implements ITransactionInput {
+        private readonly m_type: InputType = InputType.COINBASE;
+        private readonly m_blockIndex: number = 0;
+
+        /**
+         * Creates a new Coinbase input for the specified block index (0-based)
+         * @param blockIndex
+         */
+        constructor(blockIndex: number) {
+            this.m_blockIndex = blockIndex;
+        }
+
+        /**
+         * The input type
+         */
+        public get type(): InputType {
+            return this.m_type;
+        }
+
+        /**
+         * The block index of the input (0-based)
+         */
+        public get blockIndex(): number {
+            return this.m_blockIndex;
+        }
+
+        /**
+         * Represents the input as a Buffer
+         * @returns the Buffer representation of the object
+         */
+        public toBuffer(): Buffer {
+            const writer = new Writer();
+
+            writer.uint8_t(this.type);
+
+            writer.varint(this.blockIndex);
+
+            return writer.buffer;
+        }
+
+        /**
+         * Represents the input as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public toString(): string {
+            return this.toBuffer().toString('hex');
+        }
+    }
+
+    /**
+     * Represents an input from a set of keys (wallet)
+     */
+    export class KeyInput implements ITransactionInput {
+
+        private readonly m_type: InputType = InputType.KEY;
+        private readonly m_amount: BigInteger.BigInteger = BigInteger.zero;
+        private readonly m_keyOffsets: BigInteger.BigInteger[] = [];
+        private readonly m_keyImage: string = '';
+
+        /**
+         * Creates a new input from existing keys using the specified values
+         * @param amount the amount of the input
+         * @param keyOffsets the input offsets used in the transaction signature(s)
+         * @param keyImage the key image of the input
+         */
+        constructor(
+            amount: BigInteger.BigInteger | number,
+            keyOffsets: BigInteger.BigInteger[] | number[],
+            keyImage: string) {
+            if (typeof amount === 'number') {
+                amount = BigInteger(amount);
+            }
+
+            this.m_amount = amount;
+
+            const tmpKeyOffsets: BigInteger.BigInteger[] = [];
+
+            for (const index of keyOffsets) {
+                if (typeof index === 'number') {
+                    tmpKeyOffsets.push(BigInteger(index));
+                } else {
+                    tmpKeyOffsets.push(index);
+                }
+            }
+
+            this.m_keyOffsets = tmpKeyOffsets;
+
+            this.m_keyImage = keyImage;
+        }
+
+        /**
+         * The input type
+         */
+        public get type(): InputType {
+            return this.m_type;
+        }
+
+        /**
+         * The input amount
+         */
+        public get amount(): BigInteger.BigInteger {
+            return this.m_amount;
+        }
+
+        /**
+         * The input offsets used in the transaction signature(s)
+         */
+        public get keyOffsets(): BigInteger.BigInteger[] {
+            return this.m_keyOffsets;
+        }
+
+        /**
+         * The key image of the input
+         */
+        public get keyImage(): string {
+            return this.m_keyImage;
+        }
+
+        /**
+         * Represents the input as a Buffer
+         * @returns the Buffer representation of the object
+         */
+        public toBuffer(): Buffer {
+            const writer = new Writer();
+
+            writer.uint8_t(this.type);
+            writer.varint(this.amount);
+            writer.varint(this.keyOffsets.length);
+
+            for (const offset of this.keyOffsets) {
+                writer.varint(offset);
+            }
+
+            writer.hash(this.keyImage);
+
+            return writer.buffer;
+        }
+
+        /**
+         * Represents the input as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public toString(): string {
+            return this.toBuffer().toString('hex');
+        }
+    }
+}

package/src/Types/ITransactionOutput.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {BigInteger} from '../Types';
+import {Writer} from 'bytestream-helper';
+
+export namespace TransactionOutputs {
+
+    /**
+     * Transaction Output Type
+     */
+    export enum OutputType {
+        KEY = 0x02,
+    }
+
+    /**
+     * Abstract interface for structured transaction outputs
+     */
+    export abstract class ITransactionOutput {
+        /**
+         * The output type
+         */
+        public abstract get type(): OutputType;
+
+        /**
+         * Returns the output as a buffer
+         * @returns the Buffer representation of the object
+         */
+        public abstract toBuffer(): Buffer;
+
+        /**
+         * Returns the input as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public abstract toString(): string;
+    }
+
+    /**
+     * Represents an output to a set of keys (wallet)
+     */
+    export class KeyOutput implements ITransactionOutput {
+
+        private readonly m_type: OutputType = OutputType.KEY;
+        private readonly m_amount: BigInteger.BigInteger = BigInteger.zero;
+        private readonly m_key: string = '';
+
+        /**
+         * Creates a new key output using the specified values
+         * @param amount the output amount
+         * @param key the one-time output key of the output
+         */
+        constructor(amount: BigInteger.BigInteger | number, key: string) {
+            if (typeof amount === 'number') {
+                amount = BigInteger(amount);
+            }
+
+            this.m_amount = amount;
+
+            this.m_key = key;
+        }
+
+        /**
+         * The output type
+         */
+        public get type(): OutputType {
+            return this.m_type;
+        }
+
+        /**
+         * The output amount
+         */
+        public get amount(): BigInteger.BigInteger {
+            return this.m_amount;
+        }
+
+        /**
+         * The one-time output key of the output
+         */
+        public get key(): string {
+            return this.m_key;
+        }
+
+        /**
+         * Represents the output as a Buffer
+         * @returns the Buffer representation of the object
+         */
+        public toBuffer(): Buffer {
+            const writer = new Writer();
+
+            writer.varint(this.amount);
+
+            writer.uint8_t(this.type);
+
+            writer.hash(this.key);
+
+            return writer.buffer;
+        }
+
+        /**
+         * Represents the output as a hexadecimal string (blob)
+         * @returns the hexadecimal (blob) representation of the object
+         */
+        public toString(): string {
+            return this.toBuffer().toString('hex');
+        }
+    }
+}