@trezor/connect 9.7.0-beta.1 → 9.7.0

package/lib/api/firmware/parseFirmwareHeaders.js

@@ -1,35 +1,34 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.parseFirmwareHeaders = void 0;
-const parseFirmwareHeaders = (buff) => {
-    const vendorHeader = buff.subarray(0, 4).toString('utf8');
-    let trezorImageHeader = '';
-    let restbuff;
-    if (vendorHeader === 'TRZV') {
-        const vendorHeaderLength = buff.readUInt32LE(4);
-        trezorImageHeader = buff
-            .subarray(vendorHeaderLength, vendorHeaderLength + 4)
-            .toString('utf8');
-        restbuff = buff.subarray(vendorHeaderLength + 4);
-    }
-    else if (vendorHeader === 'TRZR') {
-        restbuff = buff.subarray(256 + 4);
-        trezorImageHeader = buff.subarray(256, 256 + 4).toString('utf8');
-    }
-    else {
-        restbuff = buff.subarray(4);
-        trezorImageHeader = buff.subarray(0, 4).toString('utf8');
-    }
-    if (trezorImageHeader !== 'TRZF') {
-        throw new Error(`unexpected header ${vendorHeader}`);
-    }
-    const version_major = restbuff.readInt8(12);
-    const version_minor = restbuff.readInt8(13);
-    const version_patch = restbuff.readInt8(14);
-    const version = [version_major, version_minor, version_patch];
-    return {
-        version,
-    };
+const parseFirmwareHeaders = buff => {
+  const vendorHeader = buff.subarray(0, 4).toString('utf8');
+  let trezorImageHeader = '';
+  let restbuff;
+  if (vendorHeader === 'TRZV') {
+    const vendorHeaderLength = buff.readUInt32LE(4);
+    trezorImageHeader = buff.subarray(vendorHeaderLength, vendorHeaderLength + 4).toString('utf8');
+    restbuff = buff.subarray(vendorHeaderLength + 4);
+  } else if (vendorHeader === 'TRZR') {
+    restbuff = buff.subarray(256 + 4);
+    trezorImageHeader = buff.subarray(256, 256 + 4).toString('utf8');
+  } else {
+    restbuff = buff.subarray(4);
+    trezorImageHeader = buff.subarray(0, 4).toString('utf8');
+  }
+  if (trezorImageHeader !== 'TRZF') {
+    throw new Error(`unexpected header ${vendorHeader}`);
+  }
+  const version_major = restbuff.readInt8(12);
+  const version_minor = restbuff.readInt8(13);
+  const version_patch = restbuff.readInt8(14);
+  const version = [version_major, version_minor, version_patch];
+  return {
+    version
+  };
 };
 exports.parseFirmwareHeaders = parseFirmwareHeaders;
 //# sourceMappingURL=parseFirmwareHeaders.js.map

package/lib/api/firmware/uploadFirmware.js

@@ -1,82 +1,99 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.uploadFirmware = void 0;
 const transport_1 = require("@trezor/transport");
 const constants_1 = require("../../constants");
 const events_1 = require("../../events");
 const postConfirmationMessage = (device, updateFlowType) => {
-    const freshInstall = device.features.firmware_present === false;
-    if (freshInstall || updateFlowType === 'reboot_and_upgrade')
-        return;
-    device.emit(events_1.DEVICE.BUTTON, { device, payload: { code: 'ButtonRequest_FirmwareUpdate' } });
+  const freshInstall = device.features.firmware_present === false;
+  if (freshInstall || updateFlowType === 'reboot_and_upgrade') return;
+  device.emit(events_1.DEVICE.BUTTON, {
+    device,
+    payload: {
+      code: 'ButtonRequest_FirmwareUpdate'
+    }
+  });
 };
 const postProgressMessage = (device, progress, postMessage) => {
-    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
-        device: device.toMessageObject(),
-        operation: 'flashing',
-        progress,
-    }));
+  postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+    device: device.toMessageObject(),
+    operation: 'flashing',
+    progress
+  }));
 };
 const FIRMWARE_ERASE_TIMEOUT_MILLISECONDS = 15_000;
