phantasma-sdk-ts 0.2.0-rc.8 → 0.2.0

package/dist/esm/core/ledger/Ledger-Utils.js

@@ -0,0 +1,490 @@
+import { Int2Buffer, hex2ascii } from '../utils';
+export const MAX_SIGNED_TX_LEN = 1024;
+const Debug = true;
+export const Bip44Path = '8000002C' + // 44
+    '8000003C' + // 60
+    '80000000' + // 0
+    '00000000' + // 0
+    '00000000'; // 0
+export const ErrorDescriptions = {
+    '530C': 'Unlock Ledger Device',
+    '6D02': 'App Not Open On Ledger Device',
+    6511: 'App Not Open On Ledger Device',
+    '6E00': 'App Not Open On Ledger Device',
+    '6A86': 'Incorrect Pip2',
+    '6A87': 'Wrong Data Length',
+    '6A88': 'No Data Length',
+    '6A89': 'Wrong Main Data Length',
+    '6A90': 'Incorrect Pip1',
+    6985: 'Tx Denied on Ledger',
+    '6D06': 'Tx Decoding Buffer Underflow',
+    B000: 'Wrong response length on Ledger Device',
+    B002: 'Failed to display Address on Ledger Device',
+    B005: 'Failed to parse Transaction on Ledger Device',
+    B008: 'Failed to sign Transaction on Ledger Device',
+    B009: 'Wrong signing parmeters on Ledger Device',
+};
+/**
+ * Get's the error message.
+ * @param responseStr
+ * @returns
+ */
+export const GetErrorMessage = (responseStr) => {
+    const suffix = responseStr.slice(-4);
+    if (ErrorDescriptions[suffix] !== undefined) {
+        const description = ErrorDescriptions[suffix];
+        return `[${suffix}] ${responseStr} ${description}`;
+    }
+    else {
+        return `[${suffix}] ${responseStr} Unknown Error`;
+    }
+};
+/**
+ * Get Device
+ * @param transport
+ * @returns
+ */
+export const GetDevice = async (transport) => {
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('getDevice', 'transport', transport);
+    }
+    const supported = await transport.isSupported();
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('getDevice', 'supported', supported);
+    }
+    if (!supported) {
+        return {
+            enabled: false,
+            error: true,
+            message: 'Your computer does not support the ledger device.',
+        };
+    }
+    const list = await transport.list();
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('getDevice', 'list', list);
+    }
+    if (list.length == 0) {
+        return {
+            enabled: false,
+            error: true,
+            message: 'No device connected.',
+        };
+    }
+    const path = list[0];
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('getDevice', 'path', path);
+    }
+    const device = await transport.open(path);
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('getDevice', 'device', device);
+    }
+    return {
+        enabled: true,
+        error: false,
+        device: device,
+    };
+};
+/**
+ * Get Application Name
+ * @param transport
+ * @returns
+ */
+export const GetApplicationName = async (transport) => {
+    const device = await GetDevice(transport);
+    if (!device.enabled) {
+        return {
+            success: false,
+            message: 'Your computer does not support the ledger device.',
+        };
+    }
+    try {
+        const request = Buffer.from('E004000000', 'hex');
+        /* istanbul ignore if */
+        if (Debug) {
+            console.log('exchange', 'request', request.toString('hex').toUpperCase());
+        }
+        const response = await device.device.exchange(request);
+        const responseStr = response.toString('hex').toUpperCase();
+        /* istanbul ignore if */
+        if (Debug) {
+            console.log('exchange', 'response', responseStr);
+        }
+        let success = false;
+        let message = '';
+        let applicationName = '';
+        if (responseStr.endsWith('9000')) {
+            success = true;
+            message = responseStr;
+            applicationName = responseStr.substring(0, responseStr.length - 4);
+            applicationName = hex2ascii(applicationName);
+        }
+        else {
+            message = GetErrorMessage(responseStr);
+        }
+        return {
+            success: success,
+            message: message,
+            applicationName: applicationName,
+        };
+    }
+    catch (error) {
+        /* istanbul ignore if */
+        if (Debug) {
+            console.trace('getApplicationName', 'error', error);
+        }
+        return {
+            success: false,
+            message: error.message,
+        };
+    }
+    finally {
+        await device.device.close();
+    }
+    if (device.error) {
+        return {
+            success: false,
+            message: device.message,
+        };
+    }
+};
+/**
+ * Get Version
+ * @param transport
+ * @returns
+ */
+export const GetVersion = async (transport) => {
+    const device = await GetDevice(transport);
+    if (!device.enabled) {
+        return {
+            success: false,
+            message: 'Your computer does not support the ledger device.',
+        };
+    }
+    try {
+        const request = Buffer.from('E003000000', 'hex');
+        /* istanbul ignore if */
+        if (Debug) {
+            console.log('exchange', 'request', request.toString('hex').toUpperCase());
+        }
+        const response = await device.device.exchange(request);
+        const responseStr = response.toString('hex').toUpperCase();
+        /* istanbul ignore if */
+        if (Debug) {
+            console.log('exchange', 'response', responseStr);
+        }
+        let success = false;
+        let message = '';
+        let version = '';
+        if (responseStr.endsWith('9000')) {
+            success = true;
+            message = responseStr;
+            version = responseStr.substring(0, responseStr.length - 4);
+            version = hex2ascii(version);
+        }
+        else {
+            message = GetErrorMessage(responseStr);
+        }
+        return {
+            success: success,
+            message: message,
+            version: version,
+        };
+    }
+    catch (error) {
+        /* istanbul ignore if */
+        if (Debug) {
+            console.trace('getVersion', 'error', error);
+        }
+        return {
+            success: false,
+            message: error.message,
+        };
+    }
+    finally {
+        await device.device.close();
+    }
+    if (device.error) {
+        return {
+            success: false,
+            message: device.message,
+        };
+    }
+};
+/**
+ * Get Pip44 Path Message
+ * @param messagePrefix
+ * @returns
+ */
+export const GetBip44PathMessage = (messagePrefix) => {
+    /* istanbul ignore if */
+    if (messagePrefix == undefined) {
+        throw Error('messagePrefix is a required parameter.');
+    }
+    if (messagePrefix.length !== 4) {
+        throw Error('messagePrefix must be of length 4.');
+    }
+    const bip44PathBuffer = Buffer.from(Bip44Path, 'hex');
+    const bip44PathBufferLen = 5; // bip44PathBuffer.length;
+    const bip44PathBufferLenBuffer = Int2Buffer(bip44PathBufferLen);
+    const payload = Buffer.concat([bip44PathBufferLenBuffer, bip44PathBuffer]);
+    const payloadLen = Int2Buffer(payload.length);
+    if (Debug) {
+        console.log('getBip44PathMessage', 'bip44PathBuffer', bip44PathBuffer.toString('hex').toUpperCase());
+        console.log('getBip44PathMessage', 'bip44PathBufferLen', bip44PathBufferLen);
+        console.log('getBip44PathMessage', 'bip44PathBufferLenBuffer', bip44PathBufferLenBuffer.toString('hex').toUpperCase());
+        console.log('getBip44PathMessage', 'payload', payload.toString('hex').toUpperCase());
+        console.log('getBip44PathMessage', 'payloadLen', payloadLen.toString('hex').toUpperCase());
+    }
+    const message = Buffer.concat([messagePrefix, payloadLen, payload]);
+    return message;
+};
+/**
+ * Get Public Key
+ * @param transport
+ * @param options
+ * @returns
+ */
+export const GetPublicKey = async (transport, options) => {
+    /* istanbul ignore if */
+    if (transport == undefined) {
+        throw Error('transport is a required parameter.');
+    }
+    /* istanbul ignore if */
+    if (options == undefined) {
+        throw Error('options is a required parameter.');
+    }
+    const device = await GetDevice(transport);
+    if (!device.enabled) {
+        return {
+            success: false,
+            message: 'Your computer does not support the ledger device.',
+        };
+    }
+    try {
+        let messagePrefix;
+        if (options.verifyOnDevice) {
+            messagePrefix = Buffer.from('E0050100', 'hex');
+        }
+        else {
+            messagePrefix = Buffer.from('E0050000', 'hex');
+        }
+        const request = GetBip44PathMessage(messagePrefix);
+        /* istanbul ignore if */
+        if (Debug) {
+            console.log('exchange', 'request', request.toString('hex').toUpperCase());
+        }
+        const response = await device.device.exchange(request);
+        const responseStr = response.toString('hex').toUpperCase();
+        /* istanbul ignore if */
+        if (Debug) {
+            console.log('exchange', 'response', responseStr);
+        }
+        let success = false;
+        let message = '';
+        let publicKey = '';
+        if (responseStr.endsWith('9000')) {
+            success = true;
+            message = responseStr;
+            publicKey = responseStr.substring(0, 64);
+        }
+        else {
+            message = GetErrorMessage(responseStr);
+        }
+        return {
+            success: success,
+            message: message,
+            publicKey: publicKey,
+        };
+    }
+    catch (error) {
+        /* istanbul ignore if */
+        if (Debug) {
+            console.trace('getPublicKey', 'error', error);
+        }
+        return {
+            success: false,
+            message: error.message,
+        };
+    }
+    finally {
+        await device.device.close();
+    }
+    if (device.error) {
+        return {
+            success: false,
+            message: device.message,
+        };
+    }
+    return {
+        success: false,
+        message: 'Unknown Error',
+    };
+};
+/**
+ * Chunk String
+ * @param str
+ * @param length
+ * @returns
+ */
+export const ChunkString = (str, length) => {
+    return str.match(new RegExp('.{1,' + length + '}', 'g'));
+};
+export const SplitMessageIntoChunks = (ledgerMessage) => {
+    const messages = [];
+    messages.push(GetBip44PathMessage(Buffer.from('E006' + '00' + '80', 'hex')));
+    if (Debug) {
+        console.log('splitMessageIntoChunks', 'ledgerMessage.length', ledgerMessage.length);
+    }
+    // MAX 250, as theres 5 header bytes, and max total buffer size is 255.
+    const bufferSize = 250 * 2;
+    // ledgerMessage = ledgerMessage.substring(0,bufferSize);
+    const chunks = ChunkString(ledgerMessage, bufferSize);
+    for (let chunkIx = 0; chunkIx < chunks.length; chunkIx++) {
+        const chunk = chunks[chunkIx];
+        const chunkNbr = chunkIx + 1;
+        if (Debug) {
+            console.log('splitMessageIntoChunks', 'chunk.length', chunk.length);
+        }
+        const p1 = chunkNbr.toString(16).padStart(2, '0');
+        if (Debug) {
+            console.log('splitMessageIntoChunks', 'p1', p1);
+        }
+        let p2;
+        if (chunkNbr == chunks.length) {
+            // LAST
+            p2 = '00';
+        }
+        else {
+            // MORE
+            p2 = '80';
+        }
+        if (Debug) {
+            console.log('splitMessageIntoChunks', 'p2', p2);
+        }
+        const chunkLength = chunk.length / 2;
+        const chunkLengthHex = chunkLength.toString(16).padStart(2, '0');
+        if (Debug) {
+            console.log('splitMessageIntoChunks', 'chunkLengthHex', chunkLengthHex);
+        }
+        const messageHex = 'E006' + p1 + p2 + chunkLengthHex + chunk;
+        if (Debug) {
+            console.log('splitMessageIntoChunks', 'messageHex', messageHex);
+        }
+        const message = Buffer.from(messageHex, 'hex');
+        if (Debug) {
+            console.log('splitMessageIntoChunks', 'message', message);
+        }
+        messages.push(message);
+    }
+    return messages;
+};
+export const DecodeSignature = (response) => {
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('decodeSignature', 'response', response);
+    }
+    const signature = response.substring(0, 128);
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('decodeSignature', 'signature', signature);
+    }
+    return signature;
+};
+export const SignLedger = async (transport, transactionHex) => {
+    /* istanbul ignore if */
+    if (Debug) {
+        console.log('sign', 'transactionHex', transactionHex);
+    }
+    // transactionHex = '0200000000000000';
+    const transactionByteLength = Math.ceil(transactionHex.length / 2);
+    if (transactionByteLength > MAX_SIGNED_TX_LEN) {
+        return {
+            success: false,
+            message: `Transaction length of ${transactionByteLength} bytes exceeds max length of ${MAX_SIGNED_TX_LEN} bytes. Send less candidates and consolidate utxos.`,
+        };
+    }
+    const ledgerMessage = transactionHex;
+    const messages = SplitMessageIntoChunks(ledgerMessage);
+    if (Debug) {
+        console.log('sign', 'transport', transport);
+    }
+    const device = await GetDevice(transport);
+    if (Debug) {
+        console.log('sign', 'device', device);
+        console.log('sign', 'messages.length', messages.length);
+    }
+    if (!device.enabled) {
+        return {
+            success: false,
+            message: 'Your computer does not support the ledger device.',
+        };
+    }
+    try {
+        let lastResponse = undefined;
+        // console.log('deviceThenCallback', 'messages', messages);
+        for (let ix = 0; ix < messages.length; ix++) {
+            const message = messages[ix];
+            /* istanbul ignore if */
+            if (Debug) {
+                console.log('exchange', ix, 'of', messages.length, 'message', message.toString('hex').toUpperCase());
+            }
+            const response = await device.device.exchange(message);
+            const responseStr = response.toString('hex').toUpperCase();
+            if (Debug) {
+                console.log('exchange', ix, 'of', messages.length, 'response', responseStr);
+            }
+            if (responseStr !== undefined) {
+                if (!responseStr.endsWith('9000')) {
+                    const message = GetErrorMessage(responseStr);
+                    return {
+                        success: false,
+                        message: message,
+                        signature: '',
+                    };
+                }
+            }
+            lastResponse = responseStr;
+        }
+        let signature = undefined;
+        let success = false;
+        let message = lastResponse;
+        if (lastResponse !== undefined) {
+            if (lastResponse.endsWith('9000')) {
+                signature = DecodeSignature(lastResponse);
+                success = true;
+            }
+            else {
+                message = GetErrorMessage(lastResponse);
+            }
+        }
+        return {
+            success: success,
+            message: message,
+            signature: signature,
+        };
+    }
+    catch (error) {
+        /* istanbul ignore if */
+        if (Debug) {
+            console.trace('sign', 'error', error);
+        }
+        return {
+            success: false,
+            message: error.message,
+        };
+    }
+    finally {
+        await device.device.close();
+    }
+    if (device.error) {
+        return {
+            success: false,
+            message: device.message,
+        };
+    }
+};

