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

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

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

package/src/network/gateway.ts

@@ -1,6 +1,4 @@
 import network from "@ledgerhq/live-network";
-import type { LiveNetworkRequest } from "@ledgerhq/live-network/network";
-import { getEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
 import {
   PrepareTransactionRequest,
@@ -9,7 +7,6 @@ import {
   SubmitTransactionResponse,
   PreApprovalResult,
 } from "../types/onboard";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 type OnboardingPrepareResponse = {
   party_id: string;
@@ -40,21 +37,6 @@ type OnboardingPrepareRequest = {
   public_key_type: string;
 };
 
-export type PrepareTransferResponse = {
-  hash: string;
-  json: any; // The actual structure is complex, using any for now
-  serialized: string;
-};
-
-export type PrepareTransferRequest = {
-  type: "token-transfer-request";
-  amount: string;
-  recipient: string;
-  execute_before_secs: number;
-  instrument_id: string;
-  reason?: string;
-};
-
 type OnboardingSubmitRequest = {
   prepare_request: OnboardingPrepareRequest;
   prepare_response: OnboardingPrepareResponse;
@@ -73,7 +55,7 @@ type TransactionSubmitRequest = {
   signature: string;
 };
 
-type TransactionSubmitResponse = { update_id: string };
+type TransactionSubmitResponse = { updateId: string };
 
 export type InstrumentBalance = {
   instrument_id: string;
@@ -152,9 +134,6 @@ export type OperationInfo =
           asset: string;
           details: {
             type: "pre-approval";
-            metadata: {
-              reason?: string;
-            };
           };
         },
       ];
@@ -197,9 +176,6 @@ export type OperationInfo =
           asset: string;
           details: {
             type: "tap";
-            metadata: {
-              reason?: string;
-            };
           };
         },
       ];
@@ -242,9 +218,6 @@ export type OperationInfo =
           asset: string;
           details: {
             type: "transfer";
-            metadata: {
-              reason?: string;
-            };
           };
         },
       ];
@@ -272,114 +245,84 @@ export type OperationInfo =
       };
     };
 