-const uploadFirmware = async ({ typedCall, postMessage, device, firmwareUploadRequest: { payload }, updateFlowType, }) => {
-    if (device.features.major_version === 1) {
-        postConfirmationMessage(device, updateFlowType);
-        const timeoutId = setTimeout(() => {
-            postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS_UNEXPECTED_DELAY, {}));
-        }, FIRMWARE_ERASE_TIMEOUT_MILLISECONDS);
-        await typedCall('FirmwareErase', 'Success', {});
-        clearTimeout(timeoutId);
-        postProgressMessage(device, 0, postMessage);
-        let i = 0;
-        const progressTimer = setInterval(() => {
-            i++;
-            postProgressMessage(device, Math.min(i * 2, 99), postMessage);
-        }, 300);
-        const message = await typedCall('FirmwareUpload', 'Success', {
-            payload,
-        }).finally(() => {
-            clearInterval(progressTimer);
-        });
-        postProgressMessage(device, 100, postMessage);
-        return message;
-    }
-    if (device.features.major_version === 2) {
-        postConfirmationMessage(device, updateFlowType);
-        const length = payload.byteLength;
-        let progress = 0;
-        let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
-        postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
-            device: device.toMessageObject(),
-            operation: 'start-flashing',
-            progress,
-        }));
-        while (response.type !== 'Success') {
-            const start = response.message.offset;
-            const end = response.message.offset + response.message.length;
-            const chunk = payload.slice(start, end);
-            const progressStart = Math.round((start / length) * 100);
-            const progressEnd = Math.round((end / length) * 100);
-            const progressDiff = progressEnd - progressStart;
-            device.transport.on(transport_1.TRANSPORT.SEND_MESSAGE_PROGRESS, p => {
-                const newProgress = progressStart + Math.floor(progressDiff * p);
-                if (start > 0 && newProgress > progress) {
-                    progress = newProgress;
-                    postProgressMessage(device, progress, postMessage);
-                }
-            });
-            if (start > 0) {
-                postProgressMessage(device, progressStart, postMessage);
-            }
-            response = await typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
-                payload: chunk,
-            }).finally(() => {
-                device.transport.removeAllListeners(transport_1.TRANSPORT.SEND_MESSAGE_PROGRESS);
-            });
+const uploadFirmware = async ({
+  typedCall,
+  postMessage,
+  device,
+  firmwareUploadRequest: {
+    payload
+  },
+  updateFlowType
+}) => {
+  if (device.features.major_version === 1) {
+    postConfirmationMessage(device, updateFlowType);
+    const timeoutId = setTimeout(() => {
+      postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS_UNEXPECTED_DELAY, {}));
+    }, FIRMWARE_ERASE_TIMEOUT_MILLISECONDS);
+    await typedCall('FirmwareErase', 'Success', {});
+    clearTimeout(timeoutId);
+    postProgressMessage(device, 0, postMessage);
+    let i = 0;
+    const progressTimer = setInterval(() => {
+      i++;
+      postProgressMessage(device, Math.min(i * 2, 99), postMessage);
+    }, 300);
+    const message = await typedCall('FirmwareUpload', 'Success', {
+      payload
+    }).finally(() => {
+      clearInterval(progressTimer);
+    });
+    postProgressMessage(device, 100, postMessage);
+    return message;
+  }
+  if (device.features.major_version === 2) {
+    postConfirmationMessage(device, updateFlowType);
+    const length = payload.byteLength;
+    let progress = 0;
+    let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], {
+      length
+    });
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+      device: device.toMessageObject(),
+      operation: 'start-flashing',
+      progress
+    }));
+    while (response.type !== 'Success') {
+      const start = response.message.offset;
+      const end = response.message.offset + response.message.length;
+      const chunk = payload.slice(start, end);
+      const progressStart = Math.round(start / length * 100);
+      const progressEnd = Math.round(end / length * 100);
+      const progressDiff = progressEnd - progressStart;
+      device.transport.on(transport_1.TRANSPORT.SEND_MESSAGE_PROGRESS, p => {
+        const newProgress = progressStart + Math.floor(progressDiff * p);
+        if (start > 0 && newProgress > progress) {
+          progress = newProgress;
+          postProgressMessage(device, progress, postMessage);
         }
-        postProgressMessage(device, 100, postMessage);
-        return response.message;
+      });
+      if (start > 0) {
+        postProgressMessage(device, progressStart, postMessage);
+      }
+      response = await typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+        payload: chunk
+      }).finally(() => {
+        device.transport.removeAllListeners(transport_1.TRANSPORT.SEND_MESSAGE_PROGRESS);
+      });
     }
-    throw constants_1.ERRORS.TypedError('Runtime', 'uploadFirmware: unknown major_version');
+    postProgressMessage(device, 100, postMessage);
+    return response.message;
+  }
+  throw constants_1.ERRORS.TypedError('Runtime', 'uploadFirmware: unknown major_version');
 };
 exports.uploadFirmware = uploadFirmware;
 //# sourceMappingURL=uploadFirmware.js.map

