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

Author: fAnselmi-Ledger

.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/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,

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

@@ -35,6 +35,7 @@ import { GetAppConfigurationCommand } from "./command/GetAppConfigurationCommand
 import { GetPubKeyCommand } from "./command/GetPubKeyCommand";
 import { GenerateTransactionDeviceAction } from "./device-action/GenerateTransactionDeviceAction";
 import { SignTransactionDeviceAction } from "./device-action/SignTransactionDeviceAction";
+import { SwapTransactionSignerDeviceAction } from "./device-action/SwapTransactionSignerDeviceAction";
 import { SolanaAppBinder } from "./SolanaAppBinder";
 
 describe("SolanaAppBinder", () => {
@@ -515,4 +516,94 @@ describe("SolanaAppBinder", () => {
       });
     });
   });
+
+  describe("swapTransactionSigner", () => {
+    it("should return the swapped serialized transaction", () =>
+      new Promise<void>((resolve, reject) => {
+        // given
+        const swappedSerializedTx = "SWAPPED_BASE64";
+
+        vi.spyOn(mockedDmk, "executeDeviceAction").mockReturnValue({
+          observable: from([
+            {
+              status: DeviceActionStatus.Completed,
+              output: swappedSerializedTx,
+            } as DeviceActionState<
+              unknown,
+              DmkError,
+              DeviceActionIntermediateValue
+            >,
+          ]),
+          cancel: vi.fn(),
+        });
+
+        // when
+        const appBinder = new SolanaAppBinder(
+          mockedDmk,
+          "sessionId",
+          contextModuleStub,
+        );
+        const { observable } = appBinder.SwapTransactionSigner({
+          derivationPath: "44'/501'/0'/0'",
+          serialisedTransaction: "INPUT_BASE64",
+          skipOpenApp: false,
+        });
+
+        // then
+        const states: DeviceActionState<
+          unknown,
+          DmkError,
+          DeviceActionIntermediateValue
+        >[] = [];
+        observable.subscribe({
+          next: (state) => states.push(state),
+          error: (err) => reject(err),
+          complete: () => {
+            try {
+              expect(states).toEqual([
+                {
+                  status: DeviceActionStatus.Completed,
+                  output: swappedSerializedTx,
+                },
+              ]);
+              resolve();
+            } catch (err) {
+              reject(err as Error);
+            }
+          },
+        });
+      }));
+
+    it("should call executeDeviceAction with the correct params", () => {
+      // given
+      const derivationPath = "44'/501'/0'/0'";
+      const serialisedTransaction = "INPUT_BASE64";
+      const skipOpenApp = true;
+
+      // when
+      const appBinder = new SolanaAppBinder(
+        mockedDmk,
+        "sessionId",
+        contextModuleStub,
+      );
+      appBinder.SwapTransactionSigner({
+        derivationPath,
+        serialisedTransaction,
+        skipOpenApp,
+      });
+
+      // then
+      expect(mockedDmk.executeDeviceAction).toHaveBeenCalledWith({
+        sessionId: "sessionId",
+        deviceAction: new SwapTransactionSignerDeviceAction({
+          input: {
+            derivationPath,
+            serialisedTransaction,
+            skipOpenApp,
+            contextModule: contextModuleStub,
+          },
+        }),
+      });
+    });
+  });
 });

packages/signer/signer-solana/src/internal/app-binder/SolanaAppBinder.ts

@@ -13,6 +13,7 @@ import { GetAddressDAReturnType } from "@api/app-binder/GetAddressDeviceActionTy
 import { GetAppConfigurationDAReturnType } from "@api/app-binder/GetAppConfigurationDeviceActionTypes";
 import { SignMessageDAReturnType } from "@api/app-binder/SignMessageDeviceActionTypes";
 import { SignTransactionDAReturnType } from "@api/app-binder/SignTransactionDeviceActionTypes";
+import { SwapTransactionSignerDAReturnType } from "@api/app-binder/SwapTransactionSignerDeviceActionTypes";
 import { SolanaTransactionOptionalConfig } from "@api/model/SolanaTransactionOptionalConfig";
 import { Transaction } from "@api/model/Transaction";
 import { SendSignMessageTask } from "@internal/app-binder/task/SendSignMessageTask";
@@ -22,6 +23,7 @@ import { GetAppConfigurationCommand } from "./command/GetAppConfigurationCommand
 import { GetPubKeyCommand } from "./command/GetPubKeyCommand";
 import { GenerateTransactionDeviceAction } from "./device-action/GenerateTransactionDeviceAction";
 import { SignTransactionDeviceAction } from "./device-action/SignTransactionDeviceAction";
+import { SwapTransactionSignerDeviceAction } from "./device-action/SwapTransactionSignerDeviceAction";
 
 @injectable()
 export class SolanaAppBinder {
@@ -85,6 +87,24 @@ export class SolanaAppBinder {
     });
   }
 
+  SwapTransactionSigner(args: {
+    derivationPath: string;
+    serialisedTransaction: string;
+    skipOpenApp: boolean;
+  }): SwapTransactionSignerDAReturnType {
+    return this.dmk.executeDeviceAction({
+      sessionId: this.sessionId,
+      deviceAction: new SwapTransactionSignerDeviceAction({
+        input: {
+          derivationPath: args.derivationPath,
+          serialisedTransaction: args.serialisedTransaction,
+          skipOpenApp: args.skipOpenApp,
+          contextModule: this.contextModule,
+        },
+      }),
+    });
+  }
+
   signMessage(args: {
     derivationPath: string;
     message: string;