@leocuvee/turtlecoin-utils 0.0.14

package/src/Types/MultisigInterfaces.ts

@@ -0,0 +1,65 @@
+// Copyright (c) 2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {Interfaces} from './ITransaction';
+
+export namespace MultisigInterfaces {
+    /**
+     * Represents a partial key image
+     */
+    export interface PartialKeyImage {
+        /**
+         * The partial key image
+         */
+        partialKeyImage: string;
+        /**
+         * The transaction hash for which the partial key image belongs
+         */
+        transactionHash: string;
+        /**
+         * The index in the transaction outputs for which the partial key image belongs
+         */
+        outputIndex: number;
+    }
+
+    /**
+     * Represents a partial signing key for a particular prepared transaction
+     */
+    export interface PartialSigningKey {
+        /**
+         * The transaction prefix hash for which this partial signing key is valid
+         */
+        transactionPrefixHash: string;
+        /**
+         * The transaction signature index (which signature set this applies to)
+         */
+        index: number;
+        /**
+         * The partial signing key
+         */
+        partialSigningKey: string;
+    }
+
+    /** @ignore */
+    export interface Payload {
+        publicSpendKeys: PublicSpendKey[];
+        privateViewKey: string;
+        partialKeyImages?: PartialKeyImage[];
+        partialSigningKeys?: PartialSigningKey[];
+        preparedTransactions?: Interfaces.PreparedTransaction[];
+    }
+
+    /** @ignore */
+    export interface PublicSpendKey {
+        key: string;
+        signature: string;
+    }
+
+    /** @ignore */
+    export interface Transfer {
+        address: string;
+        messageId: number;
+        payload: string;
+    }
+}

package/src/Types/PortableStorage.ts