package/lib/api/firmware/verifyEntropy.js

@@ -1,5 +1,8 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.verifyEntropy = exports.generateEntropy = void 0;
 const crypto_1 = require("@noble/hashes/crypto");
 const hmac_1 = require("@noble/hashes/hmac");
@@ -9,104 +12,106 @@ const bip39_1 = require("@scure/bip39");
 const crypto_utils_1 = require("@trezor/crypto-utils");
 const utxo_lib_1 = require("@trezor/utxo-lib");
 const constants_1 = require("../../constants");
-const generateEntropy = (len) => {
-    try {
-        return Buffer.from((0, utils_1.randomBytes)(len));
-    }
-    catch {
-        throw new Error('generateEntropy: Environment does not support crypto random');
-    }
+const generateEntropy = len => {
+  try {
+    return Buffer.from((0, utils_1.randomBytes)(len));
+  } catch {
+    throw new Error('generateEntropy: Environment does not support crypto random');
+  }
 };
 exports.generateEntropy = generateEntropy;
 const BASE_ITERATION_COUNT = 10000;
 const ROUND_COUNT = 4;
 const roundFunction = async (i, passphrase, e, salt, r) => {
-    const data = Buffer.concat([Buffer.from([i]), passphrase]);
-    const iterations = Math.floor((BASE_ITERATION_COUNT << e) / ROUND_COUNT);
-    const { subtle } = crypto_1.crypto;
-    const key = await subtle.importKey('raw', data, 'PBKDF2', false, ['deriveBits']);
-    const bits = await subtle.deriveBits({
-        name: 'PBKDF2',
-        hash: 'SHA-256',
-        salt: Buffer.concat([salt, r]),
-        iterations,
-    }, key, r.length * 8);
-    return Buffer.from(bits);
+  const data = Buffer.concat([Buffer.from([i]), passphrase]);
+  const iterations = Math.floor((BASE_ITERATION_COUNT << e) / ROUND_COUNT);
+  const {
+    subtle
+  } = crypto_1.crypto;
+  const key = await subtle.importKey('raw', data, 'PBKDF2', false, ['deriveBits']);
+  const bits = await subtle.deriveBits({
+    name: 'PBKDF2',
+    hash: 'SHA-256',
+    salt: Buffer.concat([salt, r]),
+    iterations
+  }, key, r.length * 8);
+  return Buffer.from(bits);
 };
 const xor = (a, b) => {
-    if (a.length !== b.length) {
-        throw new Error('Buffers must be of equal length to XOR.');
-    }
-    const result = Buffer.alloc(a.length);
-    for (let i = 0; i < a.length; i++) {
-        result[i] = a[i] ^ b[i];
-    }
-    return result;
+  if (a.length !== b.length) {
+    throw new Error('Buffers must be of equal length to XOR.');
+  }
+  const result = Buffer.alloc(a.length);
+  for (let i = 0; i < a.length; i++) {
+    result[i] = a[i] ^ b[i];
+  }
+  return result;
 };
-const entropyToSeedSlip39 = async (encryptedSecret) => {
-    const iterationExponent = 1;
-    const passphrase = Buffer.from('', 'utf-8');
-    const salt = Buffer.alloc(0);
-    const half = Math.floor(encryptedSecret.length / 2);
-    let l = encryptedSecret.subarray(0, half);
-    let r = encryptedSecret.subarray(half);
-    for (let round = ROUND_COUNT - 1; round >= 0; round--) {
-        const f = await roundFunction(round, passphrase, iterationExponent, salt, r);
-        const rr = xor(l, f);
-        l = r;
-        r = rr;
-    }
-    return Buffer.concat([r, l]);
+const entropyToSeedSlip39 = async encryptedSecret => {
+  const iterationExponent = 1;
+  const passphrase = Buffer.from('', 'utf-8');
+  const salt = Buffer.alloc(0);
+  const half = Math.floor(encryptedSecret.length / 2);
+  let l = encryptedSecret.subarray(0, half);
+  let r = encryptedSecret.subarray(half);
+  for (let round = ROUND_COUNT - 1; round >= 0; round--) {
+    const f = await roundFunction(round, passphrase, iterationExponent, salt, r);
+    const rr = xor(l, f);
+    l = r;
+    r = rr;
+  }
+  return Buffer.concat([r, l]);
 };
 const getEntropy = (trezorEntropy, hostEntropy, strength) => {
-    const data = Buffer.concat([
-        Buffer.from(trezorEntropy, 'hex'),
-        Buffer.from(hostEntropy, 'hex'),
-    ]);
-    const entropy = (0, sha256_1.sha256)(data);
-    return Buffer.from(entropy.subarray(0, Math.floor(strength / 8)));
+  const data = Buffer.concat([Buffer.from(trezorEntropy, 'hex'), Buffer.from(hostEntropy, 'hex')]);
+  const entropy = (0, sha256_1.sha256)(data);
+  return Buffer.from(entropy.subarray(0, Math.floor(strength / 8)));
 };
 const computeSeed = (type, secret) => {
-    const BackupType = constants_1.PROTO.Enum_BackupType;
-    if (type &&
-        [
-            BackupType.Slip39_Basic,
-            BackupType.Slip39_Advanced,
-            BackupType.Slip39_Single_Extendable,
-            BackupType.Slip39_Basic_Extendable,
-            BackupType.Slip39_Advanced_Extendable,
-        ].includes(type)) {
-        return entropyToSeedSlip39(secret);
-    }
-    return (0, bip39_1.mnemonicToSeed)((0, bip39_1.entropyToMnemonic)(secret, [...crypto_utils_1.bip39])).then(seed => Buffer.from(seed));
+  const BackupType = constants_1.PROTO.Enum_BackupType;
+  if (type && [BackupType.Slip39_Basic, BackupType.Slip39_Advanced, BackupType.Slip39_Single_Extendable, BackupType.Slip39_Basic_Extendable, BackupType.Slip39_Advanced_Extendable].includes(type)) {
+    return entropyToSeedSlip39(secret);
+  }
+  return (0, bip39_1.mnemonicToSeed)((0, bip39_1.entropyToMnemonic)(secret, [...crypto_utils_1.bip39])).then(seed => Buffer.from(seed));
 };
 const verifyCommitment = (entropy, commitment) => {
-    const hmacDigest = (0, hmac_1.hmac)(sha256_1.sha256, Buffer.from(entropy, 'hex'), Buffer.alloc(0));
-    if (!Buffer.from(hmacDigest).equals(Buffer.from(commitment, 'hex'))) {
-        throw new Error('Invalid entropy commitment');
-    }
+  const hmacDigest = (0, hmac_1.hmac)(sha256_1.sha256, Buffer.from(entropy, 'hex'), Buffer.alloc(0));
+  if (!Buffer.from(hmacDigest).equals(Buffer.from(commitment, 'hex'))) {
+    throw new Error('Invalid entropy commitment');
+  }
 };
-const verifyEntropy = async ({ type, strength, trezorEntropy, hostEntropy, commitment, xpubs, }) => {
-    try {
-        if (!trezorEntropy || !commitment || !strength || Object.keys(xpubs).length < 1) {
-            throw new Error('Missing verifyEntropy data');
-        }
-        verifyCommitment(trezorEntropy, commitment);
-        const secret = getEntropy(trezorEntropy, hostEntropy, strength);
-        const seed = await computeSeed(type, secret);
-        const node = utxo_lib_1.bip32.fromSeed(seed);
-        Object.keys(xpubs).forEach(path => {
-            const pubKey = node.derivePath(path);
-            const xpub = pubKey.neutered().toBase58();
-            if (xpub !== xpubs[path]) {
-                throw new Error('verifyEntropy xpub mismatch');
-            }
-        });
-        return { success: true };
-    }
-    catch (error) {
-        return { success: false, error: error.message };
+const verifyEntropy = async ({
+  type,
+  strength,
+  trezorEntropy,
+  hostEntropy,
+  commitment,
+  xpubs
+}) => {
+  try {
+    if (!trezorEntropy || !commitment || !strength || Object.keys(xpubs).length < 1) {
+      throw new Error('Missing verifyEntropy data');
     }
+    verifyCommitment(trezorEntropy, commitment);
+    const secret = getEntropy(trezorEntropy, hostEntropy, strength);
+    const seed = await computeSeed(type, secret);
+    const node = utxo_lib_1.bip32.fromSeed(seed);
+    Object.keys(xpubs).forEach(path => {
+      const pubKey = node.derivePath(path);
+      const xpub = pubKey.neutered().toBase58();
+      if (xpub !== xpubs[path]) {
+        throw new Error('verifyEntropy xpub mismatch');
+      }
+    });
+    return {
+      success: true
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
 };
 exports.verifyEntropy = verifyEntropy;
 //# sourceMappingURL=verifyEntropy.js.map