fix(hardware-trezor): transaction outputs format are now computed independently

Author: AngelCastilloB

packages/hardware-trezor/src/TrezorKeyAgent.ts

@@ -246,13 +246,25 @@ export class TrezorKeyAgent extends KeyAgentBase {
       const body = txBody.toCore();
       const hash = txBody.hash() as unknown as HexBlob;
 
+      const outputsFormat = txBody
+        .outputs()
+        .map((out) =>
+          out.isBabbageOutput()
+            ? Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE
+            : Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY
+        );
+      const collateralReturnFormat = txBody.collateralReturn()?.isBabbageOutput()
+        ? Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE
+        : Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY;
+
       const trezorTxData = await txToTrezor(body, {
         accountIndex: this.accountIndex,
         chainId: this.chainId,
+        collateralReturnFormat,
         knownAddresses,
+        outputsFormat,
         tagCborSets: txBody.hasTaggedSets(),
-        txInKeyPathMap,
-        useBabbageOutputs: txBody.hasBabbageOutput()
+        txInKeyPathMap
       });
 
       const signingMode = TrezorKeyAgent.matchSigningMode(trezorTxData);

packages/hardware-trezor/src/transformers/tx.ts

@@ -19,7 +19,7 @@ export const trezorTxTransformer: Transformer<
   certificates: ({ certificates }, context) => (certificates ? mapCerts(certificates, context!) : undefined),
   collateralInputs: ({ collaterals }, context) => (collaterals ? mapTxIns(collaterals, context!) : undefined),
   collateralReturn: ({ collateralReturn }, context) =>
-    collateralReturn ? toTxOut(collateralReturn, context!) : undefined,
+    collateralReturn ? toTxOut({ index: 0, isCollateral: true, txOut: collateralReturn }, context!) : undefined,
   fee: ({ fee }) => fee.toString(),
   inputs: ({ inputs }, context) => mapTxIns(inputs, context!),
   mint: ({ mint }) => mapTokenMap(mint, true),

packages/hardware-trezor/src/transformers/txOut.ts

@@ -42,31 +42,27 @@ const getScriptHex = (output: Serialization.TransactionOutput): HexBlob | undefi
 
 const getInlineDatum = (datum: Cardano.PlutusData): string => Serialization.PlutusData.fromCore(datum).toCbor();
 
-export const toTxOut: Transform<Cardano.TxOut, Trezor.CardanoOutput, TrezorTxTransformerContext> = (txOut, context) => {
-  const destination = toDestination(txOut, context);
+export const toTxOut: Transform<
+  { txOut: Cardano.TxOut; index: number; isCollateral: boolean },
+  Trezor.CardanoOutput,
+  TrezorTxTransformerContext
+> = (elem, context) => {
+  const { txOut, index, isCollateral } = elem;
   const output = Serialization.TransactionOutput.fromCore(txOut);
   const scriptHex = getScriptHex(output);
+  const format = isCollateral ? context?.collateralReturnFormat : context?.outputsFormat[index];
+  const isBabbage = format === Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE;
 
-  return context?.useBabbageOutputs
-    ? {
-        ...destination,
-        amount: txOut.value.coins.toString(),
-        datumHash: txOut.datumHash?.toString(),
-        format: Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
-        inlineDatum: txOut.datum ? getInlineDatum(txOut.datum) : undefined,
-        referenceScript: scriptHex,
-        tokenBundle: mapTokenMap(txOut.value.assets)
-      }
-    : {
-        ...destination,
-        amount: txOut.value.coins.toString(),
-        datumHash: txOut.datumHash?.toString(),
-        format: Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY,
-        inlineDatum: undefined,
-        referenceScript: undefined,
-        tokenBundle: mapTokenMap(txOut.value.assets)
-      };
+  return {
+    ...toDestination(txOut, context),
+    amount: txOut.value.coins.toString(),
+    datumHash: txOut.datumHash?.toString(),
+    format,
+    inlineDatum: isBabbage ? (txOut.datum ? getInlineDatum(txOut.datum) : undefined) : undefined,
+    referenceScript: isBabbage ? scriptHex : undefined,
+    tokenBundle: mapTokenMap(txOut.value.assets)
+  };
 };
 
 export const mapTxOuts = (txOuts: Cardano.TxOut[], context: TrezorTxTransformerContext): Trezor.CardanoOutput[] =>
-  txOuts.map((txOut) => toTxOut(txOut, context));
+  txOuts.map((txOut, index) => toTxOut({ index, isCollateral: false, txOut }, context));

packages/hardware-trezor/src/types.ts

@@ -13,8 +13,10 @@ export type TrezorTxTransformerContext = {
   accountIndex: number;
   /** Whether sets should be encoded as tagged set in CBOR */
   tagCborSets: boolean;
-  /** Whether to use Babbage output format or not. */
-  useBabbageOutputs: boolean;
+  /** The outputs format in the same order as they appear in the transaction. */
+  outputsFormat: Array<Trezor.PROTO.CardanoTxOutputSerializationFormat>;
+  /** The collateral return output format. */
+  collateralReturnFormat: Trezor.PROTO.CardanoTxOutputSerializationFormat | undefined;
 } & SignTransactionContext;
 
 export type TrezorTxOutputDestination =

packages/hardware-trezor/test/testData.ts

@@ -1,4 +1,5 @@
 import * as Crypto from '@cardano-sdk/crypto';
+import * as Trezor from '@trezor/connect';
 import { AddressType, GroupedAddress, KeyRole } from '@cardano-sdk/key-management';
 import { Cardano } from '@cardano-sdk/core';
 import { HexBlob } from '@cardano-sdk/util';
@@ -169,10 +170,15 @@ export const contextWithKnownAddresses: TrezorTxTransformerContext = {
     networkId: Cardano.NetworkId.Testnet,
     networkMagic: 999
   },
+  collateralReturnFormat: Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
   knownAddresses: [knownAddress],
+  outputsFormat: [
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY,
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY
+  ],
   tagCborSets: false,
-  txInKeyPathMap: {},
-  useBabbageOutputs: false
+  txInKeyPathMap: {}
 };
 
 export const contextWithKnownAddressesWithoutStakingCredentials: TrezorTxTransformerContext = {
@@ -181,10 +187,14 @@ export const contextWithKnownAddressesWithoutStakingCredentials: TrezorTxTransfo
     networkId: Cardano.NetworkId.Testnet,
     networkMagic: 999
   },
+  collateralReturnFormat: Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
   knownAddresses: [knownAddressWithoutStakingPath],
+  outputsFormat: [
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY,
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE
+  ],
   tagCborSets: false,
-  txInKeyPathMap: {},
-  useBabbageOutputs: false
+  txInKeyPathMap: {}
 };
 
 export const contextWithoutKnownAddresses: TrezorTxTransformerContext = {
@@ -193,10 +203,14 @@ export const contextWithoutKnownAddresses: TrezorTxTransformerContext = {
     networkId: Cardano.NetworkId.Testnet,
     networkMagic: 999
   },
+  collateralReturnFormat: Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
   knownAddresses: [],
+  outputsFormat: [
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY,
+    Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE
+  ],
   tagCborSets: false,
-  txInKeyPathMap: {},
-  useBabbageOutputs: false
+  txInKeyPathMap: {}
 };
 
 export const coreWithdrawalWithKeyHashCredential = {

packages/hardware-trezor/test/transformers/tx.test.ts

@@ -4,6 +4,7 @@ import {
   babbageTxBodyWithScripts,
   contextWithKnownAddresses,
   contextWithoutKnownAddresses,
+  knownAddress,
   knownAddressKeyPath,
   knownAddressPaymentKeyPath,
   knownAddressStakeKeyPath,
@@ -45,6 +46,11 @@ describe('tx', () => {
       expect(
         await txToTrezor(txBody, {
           ...contextWithKnownAddresses,
+          outputsFormat: [
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY,
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY,
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY
+          ],
           txInKeyPathMap: { [TxInId(txBody.inputs[0])]: knownAddressPaymentKeyPath }
         })
       ).toEqual({
@@ -202,10 +208,13 @@ describe('tx', () => {
       expect(
         await txToTrezor(babbageTxBodyWithScripts, {
           ...contextWithKnownAddresses,
+          outputsFormat: [
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE
+          ],
           txInKeyPathMap: {
             [TxInId(babbageTxBodyWithScripts.inputs[0])]: knownAddressPaymentKeyPath
-          },
-          useBabbageOutputs: true
+          }
         })
       ).toEqual({
         additionalWitnessRequests: [
@@ -286,7 +295,12 @@ describe('tx', () => {
     });
 
     test('can map transaction with collaterals', async () => {
-      expect(await txToTrezor(txBodyWithCollaterals, contextWithoutKnownAddresses)).toEqual({
+      expect(
+        await txToTrezor(txBodyWithCollaterals, {
+          ...contextWithoutKnownAddresses,
+          collateralReturnFormat: Trezor.PROTO.CardanoTxOutputSerializationFormat.ARRAY_LEGACY
+        })
+      ).toEqual({
         additionalWitnessRequests: [],
         collateralInputs: [
           {
@@ -325,11 +339,16 @@ describe('tx', () => {
       expect(
         await txToTrezor(plutusTxWithBabbage, {
           ...contextWithKnownAddresses,
+          collateralReturnFormat: Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
+          knownAddresses: [knownAddress],
+          outputsFormat: [
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE,
+            Trezor.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE
+          ],
           txInKeyPathMap: {
             [TxInId(plutusTxWithBabbage.inputs[0])]: knownAddressPaymentKeyPath,
             [TxInId(plutusTxWithBabbage.collaterals[0])]: knownAddressPaymentKeyPath
-          },
-          useBabbageOutputs: true
+          }
         })
       ).toEqual({
         additionalWitnessRequests: [