package/dist/esm/core/ledger/Mnemonic.js

@@ -0,0 +1,58 @@
+// coin used by ledger nano s.
+import { bytesToHex, hexToBytes } from '../utils';
+// 60   | 0x80000273 | SOUL   | [Phantasma](https://phantasma.info/)
+export const SOUL_COIN = 60;
+/**
+ * converts a mnemonic into a private key, using the phantasma coin's bip44 path.
+ *
+ * @param config the config
+ * @param mnemonic the mnemonic
+ * @param index the bip44 index
+ * @return returns the private key, hex encoded, upper case.
+ */
+export const GetPrivateKeyFromMnemonic = (config, mnemonic, index) => {
+    const bip39 = config.Bip39;
+    const seedBytes = bip39.mnemonicToSeedSync(mnemonic);
+    const seed = bytesToHex(seedBytes);
+    return GetPrivateKeyFromSeed(config, seed, index);
+};
+/**
+ * converts a mnemonic into a seed.
+ *
+ * @param config the config
+ * @param seed the seed
+ * @param index the bip44 index
+ * @return returns the seed, hex encoded, upper case.
+ */
+export const GetPrivateKeyFromSeed = (config, seed, index) => {
+    const bip32Factory = config.Bip32Factory;
+    const curve = config.Curve;
+    const seedBytes = hexToBytes(seed);
+    const bip32 = bip32Factory(curve);
+    const bip32node = bip32.fromSeed(seedBytes);
+    const bip44path = GetBip44Path(index);
+    const bip32child = bip32node.derivePath(bip44path);
+    return Buffer.from(bip32child.privateKey).toString('hex').toUpperCase();
+};
+/**
+ * converts a mnemonic into a Poltergeist mnemonic, using the phantasma coin's bip44 path.
+ *
+ * @param config the config
+ * @param mnemonic the mnemonic
+ * @param index the index
+ * @return returns the private key, hex encoded, upper case.
+ */
+export const GetPoltergeistMnemonic = (config, mnemonic, index) => {
+    const bip39 = config.Bip39;
+    const privateKey = GetPrivateKeyFromMnemonic(config, mnemonic, index);
+    const poltergeistMnemonic = bip39.entropyToMnemonic(privateKey);
+    return poltergeistMnemonic;
+};
+/**
+ * @param index the index
+ * @return returns the bip44 path.
+ */
+export const GetBip44Path = (index) => {
+    const bip44path = `m/44'/${SOUL_COIN}'/0'/0/${index}`;
+    return bip44path;
+};

