feat(web-extension): support wallet-specific trezorConfig in SigningCoordinator

- Add optional trezorConfig property to HardwareWallet type
- Refactor #getTrezorConfig to merge wallet-specific config with global hwOptions
- Update Trezor key agent creation to use merged configuration
- Add test for trezorConfig merging behavior
- Ensure derivationType and other wallet-specific settings are properly applied

Author: rhyslbw

packages/web-extension/src/walletManager/SigningCoordinator/SigningCoordinator.ts

@@ -1,7 +1,7 @@
 import { Cardano, Serialization } from '@cardano-sdk/core';
 import { Cip30DataSignature } from '@cardano-sdk/dapp-connector';
 import { CustomError } from 'ts-custom-error';
-import { InMemoryWallet, WalletType } from '../types';
+import { HardwareWallet, InMemoryWallet, WalletType } from '../types';
 import { KeyAgent, KeyPurpose, SignDataContext, TrezorConfig, errors } from '@cardano-sdk/key-management';
 import { KeyAgentFactory } from './KeyAgentFactory';
 import { Logger } from 'ts-log';
@@ -83,6 +83,19 @@ export class SigningCoordinator<WalletMetadata extends {}, AccountMetadata exten
     this.#logger = contextLogger(logger, 'SigningCoordinator');
   }
 
+  /**
+   * Gets the appropriate TrezorConfig for the given wallet.
+   *
+   * This allows wallets to specify only the properties they want to override
+   *    (e.g., derivationType) while inheriting global settings (e.g., communicationType, manifest)
+   */
+  #getTrezorConfig(wallet: HardwareWallet<WalletMetadata, AccountMetadata>): TrezorConfig {
+    return {
+      ...this.#hwOptions, // Global defaults (communicationType, manifest, etc.)
+      ...(wallet.type === WalletType.Trezor && wallet.trezorConfig ? wallet.trezorConfig : {}) // Wallet-specific overrides (derivationType, etc.)
+    };
+  }
+
   async signTransaction(
     { tx, signContext, options }: SignTransactionProps,
     requestContext: RequestContext<WalletMetadata, AccountMetadata>
@@ -196,7 +209,7 @@ export class SigningCoordinator<WalletMetadata extends {}, AccountMetadata exten
                             chainId: request.requestContext.chainId,
                             extendedAccountPublicKey: account.extendedAccountPublicKey,
                             purpose: account.purpose || KeyPurpose.STANDARD,
-                            trezorConfig: this.#hwOptions
+                            trezorConfig: this.#getTrezorConfig(request.requestContext.wallet)
                           })
                     ).catch((error) => throwMaybeWrappedWithNoRejectError(error, options)),
                   resolve,

packages/web-extension/src/walletManager/types.ts

@@ -1,4 +1,4 @@
-import { AccountKeyDerivationPath, KeyPurpose } from '@cardano-sdk/key-management';
+import { AccountKeyDerivationPath, KeyPurpose, TrezorConfig } from '@cardano-sdk/key-management';
 import { Bip32PublicKeyHex } from '@cardano-sdk/crypto';
 import { Cardano } from '@cardano-sdk/core';
 import { HexBlob } from '@cardano-sdk/util';
@@ -34,6 +34,7 @@ export type HardwareWallet<WalletMetadata extends {}, AccountMetadata extends {}
   AccountMetadata
 > & {
   type: WalletType.Ledger | WalletType.Trezor;
+  trezorConfig?: Partial<TrezorConfig>;
 };
 
 export type InMemoryWallet<WalletMetadata extends {}, AccountMetadata extends {}> = Bip32Wallet<

packages/web-extension/test/walletManager/SigningCoordinator.test.ts

@@ -10,15 +10,16 @@ import {
   errors
 } from '@cardano-sdk/key-management';
 import { Ed25519PublicKeyHex, Ed25519SignatureHex, Hash28ByteBase16 } from '@cardano-sdk/crypto';
-import { HexBlob } from '@cardano-sdk/util';
 import {
+  HardwareWallet,
   InMemoryWallet,
   KeyAgentFactory,
   RequestContext,
   SigningCoordinator,
   WalletType,
   WrongTargetError
 } from '../../src';
+import { HexBlob } from '@cardano-sdk/util';
 import { createAccount } from './util';
 import { dummyLogger } from 'ts-log';
 import { firstValueFrom } from 'rxjs';
@@ -53,6 +54,8 @@ describe('SigningCoordinator', () => {
       Ledger: jest.fn(),
       Trezor: jest.fn()
     };
+    keyAgentFactory.InMemory.mockResolvedValue(keyAgent);
+    keyAgentFactory.Trezor.mockResolvedValue(keyAgent as unknown as Awaited<ReturnType<KeyAgentFactory['Trezor']>>);
     signingCoordinator = new SigningCoordinator(
       {
         hwOptions: {
@@ -171,6 +174,47 @@ describe('SigningCoordinator', () => {
         expect(passphrase).toEqual(new Uint8Array([0, 0, 0]));
       });
     });
+
+    it('should pass wallet trezorConfig to Trezor key agent factory', async () => {
+      const trezorWallet: HardwareWallet<{}, {}> = {
+        accounts: [createAccount(0, 0)],
+        metadata: {},
+        trezorConfig: {
+          communicationType: CommunicationType.Web,
+          derivationType: 'ICARUS_TREZOR'
+        },
+        type: WalletType.Trezor,
+        walletId: Hash28ByteBase16('ad63f855e831d937457afc52a21a7f351137e4a9fff26c217817335a')
+      };
+
+      const trezorRequestContext: RequestContext<{}, {}> = {
+        accountIndex: 0,
+        chainId: Cardano.ChainIds.Preprod,
+        purpose: KeyPurpose.STANDARD,
+        wallet: trezorWallet
+      };
+
+      // Test that the Trezor factory is called with merged config
+      const reqEmitted = firstValueFrom(signingCoordinator.transactionWitnessRequest$);
+      void signingCoordinator.signTransaction({ signContext, tx }, trezorRequestContext);
+      const req = await reqEmitted;
+
+      // Call the sign method to trigger key agent creation
+      await req.sign(passphrase);
+
+      expect(keyAgentFactory.Trezor).toHaveBeenCalledWith(
+        expect.objectContaining({
+          trezorConfig: expect.objectContaining({
+            communicationType: CommunicationType.Web,
+            derivationType: 'ICARUS_TREZOR',
+            manifest: expect.objectContaining({
+              appUrl: 'https://test.app',
+              email: '[email protected]'
+            })
+          })
+        })
+      );
+    });
   });
 
   describe('signData', () => {