@ledgerhq/coin-canton 0.5.0-nightly.3 → 0.5.0-nightly.5

package/src/common-logic/history/listOperations.ts

@@ -1,6 +1,6 @@
 import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
 import { getOperations } from "../../network/gateway";
-import coinConfig from "../../config";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 /**
  * Returns list of operations associated to an account.
@@ -10,10 +10,11 @@ import coinConfig from "../../config";
  * Impl to finalize when backend is ready
  */
 export async function listOperations(
+  currency: CryptoCurrency,
   partyId: string,
   page: Pagination,
 ): Promise<[Operation[], string]> {
-  const { operations, next } = await getOperations(partyId, {
+  const { operations, next } = await getOperations(currency, partyId, {
     cursor: page.pagingToken !== undefined ? parseInt(page.pagingToken) : undefined,
     minOffset: page.minHeight,
     limit: page.limit,

package/src/common-logic/transaction/broadcast.test.ts

@@ -1,6 +1,7 @@
 import { submit } from "../../network/gateway";
 import * as coinConfigModule from "../../config";
 import { broadcast } from "./broadcast";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 jest.mock("../../network/gateway", () => ({
   submit: jest.fn(),
@@ -11,6 +12,10 @@ const mockSerialized = JSON.stringify({
   signature: "signature__PARTY__alice:123",
 });
 
+const mockCurrency = {
+  id: "canton_network",
+} as unknown as CryptoCurrency;
+
 describe("broadcast", () => {
   const mockGetCoinConfig = jest.spyOn(coinConfigModule.default, "getCoinConfig");
 
@@ -25,9 +30,9 @@ describe("broadcast", () => {
 
     (submit as jest.Mock).mockResolvedValue({ update_id: "my-update-id" });
 
-    const result = await broadcast(mockSerialized);
+    const result = await broadcast(mockCurrency, mockSerialized);
 
-    expect(submit).toHaveBeenCalledWith("alice:123", "serialized-tx", "signature");
+    expect(submit).toHaveBeenCalledWith(mockCurrency, "alice:123", "serialized-tx", "signature");
     expect(result).toEqual("my-update-id");
   });
 
@@ -36,7 +41,7 @@ describe("broadcast", () => {
       useGateway: false,
     } as any);
 
-    await expect(broadcast(mockSerialized)).rejects.toThrow("Not implemented");
+    await expect(broadcast(mockCurrency, mockSerialized)).rejects.toThrow("Not implemented");
     expect(submit).not.toHaveBeenCalled();
   });
 });

package/src/common-logic/transaction/broadcast.ts

@@ -1,11 +1,14 @@
 import coinConfig from "../../config";
 import { submit } from "../../network/gateway";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
-const useGateway = () => coinConfig.getCoinConfig().useGateway === true;
+const useGateway = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).useGateway === true;
 
-export async function broadcast(signedTx: string): Promise<string> {
+export async function broadcast(currency: CryptoCurrency, signedTx: string): Promise<string> {
   const parsed: { serialized: string; signature: string } = JSON.parse(signedTx);
   const [sig, party] = parsed.signature.split("__PARTY__");
-  if (useGateway()) return (await submit(party, parsed.serialized, sig)).update_id;
+  if (useGateway(currency))
+    return (await submit(currency, party, parsed.serialized, sig)).update_id;
   else throw new Error("Not implemented");
 }

package/src/common-logic/transaction/craftTransaction.ts

@@ -1,7 +1,13 @@
 import BigNumber from "bignumber.js";
-import { prepareTransferRequest, PrepareTransferResponse } from "../../network/gateway";
+import {
+  PrepareTransferRequest,
+  prepareTransferRequest,
+  PrepareTransferResponse,
+} from "../../network/gateway";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export async function craftTransaction(
+  currency: CryptoCurrency,
   account: {
     address: string;
     nextSequenceNumber?: number;
@@ -12,19 +18,30 @@ export async function craftTransaction(
     amount: BigNumber;
     tokenId: string;
     expireInSeconds: number;
+    memo?: string;
   },
 ): Promise<{
   nativeTransaction: PrepareTransferResponse;
   serializedTransaction: string;
   hash: string;
 }> {
-  const { serialized, json, hash } = await prepareTransferRequest(account.address, {
+  const params: PrepareTransferRequest = {
     recipient: transaction.recipient || "",
-    amount: transaction.amount.toNumber(),
-    type: "token-transfer-request",
+    amount: transaction.amount.toString(),
+    type: "token-transfer-request" as const,
     execute_before_secs: transaction.expireInSeconds,
     instrument_id: transaction.tokenId,
-  });
+  };
+
+  if (transaction.memo) {
+    params.reason = transaction.memo;
+  }
+
+  const { serialized, json, hash } = await prepareTransferRequest(
+    currency,
+    account.address,
+    params,
+  );
 
   return {
     nativeTransaction: json,

package/src/common-logic/transaction/estimateFees.ts

@@ -1,4 +1,8 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function estimateFees(serializedTransaction: string): Promise<bigint> {
-  return Promise.resolve(BigInt(10_000)); // TODO replace with real implementation
+import coinConfig from "../../config";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+const feeValue = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).fee ?? 1;
+
+export async function estimateFees(currency: CryptoCurrency): Promise<bigint> {
+  return Promise.resolve(BigInt(feeValue(currency)));
 }

package/src/config.ts

@@ -10,6 +10,7 @@ export type CantonConfig = {
   networkType: "mainnet" | "devnet" | "localnet";
   useGateway?: boolean;
   nativeInstrumentId?: string;
+  fee?: number;
 };
 
 export type CantonCoinConfig = CurrencyConfig & CantonConfig;

package/src/network/gateway.integ.test.ts

@@ -13,6 +13,11 @@ import {
   preparePreApprovalTransaction,
   submitPreApprovalTransaction,
 } from "./gateway";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+const mockCurrency = {
+  id: "canton_network",
+} as unknown as CryptoCurrency;
 
 describe("gateway (devnet)", () => {
   let onboardedAccount: {
@@ -50,7 +55,7 @@ describe("gateway (devnet)", () => {
       };
 
       // WHEN
-      const response = await prepareOnboarding(keyPair.publicKeyHex, "ed25519");
+      const response = await prepareOnboarding(mockCurrency, keyPair.publicKeyHex, "ed25519");
 
       // THEN
       expect(response).toHaveProperty("party_id");
@@ -58,7 +63,8 @@ describe("gateway (devnet)", () => {
       expect(response).toHaveProperty("public_key_fingerprint");
       expect(response).toHaveProperty("transactions");
       expect(response.transactions).toHaveProperty("combined_hash");
-      expect(response.party_name).toBe(keyPair.publicKeyHex);
+      expect(response.party_name).toBeDefined();
+      expect(typeof response.party_name).toBe("string");
 
       expect(response.public_key_fingerprint).toBe(keyPair.fingerprint);
     }, 30000);
@@ -69,11 +75,20 @@ describe("gateway (devnet)", () => {
       // GIVEN
       const { keyPair } = getOnboardedAccount();
       const prepareRequest = { public_key: keyPair.publicKeyHex, public_key_type: "ed25519" };
-      const prepareResponse = await prepareOnboarding(keyPair.publicKeyHex, "ed25519");
+      const prepareResponse = await prepareOnboarding(
+        mockCurrency,
+        keyPair.publicKeyHex,
+        "ed25519",
+      );
       const signature = keyPair.sign(prepareResponse.transactions.combined_hash);
 
       // WHEN
-      const response = await submitOnboarding(prepareRequest, prepareResponse, signature);
+      const response = await submitOnboarding(
+        mockCurrency,
+        prepareRequest,
+        prepareResponse,
+        signature,
+      );
 
       // Save onboarded account for all tests that need a valid party ID
       onboardedAccount = {
@@ -91,7 +106,7 @@ describe("gateway (devnet)", () => {
 
   describe("getLedgerEnd", () => {
     it("should return ledger end", async () => {
-      const end = await getLedgerEnd();
+      const end = await getLedgerEnd(mockCurrency);
       expect(end).toBeGreaterThanOrEqual(0);
     });
   });
@@ -99,7 +114,7 @@ describe("gateway (devnet)", () => {
   describe("getBalance", () => {
     it("should return user balance", async () => {
       const { partyId } = getOnboardedAccount();
-      const balance = await getBalance(partyId);
+      const balance = await getBalance(mockCurrency, partyId);
       expect(balance.length).toBeGreaterThanOrEqual(0);
       if (balance.length > 0) {
         expect(balance[0].amount).toBeGreaterThanOrEqual(0);
@@ -110,7 +125,7 @@ describe("gateway (devnet)", () => {
 
   describe("getPartyById", () => {
     it.skip("should return party info", async () => {
-      const party = await getPartyById("4f2e1485107adf5f");
+      const party = await getPartyById(mockCurrency, "4f2e1485107adf5f");
       expect(party).toBeDefined();
     });
   });
@@ -118,6 +133,7 @@ describe("gateway (devnet)", () => {
   describe("getPartyByPubKey", () => {
     it.skip("should return party info", async () => {
       const party = await getPartyByPubKey(
+        mockCurrency,
         "122027c6dbbbdbffe0fa3122ae05175f3b9328e879e9ce96b670354deb64a45683c1",
       );
       expect(party).toBeDefined();
@@ -127,7 +143,9 @@ describe("gateway (devnet)", () => {
   describe("getOperations", () => {
     it("should return user transactions", async () => {
       const { operations } = await getOperations(
+        mockCurrency,
         "party-5f29bb32e9939939::12202becd8062a1d170209956cfd977fca76fcb4d2a892d08c77a7483f35a11d6440",
+        {},
       );
       expect(operations.length).toBeGreaterThanOrEqual(0);
     });
@@ -140,7 +158,7 @@ describe("gateway (devnet)", () => {
       const amount = 1000;
 
       // WHEN
-      const response = await prepareTapRequest({ partyId, amount });
+      const response = await prepareTapRequest(mockCurrency, { partyId, amount });
 
       // THEN
       expect(response).toHaveProperty("serialized");
@@ -154,14 +172,14 @@ describe("gateway (devnet)", () => {
     it("should submit tap request with proper signature", async () => {
       // GIVEN
       const { keyPair, partyId } = getOnboardedAccount();
-      const tapPrepareResponse = await prepareTapRequest({
+      const tapPrepareResponse = await prepareTapRequest(mockCurrency, {
         partyId,
         amount: 1000,
       });
       const tapSignature = keyPair.sign(tapPrepareResponse.hash);
 
       // WHEN
-      const response = await submitTapRequest({
+      const response = await submitTapRequest(mockCurrency, {
         partyId,
         serialized: tapPrepareResponse.serialized,
         signature: tapSignature,
@@ -181,7 +199,7 @@ describe("gateway (devnet)", () => {
       const { partyId } = getOnboardedAccount();
 
       // WHEN
-      const response = await preparePreApprovalTransaction(partyId);
+      const response = await preparePreApprovalTransaction(mockCurrency, partyId);
 
       // THEN
       expect(response).toHaveProperty("serialized");
@@ -195,11 +213,12 @@ describe("gateway (devnet)", () => {
     it("should submit pre-approval transaction with proper signature", async () => {
       // GIVEN
       const { keyPair, partyId } = getOnboardedAccount();
-      const preparedTransaction = await preparePreApprovalTransaction(partyId);
+      const preparedTransaction = await preparePreApprovalTransaction(mockCurrency, partyId);
       const preApprovalSignature = keyPair.sign(preparedTransaction.hash);
 
       // WHEN
       const response = await submitPreApprovalTransaction(
+        mockCurrency,
         partyId,
         preparedTransaction,
         preApprovalSignature,

package/src/network/gateway.ts

@@ -9,6 +9,7 @@ import {
   SubmitTransactionResponse,
   PreApprovalResult,
 } from "../types/onboard";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 type OnboardingPrepareResponse = {
   party_id: string;
@@ -47,23 +48,13 @@ export type PrepareTransferResponse = {
 
 export type PrepareTransferRequest = {
   type: "token-transfer-request";
-  amount: number;
+  amount: string;
   recipient: string;
   execute_before_secs: number;
   instrument_id: string;
   reason?: string;
 };
 
-export type PrepareTapRequest = {
-  type: "tap-request";
-  amount: number;
-};
-
-export type PreparePreapprovalRequest = {
-  type: "transfer-pre-approval-proposal";
-  receiver: string;
-};
-
 type OnboardingSubmitRequest = {
   prepare_request: OnboardingPrepareRequest;
   prepare_response: OnboardingPrepareResponse;
@@ -161,6 +152,9 @@ export type OperationInfo =
           asset: string;
           details: {
             type: "pre-approval";
+            metadata: {
+              reason?: string;
+            };
           };
         },
       ];
@@ -203,6 +197,9 @@ export type OperationInfo =
           asset: string;
           details: {
             type: "tap";
+            metadata: {
+              reason?: string;
+            };
           };
         },
       ];
@@ -245,6 +242,9 @@ export type OperationInfo =
           asset: string;
           details: {
             type: "transfer";
+            metadata: {
+              reason?: string;
+            };
           };
         },
       ];
@@ -272,8 +272,10 @@ export type OperationInfo =
       };
     };
 
-const getGatewayUrl = () => coinConfig.getCoinConfig().gatewayUrl;
-const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-devnet-stg";
+const getGatewayUrl = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).gatewayUrl;
+const getNodeId = (currency: CryptoCurrency) =>
+  coinConfig.getCoinConfig(currency).nodeId || "ledger-devnet-stg";
+const getNetworkType = (currency: CryptoCurrency) => coinConfig.getCoinConfig(currency).networkType;
 
 const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
   const API_KEY = getEnv("CANTON_API_KEY");
@@ -287,11 +289,12 @@ const gatewayNetwork = <T, U = unknown>(req: LiveNetworkRequest<U>) => {
 };
 
 export async function prepareOnboarding(
+  currency: CryptoCurrency,
   pubKey: string,
   pubKeyType: string,
 ): Promise<OnboardingPrepareResponse> {
-  const gatewayUrl = getGatewayUrl();
-  const nodeId = getNodeId();
+  const gatewayUrl = getGatewayUrl(currency);
+  const nodeId = getNodeId(currency);
   const fullUrl = `${gatewayUrl}/v1/node/${nodeId}/onboarding/prepare`;
 
   const { data } = await gatewayNetwork<OnboardingPrepareResponse, OnboardingPrepareRequest>({
@@ -307,13 +310,14 @@ export async function prepareOnboarding(
 }
 
 export async function submitOnboarding(
+  currency: CryptoCurrency,
   prepareRequest: OnboardingPrepareRequest,
   prepareResponse: OnboardingPrepareResponse,
   signature: string,
 ) {
   const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/submit`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/onboarding/submit`,
     data: {
       prepare_request: prepareRequest,
       prepare_response: prepareResponse,
@@ -323,10 +327,15 @@ export async function submitOnboarding(
   return data;
 }
 
-export async function submit(partyId: string, serialized: string, signature: string) {
+export async function submit(
+  currency: CryptoCurrency,
+  partyId: string,
+  serialized: string,
+  signature: string,
+) {
   const { data } = await gatewayNetwork<TransactionSubmitResponse, TransactionSubmitRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
     data: {
       serialized,
       signature,
@@ -335,32 +344,42 @@ export async function submit(partyId: string, serialized: string, signature: str
   return data;
 }
 
-export async function getBalance(partyId: string): Promise<InstrumentBalance[]> {
+export async function getBalance(
+  currency: CryptoCurrency,
+  partyId: string,
+): Promise<InstrumentBalance[]> {
   const { data } = await gatewayNetwork<InstrumentBalance[]>({
     method: "GET",
-    // TODO: we need better solution ?
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/balance`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/balance`,
   });
   return data;
 }
 
-export async function getPartyById(partyId: string): Promise<PartyInfo> {
-  return await getParty(partyId, "party-id");
+export async function getPartyById(currency: CryptoCurrency, partyId: string): Promise<PartyInfo> {
+  return await getParty(currency, partyId, "party-id");
 }
 
-export async function getPartyByPubKey(pubKey: string): Promise<PartyInfo> {
-  return await getParty(pubKey, "public-key");
+export async function getPartyByPubKey(
+  currency: CryptoCurrency,
+  pubKey: string,
+): Promise<PartyInfo> {
+  return await getParty(currency, pubKey, "public-key");
 }
 
-async function getParty(identifier: string, by: "party-id" | "public-key"): Promise<PartyInfo> {
+async function getParty(
+  currency: CryptoCurrency,
+  identifier: string,
+  by: "party-id" | "public-key",
+): Promise<PartyInfo> {
   const { data } = await gatewayNetwork<PartyInfo>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}?by=${by}`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${identifier}?by=${by}`,
   });
   return data;
 }
 
 export async function getOperations(
+  currency: CryptoCurrency,
   partyId: string,
   options?: {
     cursor?: number | undefined;
@@ -377,21 +396,21 @@ export async function getOperations(
     operations: OperationInfo[];
   }>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/operations`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/operations`,
     params: options,
   });
   return data;
 }
 
-type PrepareTapRequestRequest = {
+type PrepareTapRequest = {
   partyId: string;
   amount?: number;
 };
 
-type PrepareTapRequestResponse = {
-  serialized: "string";
+type PrepareTapResponse = {
+  serialized: string;
   json: null;
-  hash: "string";
+  hash: string;
 };
 
 enum TransactionType {
@@ -399,16 +418,20 @@ enum TransactionType {
   TRANSFER_PRE_APPROVAL_PROPOSAL = "transfer-pre-approval-proposal",
 }
 
-export async function prepareTapRequest({
-  partyId,
-  amount = 1000000,
-}: PrepareTapRequestRequest): Promise<PrepareTapRequestResponse> {
-  const { data } = await gatewayNetwork<
-    PrepareTapRequestResponse,
-    { amount: number; type: string }
-  >({
+export async function prepareTapRequest(
+  currency: CryptoCurrency,
+  { partyId, amount = 1000000 }: PrepareTapRequest,
+): Promise<PrepareTapResponse> {
+  if (getNetworkType(currency) === "mainnet") {
+    return {
+      serialized: "",
+      json: null,
+      hash: "",
+    };
+  }
+  const { data } = await gatewayNetwork<PrepareTapResponse, { amount: number; type: string }>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: {
       amount: parseInt(amount.toString(), 10), // Convert to integer to avoid scientific notation
       type: TransactionType.TAP_REQUEST,
@@ -428,17 +451,16 @@ type SubmitTapRequestResponse = {
   update_id: string;
 };
 
-export async function submitTapRequest({
-  partyId,
-  serialized,
-  signature,
-}: SubmitTapRequestRequest): Promise<SubmitTapRequestResponse> {
+export async function submitTapRequest(
+  currency: CryptoCurrency,
+  { partyId, serialized, signature }: SubmitTapRequestRequest,
+): Promise<SubmitTapRequestResponse> {
   const { data } = await gatewayNetwork<
     SubmitTapRequestResponse,
     Omit<SubmitTapRequestRequest, "partyId">
   >({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
     data: {
       serialized,
       signature,
@@ -448,31 +470,33 @@ export async function submitTapRequest({
 }
 
 export async function prepareTransferRequest(
+  currency: CryptoCurrency,
   partyId: string,
   params: PrepareTransferRequest,
 ): Promise<PrepareTransferResponse> {
-  const { data } = await network<PrepareTransferResponse>({
+  const { data } = await gatewayNetwork<PrepareTransferResponse, PrepareTransferRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: params,
   });
   return data;
 }
 
-export async function getLedgerEnd(): Promise<number> {
+export async function getLedgerEnd(currency: CryptoCurrency): Promise<number> {
   const { data } = await gatewayNetwork<number>({
     method: "GET",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/ledger-end`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/ledger-end`,
   });
   return data;
 }
 
 export async function preparePreApprovalTransaction(
+  currency: CryptoCurrency,
   partyId: string,
 ): Promise<PrepareTransactionResponse> {
   const { data } = await gatewayNetwork<PrepareTransactionResponse, PrepareTransactionRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
     data: {
       type: TransactionType.TRANSFER_PRE_APPROVAL_PROPOSAL,
       receiver: partyId,
@@ -482,13 +506,14 @@ export async function preparePreApprovalTransaction(
 }
 
 export async function submitPreApprovalTransaction(
+  currency: CryptoCurrency,
   partyId: string,
   { serialized }: PrepareTransactionResponse,
   signature: string,
 ): Promise<PreApprovalResult> {
   const { data } = await gatewayNetwork<SubmitTransactionResponse, SubmitTransactionRequest>({
     method: "POST",
-    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
     data: {
       serialized,
       signature,

package/src/signer/getAddress.ts

@@ -1,17 +1,19 @@
 import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
 import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { CantonSigner } from "../types";
+import { CantonSigner, CantonAddress } from "../types";
 
 const getAddress = (signerContext: SignerContext<CantonSigner>): GetAddressFn => {
-  return async (deviceId: string, { path }: GetAddressOptions) => {
-    const { address, publicKey } = await signerContext(deviceId, signer => signer.getAddress(path));
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const { address, publicKey } = await signerContext(deviceId, signer =>
+      signer.getAddress(path, verify),
+    );
 
     return {
       path,
       address,
       publicKey,
-    };
+    } satisfies CantonAddress;
   };
 };