package/dist/esm/core/ledger/Transaction-Sign.js

@@ -0,0 +1,115 @@
+import * as crypto from 'crypto';
+const PUBLIC_KEY_PREFIX = '302A300506032B6570032100';
+const DEBUG = false;
+export const PrivateToDer = (privateKeyHex) => {
+    if (DEBUG) {
+        console.log('privateToDer', 'privateKeyHex', privateKeyHex);
+    }
+    const derHex = `302e020100300506032b657004220420${privateKeyHex}`;
+    if (DEBUG) {
+        console.log('privateToDer', 'derHex', derHex);
+    }
+    return Buffer.from(derHex, 'hex');
+};
+export const PublicToDer = (publicKeyHex) => {
+    const publicKeyDerHex = `${PUBLIC_KEY_PREFIX}${publicKeyHex}`;
+    return Buffer.from(publicKeyDerHex, 'hex');
+};
+export const PublicToPem = (publicKeyHex) => {
+    const publicKeyDer = PublicToDer(publicKeyHex);
+    const publicKeyDerBase64 = publicKeyDer.toString('base64');
+    return `-----BEGIN PUBLIC KEY-----\n${publicKeyDerBase64}\n-----END PUBLIC KEY-----`;
+};
+export const SignBytes = (hash, privateKey) => {
+    if (DEBUG) {
+        console.log('signBytes.hash', hash);
+        console.log('signBytes.privateKey', privateKey);
+    }
+    const privateKeyDer = PrivateToDer(privateKey.toString('hex'));
+    if (DEBUG) {
+        console.log('signBytes.privateKeyDer', privateKeyDer);
+    }
+    const privateKeyObj = crypto.createPrivateKey({
+        key: privateKeyDer,
+        format: 'der',
+        type: 'pkcs8',
+    });
+    const signature = crypto.sign(undefined, hash, privateKeyObj);
+    const signatureHex = signature.toString('hex');
+    if (DEBUG) {
+        console.log('signatureHex', signatureHex);
+    }
+    return signatureHex;
+};
+export const GetHash = (encodedTx, debug) => {
+    return Buffer.from(encodedTx, 'hex');
+};
+export const Sign = (encodedTx, privateKeyHex) => {
+    if (DEBUG) {
+        console.log('sign', 'encodedTx', encodedTx);
+    }
+    const privateKey = Buffer.from(privateKeyHex, 'hex');
+    if (DEBUG) {
+        console.log('sign', 'privateKey', privateKey.toString('hex'));
+    }
+    const hash = GetHash(encodedTx);
+    if (DEBUG) {
+        console.log('sign', 'hash', hash.toString('hex'));
+    }
+    const signature = SignBytes(hash, privateKey);
+    if (DEBUG) {
+        console.log('sign', 'signature', signature);
+    }
+    return signature.toLowerCase();
+};
+export const Verify = (encodedTx, signatureHex, publicKeyHex) => {
+    if (DEBUG) {
+        console.log('verify', 'encodedTx', encodedTx);
+        console.log('verify', 'signatureHex', signatureHex);
+        console.log('verify', 'publicKeyHex', publicKeyHex);
+    }
+    const publicKeyPem = PublicToPem(publicKeyHex);
+    if (DEBUG) {
+        console.log('verify', 'publicKeyPem', publicKeyPem);
+    }
+    const publicKeyObj = crypto.createPublicKey({
+        key: publicKeyPem,
+        format: 'pem',
+        type: 'spki',
+    });
+    const signature = Buffer.from(signatureHex, 'hex');
+    const hash = GetHash(encodedTx);
+    if (DEBUG) {
+        console.log('verify', 'hash', hash.toString('hex'));
+    }
+    return crypto.verify(undefined, hash, publicKeyObj, signature);
+};
+export const GetPublicFromPrivate = (privateKey) => {
+    const privateKeyDer = PrivateToDer(privateKey);
+    const privateKeyObj = crypto.createPrivateKey({
+        key: privateKeyDer,
+        format: 'der',
+        type: 'pkcs8',
+    });
+    const privateKeyString = privateKeyObj.export({ format: 'der', type: 'pkcs8' });
+    /*const publicKeyObj = crypto.createPublicKey({
+      key: privateKeyObj,
+      format: 'pem',
+      type: 'sec1',
+    });*/
+    const publicKeyObj = crypto.createPublicKey({
+        key: privateKeyString,
+        format: 'pem',
+        type: 'spki',
+    });
+    const encodedHex = publicKeyObj
+        .export({ format: 'der', type: 'spki' })
+        .toString('hex')
+        .toUpperCase();
+    if (encodedHex.startsWith(PUBLIC_KEY_PREFIX)) {
+        return encodedHex.substring(PUBLIC_KEY_PREFIX.length);
+    }
+    else {
+        throw new Error(`unknown prefix, expecting '${PUBLIC_KEY_PREFIX}' cannot decode public key '${encodedHex}'`);
+    }
+};