@@ -0,0 +1,289 @@
+// Copyright (c) 2019-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {Reader, Writer} from 'bytestream-helper';
+import {BigInteger, PortableStorageConstants} from '../Types';
+
+/** @ignore */
+type PortableStoreValue =
+    BigInteger.BigInteger |
+    Buffer |
+    PortableStorage |
+    PortableStorage[] |
+    string |
+    string[] |
+    boolean;
+
+/** @ignore */
+export enum StorageType {
+    NULL = 0x00,
+    INT64 = 0x01,
+    INT = 0x02,
+    INT16 = 0x03,
+    SBYTE = 0x04,
+    UINT64 = 0x05,
+    UINT32 = 0x06,
+    UINT16 = 0x07,
+    UINT8 = 0x08,
+    DOUBLE = 0x09,
+    STRING = 0x0a,
+    BOOL = 0x0b,
+    OBJECT = 0x0c,
+    OBJECT_ARRAY_BAD = 0x0d,
+    BUFFER = 0x0e,
+    STRING_ARRAY = 0x8a,
+    OBJECT_ARRAY = 0x8c,
+}
+
+/** @ignore */
+interface PortableStorageEntry {
+    name: string;
+    type: StorageType;
+    value: any;
+}
+
+/** @ignore */
+export class PortableStorage {
+
+    public get version(): number {
+        return this.m_version;
+    }
+
+    public set version(value: number) {
+        this.m_version = value;
+    }
+
+    public static from(data: Reader | Buffer | string, skipHeader: boolean = false): PortableStorage {
+        const reader = new Reader(data);
+
+        const result = new PortableStorage();
+
+        if (reader.unreadBytes === 0) {
+            return result;
+        }
+
+        if (!skipHeader) {
+            result.m_signatureA = reader.uint32_t().toJSNumber();
+            result.m_signatureB = reader.uint32_t().toJSNumber();
+
+            if (result.m_signatureA !== PortableStorageConstants.SIGNATURE_A
+                || result.m_signatureB !== PortableStorageConstants.SIGNATURE_B) {
+                throw new Error('Portable storage signature failure');
+            }
+
+            result.m_version = reader.uint8_t().toJSNumber();
+        }
+
+        result.m_entries = blobToEntries(reader);
+
+        if (!skipHeader && reader.unreadBytes !== 0) {
+            throw new RangeError('Unstructured data found in stream');
+        }
+
+        return result;
+    }
+
+    protected m_version: number = PortableStorageConstants.VERSION;
+    protected m_signatureA: number = PortableStorageConstants.SIGNATURE_A;
+    protected m_signatureB: number = PortableStorageConstants.SIGNATURE_B;
+    protected m_entries: PortableStorageEntry[] = [];
+
+    public get(name: string): PortableStoreValue {
+        for (const entry of this.m_entries) {
+            if (entry.name === name) {
+                return entry.value;
+            }
+        }
+
+        throw new Error('Entry not found');
+    }
+
+    public set(name: string, value: PortableStoreValue, type: StorageType) {
+        // tslint:disable-next-line:prefer-for-of
+        for (let i = 0; i < this.m_entries.length; i++) {
+            if (this.m_entries[i].name === name && this.m_entries[i].type === type) {
+                this.m_entries[i].value = value;
+                return;
+            }
+        }
+
+        this.m_entries.push({name, type, value});
+    }
+
+    public exists(name: string): boolean {
+        for (const entry of this.m_entries) {
+            if (entry.name === name) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public toBuffer(skipHeader: boolean = false): Buffer {
+        const writer = new Writer();
+
+        if (!skipHeader) {
+            writer.uint32_t(this.m_signatureA);
+            writer.uint32_t(this.m_signatureB);
+            writer.uint8_t(this.m_version);
+        }
+
+        writer.write(entriesToBuffer(this.m_entries));
+
+        return writer.buffer;
+    }
+
+    public toString(skipHeader: boolean = false): string {
+        return this.toBuffer(skipHeader).toString('hex');
+    }
+}
+
+/** @ignore */
+function blobToEntries(reader: Reader): PortableStorageEntry[] {
+    const entryCount = reader.varint(false, true).toJSNumber();
+    const entries: PortableStorageEntry[] = [];
+
+    for (let i = 0; i < entryCount; i++) {
+        const keyLength = reader.uint8_t().toJSNumber();
+        const name = reader.bytes(keyLength).toString();
+        const type = reader.uint8_t().toJSNumber();
+
+        let arrCount;
+        let j;
+        let value;
+        let valueLength;
+
+        switch (type) {
+            case StorageType.NULL:
+                entries.push({name, type, value: null});
+                break;
+
+            case StorageType.UINT64:
+                entries.push({name, type, value: reader.uint64_t(true)});
+                break;
+
+            case StorageType.UINT32:
+                entries.push({name, type, value: reader.uint32_t()});
+                break;
+
+            case StorageType.UINT16:
+                entries.push({name, type, value: reader.uint16_t()});
+                break;
+
+            case StorageType.UINT8:
+                entries.push({name, type, value: reader.uint8_t()});
+                break;
+
+            case StorageType.STRING:
+                valueLength = reader.varint(false, true).toJSNumber();
+                entries.push({name, type, value: reader.bytes(valueLength).toString('hex')});
+                break;
+
+            case StorageType.BOOL:
+                value = reader.uint8_t().toJSNumber();
+                entries.push({name, type, value: (value === 1)});
+                break;
+
+            case StorageType.OBJECT:
+                entries.push({name, type, value: PortableStorage.from(reader, true)});
+                break;
+
+            case StorageType.BUFFER:
+                valueLength = reader.varint(false, true).toJSNumber();
+                entries.push({name, type, value: reader.bytes(valueLength)});
+                break;
+
+            case StorageType.STRING_ARRAY:
+                arrCount = reader.varint(false, true).toJSNumber();
+                const sa_arr: string[] = [];
+
+                for (j = 0; j < arrCount; j++) {
+                    const stringLength = reader.varint(false, true).toJSNumber();
+
+                    sa_arr.push(reader.bytes(stringLength).toString('hex'));
+                }
+
+                entries.push({name, type, value: sa_arr});
+                break;
+
+            case StorageType.OBJECT_ARRAY:
+                arrCount = reader.varint(false, true).toJSNumber();
+                const oa_arr: PortableStorage[] = [];
+
+                for (j = 0; j < arrCount; j++) {
+                    oa_arr.push(PortableStorage.from(reader, true));
+                }
+
+                entries.push({name, type, value: oa_arr});
+                break;
+            default:
+                throw new Error(type + ' not implemented');
+        }
+    }
+
+    return entries;
+}
+
+/** @ignore */
+function entriesToBuffer(entries: PortableStorageEntry[]): Buffer {
+    const writer = new Writer();
+
+    writer.varint(entries.length, true);
+
+    for (const entry of entries) {
+        const keyName = Buffer.from(entry.name);
+        writer.uint8_t(keyName.length);
+        writer.write(keyName);
+        writer.uint8_t(entry.type);
+
+        switch (entry.type) {
+            case StorageType.UINT64:
+                writer.uint64_t(entry.value, true);
+                break;
+            case StorageType.UINT32:
+                writer.uint32_t(entry.value);
+                break;
+            case StorageType.UINT16:
+                writer.uint16_t(entry.value);
+                break;
+            case StorageType.UINT8:
+                writer.uint8_t(entry.value);
+                break;
+            case StorageType.STRING:
+                const s_buf = Buffer.from(entry.value, 'hex');
+                writer.varint(s_buf.length, true);
+                writer.write(s_buf);
+                break;
+            case StorageType.BOOL:
+                writer.uint8_t((entry.value) ? 1 : 0);
+                break;
+            case StorageType.OBJECT:
+                writer.write(entry.value.toBuffer(true));
+                break;
+            case StorageType.BUFFER:
+                writer.varint(entry.value.length, true);
+                writer.write(entry.value);
+                break;
+            case StorageType.STRING_ARRAY:
+                writer.varint(entry.value.length, true);
+                entry.value.forEach((v: string) => {
+                    const vb = Buffer.from(v, 'hex');
+                    writer.varint(vb.length, true);
+                    writer.write(vb);
+                });
+                break;
+            case StorageType.OBJECT_ARRAY:
+                writer.varint(entry.value.length, true);
+                entry.value.forEach((v: PortableStorage) => {
+                    writer.write(v.toBuffer(true));
+                });
+                break;
+            default:
+                throw new Error('Unknown type: ' + entry.type);
+        }
+    }
+
+    return writer.buffer;
+}

package/src/Types.ts

@@ -0,0 +1,36 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+import {Crypto} from 'turtlecoin-crypto';
+import * as BigInteger from 'big-integer';
+
+/** @ignore */
+const TurtleCoinCrypto = new Crypto();
+
+export {TurtleCoinCrypto};
+
+/** @ignore */
+export enum PortableStorageConstants {
+    SIGNATURE_A = 0x01011101,
+    SIGNATURE_B = 0x01020101,
+    VERSION = 1,
+}
+
+export * from './Types/IExtraNonce';
+
+export * from './Types/IExtraTag';
+
+export * from './Types/ITransactionInput';
+
+export * from './Types/ITransactionOutput';
+
+export * from './Types/ED25519';
+
+export * from './Types/ITransaction';
+
+export * from './Types/MultisigInterfaces';
+
+export {PortableStorage, StorageType} from './Types/PortableStorage';
+
+export {BigInteger};

package/src/index.ts

@@ -0,0 +1,36 @@
+// Copyright (c) 2018-2020, The TurtleCoin Developers
+//
+// Please see the included LICENSE file for more information.
+
+export {Address} from './Address';
+export {AddressPrefix} from './AddressPrefix';
+export {Block} from './Block';
+export {BlockTemplate} from './BlockTemplate';
+export {Crypto} from 'turtlecoin-crypto';
+export {CryptoNote} from './CryptoNote';
+export {LevinPacket, LevinProtocol} from './LevinPacket';
+export {LevinPayloads} from './Types/LevinPayloads';
+export {Multisig} from './Multisig';
+export {MultisigMessage} from './MultisigMessage';
+export {ParentBlock} from './ParentBlock';
+export {Transaction} from './Transaction';
+
+/** @ignore */
+import * as Types from './Types';
+
+/** @ignore */
+import KeyInput = Types.TransactionInputs.KeyInput;
+/** @ignore */
+import KeyOutput = Types.TransactionOutputs.KeyOutput;
+/** @ignore */
+import KeyPair = Types.ED25519.KeyPair;
+/** @ignore */
+import Keys = Types.ED25519.Keys;
+
+/** @ignore */
+export {
+    KeyInput,
+    KeyOutput,
+    KeyPair,
+    Keys,
+};

package/test/template.json

@@ -0,0 +1,6 @@
+{
+  "blocktemplate": "0500b4318c1249164393f7b9d691e60aba81ca9bbffb9e0b23e6b01c93d9c621ab800000b5f9abe605000000000000000000000000000000000000000000000000000000000000000000000000010000000023032100000000000000000000000000000000000000000000000000000000000000000001b9fe5801ff91fe58070802959f9d01c4cbd664e7c937687e7ae847f75745614ba4a11a6f5c0b25a5ca42c314026840ba5dc6c84a533d005f0a6f9758c4eb4d19bffa3b4a73547596dac17b7d169003022f88b7b85f42c789721e7ee44bded4b6e1e48f7fb9bb73dc87cda264adf06a54f02e02175cea7cf09b914749c650b9321678d3f0e4390cad20ac6896be7ac14ba4f31ab0ea01021192fdc86fd815642850c0f50bc11df8ba1d39581d2c0642aa83f72f1c3fb22580ea3002c28a03fb9b3b7f6e4f9cdf2e74e93c8282580d8134722302b9978cdc3a35f39980897a02a4978ee1742da6f77791f065326922ff8c713687d2b52215ce7911b08922a7602901296929051bf0b258b717ffdca80c8b0822063c9d3f70f0dbed9b3f2e0aca2fa1020600000000000012f6b48f1800c368e046252e50165620fbb155176d17ddfdb98fd3227237760cf579af90593ec64a4a5549bd219969dc9aa1aac2dc3eab529c90b2f8c20221f99f02bdfb9a7efb5e5e85b710ef442b3cc82431173db142947a4f755a22f45915e5f2d53027a4aee505305c7cde822f960578417779ef71c1c8b611e95f1643fd125a39df66f40ce82794c9debc342381f26763c80968f8bf8e5378b433c583a6078348457ebe6ad61e5487ac3bebe22e03c46d9c894a511561ffbe9612809c17207493941d607b152f4ce193f828085ee8afcc0a351a9cecac0f01b2729df67af831637f76a8430848d86beb643df918af6cc554a8d0b42899671ee02cfbe64905b4458647a90a50aa307be48f3db57ff7f5446926ee70cee0c0cf7ad9021de727b2f97b5e2f0fd0103b24725d0c11ddd876de27a7b837bdd43eb4d9ca479883ad2dcd853ece92e6a7544b24e44051411e6b913760b9d997ca986985b92d51ccbc5708f0cd93c0ce2d1aea46a6744cc81a3df394cd099518cb3c3a5fa43e187c9d72bc3a245256fa60b450411b56d2258d4001b6133f58a5d48af0cc12af652c202b3c9de3f426026500c493c075340ca713a49843db16bda542fd76fb597914e1c975a70d12971baf70b8f7f6f452fd669f3cc00d0a0f36a3312f7c51cadf24cac9c24841eeaa742b5d1e74a750e5763afbd2a75e341edb4439801ac665dd0a3b16cc648a651546c7a3633f0a0274bb3815d6bda05e12fb7cbb908ceb582590a84a30ba6043178279343f5107713390b8e2ca2a8723ee7e5855c6af674bbd9b5a",
+  "difficulty": 9796275295,
+  "height": 1457937,
+  "reservedOffset": 411
+}