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

package/lib/api/authenticateDevice.js

@@ -1,195 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { AuthenticateDeviceParams, deviceAuthenticityBlacklistConfig, deviceAuthenticityConfig, getRandomChallenge, prepareDeviceAuthenticityData, validateSerialNumbers, verifyAuthenticityProof } from "@trezor/device-authenticity";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class AuthenticateDevice extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(AuthenticateDeviceParams, payload);
-    const params = {
-      config: payload.config,
-      blacklistConfig: payload.blacklistConfig,
-      allowDebugKeys: payload.allowDebugKeys
-    };
-    super(message, params);
-    this.useEmptyPassphrase = true;
-    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'management'
-    }];
-  }
-  async streamAuthenticityProofs(challenge) {
-    const cmd = this.getDevice().getCommands();
-    const MAX_CHUNK_SIZE = 500;
-    this.getDevice().startPiggybackAck();
-    const {
-      message: proofSizes
-    } = await cmd.typedCall('AuthenticateDevice', 'AuthenticityProofSizes', {
-      challenge: challenge.toString('hex'),
-      stream: true
-    });
-    const proofTypes = [{
-      name: 'optiga',
-      type: PROTO.AuthenticityProofType.OPTIGA,
-      certSizes: proofSizes.optiga_certificates,
-      sigSize: proofSizes.optiga_signature
-    }, {
-      name: 'tropic',
-      type: PROTO.AuthenticityProofType.TROPIC,
-      certSizes: proofSizes.tropic_certificates,
-      sigSize: proofSizes.tropic_signature
-    }, {
-      name: 'mcu',
-      type: PROTO.AuthenticityProofType.MCU,
-      certSizes: proofSizes.mcu_certificates,
-      sigSize: proofSizes.mcu_signature
-    }];
-    const authenticityProof = {
-      optiga_certificates: [],
-      optiga_signature: '',
-      tropic_certificates: [],
-      tropic_signature: undefined,
-      mcu_certificates: [],
-      mcu_signature: undefined
-    };
-    const getChunk = async (params, chunkSize) => {
-      const chunks = [];
-      let offset = 0;
-      while (offset < chunkSize) {
-        const size = Math.min(MAX_CHUNK_SIZE, chunkSize - offset);
-        const {
-          message
-        } = await cmd.typedCall('GetAuthenticityProofChunk', 'AuthenticityProofChunk', {
-          ...params,
-          offset,
-          size
-        });
-        chunks.push(message.chunk);
-        offset += size;
-      }
-      return chunks.join('');
-    };
-    for (const {
-      name,
-      type,
-      certSizes,
-      sigSize
-    } of proofTypes) {
-      for (const [i, certSize] of certSizes.entries()) {
-        const cert = await getChunk({
-          proof_type: type,
-          index: i
-        }, certSize);
-        authenticityProof[`${name}_certificates`].push(cert);
-      }
-      if (sigSize) {
-        authenticityProof[`${name}_signature`] = await getChunk({
-          proof_type: type
-        }, sigSize);
-      }
-    }
-    await cmd.typedCall('GetAuthenticityProofChunk', 'Success', {
-      offset: 0,
-      size: 0
-    });
-    await this.getDevice().stopPiggybackAck();
-    return authenticityProof;
-  }
-  async getAuthenticityProofs(challenge) {
-    const {
-      message
-    } = await this.getDevice().getCommands().typedCall('AuthenticateDevice', 'AuthenticityProof', {
-      challenge: challenge.toString('hex')
-    });
-    return message;
-  }
-  async run() {
-    const challenge = getRandomChallenge();
-    const {
-      unavailableCapabilities
-    } = this.getDevice();
-    const authenticityProof = !unavailableCapabilities['authenticityProofChunk'] ? await this.streamAuthenticityProofs(challenge) : await this.getAuthenticityProofs(challenge);
-    const config = this.params.config || deviceAuthenticityConfig;
-    const blacklistConfig = this.params.blacklistConfig || deviceAuthenticityBlacklistConfig;
-    const commonParams = {
-      signedData: prepareDeviceAuthenticityData({
-        payload: challenge
-      }),
-      deviceModel: this.getDevice().features.internal_model,
-      allowDebugKeys: this.params.allowDebugKeys,
-      config,
-      blacklistConfig
-    };
-    const getOptigaResult = async () => {
-      const {
-        optiga_signature: signature,
-        optiga_certificates: certificates
-      } = authenticityProof;
-      const isAvailable = signature && certificates.length > 0;
-      if (isAvailable) {
-        return await verifyAuthenticityProof({
-          ...commonParams,
-          certificates,
-          signature
-        });
-      }
-      return {
-        valid: false,
-        error: 'RESPONSE_PAYLOAD_MISSING'
-      };
-    };
-    const hasTropicAbility = !unavailableCapabilities['tropicDeviceAuthentication'];
-    const getTropicResult = async () => {
-      const {
-        tropic_signature: signature,
-        tropic_certificates: certificates
-      } = authenticityProof;
-      const isAvailable = signature && certificates.length > 0;
-      const isRequired = hasTropicAbility;
-      if (isAvailable) {
-        return await verifyAuthenticityProof({
-          ...commonParams,
-          certificates,
-          signature
-        });
-      }
-      return isRequired ? {
-        valid: false,
-        error: 'RESPONSE_PAYLOAD_MISSING'
-      } : null;
-    };
-    const getMCUResult = async () => {
-      const {
-        mcu_signature: signature,
-        mcu_certificates: certificates
-      } = authenticityProof;
-      const isAvailable = signature && certificates.length > 0;
-      const isRequired = !unavailableCapabilities['mcuDeviceAuthentication'];
-      if (isAvailable) {
-        return await verifyAuthenticityProof({
-          ...commonParams,
-          certificates,
-          signature
-        });
-      }
-      return isRequired ? {
-        valid: false,
-        error: 'RESPONSE_PAYLOAD_MISSING'
-      } : null;
-    };
-    const [optigaResult, tropicResult, mcuResult] = await Promise.all([getOptigaResult(), getTropicResult(), getMCUResult()]);
-    const results = {
-      optigaResult,
-      tropicResult,
-      mcuResult
-    };
-    return hasTropicAbility ? validateSerialNumbers(results) : results;
-  }
-}