package/dist/esm/core/ledger/Transaction-Transcode.js

@@ -0,0 +1,41 @@
+'use strict';
+/**
+ * Expiration Date is in UTC Seconds
+ * @param expirationDate
+ * @returns
+ */
+export const GetDateAsUTCSeconds = (expirationDate) => {
+    const expirationDateUTCms = Date.UTC(expirationDate.getUTCFullYear(), expirationDate.getUTCMonth(), expirationDate.getUTCDate(), expirationDate.getUTCHours(), expirationDate.getUTCMinutes(), expirationDate.getUTCSeconds());
+    return expirationDateUTCms / 1000;
+};
+/**
+ * Get Expiration Date
+ * @returns
+ */
+export const GetExpirationDate = () => {
+    // TODO: make expirationDate configurable.
+    const expirationMinutes = 5; // This is in minutes
+    const expirationDate = new Date(Date.now() + expirationMinutes * 60000);
+    return expirationDate;
+};
+/**
+ *
+ * @param transaction
+ * @returns
+ */
+export const EncodeSendTxWithSignature = (transaction) => {
+    // console.log('encodeSendTx', 'transaction', transaction);
+    const sendTx = transaction.toString(true);
+    // console.log('encodeSendTx', 'sendTx', sendTx);
+    return sendTx;
+};
+/**
+ *
+ * @param transaction
+ * @returns
+ */
+export const EncodeSendTxWithoutSignature = (transaction) => {
+    const sendTx = transaction.toString(false);
+    // console.log('encodeSendTx', 'sendTx', sendTx);
+    return sendTx;
+};