✨ (keyring-eth) [DSDK-387]: Implement signTransaction use case (#228)

.changeset/real-crews-switch.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/keyring-eth": minor
+---
+
+Implement SignTransactionUseCase

packages/signer/keyring-eth/jest.config.ts

@@ -16,6 +16,7 @@ const config: JestConfigWithTsJest = {
     "!src/**/*.stub.ts",
     "!src/index.ts",
     "!src/api/index.ts",
+    "!src/**/__test-utils__/*",
   ],
   moduleNameMapper: {
     ...paths,

packages/signer/keyring-eth/src/api/KeyringEth.ts

@@ -1,19 +1,19 @@
 import { GetAddressDAReturnType } from "@api/app-binder/GetAddressDeviceActionTypes";
 import { SignTypedDataDAReturnType } from "@api/app-binder/SignTypedDataDeviceActionTypes";
 import { AddressOptions } from "@api/model/AddressOptions";
-import { Signature } from "@api/model/Signature";
 import { Transaction } from "@api/model/Transaction";
 import { TransactionOptions } from "@api/model/TransactionOptions";
 import { TypedData } from "@api/model/TypedData";
 
 import { SignPersonalMessageDAReturnType } from "./app-binder/SignPersonalMessageDeviceActionTypes";
+import { SignTransactionDAReturnType } from "./app-binder/SignTransactionDeviceActionTypes";
 
 export interface KeyringEth {
   signTransaction: (
     derivationPath: string,
     transaction: Transaction,
     options?: TransactionOptions,
-  ) => Promise<Signature>;
+  ) => SignTransactionDAReturnType;
   signMessage: (
     derivationPath: string,
     message: string,

packages/signer/keyring-eth/src/api/index.ts

@@ -6,6 +6,13 @@ export type {
   SignPersonalMessageDAOutput,
   SignPersonalMessageDAState,
 } from "@api/app-binder/SignPersonalMessageDeviceActionTypes";
+export type {
+  SignTransactionDAError,
+  SignTransactionDAInput,
+  SignTransactionDAIntermediateValue,
+  SignTransactionDAOutput,
+  SignTransactionDAState,
+} from "@api/app-binder/SignTransactionDeviceActionTypes";
 export {
   type SignTypedDataDAError,
   type SignTypedDataDAInput,

packages/signer/keyring-eth/src/internal/DefaultKeyringEth.ts

@@ -4,10 +4,10 @@ import { Container } from "inversify";
 
 import { GetAddressDAReturnType } from "@api/app-binder/GetAddressDeviceActionTypes";
 import { SignPersonalMessageDAReturnType } from "@api/app-binder/SignPersonalMessageDeviceActionTypes";
+import { SignTransactionDAReturnType } from "@api/app-binder/SignTransactionDeviceActionTypes";
 import { SignTypedDataDAReturnType } from "@api/app-binder/SignTypedDataDeviceActionTypes";
 import { KeyringEth } from "@api/KeyringEth";
 import { AddressOptions } from "@api/model/AddressOptions";
-import { Signature } from "@api/model/Signature";
 import { Transaction } from "@api/model/Transaction";
 import { TransactionOptions } from "@api/model/TransactionOptions";
 import { TypedData } from "@api/model/TypedData";
@@ -38,11 +38,11 @@ export class DefaultKeyringEth implements KeyringEth {
     this._container = makeContainer({ sdk, sessionId, contextModule });
   }
 
-  async signTransaction(
+  signTransaction(
     derivationPath: string,
     transaction: Transaction,
     options?: TransactionOptions,
-  ): Promise<Signature> {
+  ): SignTransactionDAReturnType {
     return this._container
       .get<SignTransactionUseCase>(transactionTypes.SignTransactionUseCase)
       .execute(derivationPath, transaction, options);

packages/signer/keyring-eth/src/internal/app-binder/EthAppBinder.test.ts

@@ -3,20 +3,32 @@ import { DeviceActionState, DeviceSdk } from "@ledgerhq/device-sdk-core";
 import { DeviceActionStatus } from "@ledgerhq/device-sdk-core";
 import { SendCommandInAppDeviceAction } from "@ledgerhq/device-sdk-core";
 import { UserInteractionRequired } from "@ledgerhq/device-sdk-core";
+import { Transaction } from "ethers-v6";
 import { from } from "rxjs";
 
 import {
   GetAddressDAError,
   GetAddressDAIntermediateValue,
   GetAddressDAOutput,
 } from "@api/app-binder/GetAddressDeviceActionTypes";
+import {
+  SignPersonalMessageDAError,
+  SignPersonalMessageDAIntermediateValue,
+  SignPersonalMessageDAOutput,
+} from "@api/app-binder/SignPersonalMessageDeviceActionTypes";
+import {
+  SignTransactionDAError,
+  SignTransactionDAIntermediateValue,
+  SignTransactionDAOutput,
+} from "@api/app-binder/SignTransactionDeviceActionTypes";
 import {
   SignTypedDataDAError,
   SignTypedDataDAIntermediateValue,
   SignTypedDataDAOutput,
 } from "@api/app-binder/SignTypedDataDeviceActionTypes";
 import { type Signature } from "@api/model/Signature";
 import { type TypedData } from "@api/model/TypedData";
+import { TransactionMapperService } from "@internal/transaction/service/mapper/TransactionMapperService";
 import { type TypedDataParserService } from "@internal/typed-data/service/TypedDataParserService";
 
 import { GetAddressCommand } from "./command/GetAddressCommand";
@@ -31,6 +43,9 @@ describe("EthAppBinder", () => {
     getContexts: jest.fn(),
     getTypedDataFilters: jest.fn(),
   };
+  const mockedMapper: TransactionMapperService = {
+    mapTransactionToSubset: jest.fn(),
+  } as unknown as TransactionMapperService;
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -61,6 +76,7 @@ describe("EthAppBinder", () => {
       const appBinder = new EthAppBinder(
         mockedSdk,
         mockedContextModule,
+        mockedMapper,
         "sessionId",
       );
       const { observable } = appBinder.getAddress({
@@ -114,6 +130,7 @@ describe("EthAppBinder", () => {
         const appBinder = new EthAppBinder(
           mockedSdk,
           mockedContextModule,
+          mockedMapper,
           "sessionId",
         );
         appBinder.getAddress(params);
@@ -143,6 +160,7 @@ describe("EthAppBinder", () => {
         const appBinder = new EthAppBinder(
           mockedSdk,
           mockedContextModule,
+          mockedMapper,
           "sessionId",
         );
         appBinder.getAddress(params);
@@ -162,6 +180,209 @@ describe("EthAppBinder", () => {
     });
   });
 
+  describe("signTransaction", () => {
+    it("should return the signature", (done) => {
+      // GIVEN
+      const signature: Signature = {
+        r: `0xDEAD`,
+        s: `0xBEEF`,
+        v: 0,
+      };
+      const transaction: Transaction = new Transaction();
+      transaction.to = "0x1234567890123456789012345678901234567890";
+      transaction.value = 0n;
+      const options = {};
+
+      jest.spyOn(mockedSdk, "executeDeviceAction").mockReturnValue({
+        observable: from([
+          {
+            status: DeviceActionStatus.Completed,
+            output: signature,
+          } as DeviceActionState<
+            SignTypedDataDAOutput,
+            SignTypedDataDAError,
+            SignTypedDataDAIntermediateValue
+          >,
+        ]),
+        cancel: jest.fn(),
+      });
+
+      // WHEN
+      const appBinder = new EthAppBinder(
+        mockedSdk,
+        mockedContextModule,
+        mockedMapper,
+        "sessionId",
+      );
+      const { observable } = appBinder.signTransaction({
+        derivationPath: "44'/60'/3'/2/1",
+        transaction,
+        options,
+      });
+
+      // THEN
+      const states: DeviceActionState<
+        SignTransactionDAOutput,
+        SignTransactionDAError,
+        SignTransactionDAIntermediateValue
+      >[] = [];
+      observable.subscribe({
+        next: (state) => {
+          states.push(state);
+        },
+        error: (err) => {
+          done(err);
+        },
+        complete: () => {
+          try {
+            expect(states).toEqual([
+              {
+                status: DeviceActionStatus.Completed,
+                output: signature,
+              },
+            ]);
+            done();
+          } catch (err) {
+            done(err);
+          }
+        },
+      });
+    });
+
+    it("should return the signature without options", (done) => {
+      // GIVEN
+      const signature: Signature = {
+        r: `0xDEAD`,
+        s: `0xBEEF`,
+        v: 0,
+      };
+      const transaction: Transaction = new Transaction();
+      transaction.to = "0x1234567890123456789012345678901234567890";
+      transaction.value = 0n;
+
+      jest.spyOn(mockedSdk, "executeDeviceAction").mockReturnValue({
+        observable: from([
+          {
+            status: DeviceActionStatus.Completed,
+            output: signature,
+          } as DeviceActionState<
+            SignTypedDataDAOutput,
+            SignTypedDataDAError,
+            SignTypedDataDAIntermediateValue
+          >,
+        ]),
+        cancel: jest.fn(),
+      });
+
+      // WHEN
+      const appBinder = new EthAppBinder(
+        mockedSdk,
+        mockedContextModule,
+        mockedMapper,
+        "sessionId",
+      );
+      const { observable } = appBinder.signTransaction({
+        derivationPath: "44'/60'/3'/2/1",
+        transaction,
+        options: undefined,
+      });
+
+      // THEN
+      const states: DeviceActionState<
+        SignTransactionDAOutput,
+        SignTransactionDAError,
+        SignTransactionDAIntermediateValue
+      >[] = [];
+      observable.subscribe({
+        next: (state) => {
+          states.push(state);
+        },
+        error: (err) => {
+          done(err);
+        },
+        complete: () => {
+          try {
+            expect(states).toEqual([
+              {
+                status: DeviceActionStatus.Completed,
+                output: signature,
+              },
+            ]);
+            done();
+          } catch (err) {
+            done(err);
+          }
+        },
+      });
+    });
+  });
+
+  describe("signMessage", () => {
+    it("should return the signature", (done) => {
+      // GIVEN
+      const signature: Signature = {
+        r: `0xDEAD`,
+        s: `0xBEEF`,
+        v: 0,
+      };
+      const message = "Hello, World!";
+
+      jest.spyOn(mockedSdk, "executeDeviceAction").mockReturnValue({
+        observable: from([
+          {
+            status: DeviceActionStatus.Completed,
+            output: signature,
+          } as DeviceActionState<
+            SignPersonalMessageDAOutput,
+            SignPersonalMessageDAError,
+            SignPersonalMessageDAIntermediateValue
+          >,
+        ]),
+        cancel: jest.fn(),
+      });
+
+      // WHEN
+      const appBinder = new EthAppBinder(
+        mockedSdk,
+        mockedContextModule,
+        mockedMapper,
+        "sessionId",
+      );
+      const { observable } = appBinder.signPersonalMessage({
+        derivationPath: "44'/60'/3'/2/1",
+        message,
+      });
+
+      // THEN
+      const states: DeviceActionState<
+        SignPersonalMessageDAOutput,
+        SignPersonalMessageDAError,
+        SignPersonalMessageDAIntermediateValue
+      >[] = [];
+      observable.subscribe({
+        next: (state) => {
+          states.push(state);
+        },
+        error: (err) => {
+          done(err);
+        },
+        complete: () => {
+          try {
+            expect(states).toEqual([
+              {
+                status: DeviceActionStatus.Completed,
+                output: signature,
+              },
+            ]);
+            done();
+          } catch (err) {
+            done(err);
+          }
+        },
+      });
+    });
+  });
+
   describe("signTypedData", () => {
     it("should return the signature", (done) => {
       // GIVEN
@@ -198,6 +419,7 @@ describe("EthAppBinder", () => {
       const appBinder = new EthAppBinder(
         mockedSdk,
         mockedContextModule,
+        mockedMapper,
         "sessionId",
       );
       const { observable } = appBinder.signTypedData({