[DDW-717] Update Trezor logic to cover upcoming breaking changes (#2629)

* [DDW-717] Intorduce Trezor logic improvement which covers Trezor firmware breaking changes

* [DDW-717] Add signingMode (ordinary transaction) to the Trezor tx signing method

* [DDW-717] Update trezor-connect to 8.1.30 BETA unreleased version and logic / params improvement

* [DDW-717] Remove blake2b from yarn.lock

* [DDW-717] Update storybook node version to 14.17.0

* [DDW-717] Downgrate netlify node version to 12.13.0

* [DDW-717] Change ieee754 yarn.lock entries

* [DDW-717] Reverting yarn.lock ieee changes

* [DDW-717] Update trezor-connect to unreleased 8.1.30-RC2 version

* [DDW-717] Replace trezor-connect package with RC borc free pre-release version

* [DDW-717] Update trezor-connect to the 8.1.30-beta.3 version

* [DDW-717] Reverting trezor-connect package to the borc free RC

* [DDW-717] Update netlify.toml node version

* [DDW-717] Update trezor-connect to 8.1.30-beta.4

* [DDW-717] Revert changes to trezor-connect-v8.1.30-rc.2-tx-streaming-extended-borc-patch package

* [DDW-717] Add cbor-web external

* [DDW-717] Add cbor-web to webpack.config

* [DDW-717] Add cbor-web to MacInstaller

* [DDW-717] Remove cbor-web from externals

Co-authored-by: Nikola Glumac <[email protected]>

Author: tomislavhoracek

CHANGELOG.md

@@ -17,6 +17,7 @@ Changelog
 
 ### Chores
 
+- Covered Trezor firmware breaking changes ([PR 2629](https://github.com/input-output-hk/daedalus/pull/2629))
 - Updated `cardano-wallet` to revision `9ae2d48b` which enables hardware wallet support in Alonzo era ([PR 2663](https://github.com/input-output-hk/daedalus/issues/2663))
 - Updated `cardano-wallet` to version `2021-08-27` which includes `cardano-node` 1.29.0 ([PR 2650](https://github.com/input-output-hk/daedalus/pull/2650))
 - Updated `cardano-wallet` to version `2021-08-11` which includes `cardano-node` alonzo-purple-1.0.1 ([PR 2641](https://github.com/input-output-hk/daedalus/pull/2641))

installers/common/MacInstaller.hs

@@ -282,6 +282,7 @@ buildElectronApp darwinConfig@DarwinConfig{dcAppName, dcAppNameApp} installerCon
       , "int64-buffer"
       , "call-bind"
       , "get-intrinsic"
+      , "cbor-web"
       ]
   mapM_ (\lib -> do
       cptree ("../node_modules" </> lib) ((fromText pathtoapp) </> "Contents/Resources/app/node_modules" </> lib)

netlify.toml

@@ -1,2 +1,2 @@
 [build]
-	environment = { YARN_VERSION = "1.22.4" }
+	environment = { YARN_VERSION = "1.22.4", NODE_VERSION = "12.19.0" }

package.json

@@ -245,7 +245,7 @@
     "source-map-support": "0.5.19",
     "spectron-fake-dialog": "0.0.1",
     "tcp-port-used": "1.0.1",
-    "trezor-connect": "8.1.27-extended",
+    "trezor-connect": "8.1.30-beta.4",
     "unorm": "1.6.0",
     "validator": "13.1.17"
   },

source/common/types/hardware-wallets.types.js

@@ -276,6 +276,7 @@ export type TrezorSignTransactionRequest = {
   reset?: boolean,
   devicePath: string,
   validityIntervalStartStr?: string,
+  signingMode: number,
   auxiliaryData: ?TrezorAuxiliaryDataType,
 };
 
@@ -289,11 +290,29 @@ export type LedgerSignTransactionResponse = {
   },
 };
 
+export type TrezorWitness = {|
+  type: number,
+  pubKey: string,
+  signature: string,
+  chainCode: ?string,
+|};
+
+export type TrezorSerializedTxPayload = {|
+  serializedTx: string,
+|};
+
+export type TrezorRawTxPayload = {
+  witnesses: Array<TrezorWitness>,
+  auxiliaryDataSupplement?: {
+    type: number,
+    auxiliaryDataHash: string,
+    catalystSignature: string,
+  },
+};
+
 export type TrezorSignTransactionResponse = {
   success: boolean,
-  payload: {
-    serializedTx: string,
-  },
+  payload: TrezorSerializedTxPayload | TrezorRawTxPayload,
 };
 
 export type HardwareWalletConnectionRequest = {

source/main/ipc/getHardwareWalletChannel.js

@@ -741,6 +741,7 @@ export const handleHardwareWalletRequests = async (
       validityIntervalStartStr,
       withdrawals,
       auxiliaryData,
+      signingMode,
     } = params;
 
     if (!TrezorConnect) {
@@ -759,6 +760,7 @@ export const handleHardwareWalletRequests = async (
         withdrawals,
         validityIntervalStartStr,
         auxiliaryData,
+        signingMode,
       };
       const signedTransaction = await TrezorConnect.cardanoSignTransaction({
         device: { path: devicePath },

source/renderer/app/stores/HardwareWalletsStore.js

@@ -58,6 +58,7 @@ import {
   prepareTrezorCertificate,
   prepareTrezorWithdrawal,
   prepareTrezorAuxiliaryData,
+  TrezorTransactionSigningMode,
 } from '../utils/shelleyTrezor';
 import {
   DeviceModels,
@@ -93,6 +94,7 @@ import type {
   HardwareWalletExtendedPublicKeyResponse,
   HardwareWalletConnectionRequest,
   Witness,
+  TrezorWitness,
 } from '../../../common/types/hardware-wallets.types';
 
 import { logger } from '../utils/logging';
@@ -1645,27 +1647,95 @@ export default class HardwareWalletsStore extends Store {
       throw new Error(`Missing Coins Selection for wallet: ${walletId}`);
     }
 
-    const { inputs, outputs, fee, certificates, withdrawals } = coinSelection;
+    const {
+      inputs,
+      outputs,
+      fee: flatFee,
+      certificates,
+      withdrawals,
+    } = coinSelection;
+
+    logger.debug('[HW-DEBUG] HWStore - sign transaction Trezor: ', {
+      walletId,
+    });
+
+    const hardwareWalletConnectionData = get(
+      this.hardwareWalletsConnectionData,
+      walletId
+    );
+
+    // Guard against potential null value
+    if (!hardwareWalletConnectionData)
+      throw new Error('Wallet not paired or Device not connected');
 
+    const publicKeyHex = get(hardwareWalletConnectionData, [
+      'extendedPublicKey',
+      'publicKeyHex',
+    ]);
+    const chainCodeHex = get(hardwareWalletConnectionData, [
+      'extendedPublicKey',
+      'chainCodeHex',
+    ]);
+    const xpubHex = `${publicKeyHex}${chainCodeHex}`;
+
+    const unsignedTxInputs = [];
     const inputsData = map(inputs, (input) => {
+      const shelleyTxInput = ShelleyTxInputFromUtxo(input);
+      unsignedTxInputs.push(shelleyTxInput);
       return prepareTrezorInput(input);
     });
 
-    const outputsData = map(outputs, (output) => {
-      return prepareTrezorOutput(output);
-    });
+    const unsignedTxOutputs = [];
+    const outputsData = [];
+    for (const output of outputs) {
+      const {
+        address_style: addressStyle,
+      } = await this.stores.addresses._inspectAddress({
+        addressId: output.address,
+      });
+      const shelleyTxOutput = ShelleyTxOutput(output, addressStyle);
+      unsignedTxOutputs.push(shelleyTxOutput);
+      const ledgerOutput = prepareTrezorOutput(output);
+      outputsData.push(ledgerOutput);
+    }
 
-    const withdrawalsData = map(withdrawals, (withdrawal) => {
-      return prepareTrezorWithdrawal(withdrawal);
+    // Construct certificates
+    const unsignedTxCerts = [];
+    const _certificatesData = map(certificates, async (certificate) => {
+      const accountAddress = await this._getRewardAccountAddress(
+        walletId,
+        certificate.rewardAccountPath
+      );
+      const shelleyTxCert = ShelleyTxCert({
+        accountAddress,
+        pool: certificate.pool,
+        type: CERTIFICATE_TYPE[certificate.certificateType],
+      });
+      unsignedTxCerts.push(shelleyTxCert);
+      return prepareTrezorCertificate(certificate);
     });
+    const certificatesData = await Promise.all(_certificatesData);
 
-    const certificatesData = map(certificates, (certificate) =>
-      prepareTrezorCertificate(certificate)
+    // Construct Withdrawals
+    const _withdrawalsData = map(withdrawals, async (withdrawal) =>
+      prepareTrezorWithdrawal(withdrawal)
     );
+    const withdrawalsData = await Promise.all(_withdrawalsData);
 
+    let unsignedTxAuxiliaryData = null;
     let auxiliaryData = null;
     if (this.votingData) {
-      const { votingKey, nonce } = this.votingData;
+      const { stakeAddress, stakeKey, votingKey, nonce } = this.votingData;
+      unsignedTxAuxiliaryData = {
+        nonce, // unique increaseable number e.g. current epoch number or absolute slot number ( identifies unique tx / vote registration )
+        rewardDestinationAddress: {
+          address: stakeAddress,
+          stakingPath: [2147485500, 2147485463, 2147483648, 2, 0],
+        },
+        stakePubKey: stakeKey,
+        type: CATALYST_VOTING_REGISTRATION_TYPE,
+        votingPubKey: votingKey,
+      };
       auxiliaryData = prepareTrezorAuxiliaryData({
         votingKey,
         nonce: nonce.toString(),
@@ -1715,15 +1785,16 @@ export default class HardwareWalletsStore extends Store {
       });
     }
 
-    const { isMainnet } = this.environment;
+    const fee = formattedAmountToLovelace(flatFee.toString());
     const ttl = this._getTtl();
     const absoluteSlotNumber = this._getAbsoluteSlotNumber();
+    const { isMainnet } = this.environment;
 
     try {
       const signedTransaction = await signTransactionTrezorChannel.request({
         inputs: inputsData,
         outputs: outputsData,
-        fee: formattedAmountToLovelace(fee.toString()).toString(),
+        fee: fee.toString(),
         ttl: ttl.toString(),
         validityIntervalStartStr: absoluteSlotNumber.toString(),
         networkId: isMainnet
@@ -1735,21 +1806,78 @@ export default class HardwareWalletsStore extends Store {
         certificates: certificatesData,
         withdrawals: withdrawalsData,
         devicePath: recognizedDevicePath,
+        signingMode: TrezorTransactionSigningMode.ORDINARY_TRANSACTION,
         auxiliaryData,
       });
 
-      if (!signedTransaction.success) {
+      if (signedTransaction && !signedTransaction.success) {
         throw signedTransaction.payload;
       }
+      // Compatible with old firmwares
+      const serializedTx = get(signedTransaction, ['payload', 'serializedTx']);
 
-      runInAction(
-        'HardwareWalletsStore:: transaction successfully signed',
-        () => {
-          this.txBody = signedTransaction.payload.serializedTx;
-          this.hwDeviceStatus =
-            HwDeviceStatuses.VERIFYING_TRANSACTION_SUCCEEDED;
-        }
+      if (serializedTx) {
+        runInAction(
+          'HardwareWalletsStore:: transaction successfully signed',
+          () => {
+            this.txBody = serializedTx;
+            this.hwDeviceStatus =
+              HwDeviceStatuses.VERIFYING_TRANSACTION_SUCCEEDED;
+          }
+        );
+        return;
+      }
+
+      const unsignedTxWithdrawals =
+        withdrawals.length > 0 ? ShelleyTxWithdrawal(withdrawals) : null;
+
+      // Prepare unsigned transaction structure for serialzation
+      let txAuxData = {
+        txInputs: unsignedTxInputs,
+        txOutputs: unsignedTxOutputs,
+        fee,
+        ttl,
+        certificates: unsignedTxCerts,
+        withdrawals: unsignedTxWithdrawals,
+      };
+
+      let txAuxiliaryData = null;
+      const auxiliaryDataSupplement = get(signedTransaction, [
+        'payload',
+        'auxiliaryDataSupplement',
+      ]);
+      if (unsignedTxAuxiliaryData && auxiliaryDataSupplement) {
+        txAuxData = {
+          ...txAuxData,
+          txAuxiliaryData: unsignedTxAuxiliaryData,
+          txAuxiliaryDataHash: auxiliaryDataSupplement.auxiliaryDataHash,
+        };
+        txAuxiliaryData = cborizeTxAuxiliaryVotingData(
+          unsignedTxAuxiliaryData,
+          auxiliaryDataSupplement.catalystSignature
+        );
+      }
+
+      const unsignedTx = prepareTxAux(txAuxData);
+      const witnesses = get(signedTransaction, ['payload', 'witnesses'], []);
+      const signedWitnesses = await this._signWitnesses(witnesses, xpubHex);
+      const txWitnesses = new Map();
+      if (signedWitnesses.length > 0) {
+        txWitnesses.set(0, signedWitnesses);
+      }
+
+      // Prepare serialized transaction with unsigned data and signed witnesses
+      const txBody = await prepareBody(
+        unsignedTx,
+        txWitnesses,
+        txAuxiliaryData
       );
+
+      runInAction('HardwareWalletsStore:: set Transaction verified', () => {
+        this.hwDeviceStatus = HwDeviceStatuses.VERIFYING_TRANSACTION_SUCCEEDED;
+        this.txBody = txBody;
+        this.activeDevicePath = null;
+      });
     } catch (error) {
       runInAction(
         'HardwareWalletsStore:: set Transaction verifying failed',
@@ -1758,15 +1886,17 @@ export default class HardwareWalletsStore extends Store {
           this.isTransactionInitiated = false;
         }
       );
-      // @TODO - Maybe we should handle this case as separated message in tx dialog
       if (error.code === 'Device_CallInProgress') {
         throw new Error('Device is busy - reconnect device and try again');
       }
       throw error;
     }
   };
 
-  _signWitnesses = async (witnesses: Array<Witness>, xpubHex: string) => {
+  _signWitnesses = async (
+    witnesses: Array<TrezorWitness | Witness>,
+    xpubHex: string
+  ) => {
     const signedWitnesses = [];
     for (const witness of witnesses) {
       const signedWitness = await this.ShelleyWitness(witness, xpubHex);
@@ -1775,11 +1905,25 @@ export default class HardwareWalletsStore extends Store {
     return signedWitnesses;
   };
 
-  ShelleyWitness = async (witness: Witness, xpubHex: string) => {
-    const xpub = await this._deriveXpub(witness.path, xpubHex);
-    const publicKey = xpub.slice(0, 32);
-    const signature = Buffer.from(witness.witnessSignatureHex, 'hex');
-    return ShelleyTxWitnessShelley(publicKey, signature);
+  ShelleyWitness = async (
+    witness: TrezorWitness | Witness,
+    xpubHex: string
+  ) => {
+    let publicKey;
+    let witnessSignatureHex;
+    if (witness.pubKey && witness.signature) {
+      publicKey = Buffer.from(witness.pubKey, 'hex');
+      witnessSignatureHex = witness.signature;
+    } else if (witness.path && witness.witnessSignatureHex) {
+      const xpub = await this._deriveXpub(witness.path, xpubHex);
+      publicKey = xpub.slice(0, 32);
+      witnessSignatureHex = witness.witnessSignatureHex;
+    }
+    if (witnessSignatureHex && publicKey) {
+      const signature = Buffer.from(witnessSignatureHex, 'hex');
+      return ShelleyTxWitnessShelley(publicKey, signature);
+    }
+    return null;
   };
 
   _deriveXpub = CachedDeriveXpubFactory(async (xpubHex) => {
@@ -1944,6 +2088,7 @@ export default class HardwareWalletsStore extends Store {
       let txAuxiliaryData = null;
       if (
         unsignedTxAuxiliaryData &&
+        signedTransaction &&
         signedTransaction.auxiliaryDataSupplement
       ) {
         txAuxData = {
@@ -1961,10 +2106,8 @@ export default class HardwareWalletsStore extends Store {
 
       const unsignedTx = prepareTxAux(txAuxData);
 
-      const signedWitnesses = await this._signWitnesses(
-        signedTransaction.witnesses,
-        xpubHex
-      );
+      const witnesses = get(signedTransaction, 'witnesses', []);
+      const signedWitnesses = await this._signWitnesses(witnesses, xpubHex);
       const txWitnesses = new Map();
       if (signedWitnesses.length > 0) {
         txWitnesses.set(0, signedWitnesses);

source/renderer/app/utils/shelleyLedger.js

@@ -104,7 +104,7 @@ export const derivationScheme = {
 
 // Constructors
 export const ShelleyTxWitnessShelley = (
-  publicKey: string,
+  publicKey: Buffer,
   signature: Buffer
 ) => {
   function encodeCBOR(encoder: any) {