✨ (signer-solana) [DSDK-564]: Add solana SignDataTask and utils

.changeset/fresh-walls-jam.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/device-signer-kit-solana": patch
+---
+
+Add solana SignDataTask and utils

packages/signer/signer-solana/src/internal/app-binder/command/SignOffChainMessageCommand.test.ts

@@ -3,6 +3,7 @@ import {
   ApduResponse,
   isSuccessCommandResult,
 } from "@ledgerhq/device-management-kit";
+import { Just } from "purify-ts";
 
 import { SignOffChainMessageCommand } from "./SignOffChainMessageCommand";
 
@@ -50,7 +51,7 @@ describe("SignOffChainMessageCommand", () => {
 
       expect(isSuccessCommandResult(parsed)).toBe(true);
       if (isSuccessCommandResult(parsed)) {
-        expect(parsed.data).toEqual(signature);
+        expect(parsed.data).toEqual(Just(signature));
       } else {
         fail("Expected success result");
       }

packages/signer/signer-solana/src/internal/app-binder/command/SignOffChainMessageCommand.ts

@@ -10,13 +10,15 @@ import {
   GlobalCommandErrorHandler,
   InvalidStatusWordError,
 } from "@ledgerhq/device-management-kit";
+import { Just, type Maybe, Nothing } from "purify-ts";
 
-const SIGNATURE_LENGTH = 64;
+import { type Signature } from "@api/model/Signature";
 
-type SignOffChainMessageCommandResponse = Uint8Array;
+const SIGNATURE_LENGTH = 64;
 
-type SignOffChainMessageCommandArgs = {
-  message: Uint8Array;
+export type SignOffChainMessageCommandResponse = Maybe<Signature>;
+export type SignOffChainMessageCommandArgs = {
+  readonly message: Uint8Array;
 };
 
 export class SignOffChainMessageCommand
@@ -57,6 +59,12 @@ export class SignOffChainMessageCommand
       });
     }
 
+    if (parser.getUnparsedRemainingLength() === 0) {
+      return CommandResultFactory({
+        data: Nothing,
+      });
+    }
+
     const signature = parser.extractFieldByLength(SIGNATURE_LENGTH);
     if (!signature) {
       return CommandResultFactory({
@@ -65,7 +73,7 @@ export class SignOffChainMessageCommand
     }
 
     return CommandResultFactory({
-      data: signature,
+      data: Just(signature),
     });
   }
 }

packages/signer/signer-solana/src/internal/app-binder/device-action/__test-utils__/makeInternalApi.ts

@@ -0,0 +1,17 @@
+import { type InternalApi } from "@ledgerhq/device-management-kit";
+
+const sendCommandMock = jest.fn();
+const apiGetDeviceSessionStateMock = jest.fn();
+const apiGetDeviceSessionStateObservableMock = jest.fn();
+const setDeviceSessionStateMock = jest.fn();
+const getMetadataForAppHashesMock = jest.fn();
+
+export function makeDeviceActionInternalApiMock(): jest.Mocked<InternalApi> {
+  return {
+    sendCommand: sendCommandMock,
+    getDeviceSessionState: apiGetDeviceSessionStateMock,
+    getDeviceSessionStateObservable: apiGetDeviceSessionStateObservableMock,
+    setDeviceSessionState: setDeviceSessionStateMock,
+    getMetadataForAppHashes: getMetadataForAppHashesMock,
+  };
+}

packages/signer/signer-solana/src/internal/app-binder/task/SendCommandInChunksTask.ts

@@ -0,0 +1,63 @@
+import {
+  APDU_MAX_PAYLOAD,
+  ByteArrayBuilder,
+  type Command,
+  type CommandResult,
+  CommandResultFactory,
+  type InternalApi,
+  InvalidStatusWordError,
+  isSuccessCommandResult,
+} from "@ledgerhq/device-management-kit";
+
+export type SendCommandInChunksTaskArgs<T> = {
+  data: Uint8Array;
+  commandFactory: CommandFactory<T>;
+};
+
+export type CommandFactory<T> = <V extends ChunkableCommandArgs>(
+  args: ChunkableCommandArgs,
+) => Command<T, V>;
+
+export type ChunkableCommandArgs = {
+  chunkedData: Uint8Array;
+};
+
+export class SendCommandInChunksTask<T> {
+  constructor(
+    private api: InternalApi,
+    private args: SendCommandInChunksTaskArgs<T>,
+  ) {}
+
+  async run(): Promise<CommandResult<T, void>> {
+    const { data: fullPayload, commandFactory } = this.args;
+
+    const dataBuffer = new ByteArrayBuilder(fullPayload.length)
+      .addBufferToData(fullPayload)
+      .build();
+
+    for (
+      let offset = 0;
+      offset < dataBuffer.length;
+      offset += APDU_MAX_PAYLOAD
+    ) {
+      const isLastChunk = offset + APDU_MAX_PAYLOAD >= dataBuffer.length;
+      const result = await this.api.sendCommand(
+        commandFactory({
+          chunkedData: dataBuffer.slice(offset, offset + APDU_MAX_PAYLOAD),
+        }),
+      );
+
+      if (!isSuccessCommandResult(result)) {
+        return result;
+      }
+
+      if (isLastChunk) {
+        return CommandResultFactory({
+          data: result.data,
+        });
+      }
+    }
+
+    throw new InvalidStatusWordError("No result after processing all chunks");
+  }
+}