@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/firmware/calculateFirmwareHash.mjs

@@ -0,0 +1,56 @@
+import { blake2s } from "@noble/hashes/blake2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { DeviceModelInternal } from "@trezor/device-utils";
+import { versionUtils } from "@trezor/utils";
+const SIZE_T1B1 = (7 * 128 + 64) * 1024;
+const SIZE_T2T1 = 13 * 128 * 1024;
+const SIZE_T2B1 = 13 * 128 * 1024;
+const SIZE_T3B1 = 208 * 8 * 1024;
+const SIZE_T3T1 = 208 * 8 * 1024;
+const SIZE_T3W1 = 417 * 8 * 1024;
+const firmwareSizeMap = {
+  [DeviceModelInternal.T1B1]: SIZE_T1B1,
+  [DeviceModelInternal.T2T1]: SIZE_T2T1,
+  [DeviceModelInternal.T2B1]: SIZE_T2B1,
+  [DeviceModelInternal.T3B1]: SIZE_T3B1,
+  [DeviceModelInternal.T3T1]: SIZE_T3T1,
+  [DeviceModelInternal.T3W1]: SIZE_T3W1
+};
+const getSizeForModel = ({
+  internal_model,
+  firmwareVersion
+}) => {
+  const size = firmwareSizeMap[internal_model] ?? SIZE_T1B1;
+  if (firmwareVersion !== undefined && internal_model === DeviceModelInternal.T3W1 && versionUtils.isEqual(firmwareVersion, [2, 9, 3])) {
+    return size - 16 * 1024;
+  }
+  return size;
+};
+export const calculateFirmwareHash = ({
+  internal_model,
+  firmwareVersion,
+  fw,
+  key
+}) => {
+  const size = getSizeForModel({
+    internal_model,
+    firmwareVersion
+  });
+  const padding = size - fw.byteLength;
+  if (padding < 0) {
+    throw new Error('Firmware too big');
+  }
+  const data = new Uint8Array(new ArrayBuffer(size));
+  data.set(new Uint8Array(fw));
+  if (padding > 0) {
+    const zeroBytes = Buffer.alloc(padding);
+    zeroBytes.fill(Buffer.from('ff', 'hex'));
+    data.set(zeroBytes, fw.byteLength);
+  }
+  return {
+    hash: key && key.length > 0 ? bytesToHex(blake2s(data, {
+      key
+    })) : bytesToHex(blake2s(data)),
+    challenge: key ? key.toString('hex') : ''
+  };
+};

package/libESM/api/firmware/calculateXPubHash.d.mts

@@ -0,0 +1,10 @@
+import type { XPubHashesPerBip43Path } from '@trezor/connect-common';
+export declare const calculateXPubHash: (xpub: string) => string;
+export declare const calculateXPubHashes: (xpubs: Record<string, string>) => XPubHashesPerBip43Path;
+type CheckXPubWithHashesParams = {
+    xpub: string;
+    path: string;
+    knownXPubHashes: XPubHashesPerBip43Path;
+};
+export declare const checkXPubWithHashes: ({ xpub, path, knownXPubHashes, }: CheckXPubWithHashesParams) => boolean;
+export {};

package/libESM/api/firmware/calculateXPubHash.mjs

@@ -0,0 +1,14 @@
+import { createHash } from "crypto";
+export const calculateXPubHash = xpub => createHash('sha256').update(xpub, 'utf8').digest('hex');
+export const calculateXPubHashes = xpubs => {
+  const hashes = {};
+  Object.keys(xpubs).forEach(path => {
+    hashes[path] = calculateXPubHash(xpubs[path]);
+  });
+  return hashes;
+};
+export const checkXPubWithHashes = ({
+  xpub,
+  path,
+  knownXPubHashes
+}) => knownXPubHashes[path] === undefined || knownXPubHashes[path] === calculateXPubHash(xpub);

package/libESM/api/firmware/getBinary.d.mts

