✨ (signer-btc) [DSDK-475]: Implement GetExtendedPublicKey device action with DefaultSigner DI (#532)

Author: jdabbech-ledger

.changeset/twenty-beans-teach.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/device-signer-kit-bitcoin": minor
+---
+
+Implement SignerBtc, DI & GetExtendedPkeyDA

packages/signer/signer-btc/package.json

@@ -53,6 +53,7 @@
     "@ledgerhq/signer-utils": "workspace:*",
     "@ledgerhq/tsconfig-dsdk": "workspace:*",
     "bitcoinjs-lib": "^6.1.6",
+    "rxjs": "^7.8.1",
     "ts-node": "^10.9.2"
   },
   "peerDependencies": {

packages/signer/signer-btc/src/api/SignerBtc.ts

@@ -1,15 +1,17 @@
+// import { type AddressOptions } from "@api/model/AddressOptions";
+// import { type Psbt } from "@api/model/Psbt";
+// import { type Signature } from "@api/model/Signature";
+// import { type Wallet } from "@api/model/Wallet";
 import { type AddressOptions } from "@api/model/AddressOptions";
-import { type Psbt } from "@api/model/Psbt";
-import { type Signature } from "@api/model/Signature";
-import { type Wallet } from "@api/model/Wallet";
+import { type GetExtendedPublicKeyReturnType } from "@root/src";
 
 export interface SignerBtc {
-  getExtendedPubkey: (
+  getExtendedPublicKey: (
     derivationPath: string,
-    checkOnDevice?: boolean,
-  ) => Promise<string>;
-  getAddress: (wallet: Wallet, options?: AddressOptions) => Promise<string>;
-  signMessage: (wallet: Wallet, message: string) => Promise<Signature>;
-  signPsbt: (wallet: Wallet, psbt: Psbt) => Promise<Psbt>;
-  signTransaction: (wallet: Wallet, psbt: Psbt) => Promise<Uint8Array>;
+    options: AddressOptions,
+  ) => GetExtendedPublicKeyReturnType;
+  // getAddress: (wallet: Wallet, options?: AddressOptions) => Promise<string>;
+  // signMessage: (wallet: Wallet, message: string) => Promise<Signature>;
+  // signPsbt: (wallet: Wallet, psbt: Psbt) => Promise<Psbt>;
+  // signTransaction: (wallet: Wallet, psbt: Psbt) => Promise<Uint8Array>;
 }

packages/signer/signer-btc/src/api/app-binder/GetExtendedPublicKeyDeviceActionTypes.ts

@@ -0,0 +1,32 @@
+import {
+  type ExecuteDeviceActionReturnType,
+  type SendCommandInAppDAError,
+  type SendCommandInAppDAIntermediateValue,
+  type SendCommandInAppDAOutput,
+  type UserInteractionRequired,
+} from "@ledgerhq/device-management-kit";
+
+import {
+  type GetExtendedPublicKeyCommandArgs,
+  type GetExtendedPublicKeyCommandResponse,
+} from "@internal/app-binder/command/GetExtendedPublicKeyCommand";
+
+type GetExtendedPublicKeyDARequiredInteraction =
+  | UserInteractionRequired.None
+  | UserInteractionRequired.VerifyAddress;
+
+export type GetExtendedPublicKeyDAOutput =
+  SendCommandInAppDAOutput<GetExtendedPublicKeyCommandResponse>;
+
+export type GetExtendedPublicKeyDAError = SendCommandInAppDAError;
+
+export type GetExtendedDAIntermediateValue =
+  SendCommandInAppDAIntermediateValue<GetExtendedPublicKeyDARequiredInteraction>;
+
+export type GetExtendedPublicKeyDAInput = GetExtendedPublicKeyCommandArgs;
+
+export type GetExtendedPublicKeyReturnType = ExecuteDeviceActionReturnType<
+  GetExtendedPublicKeyDAOutput,
+  GetExtendedPublicKeyDAError,
+  GetExtendedDAIntermediateValue
+>;

packages/signer/signer-btc/src/api/index.ts

@@ -0,0 +1,2 @@
+export { type SignerBtc } from "./SignerBtc";
+export * from "@api/app-binder/GetExtendedPublicKeyDeviceActionTypes";

packages/signer/signer-btc/src/index.ts

@@ -1 +1,4 @@
-export * from "@api/SignerBtc";
+// inversify
+import "reflect-metadata";
+
+export * from "@api/index";

packages/signer/signer-btc/src/internal/DefaultSignerBtc.test.ts

@@ -0,0 +1,27 @@
+import { type DeviceManagementKit } from "@ledgerhq/device-management-kit";
+
+import { DefaultSignerBtc } from "@internal/DefaultSignerBtc";
+import { GetExtendedPublicKeyUseCase } from "@internal/use-cases/get-extended-public-key/GetExtendedPublicKeyUseCase";
+
+describe("DefaultSignerSolana", () => {
+  it("should be defined", () => {
+    const signer = new DefaultSignerBtc({
+      dmk: {} as DeviceManagementKit,
+      sessionId: "session-id",
+    });
+    expect(signer).toBeDefined();
+  });
+
+  it("should call getExtendedPublicKeyUseCase", () => {
+    jest.spyOn(GetExtendedPublicKeyUseCase.prototype, "execute");
+    const sessionId = "session-id";
+    const dmk = {
+      executeDeviceAction: jest.fn(),
+    } as unknown as DeviceManagementKit;
+    const signer = new DefaultSignerBtc({ dmk, sessionId });
+    signer.getExtendedPublicKey("44'/0'/0'/0/0", {
+      checkOnDevice: true,
+    });
+    expect(GetExtendedPublicKeyUseCase.prototype.execute).toHaveBeenCalled();
+  });
+});

packages/signer/signer-btc/src/internal/DefaultSignerBtc.ts

@@ -0,0 +1,36 @@
+import {
+  type DeviceManagementKit,
+  type DeviceSessionId,
+} from "@ledgerhq/device-management-kit";
+import { type Container } from "inversify";
+
+import { type AddressOptions } from "@api/model/AddressOptions";
+import { type SignerBtc } from "@api/SignerBtc";
+import { useCasesTypes } from "@internal/use-cases/di/useCasesTypes";
+import { type GetExtendedPublicKeyUseCase } from "@internal/use-cases/get-extended-public-key/GetExtendedPublicKeyUseCase";
+
+import { makeContainer } from "./di";
+
+type DefaultSignerBtcConstructorArgs = {
+  dmk: DeviceManagementKit;
+  sessionId: DeviceSessionId;
+};
+
+export class DefaultSignerBtc implements SignerBtc {
+  private readonly _container: Container;
+
+  constructor({ dmk, sessionId }: DefaultSignerBtcConstructorArgs) {
+    this._container = makeContainer({ dmk, sessionId });
+  }
+
+  getExtendedPublicKey(
+    derivationPath: string,
+    { checkOnDevice = false }: AddressOptions,
+  ) {
+    return this._container
+      .get<GetExtendedPublicKeyUseCase>(
+        useCasesTypes.GetExtendedPublicKeyUseCase,
+      )
+      .execute(derivationPath, { checkOnDevice });
+  }
+}

packages/signer/signer-btc/src/internal/app-binder/BtcAppBinder.test.ts

@@ -0,0 +1,155 @@
+import {
+  type DeviceActionState,
+  DeviceActionStatus,
+  type DeviceManagementKit,
+  type DeviceSessionId,
+  SendCommandInAppDeviceAction,
+  UserInteractionRequired,
+} from "@ledgerhq/device-management-kit";
+import { from, type Subscription } from "rxjs";
+
+import {
+  type GetExtendedDAIntermediateValue,
+  type GetExtendedPublicKeyDAError,
+  type GetExtendedPublicKeyDAOutput,
+} from "@api/app-binder/GetExtendedPublicKeyDeviceActionTypes";
+import { BtcAppBinder } from "@internal/app-binder/BtcAppBinder";
+import { GetExtendedPublicKeyCommand } from "@internal/app-binder/command/GetExtendedPublicKeyCommand";
+
+describe("BtcAppBinder", () => {
+  const mockedDmk: DeviceManagementKit = {
+    sendCommand: jest.fn(),
+    executeDeviceAction: jest.fn(),
+  } as unknown as DeviceManagementKit;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should be defined", () => {
+    const binder = new BtcAppBinder(
+      {} as DeviceManagementKit,
+      {} as DeviceSessionId,
+    );
+    expect(binder).toBeDefined();
+  });
+
+  describe("getExtendedPublicKey", () => {
+    let subscription: Subscription;
+    afterEach(() => {
+      if (subscription) {
+        subscription.unsubscribe();
+      }
+    });
+    it("should return the pub key", (done) => {
+      // GIVEN
+      const extendedPublicKey = "D2PPQSYFe83nDzk96FqGumVU8JA7J8vj2Rhjc2oXzEi5";
+
+      jest.spyOn(mockedDmk, "executeDeviceAction").mockReturnValue({
+        observable: from([
+          {
+            status: DeviceActionStatus.Completed,
+            output: { extendedPublicKey },
+          } as DeviceActionState<
+            GetExtendedPublicKeyDAOutput,
+            GetExtendedPublicKeyDAError,
+            GetExtendedDAIntermediateValue
+          >,
+        ]),
+        cancel: jest.fn(),
+      });
+
+      // WHEN
+      const appBinder = new BtcAppBinder(mockedDmk, "sessionId");
+      const { observable } = appBinder.getExtendedPublicKey({
+        derivationPath: "44'/501'",
+        checkOnDevice: false,
+      });
+
+      // THEN
+      const states: DeviceActionState<
+        GetExtendedPublicKeyDAOutput,
+        GetExtendedPublicKeyDAError,
+        GetExtendedDAIntermediateValue
+      >[] = [];
+      subscription = observable.subscribe({
+        next: (state) => {
+          states.push(state);
+        },
+        error: (err) => {
+          done(err);
+        },
+        complete: () => {
+          try {
+            expect(states).toEqual([
+              {
+                status: DeviceActionStatus.Completed,
+                output: { extendedPublicKey },
+              },
+            ]);
+            done();
+          } catch (err) {
+            done(err);
+          }
+        },
+      });
+    });
+
+    describe("calls of executeDeviceAction with the correct params", () => {
+      const baseParams = {
+        derivationPath: "44'/60'/3'/2/1",
+        returnChainCode: false,
+      };
+
+      it("when checkOnDevice is true: UserInteractionRequired.VerifyAddress", () => {
+        // GIVEN
+        const checkOnDevice = true;
+        const params = {
+          ...baseParams,
+          checkOnDevice,
+        };
+
+        // WHEN
+        const appBinder = new BtcAppBinder(mockedDmk, "sessionId");
+        appBinder.getExtendedPublicKey(params);
+
+        // THEN
+        expect(mockedDmk.executeDeviceAction).toHaveBeenCalledWith({
+          sessionId: "sessionId",
+          deviceAction: new SendCommandInAppDeviceAction({
+            input: {
+              command: new GetExtendedPublicKeyCommand(params),
+              appName: "Bitcoin",
+              requiredUserInteraction: UserInteractionRequired.VerifyAddress,
+            },
+          }),
+        });
+      });
+
+      it("when checkOnDevice is false: UserInteractionRequired.None", () => {
+        // GIVEN
+        const checkOnDevice = false;
+        const params = {
+          ...baseParams,
+          checkOnDevice,
+        };
+
+        // WHEN
+        const appBinder = new BtcAppBinder(mockedDmk, "sessionId");
+        appBinder.getExtendedPublicKey(params);
+
+        // THEN
+        expect(mockedDmk.executeDeviceAction).toHaveBeenCalledWith({
+          sessionId: "sessionId",
+          deviceAction: new SendCommandInAppDeviceAction({
+            input: {
+              command: new GetExtendedPublicKeyCommand(params),
+              appName: "Bitcoin",
+              requiredUserInteraction: UserInteractionRequired.None,
+            },
+          }),
+        });
+      });
+    });
+  });
+});