-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");
-  return network<T, U>({
-    ...req,
-    headers: {
-      ...(req.headers || {}),
-      ...(API_KEY && { "X-Ledger-Canton-Api-Key": API_KEY }),
-    },
-  });
-};
+const getGatewayUrl = () => coinConfig.getCoinConfig().gatewayUrl;
+const getNodeId = () => coinConfig.getCoinConfig().nodeId || "ledger-devnet-stg";
 
 export async function prepareOnboarding(
-  currency: CryptoCurrency,
   pubKey: string,
   pubKeyType: string,
 ): Promise<OnboardingPrepareResponse> {
-  const gatewayUrl = getGatewayUrl(currency);
-  const nodeId = getNodeId(currency);
+  const gatewayUrl = getGatewayUrl();
+  const nodeId = getNodeId();
   const fullUrl = `${gatewayUrl}/v1/node/${nodeId}/onboarding/prepare`;
 
-  const { data } = await gatewayNetwork<OnboardingPrepareResponse, OnboardingPrepareRequest>({
+  const { data } = await network<OnboardingPrepareResponse>({
     method: "POST",
     url: fullUrl,
     data: {
       public_key: pubKey,
       public_key_type: pubKeyType,
-    },
+    } satisfies OnboardingPrepareRequest,
   });
 
   return data;
 }
 
 export async function submitOnboarding(
-  currency: CryptoCurrency,
   prepareRequest: OnboardingPrepareRequest,
   prepareResponse: OnboardingPrepareResponse,
   signature: string,
 ) {
-  const { data } = await gatewayNetwork<OnboardingSubmitResponse, OnboardingSubmitRequest>({
+  const { data } = await network<OnboardingSubmitResponse>({
     method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/onboarding/submit`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/onboarding/submit`,
     data: {
       prepare_request: prepareRequest,
       prepare_response: prepareResponse,
       signature,
-    },
+    } satisfies OnboardingSubmitRequest,
   });
   return data;
 }
 
-export async function submit(
-  currency: CryptoCurrency,
-  partyId: string,
-  serialized: string,
-  signature: string,
-) {
-  const { data } = await gatewayNetwork<TransactionSubmitResponse, TransactionSubmitRequest>({
+export async function submit(serializedTx: string, signature: string) {
+  const { data } = await network<TransactionSubmitResponse>({
     method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/transaction/submit`,
     data: {
-      serialized,
+      serialized: serializedTx,
       signature,
-    },
+    } satisfies TransactionSubmitRequest,
   });
   return data;
 }
 
-export async function getBalance(
-  currency: CryptoCurrency,
-  partyId: string,
-): Promise<InstrumentBalance[]> {
-  const { data } = await gatewayNetwork<InstrumentBalance[]>({
+export async function getBalance(partyId: string): Promise<InstrumentBalance[]> {
+  const { data } = await network<InstrumentBalance[]>({
     method: "GET",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/balance`,
+    // TODO: we need better solution ?
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/balance`,
   });
   return data;
 }
 
-export async function getPartyById(currency: CryptoCurrency, partyId: string): Promise<PartyInfo> {
-  return await getParty(currency, partyId, "party-id");
+export async function getPartyById(partyId: string): Promise<PartyInfo> {
+  return await getParty(partyId, "party-id");
 }
 
-export async function getPartyByPubKey(
-  currency: CryptoCurrency,
-  pubKey: string,
-): Promise<PartyInfo> {
-  return await getParty(currency, pubKey, "public-key");
+export async function getPartyByPubKey(pubKey: string): Promise<PartyInfo> {
+  return await getParty(pubKey, "public-key");
 }
 
-async function getParty(
-  currency: CryptoCurrency,
-  identifier: string,
-  by: "party-id" | "public-key",
-): Promise<PartyInfo> {
-  const { data } = await gatewayNetwork<PartyInfo>({
+async function getParty(identifier: string, by: "party-id" | "public-key"): Promise<PartyInfo> {
+  const { data } = await network<PartyInfo>({
     method: "GET",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${identifier}?by=${by}`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${identifier}?by=${by}`,
   });
   return data;
 }
 
 export async function getOperations(
-  currency: CryptoCurrency,
   partyId: string,
   options?: {
     cursor?: number | undefined;
@@ -391,26 +334,26 @@ export async function getOperations(
   next: number;
   operations: OperationInfo[];
 }> {
-  const { data } = await gatewayNetwork<{
+  const { data } = await network<{
     next: number;
     operations: OperationInfo[];
   }>({
     method: "GET",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/operations`,
-    params: options,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId.replace(/_/g, ":")}/operations`,
+    data: options,
   });
   return data;
 }
 
-type PrepareTapRequest = {
+type PrepareTapRequestRequest = {
   partyId: string;
   amount?: number;
 };
 
-type PrepareTapResponse = {
-  serialized: string;
+type PrepareTapRequestResponse = {
+  serialized: "string";
   json: null;
-  hash: string;
+  hash: "string";
 };
 
 enum TransactionType {
@@ -418,20 +361,13 @@ enum TransactionType {
   TRANSFER_PRE_APPROVAL_PROPOSAL = "transfer-pre-approval-proposal",
 }
 
-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 }>({
+export async function prepareTapRequest({
+  partyId,
+  amount = 1000000,
+}: PrepareTapRequestRequest): Promise<PrepareTapRequestResponse> {
+  const { data } = await network<PrepareTapRequestResponse>({
     method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
     data: {
       amount: parseInt(amount.toString(), 10), // Convert to integer to avoid scientific notation
       type: TransactionType.TAP_REQUEST,
@@ -451,73 +387,58 @@ type SubmitTapRequestResponse = {
   update_id: string;
 };
 
-export async function submitTapRequest(
-  currency: CryptoCurrency,
-  { partyId, serialized, signature }: SubmitTapRequestRequest,
-): Promise<SubmitTapRequestResponse> {
-  const { data } = await gatewayNetwork<
-    SubmitTapRequestResponse,
-    Omit<SubmitTapRequestRequest, "partyId">
-  >({
+export async function submitTapRequest({
+  partyId,
+  serialized,
+  signature,
+}: SubmitTapRequestRequest): Promise<SubmitTapRequestResponse> {
+  const { data } = await network<SubmitTapRequestResponse>({
     method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
     data: {
       serialized,
       signature,
-    },
+    } satisfies Omit<SubmitTapRequestRequest, "partyId">,
   });
   return data;
 }
 
-export async function prepareTransferRequest(
-  currency: CryptoCurrency,
-  partyId: string,
-  params: PrepareTransferRequest,
-): Promise<PrepareTransferResponse> {
-  const { data } = await gatewayNetwork<PrepareTransferResponse, PrepareTransferRequest>({
-    method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
-    data: params,
-  });
-  return data;
-}
-
-export async function getLedgerEnd(currency: CryptoCurrency): Promise<number> {
-  const { data } = await gatewayNetwork<number>({
+export async function getLedgerEnd(): Promise<number> {
+  const { data } = await network<number>({
     method: "GET",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/ledger-end`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/ledger-end`,
   });
   return data;
 }
 
 export async function preparePreApprovalTransaction(
-  currency: CryptoCurrency,
   partyId: string,
 ): Promise<PrepareTransactionResponse> {
-  const { data } = await gatewayNetwork<PrepareTransactionResponse, PrepareTransactionRequest>({
+  const { data } = await network<PrepareTransactionResponse>({
     method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/prepare`,
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/prepare`,
     data: {
       type: TransactionType.TRANSFER_PRE_APPROVAL_PROPOSAL,
       receiver: partyId,
-    },
+    } satisfies PrepareTransactionRequest,
   });
   return data;
 }
 
 export async function submitPreApprovalTransaction(
-  currency: CryptoCurrency,
   partyId: string,
-  { serialized }: PrepareTransactionResponse,
+  preparedTransaction: PrepareTransactionResponse,
   signature: string,
 ): Promise<PreApprovalResult> {
-  const { data } = await gatewayNetwork<SubmitTransactionResponse, SubmitTransactionRequest>({
+  const submitRequest: SubmitTransactionRequest = {
+    serialized: preparedTransaction.serialized,
+    signature,
+  };
+
+  const { data } = await network<SubmitTransactionResponse>({
     method: "POST",
-    url: `${getGatewayUrl(currency)}/v1/node/${getNodeId(currency)}/party/${partyId}/transaction/submit`,
-    data: {
-      serialized,
-      signature,
-    },
+    url: `${getGatewayUrl()}/v1/node/${getNodeId()}/party/${partyId}/transaction/submit`,
+    data: submitRequest,
   });
 
   return {

package/src/network/node.ts

@@ -3,7 +3,7 @@ import network from "@ledgerhq/live-network";
 import type { LiveNetworkRequest } from "@ledgerhq/live-network/network";
 import { getEnv } from "@ledgerhq/live-env";
 import coinConfig from "../config";
-import { AccountInfoResponse, SubmitResponse } from "./types";
+import { AccountInfoResponse, SubmitReponse } from "./types";
 import crypto from "crypto";
 
 const getNodeUrl = () => coinConfig.getCoinConfig().nodeUrl || "";
@@ -86,10 +86,10 @@ export const getLedgerEnd = async (): Promise<number> => {
   return data.offset;
 };
 
-export const submit = async (signedTx: string): Promise<SubmitResponse> => {
+export const submit = async (signedTx: string): Promise<SubmitReponse> => {
   // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
   const url = `${getEnv("NODE_BOILERPLATE")}/submit`;
-  const { data } = await network<SubmitResponse>({
+  const { data } = await network<SubmitReponse>({
     url,
     method: "GET",
   });

package/src/network/types.ts

@@ -40,7 +40,7 @@ export type AccountInfoResponse = {
   validated: boolean;
 } & ResponseStatus;
 
-export type SubmitResponse = {
+export type SubmitReponse = {
   accepted: boolean;
   tx_hash: string;
 };

package/src/signer/getAddress.ts

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

package/src/types/bridge.ts

@@ -1,8 +1,6 @@
 import type { BigNumber } from "bignumber.js";
 import type { Observable } from "rxjs";
 import type {
-  Account,
-  AccountRaw,
   CurrencyBridge,
   TransactionCommon,
   TransactionCommonRaw,
@@ -15,16 +13,13 @@ import type {
   CantonPreApprovalProgress,
   CantonPreApprovalResult,
 } from "./onboard";
-import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 
 export interface CantonCurrencyBridge extends CurrencyBridge {
   onboardAccount: (
-    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
   ) => Observable<CantonOnboardProgress | CantonOnboardResult>;
   authorizePreapproval: (
-    currency: CryptoCurrency,
     deviceId: string,
     derivationPath: string,
     partyId: string,
@@ -46,28 +41,12 @@ export type NetworkInfoRaw = {
 export type Transaction = TransactionCommon & {
   family: "canton";
   fee: BigNumber | null | undefined;
-  memo?: string;
 };
 
 export type TransactionRaw = TransactionCommonRaw & {
   family: "canton";
   fee: string | null | undefined;
-  memo?: string;
 };
 
 export type TransactionStatus = TransactionStatusCommon;
 export type TransactionStatusRaw = TransactionStatusCommonRaw;
-
-export type CantonResources = {
-  partyId: string;
-};
-export type CantonResourcesRaw = {
-  partyId: string;
-};
-
-export type CantonAccount = Account & {
-  cantonResources?: CantonResources;
-};
-export type CantonAccountRaw = AccountRaw & {
-  cantonResources: CantonResourcesRaw;
-};

package/src/types/index.ts

@@ -1,3 +1,14 @@
 export * from "./bridge";
 export * from "./onboard";
 export * from "./signer";
+
+export type BoilerplateNativeTransaction = {
+  TransactionType: "Payment";
+  Account: string;
+  Amount: string;
+  Destination: string;
+  Fee: string;
+  Sequence: number;
+  SigningPubKey?: string;
+  TxnSignature?: string;
+};

package/src/types/onboard.ts

@@ -1,5 +1,3 @@
-import { Account } from "@ledgerhq/types-live";
-
 export enum OnboardStatus {
   INIT,
   PREPARE,
@@ -24,7 +22,6 @@ export type CantonOnboardProgress = {
 
 export type CantonOnboardResult = {
   partyId: string;
-  account: Partial<Account>;
 };
 
 export type CantonPreApprovalProgress = {

package/src/types/signer.ts

@@ -1,12 +1,11 @@
 export type CantonAddress = {
   publicKey: string;
   address: string;
-  path: string; // TODO: check if necessary
 };
 
 export type CantonSignature = string; // `0x${string}`
 
 export interface CantonSigner {
-  getAddress(path: string, display?: boolean): Promise<CantonAddress>;
+  getAddress(path: string): Promise<CantonAddress>;
   signTransaction(path: string, rawTx: string): Promise<CantonSignature>;
 }

package/lib/bridge/serialization.d.ts

@@ -1,4 +0,0 @@
-import type { Account, AccountRaw } from "@ledgerhq/types-live";
-export declare function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void;
-export declare function assignFromAccountRaw(accountRaw: AccountRaw, account: Account): void;
-//# sourceMappingURL=serialization.d.ts.map

package/lib/bridge/serialization.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../src/bridge/serialization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAqBhE,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI,CAMjF;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAMnF"}