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

package/lib/api/backupDevice.js

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

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

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

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

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

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

package/lib/api/bitcoin/enhanceSignTx.js

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

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

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

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

package/lib/api/bitcoin/inputs.js

@@ -0,0 +1,63 @@
+import { convertMultisigPubKey } from "../../utils/hdnodeUtils.js";
+import { fixPath, getHDPath, getScriptType, validatePath } from "../../utils/pathUtils.js";
+import { validateParams } from "../common/paramsValidator.js";
+export const validateTrezorInputs = (inputs, coinInfo) => inputs.map(i => fixPath(i)).map(i => convertMultisigPubKey(coinInfo.network, i)).map(input => {
+  validateParams(input, [{
+    name: 'prev_hash',
+    type: 'string',
+    required: true
+  }, {
+    name: 'prev_index',
+    type: 'number',
+    required: true
+  }, {
+    name: 'amount',
+    type: 'uint',
+    required: true
+  }, {
+    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 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/lib/api/bitcoin/outputs.d.ts

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

package/lib/api/bitcoin/outputs.js

@@ -0,0 +1,128 @@
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { isValidAddress } from "../../utils/addressUtils.js";
+import { convertMultisigPubKey } from "../../utils/hdnodeUtils.js";
+import { fixPath, getHDPath, getOutputScriptType } from "../../utils/pathUtils.js";
+import { validateParams } from "../common/paramsValidator.js";
+export const validateTrezorOutputs = (outputs, coinInfo) => {
+  const trezorOutputs = outputs.map(o => fixPath(o)).map(o => convertMultisigPubKey(coinInfo.network, o));
+  trezorOutputs.forEach(output => {
+    validateParams(output, [{
+      name: 'address_n',
+      type: 'array'
+    }, {
+      name: 'address',
+      type: 'string'
+    }, {
+      name: 'amount',
+      type: 'uint'
+    }, {
+      name: 'op_return_data',
+      type: 'string'
+    }, {
+      name: 'script_type',
+      type: 'string'
+    }, {
+      name: 'multisig',
+      type: 'object'
+    }]);
+    if (Object.prototype.hasOwnProperty.call(output, 'address_n') && Object.prototype.hasOwnProperty.call(output, 'address')) {
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Cannot use address and address_n in one output');
+    }
+    if (output.address_n && !output.script_type) {
+      output.script_type = getOutputScriptType(output.address_n);
+    }
+    if ('address' in output && typeof output.address === 'string') {
+      const externalOutput = output;
+      if (!externalOutput.script_type) {
+        externalOutput.script_type = 'PAYTOADDRESS';
+      } else if (externalOutput.script_type !== 'PAYTOADDRESS') {
+        throw ERRORS.TypedError('Method_InvalidParameter', `External output (with address) must use script_type PAYTOADDRESS, got ${externalOutput.script_type}`);
+      }
+      if (!isValidAddress(externalOutput.address, coinInfo)) {
+        throw ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address ${externalOutput.address}`);
+      }
+    }
+  });
+  return trezorOutputs;
+};
+export const validateHDOutput = (output, coinInfo) => {
+  const validateAddress = address => {
+    if (!address || !isValidAddress(address, coinInfo)) {
+      throw ERRORS.TypedError('Method_InvalidParameter', `Invalid ${coinInfo.label} output address format`);
+    }
+  };
+  switch (output.type) {
+    case 'opreturn':
+      validateParams(output, [{
+        name: 'dataHex',
+        type: 'string'
+      }]);
+      return {
+        type: 'opreturn',
+        dataHex: output.dataHex
+      };
+    case 'send-max':
+      validateParams(output, [{
+        name: 'address',
+        type: 'string',
+        required: true
+      }]);
+      validateAddress(output.address);
+      return {
+        type: 'send-max',
+        address: output.address
+      };
+    case 'payment-noaddress':
+      validateParams(output, [{
+        name: 'amount',
+        type: 'uint',
+        required: true
+      }]);
+      return {
+        type: 'payment-noaddress',
+        amount: output.amount
+      };
+    case 'send-max-noaddress':
+      return {
+        type: 'send-max-noaddress'
+      };
+    default:
+      validateParams(output, [{
+        name: 'amount',
+        type: 'uint',
+        required: true
+      }, {
+        name: 'address',
+        type: 'string',
+        required: true
+      }]);
+      validateAddress(output.address);
+      return {
+        type: 'payment',
+        address: output.address,
+        amount: output.amount
+      };
+  }
+};
+export const outputToTrezor = output => {
+  if (output.type === 'opreturn') {
+    return {
+      amount: '0',
+      op_return_data: output.dataHex,
+      script_type: 'PAYTOOPRETURN'
+    };
+  }
+  if (output.type === 'change') {
+    const address_n = getHDPath(output.path);
+    return {
+      address_n,
+      amount: output.amount,
+      script_type: getOutputScriptType(address_n)
+    };
+  }
+  return {
+    address: output.address,
+    amount: output.amount,
+    script_type: 'PAYTOADDRESS'
+  };
+};

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

@@ -0,0 +1,23 @@
+import type { AccountAddresses, AccountTransaction, BitcoinNetworkInfo, CoinInfo, RefTransaction, TransactionOptions } from '@trezor/connect-common';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import { Transaction as BitcoinJsTransaction, type Network } from '@trezor/utxo-lib';
+export declare const requireReferencedTransactions: (inputs: PROTO.TxInputType[], options?: TransactionOptions, coinInfo?: CoinInfo) => boolean;
+export declare const getReferencedTransactions: (inputs: PROTO.TxInputType[]) => string[];
+export declare const getOrigTransactions: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[]) => string[];
+export declare const parseTransactionHexes: (network?: Network) => (hexes: string[]) => (import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<undefined> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/dash").DashSpecific> | import("@trezor/utxo-lib/lib/transaction/base").TransactionBase<import("@trezor/utxo-lib/lib/transaction/zcash").ZcashSpecific>)[];
+export declare const transformOrigTransactions: (txs: BitcoinJsTransaction[], coinInfo: BitcoinNetworkInfo, currentInputs: PROTO.TxInputType[], addresses: AccountAddresses) => RefTransaction[];
+export declare const transformReferencedTransaction: (tx: BitcoinJsTransaction) => RefTransaction;
+export declare const transformReferencedTransactions: (txs: BitcoinJsTransaction[]) => RefTransaction[];
+export declare const validateReferencedTransactions: ({
+  transactions,
+  inputs,
+  outputs,
+  addresses,
+  coinInfo
+}: {
+  transactions?: (RefTransaction | AccountTransaction)[];
+  inputs: PROTO.TxInputType[];
+  outputs: PROTO.TxOutputType[];
+  addresses?: AccountAddresses;
+  coinInfo: BitcoinNetworkInfo;
+}) => RefTransaction[] | undefined;