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

package/libESM/api/applyFlags.d.mts

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

package/libESM/api/applyFlags.mjs

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

package/libESM/api/applySettings.d.mts

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

package/libESM/api/applySettings.mjs

@@ -1,55 +0,0 @@
-import { ApplySettings as ApplySettingsSchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-export default class ApplySettings extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(ApplySettingsSchema, payload);
-    const params = {
-      ...payload,
-      _passphrase_source: payload.passphrase_source
-    };
-    super(message, params);
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  init() {}
-  get confirmation() {
-    return {
-      view: 'device-management',
-      customConfirmButton: {
-        className: 'confirm',
-        label: 'Proceed'
-      },
-      label: 'Do you really want to change device settings?'
-    };
-  }
-  async run() {
-    const device = this.getDevice();
-    const cmd = device.getCommands();
-    const homescreenBytes = this.params.homescreen ? Buffer.from(this.params.homescreen, 'hex') : undefined;
-    if (device.atLeast('2.9.0') && homescreenBytes) {
-      this.params.homescreen = undefined;
-      this.params.homescreen_length = homescreenBytes.length;
-    }
-    if (homescreenBytes !== undefined) {
-      device.startPiggybackAck();
-    }
-    let response = await cmd.typedCall('ApplySettings', ['DataChunkRequest', 'Success'], this.params);
-    while (response.type !== 'Success') {
-      const start = response.message.data_offset;
-      const end = start + response.message.data_length;
-      const data_chunk = homescreenBytes?.subarray(start, end).toString('hex') || '';
-      response = await cmd.typedCall('DataChunkAck', ['DataChunkRequest', 'Success'], {
-        data_chunk
-      });
-    }
-    await device.stopPiggybackAck();
-    return response.message;
-  }
-}

package/libESM/api/authenticateDevice.d.mts

@@ -1,9 +0,0 @@
-import type { MethodPermission } from '@trezor/connect-common';
-import { AuthenticateDeviceParams } from '@trezor/device-authenticity';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class AuthenticateDevice extends AbstractMethod<'authenticateDevice', AuthenticateDeviceParams> {
-    constructor(message: MethodMessage<'authenticateDevice'>);
-    get requiredPermissions(): MethodPermission[];
-    run(): Promise<import("@trezor/device-authenticity/libESM/types").ResultsToValidate>;
-}

package/libESM/api/authenticateDevice.mjs

@@ -1,108 +0,0 @@
-import { UI_REQUEST } from "@trezor/connect-common";
-import { AuthenticateDeviceParams, deviceAuthenticityBlacklistConfig, deviceAuthenticityConfig, getRandomChallenge, prepareDeviceAuthenticityData, validateSerialNumbers, verifyAuthenticityProof } from "@trezor/device-authenticity";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-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 ['management'];
-  }
-  async run() {
-    const challenge = getRandomChallenge();
-    const {
-      message
-    } = await this.getDevice().getCommands().typedCall('AuthenticateDevice', 'AuthenticityProof', {
-      challenge: challenge.toString('hex')
-    });
-    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
-      } = message;
-      const isAvailable = signature !== undefined && certificates.length > 0;
-      if (isAvailable) {
-        return await verifyAuthenticityProof({
-          ...commonParams,
-          certificates,
-          signature
-        });
-      }
-      return {
-        valid: false,
-        error: 'RESPONSE_PAYLOAD_MISSING'
-      };
-    };
-    const hasTropicAbility = !this.getDevice().unavailableCapabilities['tropicDeviceAuthentication'];
-    const getTropicResult = async () => {
-      const {
-        tropic_signature: signature,
-        tropic_certificates: certificates
-      } = message;
-      const isAvailable = signature !== undefined && 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
-      } = message;
-      const isAvailable = signature !== undefined && certificates.length > 0;
-      const isRequired = !this.getDevice().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/libESM/api/authorizeCoinjoin.d.mts

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

package/libESM/api/authorizeCoinjoin.mjs

@@ -1,44 +0,0 @@
-import { AuthorizeCoinjoin as AuthorizeCoinjoinSchema } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { getBitcoinNetwork } from "../data/coinInfo.mjs";
-import { getScriptType, validatePath } from "../utils/pathUtils.mjs";
-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 ['management'];
-  }
-  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/libESM/api/backupDevice.d.mts

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

package/libESM/api/backupDevice.mjs

@@ -1,36 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-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
-    };
-    super(message, params);
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return ['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/libESM/api/bitcoin/TransactionComposer.d.mts

@@ -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';
-import type { BitcoinFeeLevels } from '../../backend/fees/BitcoinFeeLevels';
-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/libESM/api/bitcoin/TransactionComposer.mjs

@@ -1,139 +0,0 @@
-import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
-import { composeTx } from "@trezor/utxo-lib";
-import { getOrInitBitcoinFeeLevels } from "../../backend/fees/index.mjs";
-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 && 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 changeAddress = addresses.change.find(a => !a.transfers) || addresses.change[addresses.change.length - 1];
-    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
-    });
-  }
-  dispose() {}
-}

package/libESM/api/bitcoin/createPendingTx.d.mts

@@ -1,33 +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/libESM/api/bitcoin/createPendingTx.mjs

@@ -1,54 +0,0 @@
-import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
-import { getSerializedPath } from "../../utils/pathUtils.mjs";
-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);
-  };
-  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/libESM/api/bitcoin/enhanceSignTx.d.mts

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

package/libESM/api/bitcoin/enhanceSignTx.mjs

@@ -1,23 +0,0 @@
-import { findBackend } from "../../backend/BlockchainLink.mjs";
-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 && backend.serverInfo?.consensusBranchId) {
-        options.branch_id = backend.serverInfo.consensusBranchId;
-      } else {
-        options.branch_id = 0xc2d6d0b4;
-      }
-    }
-  }
-  return options;
-};

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

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