package/lib/api/authorizeCoinjoin.d.ts

@@ -1,11 +0,0 @@
-import { type PermissionRequest } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class AuthorizeCoinjoin extends AbstractMethod<'authorizeCoinjoin', PROTO.AuthorizeCoinJoin> {
-  constructor(message: MethodMessage<'authorizeCoinjoin'>);
-  get requiredPermissions(): PermissionRequest[];
-  run(): Promise<{
-    message: string;
-  }>;
-}

package/lib/api/authorizeCoinjoin.js

@@ -1,44 +0,0 @@
-import { AuthorizeCoinjoin as AuthorizeCoinjoinSchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getBitcoinNetwork } from "../data/coinInfo.js";
-import { getScriptType, validatePath } from "../utils/pathUtils.js";
-export default class AuthorizeCoinjoin extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(AuthorizeCoinjoinSchema, payload);
-    const address_n = validatePath(payload.path, 3);
-    const script_type = payload.scriptType || getScriptType(address_n);
-    const coinInfo = getBitcoinNetwork(payload.coin || address_n);
-    const params = {
-      coordinator: payload.coordinator,
-      max_rounds: payload.maxRounds,
-      max_coordinator_fee_rate: payload.maxCoordinatorFeeRate,
-      max_fee_per_kvbyte: payload.maxFeePerKvbyte,
-      address_n,
-      coin_name: coinInfo?.name,
-      script_type,
-      amount_unit: payload.amountUnit
-    };
-    super(message, params);
-    this.requiredFirmwareCoins = [coinInfo];
-    this.preauthorized = payload.preauthorized;
-  }
-  get requiredPermissions() {
-    return [this.coinPerm('internal', this.requiredFirmwareCoins[0])];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    if (this.preauthorized) {
-      if (await cmd.preauthorize(false)) {
-        return {
-          message: 'Success'
-        };
-      }
-    }
-    const response = await cmd.typedCall('AuthorizeCoinJoin', 'Success', this.params);
-    return response.message;
-  }
-}

package/lib/api/backupDevice.d.ts

@@ -1,19 +0,0 @@
-import { type PermissionRequest } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class BackupDevice extends AbstractMethod<'backupDevice', PROTO.BackupDevice> {
-  constructor(message: MethodMessage<'backupDevice'>);
-  get requiredPermissions(): PermissionRequest[];
-  get confirmation(): {
-    view: "device-management";
-    customConfirmButton: {
-      className: string;
-      label: string;
-    };
-    label: string;
-  };
-  run(): Promise<{
-    message: string;
-  }>;
-}

package/lib/api/backupDevice.js

