feat(web-extension): add trezorConfig support in wallet metadata

- Add trezorConfig to wallet metadata for TrezorHardwareWallet
- Update SigningCoordinator to read trezorConfig from wallet.metadata
- Add minimal test to verify trezorConfig functionality
- Ensures trezorConfig can be updated via wallet manager and persists properly
- Supports both wallet-specific trezorConfig and global hwOptions fallback

Author: rhyslbw

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

@@ -1,7 +1,7 @@
+import { AnyBip32Wallet, InMemoryWallet, WalletType } from '../types';
 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 { KeyAgent, KeyPurpose, SignDataContext, TrezorConfig, errors } from '@cardano-sdk/key-management';
 import { KeyAgentFactory } from './KeyAgentFactory';
 import { Logger } from 'ts-log';
@@ -83,6 +83,24 @@ 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: AnyBip32Wallet<WalletMetadata, AccountMetadata>): TrezorConfig {
+    const trezorConfig =
+      wallet.type === WalletType.Trezor && 'trezorConfig' in wallet.metadata
+        ? (wallet.metadata as { trezorConfig?: Partial<TrezorConfig> }).trezorConfig
+        : undefined;
+
+    return {
+      ...this.#hwOptions, // Global defaults (communicationType, manifest, etc.)
+      ...(trezorConfig || {}) // Wallet-specific overrides (derivationType, etc.)
+    };
+  }
+
   async signTransaction(
     { tx, signContext, options }: SignTransactionProps,
     requestContext: RequestContext<WalletMetadata, AccountMetadata>
@@ -123,6 +141,7 @@ export class SigningCoordinator<WalletMetadata extends {}, AccountMetadata exten
     request: Omit<Req, 'reject' | 'sign'>,
     sign: (keyAgent: KeyAgent) => Promise<R>
   ) {
+    /* eslint-disable sonarjs/cognitive-complexity */
     return new Promise<R>((resolve, reject) => {
       if (!emitter$.observed) {
         return reject(new WrongTargetError('Not expecting sign requests at this time'));
@@ -181,30 +200,36 @@ export class SigningCoordinator<WalletMetadata extends {}, AccountMetadata exten
               ...commonRequestProps,
               sign: async (): Promise<R> =>
                 bubbleResolveReject(
-                  async (options?: SignOptions) =>
-                    sign(
-                      request.walletType === WalletType.Ledger
-                        ? await this.#keyAgentFactory.Ledger({
-                            accountIndex: request.requestContext.accountIndex,
-                            chainId: request.requestContext.chainId,
-                            communicationType: this.#hwOptions.communicationType,
-                            extendedAccountPublicKey: account.extendedAccountPublicKey,
-                            purpose: account.purpose || KeyPurpose.STANDARD
-                          })
-                        : await this.#keyAgentFactory.Trezor({
-                            accountIndex: request.requestContext.accountIndex,
-                            chainId: request.requestContext.chainId,
-                            extendedAccountPublicKey: account.extendedAccountPublicKey,
-                            purpose: account.purpose || KeyPurpose.STANDARD,
-                            trezorConfig: this.#hwOptions
-                          })
-                    ).catch((error) => throwMaybeWrappedWithNoRejectError(error, options)),
+                  async (options?: SignOptions) => {
+                    try {
+                      const keyAgent =
+                        request.walletType === WalletType.Ledger
+                          ? await this.#keyAgentFactory.Ledger({
+                              accountIndex: request.requestContext.accountIndex,
+                              chainId: request.requestContext.chainId,
+                              communicationType: this.#hwOptions.communicationType,
+                              extendedAccountPublicKey: account.extendedAccountPublicKey,
+                              purpose: account.purpose || KeyPurpose.STANDARD
+                            })
+                          : await this.#keyAgentFactory.Trezor({
+                              accountIndex: request.requestContext.accountIndex,
+                              chainId: request.requestContext.chainId,
+                              extendedAccountPublicKey: account.extendedAccountPublicKey,
+                              purpose: account.purpose || KeyPurpose.STANDARD,
+                              trezorConfig: this.#getTrezorConfig(request.requestContext.wallet)
+                            });
+                      return await sign(keyAgent);
+                    } catch (error) {
+                      return throwMaybeWrappedWithNoRejectError(error, options);
+                    }
+                  },
                   resolve,
                   reject
                 ),
               walletType: request.walletType
             } as Req)
       );
     });