@@ -0,0 +1,10 @@
+import type { BinaryInfo } from '@trezor/connect-common';
+import type { FirmwareRelease } from '@trezor/device-utils';
+interface GetBinaryParams {
+    baseUrl: string;
+    path: string;
+    release: FirmwareRelease;
+}
+export declare const getBinary: ({ baseUrl, path, release, }: GetBinaryParams) => Promise<BinaryInfo>;
+export declare const getBinaryOptional: (params: GetBinaryParams) => Promise<BinaryInfo | null>;
+export {};

package/libESM/api/firmware/getBinary.mjs

@@ -0,0 +1,33 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { removeTrailingSlashes } from "@trezor/utils";
+import { parseFirmwareHeaders } from "./parseFirmwareHeaders.mjs";
+import { httpRequest } from "../../utils/assets.mjs";
+const MIN_FIRMWARE_SIZE_BYTES = 200;
+export const getBinary = async ({
+  baseUrl,
+  path,
+  release
+}) => {
+  const sanitizedBaseUrl = removeTrailingSlashes(baseUrl);
+  const url = `${sanitizedBaseUrl}/${path}`;
+  const binaryArrayBuffer = await httpRequest(url, 'binary');
+  if (binaryArrayBuffer.byteLength < MIN_FIRMWARE_SIZE_BYTES) {
+    throw ERRORS.TypedError('Runtime', 'Firmware binary is too small');
+  }
+  const firmwareBuffer = Buffer.from(binaryArrayBuffer);
+  const {
+    version: binaryVersion
+  } = parseFirmwareHeaders(firmwareBuffer);
+  return {
+    binary: binaryArrayBuffer,
+    binaryVersion,
+    release
+  };
+};
+export const getBinaryOptional = async params => {
+  try {
+    return await getBinary(params);
+  } catch {
+    return null;
+  }
+};

package/libESM/api/firmware/index.d.mts

@@ -0,0 +1,6 @@
+export { getBinary, getBinaryOptional } from './getBinary';
+export { shouldStripFwHeaders, stripFwHeaders } from './modifyFirmware';
+export { uploadFirmware } from './uploadFirmware';
+export { calculateFirmwareHash } from './calculateFirmwareHash';
+export { parseFirmwareHeaders } from './parseFirmwareHeaders';
+export { calculateXPubHash, calculateXPubHashes, checkXPubWithHashes } from './calculateXPubHash';

package/libESM/api/firmware/index.mjs

@@ -0,0 +1,6 @@
+export { getBinary, getBinaryOptional } from "./getBinary.mjs";
+export { shouldStripFwHeaders, stripFwHeaders } from "./modifyFirmware.mjs";
+export { uploadFirmware } from "./uploadFirmware.mjs";
+export { calculateFirmwareHash } from "./calculateFirmwareHash.mjs";
+export { parseFirmwareHeaders } from "./parseFirmwareHeaders.mjs";
+export { calculateXPubHash, calculateXPubHashes, checkXPubWithHashes } from "./calculateXPubHash.mjs";

package/libESM/api/firmware/modifyFirmware.d.mts

@@ -0,0 +1,3 @@
+import type { Features } from '@trezor/connect-common';
+export declare const shouldStripFwHeaders: (features: Features) => boolean;
+export declare const stripFwHeaders: (fw: ArrayBuffer) => ArrayBuffer;

package/libESM/api/firmware/modifyFirmware.mjs

@@ -0,0 +1,13 @@
+import { getFirmwareOrBootloaderVersionArray } from "@trezor/device-utils";
+import { versionUtils } from "@trezor/utils";
+export const shouldStripFwHeaders = features => {
+  if (features.major_version === 2) return false;
+  return versionUtils.isNewerOrEqual(getFirmwareOrBootloaderVersionArray(features), [1, 8, 0]);
+};
+export const stripFwHeaders = fw => {
+  const fwView = new Uint8Array(fw);
+  if (String.fromCharCode(...Array.from(fwView.slice(0, 4))) === 'TRZR' && String.fromCharCode(...Array.from(fwView.slice(256, 260))) === 'TRZF') {
+    return fw.slice(256);
+  }
+  return fw;
+};

package/libESM/api/firmware/parseFirmwareHeaders.d.mts

@@ -0,0 +1,4 @@
+import type { VersionArray } from '@trezor/utils/libESM/versionUtils';
+export declare const parseFirmwareHeaders: (buff: Buffer) => {
+    version: VersionArray;
+};