@@ -1,39 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-export default class BackupDevice extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.BackupDevice, payload);
-    const params = {
-      group_threshold: payload.group_threshold,
-      groups: payload.groups,
-      backup_method: payload.backup_method
-    };
-    super(message, params);
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return [{
-      permission: 'management'
-    }];
-  }
-  get confirmation() {
-    return {
-      view: 'device-management',
-      customConfirmButton: {
-        className: 'confirm',
-        label: 'Proceed'
-      },
-      label: 'Do you want to initiate backup procedure?'
-    };
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('BackupDevice', 'Success', this.params);
-    return response.message;
-  }
-}

package/lib/api/bitcoin/TransactionComposer.d.ts

@@ -1,46 +0,0 @@
-import type { BitcoinNetworkInfo, ComposeResult, ComposeUtxo, ComposedInputs, DiscoveryAccount } from '@trezor/connect-common';
-import type { ComposeOutput, TransactionInputOutputSortingStrategy } from '@trezor/utxo-lib';
-import type { Blockchain } from "../../backend/BlockchainLink.js";
-import type { BitcoinFeeLevels } from "../../backend/fees/BitcoinFeeLevels.js";
-type Options = {
-  account: DiscoveryAccount;
-  utxos: ComposeUtxo[];
-  outputs: ComposeOutput[];
-  coinInfo: BitcoinNetworkInfo;
-  baseFee?: number;
-  sortingStrategy: TransactionInputOutputSortingStrategy;
-};
-export declare class TransactionComposer {
-  account: DiscoveryAccount;
-  utxos: ComposedInputs[];
-  outputs: ComposeOutput[];
-  coinInfo: BitcoinNetworkInfo;
-  blockHeight: number;
-  baseFee: number;
-  sortingStrategy: TransactionInputOutputSortingStrategy;
-  feeLevels: BitcoinFeeLevels;
-  composed: {
-    [key: string]: ComposeResult;
-  };
-  constructor(options: Options);
-  init(blockchain: Blockchain): Promise<void>;
-  composeAllFeeLevels(): boolean;
-  composeCustomFee(fee: string): void;
-  getFeeLevelList(): ({
-    blocks?: undefined;
-    feePerByte?: undefined;
-    name: string;
-    fee: "0";
-    disabled: true;
-  } | {
-    name: string;
-    blocks: number;
-    fee: string;
-    feePerByte: string;
-    minutes: number;
-    total: string;
-  })[];
-  compose(feeRate: string): ComposeResult;
-  dispose(): void;
-}
-export {};

package/lib/api/bitcoin/TransactionComposer.js