packages/signer/signer-btc/src/internal/app-binder/BtcAppBinder.ts

@@ -0,0 +1,38 @@
+import {
+  DeviceManagementKit,
+  type DeviceSessionId,
+  SendCommandInAppDeviceAction,
+  UserInteractionRequired,
+} from "@ledgerhq/device-management-kit";
+import { inject, injectable } from "inversify";
+
+import {
+  GetExtendedPublicKeyDAInput,
+  GetExtendedPublicKeyReturnType,
+} from "@api/app-binder/GetExtendedPublicKeyDeviceActionTypes";
+import { GetExtendedPublicKeyCommand } from "@internal/app-binder/command/GetExtendedPublicKeyCommand";
+import { externalTypes } from "@internal/externalTypes";
+
+@injectable()
+export class BtcAppBinder {
+  constructor(
+    @inject(externalTypes.Dmk) private dmk: DeviceManagementKit,
+    @inject(externalTypes.SessionId) private sessionId: DeviceSessionId,
+  ) {}
+  getExtendedPublicKey(
+    args: GetExtendedPublicKeyDAInput,
+  ): GetExtendedPublicKeyReturnType {
+    return this.dmk.executeDeviceAction({
+      sessionId: this.sessionId,
+      deviceAction: new SendCommandInAppDeviceAction({
+        input: {
+          command: new GetExtendedPublicKeyCommand(args),
+          appName: "Bitcoin",
+          requiredUserInteraction: args.checkOnDevice
+            ? UserInteractionRequired.VerifyAddress
+            : UserInteractionRequired.None,
+        },
+      }),
+    });
+  }
+}

