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

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';

package/libESM/api/bitcoin/index.mjs

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

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

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

package/libESM/api/bitcoin/inputs.mjs

@@ -1,75 +0,0 @@
-import { convertMultisigPubKey } from "../../utils/hdnodeUtils.mjs";
-import { fixPath, getHDPath, getScriptType, isSegwitPath, validatePath } from "../../utils/pathUtils.mjs";
-import { validateParams } from "../common/paramsValidator.mjs";
-export const validateTrezorInputs = (inputs, coinInfo) => inputs.map(i => fixPath(i)).map(i => convertMultisigPubKey(coinInfo.network, i)).map(input => {
-  const useAmount = input.script_type === 'EXTERNAL' || isSegwitPath(input.address_n);
-  validateParams(input, [{
-    name: 'prev_hash',
-    type: 'string',
-    required: true
-  }, {
-    name: 'prev_index',
-    type: 'number',
-    required: true
-  }, {
-    name: 'amount',
-    type: 'uint',
-    required: useAmount
-  }, {
-    name: 'script_type',
-    type: 'string'
-  }, {
-    name: 'sequence',
-    type: 'number'
-  }, {
-    name: 'multisig',
-    type: 'object'
-  }, {
-    name: 'coinjoin_flags',
-    type: 'number'
-  }]);
-  if (input.script_type === 'EXTERNAL') {
-    validateParams(input, [{
-      name: 'script_pubkey',
-      type: 'string',
-      required: true
-    }, {
-      name: 'commitment_data',
-      type: 'string'
-    }, {
-      name: 'ownership_proof',
-      type: 'string'
-    }, {
-      name: 'script_sig',
-      type: 'string'
-    }, {
-      name: 'witness',
-      type: 'string'
-    }]);
-  } else {
-    validatePath(input.address_n);
-  }
-  return input;
-});
-export const enhanceTrezorInputs = (inputs, rawTxs) => {
-  inputs.forEach(input => {
-    if (!input.amount) {
-      console.warn('TrezorConnect.signTransaction deprecation: missing input amount.');
-      const refTx = rawTxs.find(t => t.getId() === input.prev_hash);
-      if (refTx && refTx.outs[input.prev_index]) {
-        input.amount = refTx.outs[input.prev_index].value;
-      }
-    }
-  });
-};
-export const inputToTrezor = (input, sequence = 0xffffffff) => {
-  const address_n = getHDPath(input.path);
-  return {
-    address_n,
-    prev_index: input.vout,
-    prev_hash: input.txid,
-    script_type: getScriptType(address_n),
-    amount: input.amount,
-    sequence
-  };
-};

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

@@ -1,5 +0,0 @@
-import type { BitcoinNetworkInfo, ComposeOutput, ComposeResultFinal, PROTO, ProtoWithDerivationPath } from '@trezor/connect-common';
-import type { ComposeOutput as ComposeOutputBase } from '@trezor/utxo-lib';
-export declare const validateTrezorOutputs: (outputs: ProtoWithDerivationPath<PROTO.TxOutputType>[], coinInfo: BitcoinNetworkInfo) => PROTO.TxOutputType[];
-export declare const validateHDOutput: (output: ComposeOutput, coinInfo: BitcoinNetworkInfo) => ComposeOutputBase;
-export declare const outputToTrezor: (output: ComposeResultFinal["outputs"][number]) => PROTO.TxOutputType;