+    /* eslint-enable sonarjs/cognitive-complexity */
   }
 }

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';
@@ -36,10 +36,10 @@ export type LedgerHardwareWallet<WalletMetadata extends {}, AccountMetadata exte
   type: WalletType.Ledger;
 };
 
-export type TrezorHardwareWallet<WalletMetadata extends {}, AccountMetadata extends {}> = Bip32Wallet<
-  WalletMetadata,
-  AccountMetadata
-> & {
+export type TrezorHardwareWallet<
+  WalletMetadata extends { trezorConfig?: Partial<TrezorConfig> },
+  AccountMetadata extends {}
+> = Bip32Wallet<WalletMetadata, AccountMetadata> & {
   type: WalletType.Trezor;
 };
 

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

@@ -4,21 +4,26 @@ import {
   CommunicationType,
   InMemoryKeyAgent,
   KeyPurpose,
+  MasterKeyGeneration,
   SignDataContext,
   SignTransactionContext,
+  TrezorConfig,
   cip8,
   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,
+  SignOptions,
   SigningCoordinator,
+  SignOptions,
   WalletType,
   WrongTargetError
 } from '../../src';
+import { HexBlob } from '@cardano-sdk/util';
 import { createAccount } from './util';
 import { dummyLogger } from 'ts-log';
 import { firstValueFrom } from 'rxjs';
@@ -73,7 +78,9 @@ describe('SigningCoordinator', () => {
       signCip8Data: jest.fn(),
       signTransaction: jest.fn()
     } as unknown as jest.Mocked<InMemoryKeyAgent>;
+
     keyAgentFactory.InMemory.mockResolvedValue(keyAgent);
+    keyAgentFactory.Trezor.mockResolvedValue(keyAgent as unknown as Awaited<ReturnType<KeyAgentFactory['Trezor']>>);
   });
 
   describe('signTransaction', () => {
@@ -171,6 +178,62 @@ describe('SigningCoordinator', () => {
         expect(passphrase).toEqual(new Uint8Array([0, 0, 0]));
       });
     });
+
+    it('should pass wallet trezorConfig to Trezor key agent factory', async () => {
+      const trezorWallet: HardwareWallet<{ trezorConfig?: Partial<TrezorConfig> }, {}> = {
+        accounts: [createAccount(0, 0)],
+        metadata: {
+          trezorConfig: {
+            communicationType: CommunicationType.Web,
+            derivationType: 'ICARUS_TREZOR' as MasterKeyGeneration,
+            manifest: {
+              appUrl: 'https://custom.app',
+              email: '[email protected]'
+            }
+          }
+        },
+        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;
+
+      // Verify the request was created
+      expect(req.walletType).toBe(WalletType.Trezor);
+      expect(req.requestContext.wallet).toBe(trezorWallet);
+
+      // Now call sign() to trigger the key agent factory call
+      // Cast to hardware wallet request type to access the correct sign method
+      const hardwareReq = req as { sign(options?: SignOptions): Promise<Cardano.Signatures> };
+      await hardwareReq.sign({});
+
+      // Verify keyAgentFactory.Trezor was called with the correct merged configuration
+      expect(keyAgentFactory.Trezor).toHaveBeenCalledWith({
+        accountIndex: 0,
+        chainId: Cardano.ChainIds.Preprod,
+        extendedAccountPublicKey: expect.any(String),
+        purpose: KeyPurpose.STANDARD,
+        trezorConfig: {
+          // Wallet-specific overrides take precedence over global defaults
+          communicationType: CommunicationType.Web, // Wallet override
+          derivationType: 'ICARUS_TREZOR', // Wallet override
+          manifest: {
+            appUrl: 'https://custom.app', // Wallet override
+            email: '[email protected]' // Wallet override
+          }
+        }
+      });
+    });
   });
 
   describe('signData', () => {