packages/signer/signer-btc/src/internal/app-binder/command/GetExtendedPublicKeyCommand.test.ts

@@ -41,7 +41,7 @@ const GET_EXTENDED_PUBLIC_KEY_VALID_RESPONSE = new Uint8Array([
 describe("GetExtendedPublicKeyCommand", () => {
   let command: GetExtendedPublicKeyCommand;
   const defaultArgs: GetExtendedPublicKeyCommandArgs = {
-    displayOnDevice: true,
+    checkOnDevice: true,
     derivationPath: "84'/0'/0'",
   };
 
@@ -65,7 +65,7 @@ describe("GetExtendedPublicKeyCommand", () => {
       // GIVEN
       command = new GetExtendedPublicKeyCommand({
         ...defaultArgs,
-        displayOnDevice: false,
+        checkOnDevice: false,
       });
 
       // WHEN

packages/signer/signer-btc/src/internal/app-binder/command/GetExtendedPublicKeyCommand.ts

@@ -17,7 +17,7 @@ import { DerivationPathUtils } from "@ledgerhq/signer-utils";
 const STATUS_CODE_LENGTH = 2;
 
 export type GetExtendedPublicKeyCommandArgs = {
-  displayOnDevice: boolean;
+  checkOnDevice: boolean;
   derivationPath: string;
 };
 
@@ -35,7 +35,7 @@ export class GetExtendedPublicKeyCommand
   constructor(private readonly args: GetExtendedPublicKeyCommandArgs) {}
 
   getApdu(): Apdu {
-    const { displayOnDevice, derivationPath } = this.args;
+    const { checkOnDevice, derivationPath } = this.args;
 
     const getExtendedPublicKeyArgs: ApduBuilderArgs = {
       cla: 0xe1,
@@ -44,7 +44,7 @@ export class GetExtendedPublicKeyCommand
       p2: 0x00,
     };
     const builder = new ApduBuilder(getExtendedPublicKeyArgs).add8BitUIntToData(
-      displayOnDevice ? 0x01 : 0x00,
+      checkOnDevice ? 0x01 : 0x00,
     );
 
     const path = DerivationPathUtils.splitPath(derivationPath);