@@ -1,147 +0,0 @@
-import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
-import { composeTx, networks } from "@trezor/utxo-lib";
-import { getOrInitBitcoinFeeLevels } from "../../backend/fees/index.js";
-export class TransactionComposer {
-  account;
-  utxos;
-  outputs;
-  coinInfo;
-  blockHeight = 0;
-  baseFee;
-  sortingStrategy;
-  feeLevels;
-  composed = {};
-  constructor(options) {
-    this.account = options.account;
-    this.outputs = options.outputs;
-    this.coinInfo = options.coinInfo;
-    this.blockHeight = 0;
-    this.baseFee = options.baseFee || 0;
-    this.sortingStrategy = options.sortingStrategy;
-    this.feeLevels = getOrInitBitcoinFeeLevels(options.coinInfo);
-    const {
-      addresses
-    } = options.account;
-    const allAddresses = !addresses ? [] : addresses.used.concat(addresses.unused).concat(addresses.change).map(a => a.address);
-    this.utxos = options.utxos.flatMap(u => {
-      if (!u.required && new BigNumber(u.amount).lte(this.coinInfo.dustLimit)) return [];
-      return {
-        ...u,
-        coinbase: typeof u.coinbase === 'boolean' ? u.coinbase : false,
-        own: allAddresses.includes(u.address)
-      };
-    });
-  }
-  async init(blockchain) {
-    const {
-      blockHeight
-    } = await blockchain.getNetworkInfo();
-    this.blockHeight = blockHeight;
-    if (!this.feeLevels.wasFetchedSuccessfully) {
-      await this.feeLevels.load(blockchain);
-    }
-  }
-  composeAllFeeLevels() {
-    const {
-      levels
-    } = this.feeLevels;
-    if (this.utxos.length < 1) return false;
-    this.composed = {};
-    let atLeastOneValid = false;
-    levels.forEach(level => {
-      if (level.feePerUnit !== '0') {
-        const tx = this.compose(level.feePerUnit);
-        if (tx.type === 'final') {
-          atLeastOneValid = true;
-        }
-        this.composed[level.label] = tx;
-      }
-    });
-    if (!atLeastOneValid) {
-      const lastLevel = levels[levels.length - 1];
-      let lastFee = new BigNumber(lastLevel.feePerUnit);
-      while (lastFee.gt(this.coinInfo.minFee) && this.composed.custom === undefined) {
-        lastFee = lastFee.minus(1);
-        const tx = this.compose(lastFee.toString());
-        if (tx.type === 'final') {
-          this.feeLevels.updateBitcoinCustomFee(lastFee.toString());
-          this.composed.custom = tx;
-          return true;
-        }
-      }
-      return false;
-    }
-    return true;
-  }
-  composeCustomFee(fee) {
-    const tx = this.compose(fee);
-    this.composed.custom = tx;
-    if (tx.type === 'final') {
-      this.feeLevels.updateBitcoinCustomFee(tx.feePerByte);
-    } else {
-      this.feeLevels.updateBitcoinCustomFee(fee);
-    }
-  }
-  getFeeLevelList() {
-    const list = [];
-    const {
-      levels
-    } = this.feeLevels;
-    levels.forEach(level => {
-      const tx = this.composed[level.label];
-      if (tx?.type === 'final') {
-        list.push({
-          name: level.label,
-          fee: tx.fee,
-          feePerByte: level.feePerUnit,
-          blocks: level.blocks,
-          minutes: level.blocks * this.coinInfo.blockTime,
-          total: tx.totalSpent
-        });
-      } else {
-        list.push({
-          name: level.label,
-          fee: '0',
-          disabled: true
-        });
-      }
-    });
-    return list;
-  }
-  compose(feeRate) {
-    const {
-      account,
-      coinInfo,
-      baseFee
-    } = this;
-    const {
-      addresses
-    } = account;
-    if (!addresses) return {
-      type: 'error',
-      error: 'ADDRESSES-NOT-SET'
-    };
-    const lastChange = addresses.change[addresses.change.length - 1];
-    const changeAddress = addresses.change.find(a => !a.transfers) || lastChange;
-    let feePolicy;
-    if (networks.isNetworkType('doge', coinInfo.network)) {
-      feePolicy = 'doge';
-    } else if (networks.isNetworkType('zcash', coinInfo.network)) {
-      feePolicy = 'zcash';
-    }
-    return composeTx({
-      txType: account.type,
-      utxos: this.utxos,
-      outputs: this.outputs,
-      feeRate,
-      longTermFeeRate: this.feeLevels.longTermFeeRate,
-      sortingStrategy: this.sortingStrategy,
-      network: coinInfo.network,
-      changeAddress,
-      dustThreshold: coinInfo.dustLimit,
-      baseFee,
-      feePolicy
-    });
-  }
-  dispose() {}
-}

package/lib/api/bitcoin/createPendingTx.d.ts

@@ -1,37 +0,0 @@
-import type { AccountAddresses, PROTO } from '@trezor/connect-common';
-import type { Transaction as BitcoinJsTransaction } from '@trezor/utxo-lib';
-export declare const createPendingTransaction: (tx: BitcoinJsTransaction, {
-  addresses,
-  inputs,
-  outputs
-}: {
-  addresses: AccountAddresses;
-  inputs: PROTO.TxInputType[];
-  outputs: PROTO.TxOutputType[];
-}) => {
-  txid: string;
-  hex: string;
-  blockHeight: number;
-  blockTime: number;
-  confirmations: number;
-  vsize: number;
-  size: number;
-  value: string;
-  valueIn: string;
-  fees: string;
-  vin: {
-    n: number;
-    txid: string;
-    vout: number;
-    isAddress: boolean;
-    addresses: string[];
-    value: string;
-    sequence: number | undefined;
-  }[];
-  vout: {
-    n: number;
-    isAddress: boolean;
-    addresses: string[];
-    value: string;
-  }[];
-};

package/lib/api/bitcoin/createPendingTx.js

