phantasma-sdk-ts 0.1.76 → 0.2.0-rc.1

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

@@ -0,0 +1,503 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignLedger = exports.DecodeSignature = exports.SplitMessageIntoChunks = exports.ChunkString = exports.GetPublicKey = exports.GetBip44PathMessage = exports.GetVersion = exports.GetApplicationName = exports.GetDevice = exports.GetErrorMessage = exports.ErrorDescriptions = exports.Bip44Path = exports.MAX_SIGNED_TX_LEN = void 0;
+const utils_1 = require("../utils");
+exports.MAX_SIGNED_TX_LEN = 1024;
+const Debug = true;
+exports.Bip44Path = '8000002C' + // 44
+    '8000003C' + // 60
+    '80000000' + // 0
+    '00000000' + // 0
+    '00000000'; // 0
+exports.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
+ */
+const GetErrorMessage = (responseStr) => {
+    const suffix = responseStr.slice(-4);
+    if (exports.ErrorDescriptions[suffix] !== undefined) {
+        const description = exports.ErrorDescriptions[suffix];
+        return `[${suffix}] ${responseStr} ${description}`;
+    }
+    else {
+        return `[${suffix}] ${responseStr} Unknown Error`;
+    }
+};
+exports.GetErrorMessage = GetErrorMessage;
+/**
+ * Get Device
+ * @param transport
+ * @returns
+ */
+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,
+    };
+};
+exports.GetDevice = GetDevice;
+/**
+ * Get Application Name
+ * @param transport
+ * @returns
+ */
+const GetApplicationName = async (transport) => {
+    const device = await (0, exports.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 = (0, utils_1.hex2ascii)(applicationName);
+        }
+        else {
+            message = (0, exports.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,
+        };
+    }
+};
+exports.GetApplicationName = GetApplicationName;
+/**
+ * Get Version
+ * @param transport
+ * @returns
+ */
+const GetVersion = async (transport) => {
+    const device = await (0, exports.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 = (0, utils_1.hex2ascii)(version);
+        }
+        else {
+            message = (0, exports.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,
+        };
+    }
+};
+exports.GetVersion = GetVersion;
+/**
+ * Get Pip44 Path Message
+ * @param messagePrefix
+ * @returns
+ */
+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(exports.Bip44Path, 'hex');
+    const bip44PathBufferLen = 5; // bip44PathBuffer.length;
+    const bip44PathBufferLenBuffer = (0, utils_1.Int2Buffer)(bip44PathBufferLen);
+    const payload = Buffer.concat([bip44PathBufferLenBuffer, bip44PathBuffer]);
+    const payloadLen = (0, utils_1.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;
+};
+exports.GetBip44PathMessage = GetBip44PathMessage;
+/**
+ * Get Public Key
+ * @param transport
+ * @param options
+ * @returns
+ */
+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 (0, exports.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 = (0, exports.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 = (0, exports.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',
+    };
+};
+exports.GetPublicKey = GetPublicKey;
+/**
+ * Chunk String
+ * @param str
+ * @param length
+ * @returns
+ */
+const ChunkString = (str, length) => {
+    return str.match(new RegExp('.{1,' + length + '}', 'g'));
+};
+exports.ChunkString = ChunkString;
+const SplitMessageIntoChunks = (ledgerMessage) => {
+    const messages = [];
+    messages.push((0, exports.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 = (0, exports.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;
+};
+exports.SplitMessageIntoChunks = SplitMessageIntoChunks;
+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;
+};
+exports.DecodeSignature = DecodeSignature;
+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 > exports.MAX_SIGNED_TX_LEN) {
+        return {
+            success: false,
+            message: `Transaction length of ${transactionByteLength} bytes exceeds max length of ${exports.MAX_SIGNED_TX_LEN} bytes. Send less candidates and consolidate utxos.`,
+        };
+    }
+    const ledgerMessage = transactionHex;
+    const messages = (0, exports.SplitMessageIntoChunks)(ledgerMessage);
+    if (Debug) {
+        console.log('sign', 'transport', transport);
+    }
+    const device = await (0, exports.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 = (0, exports.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 = (0, exports.DecodeSignature)(lastResponse);
+                success = true;
+            }
+            else {
+                message = (0, exports.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,
+        };
+    }
+};
+exports.SignLedger = SignLedger;

package/dist/core/ledger/Mnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mnemonic.d.ts","sourceRoot":"","sources":["../../../src/core/ledger/Mnemonic.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAGzD,eAAO,MAAM,SAAS,EAAE,MAAW,CAAC;AAEpC;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,WAC5B,YAAY,YACV,MAAM,SACT,MAAM,KACZ,MAKF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,WACxB,YAAY,QACd,MAAM,SACL,MAAM,KACZ,MAWF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,WACzB,YAAY,YACV,MAAM,SACT,MAAM,KACZ,MAKF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,KAAG,MAG5C,CAAC"}

package/{core → dist/core}/ledger/Mnemonic.js

@@ -2,7 +2,7 @@
 // coin used by ledger nano s.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetBip44Path = exports.GetPoltergeistMnemonic = exports.GetPrivateKeyFromSeed = exports.GetPrivateKeyFromMnemonic = exports.SOUL_COIN = void 0;
-var utils_1 = require("../utils");
+const utils_1 = require("../utils");
 // 60   | 0x80000273 | SOUL   | [Phantasma](https://phantasma.info/)
 exports.SOUL_COIN = 60;
 /**
@@ -13,10 +13,10 @@ exports.SOUL_COIN = 60;
  * @param index the bip44 index
  * @return returns the private key, hex encoded, upper case.
  */
-var GetPrivateKeyFromMnemonic = function (config, mnemonic, index) {
-    var bip39 = config.Bip39;
-    var seedBytes = bip39.mnemonicToSeedSync(mnemonic);
-    var seed = (0, utils_1.bufferToHex)(seedBytes);
+const GetPrivateKeyFromMnemonic = (config, mnemonic, index) => {
+    const bip39 = config.Bip39;
+    const seedBytes = bip39.mnemonicToSeedSync(mnemonic);
+    const seed = (0, utils_1.bytesToHex)(seedBytes);
     return (0, exports.GetPrivateKeyFromSeed)(config, seed, index);
 };
 exports.GetPrivateKeyFromMnemonic = GetPrivateKeyFromMnemonic;
@@ -28,14 +28,14 @@ exports.GetPrivateKeyFromMnemonic = GetPrivateKeyFromMnemonic;
  * @param index the bip44 index
  * @return returns the seed, hex encoded, upper case.
  */
-var GetPrivateKeyFromSeed = function (config, seed, index) {
-    var bip32Factory = config.Bip32Factory;
-    var curve = config.Curve;
-    var seedBytes = (0, utils_1.hexToBuffer)(seed);
-    var bip32 = bip32Factory(curve);
-    var bip32node = bip32.fromSeed(seedBytes);
-    var bip44path = (0, exports.GetBip44Path)(index);
-    var bip32child = bip32node.derivePath(bip44path);
+const GetPrivateKeyFromSeed = (config, seed, index) => {
+    const bip32Factory = config.Bip32Factory;
+    const curve = config.Curve;
+    const seedBytes = (0, utils_1.hexToBytes)(seed);
+    const bip32 = bip32Factory(curve);
+    const bip32node = bip32.fromSeed(seedBytes);
+    const bip44path = (0, exports.GetBip44Path)(index);
+    const bip32child = bip32node.derivePath(bip44path);
     return Buffer.from(bip32child.privateKey).toString('hex').toUpperCase();
 };
 exports.GetPrivateKeyFromSeed = GetPrivateKeyFromSeed;
@@ -47,10 +47,10 @@ exports.GetPrivateKeyFromSeed = GetPrivateKeyFromSeed;
  * @param index the index
  * @return returns the private key, hex encoded, upper case.
  */
-var GetPoltergeistMnemonic = function (config, mnemonic, index) {
-    var bip39 = config.Bip39;
-    var privateKey = (0, exports.GetPrivateKeyFromMnemonic)(config, mnemonic, index);
-    var poltergeistMnemonic = bip39.entropyToMnemonic(privateKey);
+const GetPoltergeistMnemonic = (config, mnemonic, index) => {
+    const bip39 = config.Bip39;
+    const privateKey = (0, exports.GetPrivateKeyFromMnemonic)(config, mnemonic, index);
+    const poltergeistMnemonic = bip39.entropyToMnemonic(privateKey);
     return poltergeistMnemonic;
 };
 exports.GetPoltergeistMnemonic = GetPoltergeistMnemonic;
@@ -58,8 +58,8 @@ exports.GetPoltergeistMnemonic = GetPoltergeistMnemonic;
  * @param index the index
  * @return returns the bip44 path.
  */
-var GetBip44Path = function (index) {
-    var bip44path = "m/44'/".concat(exports.SOUL_COIN, "'/0'/0/").concat(index);
+const GetBip44Path = (index) => {
+    const bip44path = `m/44'/${exports.SOUL_COIN}'/0'/0/${index}`;
     return bip44path;
 };
 exports.GetBip44Path = GetBip44Path;

package/dist/core/ledger/Transaction-Sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transaction-Sign.d.ts","sourceRoot":"","sources":["../../../src/core/ledger/Transaction-Sign.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,YAAY,kBAAmB,MAAM,KAAG,MASpD,CAAC;AAEF,eAAO,MAAM,WAAW,iBAAkB,MAAM,KAAG,MAGlD,CAAC;AAEF,eAAO,MAAM,WAAW,iBAAkB,MAAM,KAAG,MAIlD,CAAC;AAEF,eAAO,MAAM,SAAS,SAAU,MAAM,cAAc,MAAM,KAAG,MAoB5D,CAAC;AAEF,eAAO,MAAM,OAAO,cAAe,MAAM,UAAU,OAAO,KAAG,MAE5D,CAAC;AAEF,eAAO,MAAM,IAAI,cAAe,MAAM,iBAAiB,MAAM,KAAG,MAkB/D,CAAC;AAEF,eAAO,MAAM,MAAM,cAAe,MAAM,gBAAgB,MAAM,gBAAgB,MAAM,KAAG,OAqBtF,CAAC;AAEF,eAAO,MAAM,oBAAoB,eAAgB,MAAM,KAAG,MA6BzD,CAAC"}