@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/libESM/api/firmware/calculateXPubHash.mjs

@@ -1,14 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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/parseFirmwareHeaders.d.mts

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

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

@@ -1,19 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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 {};