@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

package/src/families/ethereum/modules/send.ts

@@ -402,7 +402,6 @@ const send: ModeModule = {
       }
     }
   },
-
   fillTransactionData(a, t, tx) {
     const subAccount = inferTokenAccount(a, t);
 
@@ -479,7 +478,6 @@ const send: ModeModule = {
           },
     );
   },
-
   fillOptimisticOperation(a, t, op) {
     const subAccount = inferTokenAccount(a, t);
 
@@ -506,7 +504,6 @@ const send: ModeModule = {
       ];
     }
   },
-
   // This is resolution config is necessary for plugins like Lido and stuff cause they use the send mode
   getResolutionConfig: () => ({
     erc20: true,

package/src/families/ethereum/nftResolvers.ts

@@ -3,8 +3,9 @@ import {
   NFTCollectionMetadataResponse,
   NFTMetadataResponse,
 } from "@ledgerhq/types-live";
+import { metadataCallBatcher } from "@ledgerhq/coin-framework/nft/support";
 import { getCryptoCurrencyById } from "../../currencies";
-import { metadataCallBatcher } from "../../nft";
+import { apiForCurrency } from "./api";
 
 const SUPPORTED_CHAIN_IDS = new Set([
   1, // Ethereum
@@ -38,10 +39,11 @@ export const nftMetadata: NftResolvers["nftMetadata"] = async ({
     throw new Error("Ethereum Bridge NFT Resolver: Unsupported chainId");
   }
 
-  const response = (await metadataCallBatcher(currency).loadNft({
+  const api = apiForCurrency(currency);
+  const response = await metadataCallBatcher(currency, api).loadNft({
     contract,
     tokenId,
-  })) as NFTMetadataResponse;
+  });
 
   return response;
 };
@@ -69,9 +71,10 @@ export const collectionMetadata: NftResolvers["collectionMetadata"] = async ({
     throw new Error("Ethereum Bridge NFT Resolver: Unsupported chainId");
   }
 
-  const response = (await metadataCallBatcher(currency).loadCollection({
+  const api = apiForCurrency(currency);
+  const response = await metadataCallBatcher(currency, api).loadCollection({
     contract,
-  })) as NFTCollectionMetadataResponse;
+  });
 
   return response;
 };

package/src/families/ethereum/postSyncPatch.ts

@@ -19,7 +19,7 @@ const postSyncPatchGen = <T extends AccountLike>(
     op =>
       (!parentPendingOperation || // a child pending parent need to disappear if parent eth op disappear
         parentPendingOperation.some(o => o.hash === op.hash)) &&
-      op.transactionSequenceNumber &&
+      op.transactionSequenceNumber !== undefined &&
       op.transactionSequenceNumber > latestNonce && // retain logic
       (shouldRetainPendingOperation(mainAccount, op) || // after retain logic, we need operation to appear
         !operations.some(o => o.hash === op.hash)),
@@ -29,7 +29,7 @@ const postSyncPatchGen = <T extends AccountLike>(
 
 const postSyncPatch = (initial: Account, synced: Account): Account => {
   const last = synced.operations.find(op => ["OUT", "FEES"].includes(op.type));
-  const latestNonce = last?.transactionSequenceNumber || 0;
+  const latestNonce = last?.transactionSequenceNumber || -1;
   const acc = postSyncPatchGen(initial, synced, latestNonce, synced);
   const { subAccounts, pendingOperations } = acc;
   const initialSubAccounts = initial.subAccounts;

package/src/families/ethereum/signOperation.ts

@@ -154,6 +154,9 @@ export const signOperation = ({
                 transaction.amount = new BigNumber(value);
               }
               const accountId = account.id;
+              const editingOp = account.pendingOperations.find(
+                op => op.transactionSequenceNumber === nonce,
+              );
               // currently, all mode are always at least one OUT tx on ETH parent
               const operation: Operation = {
                 id: `${accountId}-${txHash}-OUT`,
@@ -167,7 +170,7 @@ export const signOperation = ({
                 senders,
                 recipients,
                 accountId,
-                date: new Date(),
+                date: editingOp ? editingOp.date : new Date(),
                 extra: {},
                 transactionRaw: toTransactionRaw(transaction),
               };

package/src/families/ethereum/synchronisation.ts

@@ -4,6 +4,7 @@ import throttle from "lodash/throttle";
 import flatMap from "lodash/flatMap";
 import eip55 from "eip55";
 import { log } from "@ledgerhq/logs";
+import { nftsFromOperations } from "@ledgerhq/coin-framework/nft/helpers";
 import { mergeNfts, mergeOps } from "../../bridge/jsHelpers";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import {
@@ -18,7 +19,7 @@ import { encodeAccountId } from "../../account";
 import type { Operation, TokenAccount, SubAccount, Account } from "@ledgerhq/types-live";
 import { API, apiForCurrency, Block, Tx } from "./api";
 import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
-import { encodeNftId, isNFTActive, nftsFromOperations } from "../../nft";
+import { encodeNftId, isNFTActive } from "../../nft";
 import { encodeOperationId, encodeSubOperationId } from "../../operation";
 import { encodeERC1155OperationId, encodeERC721OperationId } from "../../nft/nftOperationId";
 import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
@@ -77,6 +78,11 @@ export const getAccountShape: GetAccountShape = async (infoInput, { blacklistedT
 
   // transform transactions into operations
   let newOps = flatMap(txs, txToOps({ address, id: accountId, currency }));
+
+  if (initialAccount) {
+    newOps = preserveInitialOperationsDate(newOps, initialAccount);
+  }
+
   // extracting out the sub operations by token account
   const perTokenAccountIdOperations = {};
   newOps.forEach(op => {
@@ -677,3 +683,31 @@ function reconciliateSubAccounts(
 
   return subAccounts;
 }
+
+// keep the initial dates of the operations to avoid the dates are overwrited by the ones from the blockchain
+export function preserveInitialOperationsDate(
+  newOps: Operation[],
+  initialAccount: Account,
+): Operation[] {
+  const initialOperationsDate = initialAccount.pendingOperations
+    .concat(initialAccount.operations)
+    .reduce((acc, op) => {
+      acc[op.hash] = op.date;
+      return acc;
+    }, {});
+
+  if (Object.keys(initialOperationsDate).length > 0) {
+    return newOps.map(op => {
+      const date = initialOperationsDate[op.hash];
+      if (date) {
+        return {
+          ...op,
+          date,
+          nftOperations: op.nftOperations?.map(nftOp => ({ ...nftOp, date })),
+        };
+      }
+      return op;
+    });
+  }
+  return newOps;
+}

package/src/families/ethereum/synchronisation.unit.test.ts

@@ -0,0 +1,127 @@
+import { API } from "./api";
+import { fetchAllTransactions, preserveInitialOperationsDate } from "./synchronisation";
+import { ethereum2 } from "./datasets/ethereum2";
+import { OperationRaw } from "@ledgerhq/types-live";
+import { fromAccountRaw, fromOperationRaw } from "../../account";
+import { setSupportedCurrencies } from "../../currencies";
+
+setSupportedCurrencies(["ethereum"]);
+
+describe("fetchAllTransactions", () => {
+  const apiMock = {
+    getTransactions: jest.fn(),
+  } as unknown as API;
+
+  const sampleAddress = "toto";
+
+  const sampleBlockHeight = 42;
+
+  let getTransactionsSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    getTransactionsSpy = jest.spyOn(apiMock, "getTransactions");
+  });
+
+  afterEach(() => {
+    getTransactionsSpy.mockReset();
+  });
+
+  it("should keep calling getTransactions until token is null", async () => {
+    getTransactionsSpy.mockReturnValueOnce(Promise.resolve({ txs: [], nextPageToken: "token1" }));
+    getTransactionsSpy.mockReturnValueOnce(Promise.resolve({ txs: [], nextPageToken: "token2" }));
+    getTransactionsSpy.mockReturnValueOnce(Promise.resolve({ txs: [], nextPageToken: null }));
+    await fetchAllTransactions(apiMock, sampleAddress, sampleBlockHeight);
+    expect(getTransactionsSpy).toHaveBeenCalledTimes(3);
+  });
+
+  it("should call getTransactions once if token is null", async () => {
+    getTransactionsSpy.mockReturnValueOnce(Promise.resolve({ txs: [], nextPageToken: null }));
+    await fetchAllTransactions(apiMock, sampleAddress, sampleBlockHeight);
+    expect(getTransactionsSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("should accumulate txs between calls", async () => {
+    getTransactionsSpy.mockReturnValueOnce(
+      Promise.resolve({
+        txs: [{ hash: "1" }, { hash: "2" }],
+        nextPageToken: "token1",
+      }),
+    );
+    getTransactionsSpy.mockReturnValueOnce(
+      Promise.resolve({ txs: [{ hash: "3" }], nextPageToken: null }),
+    );
+    const txs = await fetchAllTransactions(apiMock, sampleAddress, sampleBlockHeight);
+    expect(txs.length).toEqual(3);
+  });
+});
+
+describe("preserveInitialOperationsDate", () => {
+  const operation: OperationRaw = {
+    id: "1",
+    hash: "hash1",
+    type: "OUT",
+    value: "1",
+    fee: "string",
+    senders: ["0x789d2f10826BF8f3a56Ec524359bBA4e738Af5bF"],
+    recipients: ["0xdA9EDcC3CF66bc18050dB55D376407Cf85e0617B"],
+    blockHeight: 10042069,
+    blockHash: "0x00000000000000000000000000000000000Th1sH4shSh0u1dN0t3x1sTOnCh4iN",
+    transactionSequenceNumber: 1,
+    date: "May-11-2020 01:50:10 UTC",
+    extra: {},
+    accountId: ethereum2.id,
+  };
+  const operation1 = {
+    ...operation,
+    id: "1",
+    hash: "hash1",
+    date: "2023-04-01",
+  };
+  const operation2 = {
+    ...operation,
+    id: "2",
+    hash: "hash2",
+    date: "2023-04-02",
+  };
+  const operation3 = {
+    ...operation,
+    id: "3",
+    hash: "hash2",
+    date: "2023-04-01",
+  };
+  const operation4 = {
+    ...operation,
+    id: "4",
+    hash: "hash4",
+    date: "2023-04-01",
+  };
+  const newOps = [
+    fromOperationRaw(operation1, ethereum2.id),
+    fromOperationRaw(operation2, ethereum2.id),
+  ];
+  it("should update operations date in newOps with initial date in existing account", () => {
+    const account = fromAccountRaw({
+      ...ethereum2,
+      blockHeight: 10042069,
+      syncHash: "NotImportant",
+      operations: [operation3],
+      operationsCount: 1,
+    });
+    const result = preserveInitialOperationsDate(newOps, account);
+    // preserve initial date, initial date is from the "operation3" of "account". So result is updated from newOps
+    expect(result.find(op => op.hash === "hash2")?.date).toEqual(new Date("2023-04-01"));
+  });
+  it("no need to update operations date in newOps as newOps contains different operations hash than those in existing account", () => {
+    const account = fromAccountRaw({
+      ...ethereum2,
+      blockHeight: 10042069,
+      syncHash: "NotImportant",
+      operations: [operation4],
+      operationsCount: 1,
+    });
+    const result = preserveInitialOperationsDate(newOps, account);
+    // no need to update date in newOps because operation4 has a different hash. So result is same as newOps
+    expect(result[0].date).toEqual(new Date("2023-04-01")); // operation1 date
+    expect(result[1].date).toEqual(new Date("2023-04-02")); // operation2 date
+  });
+});

package/src/families/ethereum/types.ts

@@ -1,15 +1,13 @@
-import type { BigNumber } from "bignumber.js";
-import { EIP712Message } from "@ledgerhq/hw-app-eth/lib/modules/EIP712/EIP712.types";
-import type { Unit } from "@ledgerhq/types-cryptoassets";
-import type { TransactionMode, ModeModule } from "./modules";
-import type { Range, RangeRaw } from "../../range";
 import type {
   TransactionCommon,
   TransactionCommonRaw,
   TransactionStatusCommon,
   TransactionStatusCommonRaw,
 } from "@ledgerhq/types-live";
-import type { MessageData } from "../../hw/signMessage/types";
+import type { BigNumber } from "bignumber.js";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import type { TransactionMode, ModeModule } from "./modules";
+import type { Range, RangeRaw } from "../../range";
 
 export type NetworkInfo = {
   family: "ethereum";
@@ -65,15 +63,6 @@ export type TransactionRaw = TransactionCommonRaw & {
   quantities?: string[];
 };
 
-export type TypedMessageData = Omit<MessageData, "message"> & {
-  message: EIP712Message;
-  hashes: {
-    stringHash: string;
-    domainHash: string;
-    messageHash: string;
-  };
-};
-
 export type TransactionStatus = TransactionStatusCommon;
 
 export type TransactionStatusRaw = TransactionStatusCommonRaw;

package/src/families/ethereum/updateTransaction.ts

@@ -1,12 +1,13 @@
 import { AccountBridge } from "@ledgerhq/types-live";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { Transaction } from "./types";
 
 export const updateTransaction: AccountBridge<Transaction>["updateTransaction"] = (tx, patch) => {
   if ("recipient" in patch && patch.recipient !== tx.recipient) {
-    return { ...tx, ...patch, userGasLimit: null, estimatedGasLimit: null };
+    patch = { ...patch, userGasLimit: null, estimatedGasLimit: null };
   }
 
-  return { ...tx, ...patch };
+  return defaultUpdateTransaction(tx, patch);
 };
 
 export default updateTransaction;

package/src/families/evm/bridge.integration.test.ts

@@ -1,7 +1,5 @@
-import { dataset } from "@ledgerhq/coin-evm/bridge.integration.test";
+import { dataset } from "@ledgerhq/coin-evm/__tests__/integration/bridge.integration.test";
 import { testBridge } from "../../__tests__/test-helpers/bridge";
 import "../../__tests__/test-helpers/setup";
 
-import "@ledgerhq/coin-evm/bridge.integration.test";
-
 testBridge(dataset);

package/src/families/evm/setup.ts

@@ -3,9 +3,15 @@
 import { createBridges } from "@ledgerhq/coin-evm/bridge/js";
 import makeCliTools from "@ledgerhq/coin-evm/cli-transaction";
 import evmResolver from "@ledgerhq/coin-evm/hw-getAddress";
+import { prepareMessageToSign, signMessage } from "@ledgerhq/coin-evm/hw-signMessage";
 import { Transaction } from "@ledgerhq/coin-evm/types";
 import Eth from "@ledgerhq/hw-app-eth";
-import { CreateSigner, createResolver, executeWithSigner } from "../../bridge/setup";
+import {
+  CreateSigner,
+  createMessageSigner,
+  createResolver,
+  executeWithSigner,
+} from "../../bridge/setup";
 import { Resolver } from "../../hw/getAddress/types";
 import Transport from "@ledgerhq/hw-transport";
 import { Bridge } from "@ledgerhq/types-live";
@@ -16,8 +22,13 @@ const createSigner: CreateSigner<Eth> = (transport: Transport) => {
 
 const bridge: Bridge<Transaction> = createBridges(executeWithSigner(createSigner));
 
+const messageSigner = {
+  prepareMessageToSign,
+  signMessage: createMessageSigner(createSigner, signMessage),
+};
+
 const resolver: Resolver = createResolver(createSigner, evmResolver);
 
 const cliTools = makeCliTools();
 
-export { bridge, cliTools, resolver };
+export { bridge, cliTools, resolver, messageSigner };

package/src/families/filecoin/__snapshots__/bridge.integration.test.ts.snap

@@ -93,6 +93,7 @@ Array [
       "contract": undefined,
       "extra": Object {},
       "fee": "0",
+      "hasFailed": false,
       "hash": "bafy2bzaceawypi647m4rz5czma3xm7syif67bfzce5q2w2tifd5jrvqeaowok",
       "id": "js:2:filecoin:t15lauyzdivqj7m3yob3rxmzdsy7uyhfflwyheuri:gliflegacy-bafy2bzaceawypi647m4rz5czma3xm7syif67bfzce5q2w2tifd5jrvqeaowok-IN",
       "operator": undefined,
@@ -116,6 +117,7 @@ Array [
       "contract": undefined,
       "extra": Object {},
       "fee": "0",
+      "hasFailed": false,
       "hash": "bafy2bzaceaztepnzdzbul7nmkef6blk5x2luvbvangrjal25k6xi5qob36k32",
       "id": "js:2:filecoin:f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a:-bafy2bzaceaztepnzdzbul7nmkef6blk5x2luvbvangrjal25k6xi5qob36k32-IN",
       "operator": undefined,

package/src/families/filecoin/bridge/account.ts

@@ -10,6 +10,7 @@ import Fil from "@zondax/ledger-filecoin";
 import { Observable } from "rxjs";
 
 import { makeAccountBridgeReceive, makeSync } from "../../../bridge/jsHelpers";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import {
   Account,
   AccountBridge,
@@ -50,12 +51,6 @@ const createTransaction = (): Transaction => {
   };
 };
 
-const updateTransaction = (t: Transaction, patch: Transaction): Transaction => {
-  // log("debug", "[updateTransaction] patching tx");
-
-  return { ...t, ...patch };
-};
-
 const getTransactionStatus = async (a: Account, t: Transaction): Promise<TransactionStatus> => {
   // log("debug", "[getTransactionStatus] start fn");
 
@@ -147,21 +142,24 @@ const prepareTransaction = async (a: Account, t: Transaction): Promise<Transacti
   const { address } = getAddress(a);
   const { recipient, useAllAmount } = t;
 
-  if (recipient && address) {
-    if (validateAddress(recipient).isValid && validateAddress(address).isValid) {
-      const newTx = { ...t };
+  if (
+    recipient &&
+    address &&
+    validateAddress(recipient).isValid &&
+    validateAddress(address).isValid
+  ) {
+    const patch: Partial<Transaction> = {};
 
-      const result = await fetchEstimatedFees({ to: recipient, from: address });
-      newTx.gasFeeCap = new BigNumber(result.gas_fee_cap);
-      newTx.gasPremium = new BigNumber(result.gas_premium);
-      newTx.gasLimit = new BigNumber(result.gas_limit);
-      newTx.nonce = result.nonce;
+    const result = await fetchEstimatedFees({ to: recipient, from: address });
+    patch.gasFeeCap = new BigNumber(result.gas_fee_cap);
+    patch.gasPremium = new BigNumber(result.gas_premium);
+    patch.gasLimit = new BigNumber(result.gas_limit);
+    patch.nonce = result.nonce;
 
-      const fee = calculateEstimatedFees(newTx.gasFeeCap, newTx.gasLimit);
-      if (useAllAmount) newTx.amount = balance.minus(fee);
+    const fee = calculateEstimatedFees(patch.gasFeeCap, patch.gasLimit);
+    if (useAllAmount) patch.amount = balance.minus(fee);
 
-      return newTx;
-    }
+    return defaultUpdateTransaction(t, patch);
   }
 
   return t;
@@ -284,7 +282,7 @@ const signOperation: SignOperationFnSignature<Transaction> = ({
 
 export const accountBridge: AccountBridge<Transaction> = {
   createTransaction,
-  updateTransaction,
+  updateTransaction: defaultUpdateTransaction,
   prepareTransaction,
   getTransactionStatus,
   estimateMaxSpendable,

package/src/families/filecoin/bridge/utils/api.ts

@@ -2,6 +2,7 @@ import { log } from "@ledgerhq/logs";
 import { AxiosRequestConfig, AxiosResponse } from "axios";
 
 import network from "@ledgerhq/live-network/network";
+import { makeLRUCache } from "@ledgerhq/live-network/cache";
 import { getEnv } from "../../../../env";
 import {
   BalanceResponse,
@@ -62,12 +63,16 @@ export const fetchBalances = async (addr: string): Promise<BalanceResponse> => {
   return data; // TODO Validate if the response fits this interface
 };
 
-export const fetchEstimatedFees = async (
-  request: EstimatedFeesRequest,
-): Promise<EstimatedFeesResponse> => {
-  const data = await send<EstimatedFeesResponse>(`/fees/estimate`, request);
-  return data; // TODO Validate if the response fits this interface
-};
+export const fetchEstimatedFees = makeLRUCache(
+  async (request: EstimatedFeesRequest): Promise<EstimatedFeesResponse> => {
+    const data = await send<EstimatedFeesResponse>(`/fees/estimate`, request);
+    return data; // TODO Validate if the response fits this interface
+  },
+  request => `${request.from}-${request.to}`,
+  {
+    ttl: 5 * 1000, // 5 seconds
+  },
+);
 
 export const fetchBlockHeight = async (): Promise<NetworkStatusResponse> => {
   const data = await fetch<NetworkStatusResponse>("/network/status");

package/src/families/filecoin/bridge.integration.test.ts

@@ -13,7 +13,6 @@ const SEED_IDENTIFIER = "f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a";
 const ACCOUNT_1 = "f1p74d4mlmeyc4agflhjqsnvoyzyfdai7fmkyso2a";
 
 const filecoin: CurrenciesData<Transaction> = {
-  FIXME_ignoreAccountFields: [],
   scanAccounts: [
     {
       name: "filecoin seed 1",
@@ -43,7 +42,6 @@ const filecoin: CurrenciesData<Transaction> = {
   ],
   accounts: [
     {
-      FIXME_tests: ["balance is sum of ops"],
       raw: {
         id: `js:2:filecoin:${SEED_IDENTIFIER}:glif`,
         seedIdentifier: SEED_IDENTIFIER,

package/src/families/filecoin/hw-signMessage.ts

@@ -4,14 +4,15 @@ import { log } from "@ledgerhq/logs";
 import type { SignMessage, Result } from "../../hw/signMessage/types";
 import { getBufferFromString, getPath, isError } from "./utils";
 
-const signMessage: SignMessage = async (transport, { path, message }): Promise<Result> => {
+const signMessage: SignMessage = async (transport, account, { message }): Promise<Result> => {
   log("debug", "start signMessage process");
 
   const fil = new Fil(transport);
 
-  if (!message) throw new Error(`Message cannot be empty`);
+  if (typeof message !== "string") throw new Error("Invalid message type");
+  if (!message) throw new Error("Message cannot be empty");
 
-  const r = await fil.sign(getPath(path), getBufferFromString(message as string));
+  const r = await fil.sign(getPath(account.freshAddressPath), getBufferFromString(message));
   isError(r);
 
   return {

package/src/families/hedera/bridge/js.ts

@@ -6,7 +6,8 @@ import signOperation from "../js-signOperation";
 import broadcast from "../js-broadcast";
 import { scanAccounts, sync } from "../js-synchronisation";
 import receive from "../js-receive";
-import { createTransaction, updateTransaction, prepareTransaction } from "../js-transaction";
+import { createTransaction, prepareTransaction } from "../js-transaction";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 
 const currencyBridge: CurrencyBridge = {
   preload: () => Promise.resolve({}),
@@ -17,7 +18,7 @@ const currencyBridge: CurrencyBridge = {
 const accountBridge: AccountBridge<Transaction> = {
   estimateMaxSpendable,
   createTransaction,
-  updateTransaction,
+  updateTransaction: defaultUpdateTransaction,
   getTransactionStatus,
   prepareTransaction,
   sync,

package/src/families/hedera/js-transaction.ts

@@ -17,18 +17,6 @@ export function createTransaction(_account: Account): Transaction {
   };
 }
 
-/**
- * Update a base property of the transaction.
- *
- * @returns  {Transaction}
- */
-export function updateTransaction(
-  transaction: Transaction,
-  patch: Partial<Transaction>,
-): Transaction {
-  return { ...transaction, ...patch };
-}
-
 /**
  * Gather any more neccessary information for a transaction,
  * potentially from a network.

package/src/families/hedera/tests/js-transaction.test.ts

@@ -1,7 +1,8 @@
 import BigNumber from "bignumber.js";
 import type { Account } from "@ledgerhq/types-live";
 import type { Transaction } from "../../../families/hedera/types";
-import { createTransaction, updateTransaction, prepareTransaction } from "../js-transaction";
+import { defaultUpdateTransaction as updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { createTransaction, prepareTransaction } from "../js-transaction";
 
 const account: Account = {
   type: "Account",