package/libESM/api/firmware/parseFirmwareHeaders.mjs

@@ -0,0 +1,26 @@
+export 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
+  };
+};

package/libESM/api/firmware/uploadFirmware.d.mts

@@ -0,0 +1,19 @@
+import type { CoreEventMessage, FirmwareUpdateFlowType, PROTO } from '@trezor/connect-common';
+import type { TypedCall } from '../../device/DeviceCommands';
+import type { IDevice } from '../../types/idevice';
+type UploadFirmwareProps = {
+    typedCall: TypedCall;
+    postMessage: (message: CoreEventMessage) => void;
+    device: IDevice;
+    firmwareUploadRequest: PROTO.FirmwareUpload;
+    updateFlowType: FirmwareUpdateFlowType;
+};
+export declare const uploadFirmware: ({ typedCall, postMessage, device, firmwareUploadRequest: { payload }, updateFlowType, }: UploadFirmwareProps) => Promise<{
+    type: "Success";
+    message: {
+        message: string;
+    };
+} | {
+    message: string;
+}>;
+export {};

package/libESM/api/firmware/uploadFirmware.mjs

@@ -0,0 +1,99 @@
+import { DEVICE, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { getFirmwareVersionArray } from "@trezor/device-utils";
+import { TRANSPORT } from "@trezor/transport";
+import { isWithinRange } from "@trezor/utils/libESM/versionUtils.mjs";
+const postConfirmationMessage = (device, updateFlowType) => {
+  const freshInstall = device.features.firmware_present === false;
+  if (freshInstall || updateFlowType === 'reboot_and_upgrade') return;
+  device.emit(DEVICE.BUTTON, {
+    device,
+    payload: {
+      code: 'ButtonRequest_FirmwareUpdate'
+    }
+  });
+};
+const postProgressMessage = (device, progress, postMessage) => {
+  postMessage(createUiMessage(UI_REQUEST.FIRMWARE_PROGRESS, {
+    device: device.toMessageObject(),
+    operation: 'flashing',
+    progress
+  }));
+};
+const FIRMWARE_ERASE_TIMEOUT_MILLISECONDS = 15_000;
+const TIMEOUT_MIN_FW_VERSION = '1.12.1';
+const TIMEOUT_MAX_FW_VERSION = '1.13.0';
+export const uploadFirmware = async ({
+  typedCall,
+  postMessage,
+  device,
+  firmwareUploadRequest: {
+    payload
+  },
+  updateFlowType
+}) => {
+  if (device.features.major_version === 1) {
+    postConfirmationMessage(device, updateFlowType);
+    const timeoutId = setTimeout(() => {
+      const version = getFirmwareVersionArray(device.toMessageObject());
+      if (version === null) return;
+      if (isWithinRange(version, TIMEOUT_MIN_FW_VERSION, TIMEOUT_MAX_FW_VERSION)) {
+        postMessage(createUiMessage(UI_REQUEST.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(createUiMessage(UI_REQUEST.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.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.SEND_MESSAGE_PROGRESS);
+      });
+    }
+    postProgressMessage(device, 100, postMessage);
+    return response.message;
+  }
+  throw ERRORS.TypedError('Runtime', 'uploadFirmware: unknown major_version');
+};

package/libESM/api/firmware/verifyEntropy.d.mts

@@ -0,0 +1,18 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+export declare const generateEntropy: (len: number) => Buffer<ArrayBuffer>;
+type VerifyEntropyOptions = {
+    type?: PROTO.Enum_BackupType;
+    strength?: number;
+    commitment?: string;
+    hostEntropy: string;
+    trezorEntropy?: string;
+    xpubs: Record<string, string>;
+};
+export declare const verifyEntropy: ({ type, strength, trezorEntropy, hostEntropy, commitment, xpubs, }: VerifyEntropyOptions) => Promise<{
+    success: true;
+    error?: undefined;
+} | {
+    success: false;
+    error: any;
+}>;
+export {};

package/libESM/api/firmware/verifyEntropy.mjs

@@ -0,0 +1,107 @@
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+import { entropyToMnemonic, mnemonicToSeed } from "@scure/bip39";
+import { bip39 } from "@trezor/crypto-utils";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { bip32 } from "@trezor/utxo-lib";
+export const generateEntropy = len => {
+  try {
+    return Buffer.from(randomBytes(len));
+  } catch {
+    throw new Error('generateEntropy: Environment does not support crypto random');
+  }
+};
+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;
+  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;
+};
+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 = sha256(data);
+  return Buffer.from(entropy.subarray(0, Math.floor(strength / 8)));
+};
+const computeSeed = (type, secret) => {
+  const BackupType = 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 mnemonicToSeed(entropyToMnemonic(secret, [...bip39])).then(seed => Buffer.from(seed));
+};
+const verifyCommitment = (entropy, commitment) => {
+  const hmacDigest = hmac(sha256, Buffer.from(entropy, 'hex'), Buffer.alloc(0));
+  if (!Buffer.from(hmacDigest).equals(Buffer.from(commitment, 'hex'))) {
+    throw new Error('Invalid entropy commitment');
+  }
+};
+export 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 = 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
+    };
+  }
+};