@@ -1,55 +0,0 @@
-import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
-import { __btcUnknownTxDebug__, getSerializedPath } from "../../utils/pathUtils.js";
-export const createPendingTransaction = (tx, {
-  addresses,
-  inputs,
-  outputs
-}) => {
-  const valueOut = outputs.reduce((sum, out) => BigNumber(sum).plus(out.amount), new BigNumber('0'));
-  const valueIn = inputs.reduce((sum, ins) => BigNumber(sum).plus(ins.amount), new BigNumber('0'));
-  const allAddresses = addresses.unused.concat(addresses.used, addresses.change);
-  const findAddress = ({
-    address_n
-  }) => {
-    const path = address_n ? getSerializedPath(address_n) : undefined;
-    return allAddresses.filter(address => address.path === path).map(address => address.address);
-  };
-  __btcUnknownTxDebug__('createPendingTransaction', inputs, addresses);
-  return {
-    txid: tx.getId(),
-    hex: tx.toHex(),
-    blockHeight: 0,
-    blockTime: Math.floor(Date.now() / 1000),
-    confirmations: 0,
-    vsize: tx.virtualSize(),
-    size: tx.weight(),
-    value: valueOut.toString(),
-    valueIn: valueIn.toString(),
-    fees: valueIn.minus(valueOut).toString(),
-    vin: inputs.map((ins, n) => ({
-      n,
-      txid: ins.prev_hash,
-      vout: ins.prev_index,
-      isAddress: true,
-      addresses: findAddress(ins),
-      value: ins.amount.toString(),
-      sequence: ins.sequence
-    })),
-    vout: outputs.map((out, n) => {
-      let transformedAddresses = [];
-      if (out.address) {
-        transformedAddresses = [out.address];
-      } else if ('op_return_data' in out) {
-        transformedAddresses = [`OP_RETURN (${Buffer.from(out.op_return_data, 'hex').toString('ascii')})`];
-      } else {
-        transformedAddresses = findAddress(out);
-      }
-      return {
-        n,
-        isAddress: out.script_type !== 'PAYTOOPRETURN',
-        addresses: transformedAddresses,
-        value: out.amount.toString()
-      };
-    })
-  };
-};

package/lib/api/bitcoin/enhanceSignTx.d.ts

@@ -1,2 +0,0 @@
-import type { BitcoinNetworkInfo, TransactionOptions } from '@trezor/connect-common';
-export declare const enhanceSignTx: (options: TransactionOptions, coinInfo: BitcoinNetworkInfo) => TransactionOptions;

package/lib/api/bitcoin/enhanceSignTx.js

@@ -1,23 +0,0 @@
-import { findBackend } from "../../backend/BlockchainLink.js";
-export const enhanceSignTx = (options, coinInfo) => {
-  if (coinInfo.shortcut === 'ZEC' || coinInfo.shortcut === 'TAZ') {
-    if (typeof options.overwintered !== 'boolean') {
-      options.overwintered = true;
-    }
-    if (typeof options.version !== 'number') {
-      options.version = 5;
-    }
-    if (typeof options.version_group_id !== 'number') {
-      options.version_group_id = 0x26a7270a;
-    }
-    if (typeof options.branch_id !== 'number') {
-      const backend = findBackend(coinInfo.shortcut);
-      if (backend?.serverInfo?.consensusBranchId) {
-        options.branch_id = backend.serverInfo.consensusBranchId;
-      } else {
-        options.branch_id = 0xc2d6d0b4;
-      }
-    }
-  }
-  return options;
-};

package/lib/api/bitcoin/index.d.ts

@@ -1,9 +0,0 @@
-export * from "./createPendingTx.js";
-export * from "./enhanceSignTx.js";
-export * from "./inputs.js";
-export * from "./outputs.js";
-export * from "./refTx.js";
-export * from "./signtx.js";
-export * from "./signtxLegacy.js";
-export * from "./signtxVerify.js";
-export * from "./TransactionComposer.js";

package/lib/api/bitcoin/index.js

@@ -1,9 +0,0 @@
-export * from "./createPendingTx.js";
-export * from "./enhanceSignTx.js";
-export * from "./inputs.js";
-export * from "./outputs.js";
-export * from "./refTx.js";
-export * from "./signtx.js";
-export * from "./signtxLegacy.js";
-export * from "./signtxVerify.js";
-export * from "./TransactionComposer.js";

package/lib/api/bitcoin/inputs.d.ts

@@ -1,4 +0,0 @@
-import type { BitcoinNetworkInfo, ComposeUtxo, ProtoWithDerivationPath } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-export declare const validateTrezorInputs: (inputs: ProtoWithDerivationPath<PROTO.TxInputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxInputType[];
-export declare const inputToTrezor: (input: ComposeUtxo, sequence?: number) => PROTO.TxInputType;