✨ (solana-signer): Add solana swap transaction signer

Author: fAnselmi-Ledger

.changeset/calm-beds-fly.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/device-management-kit": patch
+---
+
+Add bufferToBase64String util

.changeset/slimy-walls-talk.md

@@ -0,0 +1,5 @@
+---
+"@ledgerhq/device-signer-kit-solana": minor
+---
+
+Add swap transaction signer

apps/sample/src/components/SignerSolanaView/index.tsx

@@ -23,6 +23,11 @@ import {
   type SignTransactionDAOutput,
   SolanaToolsBuilder,
 } from "@ledgerhq/device-signer-kit-solana";
+import {
+  type SwapTransactionSignerDAError,
+  type SwapTransactionSignerDAIntermediateValue,
+  type SwapTransactionSignerDAOutput,
+} from "@ledgerhq/device-signer-kit-solana/api/app-binder/SwapTransactionSignerDeviceActionTypes.js";
 
 import { DeviceActionsList } from "@/components/DeviceActionsView/DeviceActionsList";
 import { type DeviceActionProps } from "@/components/DeviceActionsView/DeviceActionTester";
@@ -82,7 +87,7 @@ export const SignerSolanaView: React.FC<{ sessionId: string }> = ({
         GetAddressDAIntermediateValue
       >,
       {
-        title: "Sign Transaction",
+        title: "Sign transaction",
         description:
           "Perform all the actions necessary to sign a Solana transaction with the device",
         executeDeviceAction: ({ derivationPath, transaction }) => {
@@ -146,7 +151,7 @@ export const SignerSolanaView: React.FC<{ sessionId: string }> = ({
         GetAppConfigurationDAIntermediateValue
       >,
       {
-        title: "Generate Transaction",
+        title: "Generate transaction",
         description:
           "Perform all the actions necessary to generate a transaction to test the Solana signer",
         executeDeviceAction: ({ derivationPath }) => {
@@ -166,6 +171,32 @@ export const SignerSolanaView: React.FC<{ sessionId: string }> = ({
         GenerateTransactionDAError,
         GenerateTransactionDAIntermediateValue
       >,
+      {
+        title: "Swap transaction signer",
+        description:
+          "Perform all the actions necessary to swap a transaction signer",
+        executeDeviceAction: ({ derivationPath, serialisedTransaction }) => {
+          return solanaTools.swapTransactionSigner(
+            derivationPath,
+            serialisedTransaction,
+          );
+        },
+        initialValues: {
+          derivationPath: DEFAULT_DERIVATION_PATH,
+          serialisedTransaction: "",
+          skipOpenApp: false,
+        },
+        deviceModelId,
+      } satisfies DeviceActionProps<
+        SwapTransactionSignerDAOutput,
+        {
+          derivationPath: string;
+          serialisedTransaction: string;
+          skipOpenApp: boolean;
+        },
+        SwapTransactionSignerDAError,
+        SwapTransactionSignerDAIntermediateValue
+      >,
     ],
     [deviceModelId, solanaTools, signer],
   );

packages/device-management-kit/src/api/index.ts

@@ -119,6 +119,7 @@ export { TransportConnectedDevice } from "@api/transport/model/TransportConnecte
 export { connectedDeviceStubBuilder } from "@api/transport/model/TransportConnectedDevice.stub";
 export * from "@api/types";
 export { base64StringToBuffer, isBase64String } from "@api/utils/Base64String";
+export { bufferToBase64String } from "@api/utils/BufferToBase64String";
 export {
   bufferToHexaString,
   hexaStringToBuffer,

packages/device-management-kit/src/api/utils/BufferToBase64String.test.ts

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { bufferToBase64String } from "./BufferToBase64String";
+
+describe("bufferToBase64String", () => {
+  const originalBtoa = (globalThis as any).btoa;
+  const originalBuffer = (globalThis as any).Buffer;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    (globalThis as any).btoa = originalBtoa;
+    (globalThis as any).Buffer = originalBuffer;
+  });
+
+  afterAll(() => {
+    (globalThis as any).btoa = originalBtoa;
+    (globalThis as any).Buffer = originalBuffer;
+  });
+
+  it("should encode an empty buffer to an empty base64 string when btoa is available", () => {
+    // GIVEN
+    (globalThis as any).btoa = vi.fn((input: string) => {
+      expect(input).toBe("");
+      return "";
+    });
+
+    const bytes = new Uint8Array();
+
+    // WHEN
+    const result = bufferToBase64String(bytes);
+
+    // THEN
+    expect(result).toBe("");
+    expect(globalThis.btoa).toHaveBeenCalledTimes(1);
+  });
+
+  it("should encode a buffer to base64 using btoa when available", () => {
+    // GIVEN
+    const text = "first testing str";
+    const bytes = Uint8Array.from(text.split("").map((c) => c.charCodeAt(0)));
+
+    (globalThis as any).btoa = vi.fn((input: string) => {
+      expect(input).toBe(text);
+      return "Zmlyc3QgdGVzdGluZyBzdHI=";
+    });
+
+    // WHEN
+    const result = bufferToBase64String(bytes);
+
+    // THEN
+    expect(result).toBe("Zmlyc3QgdGVzdGluZyBzdHI=");
+    expect(globalThis.btoa).toHaveBeenCalledTimes(1);
+  });
+
+  it("should encode a buffer to base64 using Buffer when btoa is not available", () => {
+    // GIVEN
+    (globalThis as any).btoa = undefined;
+
+    const text = "testing str";
+    const expectedBase64 = Buffer.from(text, "binary").toString("base64");
+    const bytes = Uint8Array.from(text.split("").map((c) => c.charCodeAt(0)));
+
+    const bufferFromSpy = vi.spyOn(Buffer, "from");
+
+    // WHEN
+    const result = bufferToBase64String(bytes);
+
+    // THEN
+    expect(result).toBe(expectedBase64);
+    expect(bufferFromSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should throw an error when no Base64 encoder is available", () => {
+    // GIVEN
+    (globalThis as any).btoa = undefined;
+    (globalThis as any).Buffer = undefined;
+
+    const bytes = Uint8Array.from([0x01, 0x02, 0x03]);
+
+    // WHEN / THEN
+    expect(() => bufferToBase64String(bytes)).toThrowError(
+      "No Base64 encoder available in this environment.",
+    );
+  });
+
+  it("should throw if an undefined byte is encountered (defensive check)", () => {
+    // GIVEN
+    const bytes = {
+      length: 3,
+      0: 0x66,
+      1: undefined,
+      2: 0x6f,
+    } as unknown as Uint8Array;
+
+    (globalThis as any).btoa = vi.fn();
+
+    // WHEN / THEN
+    expect(() => bufferToBase64String(bytes)).toThrowError(
+      "Unexpected undefined byte in array.",
+    );
+  });
+});

packages/device-management-kit/src/api/utils/BufferToBase64String.ts

@@ -0,0 +1,26 @@
+export function bufferToBase64String(bytes: Uint8Array): string {
+  const g = globalThis as typeof globalThis & {
+    Buffer?: typeof Buffer;
+    btoa?: (data: string) => string;
+  };
+
+  if (typeof g.btoa === "function") {
+    // convert bytes to a binary string for btoa
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+      const byte = bytes[i];
+      if (byte === undefined) {
+        throw new Error("Unexpected undefined byte in array.");
+      }
+      binary += String.fromCharCode(byte);
+    }
+    return g.btoa(binary);
+  }
+
+  const Buf = g.Buffer;
+  if (typeof Buf !== "undefined") {
+    return Buf.from(bytes).toString("base64");
+  }
+
+  throw new Error("No Base64 encoder available in this environment.");
+}

packages/signer/signer-solana/src/api/app-binder/SwapTransactionSignerDeviceActionTypes.ts

@@ -0,0 +1,51 @@
+import { type ContextModule } from "@ledgerhq/context-module";
+import {
+  type DeviceActionState,
+  type ExecuteDeviceActionReturnType,
+  type OpenAppDAError,
+  type OpenAppDARequiredInteraction,
+  type SendCommandInAppDAError,
+  type UserInteractionRequired,
+} from "@ledgerhq/device-management-kit";
+
+import { type PublicKey } from "@api/model/PublicKey";
+import { type SolanaAppErrorCodes } from "@internal/app-binder/command/utils/SolanaApplicationErrors";
+
+export type SwapTransactionSignerDAOutput = string;
+
+export type SwapTransactionSignerDAInput = {
+  readonly derivationPath: string;
+  readonly serialisedTransaction: string;
+  readonly skipOpenApp: boolean;
+  readonly contextModule: ContextModule;
+};
+
+export type SwapTransactionSignerDAError =
+  | OpenAppDAError
+  | SendCommandInAppDAError<SolanaAppErrorCodes>;
+
+type SwapTransactionSignerDARequiredInteraction =
+  | UserInteractionRequired
+  | OpenAppDARequiredInteraction;
+
+export type SwapTransactionSignerDAIntermediateValue = {
+  requiredUserInteraction: SwapTransactionSignerDARequiredInteraction;
+};
+
+export type SwapTransactionSignerDAState = DeviceActionState<
+  SwapTransactionSignerDAOutput,
+  SwapTransactionSignerDAError,
+  SwapTransactionSignerDAIntermediateValue
+>;
+
+export type SwapTransactionSignerDAInternalState = {
+  readonly error: SwapTransactionSignerDAError | null;
+  readonly publicKey: PublicKey | null;
+  readonly serialisedTransaction: string | null;
+};
+
+export type SwapTransactionSignerDAReturnType = ExecuteDeviceActionReturnType<
+  SwapTransactionSignerDAOutput,
+  SwapTransactionSignerDAError,
+  SwapTransactionSignerDAIntermediateValue
+>;

packages/signer/signer-solana/src/internal/DefaultSolanaTools.test.ts

@@ -60,4 +60,21 @@ describe("DefaultSolanaTools", () => {
     solanaTools.generateTransaction("derivationPath");
     expect(dmk.executeDeviceAction).toHaveBeenCalled();
   });
+
+  it("should call swapTransaction", () => {
+    const dmk = {
+      executeDeviceAction: vi.fn(),
+    } as unknown as DeviceManagementKit;
+    const sessionId = {} as DeviceSessionId;
+    const solanaTools = new DefaultSolanaTools({
+      dmk,
+      sessionId,
+      contextModule: contextModuleStub,
+    });
+    solanaTools.swapTransactionSigner(
+      "derivationPath",
+      "serialisedTransaction",
+    );
+    expect(dmk.executeDeviceAction).toHaveBeenCalled();
+  });
 });

packages/signer/signer-solana/src/internal/DefaultSolanaTools.ts

@@ -8,13 +8,15 @@ import { type Container } from "inversify";
 import { type GenerateTransactionDAReturnType } from "@api/app-binder/GenerateTransactionDeviceActionTypes";
 import { type GetAddressDAReturnType } from "@api/app-binder/GetAddressDeviceActionTypes";
 import { type GetAppConfigurationDAReturnType } from "@api/app-binder/GetAppConfigurationDeviceActionTypes";
+import { type SwapTransactionSignerDAReturnType } from "@api/app-binder/SwapTransactionSignerDeviceActionTypes";
 import { type AddressOptions } from "@api/model/AddressOption";
 import { type SolanaTools } from "@api/SolanaTools";
 
 import { type GetAddressUseCase } from "./use-cases/address/GetAddressUseCase";
 import { type GetAppConfigurationUseCase } from "./use-cases/app-configuration/GetAppConfigurationUseCase";
 import { useCasesTypes } from "./use-cases/di/useCasesTypes";
 import { type GenerateTransactionUseCase } from "./use-cases/generateTransaction/GenerateTransactionUseCase";
+import { type SwapTransactionSignerUseCase } from "./use-cases/swap-transaction-signer/SwapTransactionSignerUseCase";
 import { makeContainer } from "./di";
 
 export type DefaultSolanaToolsConstructorArgs = {
@@ -40,6 +42,17 @@ export class DefaultSolanaTools implements SolanaTools {
       .execute(derivationPath);
   }
 
+  swapTransactionSigner(
+    derivationPath: string,
+    serialisedTransaction: string,
+  ): SwapTransactionSignerDAReturnType {
+    return this._container
+      .get<SwapTransactionSignerUseCase>(
+        useCasesTypes.SwapTransactionSignerUseCase,
+      )
+      .execute(derivationPath, serialisedTransaction);
+  }
+
   getAddress(
     derivationPath: string,
     options?: AddressOptions,