package/libESM/api/getAccountInfo.d.mts

@@ -0,0 +1,94 @@
+import type { AccountInfo, AccountUtxo, CoinInfo, GetAccountInfo as GetAccountInfoParams, MethodPermission } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
+import { AbstractMethod } from '../core/AbstractMethod';
+import { Discovery } from './common/Discovery';
+type Request = GetAccountInfoParams & {
+    address_n: number[];
+    coinInfo: CoinInfo;
+};
+export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Request[]> {
+    disposed: boolean;
+    hasBundle?: boolean;
+    discovery?: Discovery;
+    constructor(message: MethodMessage<'getAccountInfo'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "export-account-info";
+        label: string;
+        customConfirmButton: {
+            label: string;
+            className: string;
+        };
+    } | {
+        view: "export-account-info";
+        label: string;
+        customConfirmButton?: undefined;
+    };
+    run(context: MethodContext): Promise<AccountInfo | (AccountInfo | null)[] | {
+        utxo: AccountUtxo[] | undefined;
+        descriptor: string;
+        balance: string;
+        availableBalance: string;
+        empty: boolean;
+        tokens?: import("@trezor/blockchain-link-types").TokenInfo[];
+        addresses?: import("@trezor/blockchain-link-types").AccountAddresses;
+        history: {
+            total: number;
+            tokens?: number;
+            unconfirmed: number;
+            transactions?: import("@trezor/blockchain-link-types").Transaction[];
+            txids?: string[];
+            addrTxCount?: number;
+        };
+        misc?: {
+            nonce?: string;
+            contractInfo?: import("@trezor/blockchain-link-types").ContractInfo;
+            stakingPools?: import("@trezor/blockchain-link-types").StakingPool[];
+            addressAliases?: {
+                [key: string]: import("@trezor/blockchain-link-types").AddressAlias;
+            };
+            sequence?: number;
+            stellarSequence?: string;
+            reserve?: string;
+            rewards?: string;
+            staking?: {
+                address: string;
+                isActive: boolean;
+                rewards: string;
+                poolId: string | null;
+                drep: {
+                    drep_id: string;
+                    hex: string;
+                    amount: string;
+                    active: boolean;
+                    active_epoch: number | null;
+                    has_script: boolean;
+                } | null;
+            };
+            owner?: string;
+            rent?: number;
+            solStakingAccounts?: import("@trezor/blockchain-link-types").SolanaStakingAccount[];
+            solExternalStakingAccounts?: import("@trezor/blockchain-link-types").SolanaStakingAccount[];
+            solEpoch?: number;
+            tronResources?: import("@trezor/blockchain-link-types").TronAccountExtraData;
+        };
+        page?: {
+            index: number;
+            size: number;
+            total: number;
+        };
+        marker?: {
+            ledger: number;
+            seq: number;
+        };
+        stellarCursor?: string;
+        path: string;
+    }>;
+    private discover;
+    private selectExistingAccount;
+    private runDiscovery;
+    private fetchAccountInfo;
+    dispose(): void;
+}
+export {};