@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/src/families/tron/react.test.ts

@@ -24,6 +24,14 @@ import {
 import superRepresentatives from "./api/superRepresentativesData.mock";
 
 jest.mock("./api", () => {
+  return {
+    getTronSuperRepresentatives: jest.fn().mockImplementation(() => {
+      return Promise.resolve(superRepresentatives);
+    }),
+  };
+});
+
+jest.mock("./utils", () => {
   return {
     extractBandwidthInfo: jest.fn().mockImplementation(() => {
       return {
@@ -33,9 +41,6 @@ jest.mock("./api", () => {
         gainedLimit: 0,
       };
     }),
-    getTronSuperRepresentatives: jest.fn().mockImplementation(() => {
-      return Promise.resolve(superRepresentatives);
-    }),
   };
 });
 

package/src/families/tron/react.ts

@@ -4,7 +4,7 @@ import { getTronSuperRepresentatives } from "./api";
 import { BigNumber } from "bignumber.js";
 import type { SuperRepresentative, TronAccount, Vote } from "./types";
 import { useBridgeSync } from "../../bridge/react";
-import { oneTrx } from "./constants";
+import { ONE_TRX } from "./constants";
 
 export type Action = {
   type: "updateVote" | "resetVotes" | "clearVotes";
@@ -26,7 +26,7 @@ export type State = {
   initialVotes: Record<string, number>; // initial Map of votes
 };
 
-export const MIN_TRANSACTION_AMOUNT = oneTrx;
+export const MIN_TRANSACTION_AMOUNT = ONE_TRX;
 export const SR_THRESHOLD = 27;
 export const SR_MAX_VOTES = 5;
 

package/src/families/tron/signOperation.ts

@@ -0,0 +1,123 @@
+import { Observable } from "rxjs";
+import BigNumber from "bignumber.js";
+import { AccountBridge, TokenAccount } from "@ledgerhq/types-live";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import signTransaction from "../../hw/signTransaction";
+import { Transaction, TronAccount } from "./types";
+import { withDevice } from "../../hw/deviceAccess";
+import { getEstimatedFees } from "./logic";
+import {
+  claimRewardTronTransaction,
+  createTronTransaction,
+  fetchTronContract,
+  freezeTronTransaction,
+  legacyUnfreezeTronTransaction,
+  unDelegateResourceTransaction,
+  unfreezeTronTransaction,
+  voteTronSuperRepresentatives,
+  withdrawExpireUnfreezeTronTransaction,
+} from "./api";
+
+export const signOperation: AccountBridge<Transaction, TronAccount>["signOperation"] = ({
+  account,
+  transaction,
+  deviceId,
+}) =>
+  withDevice(deviceId)(
+    transport =>
+      new Observable(o => {
+        async function main() {
+          const subAccount = transaction.subAccountId
+            ? account.subAccounts?.find(sa => sa.id === transaction.subAccountId)
+            : undefined;
+          const isContractAddressRecipient = !!(await fetchTronContract(transaction.recipient));
+          const fee = await getEstimatedFees(account, transaction, isContractAddressRecipient);
+          const balance = subAccount
+            ? subAccount.balance
+            : BigNumber.max(0, account.spendableBalance.minus(fee));
+
+          if (transaction.useAllAmount) {
+            transaction = { ...transaction }; // transaction object must not be mutated
+            transaction.amount = balance; // force the amount to be the max
+          }
+
+          const {
+            raw_data_hex: rawDataHex,
+            raw_data: rawData,
+            txID: hash,
+          } = await prepareTransactionForSignature(account, subAccount, transaction);
+
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          // Sign by device
+          const signature = await signTransaction(
+            account.currency,
+            transport,
+            account.freshAddressPath,
+            {
+              rawDataHex,
+              // only for trc10, we need to put the token ledger signature
+              tokenSignature:
+                subAccount &&
+                subAccount.type === "TokenAccount" &&
+                subAccount.token.id.includes("trc10")
+                  ? subAccount.token.ledgerSignature
+                  : undefined,
+            },
+          );
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          const operation = buildOptimisticOperation(account, subAccount, transaction, fee, hash);
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature,
+              rawData,
+            },
+          });
+        }
+
+        main().then(
+          () => o.complete(),
+          e => o.error(e),
+        );
+      }),
+  );
+
+const prepareTransactionForSignature = (
+  account: TronAccount,
+  subAccount: TokenAccount | undefined,
+  transaction: Transaction,
+) => {
+  switch (transaction.mode) {
+    case "freeze":
+      return freezeTronTransaction(account, transaction);
+
+    case "unfreeze":
+      return unfreezeTronTransaction(account, transaction);
+
+    case "vote":
+      return voteTronSuperRepresentatives(account, transaction);
+
+    case "claimReward":
+      return claimRewardTronTransaction(account);
+
+    case "withdrawExpireUnfreeze":
+      return withdrawExpireUnfreezeTronTransaction(account, transaction);
+
+    case "unDelegateResource":
+      return unDelegateResourceTransaction(account, transaction);
+
+    case "legacyUnfreeze":
+      return legacyUnfreezeTronTransaction(account, transaction);
+
+    default:
+      return createTronTransaction(account, transaction, subAccount);
+  }
+};

package/src/families/tron/synchronisation.integration.test.ts

@@ -4,8 +4,7 @@ import { getCryptoCurrencyById } from "../../currencies";
 import { syncAccount } from "../../__tests__/test-helpers/bridge";
 import { defaultTronResources } from "./utils";
 import bridge from "./bridge/js";
-import { Account } from "@ledgerhq/types-live";
-import { TronAccount } from "./types";
+import { Transaction, TronAccount } from "./types";
 
 jest.setTimeout(30000);
 
@@ -15,7 +14,7 @@ const defaultSyncConfig = {
   blacklistedTokenIds: [],
 };
 
-const dummyAccount: Account = {
+const dummyAccount: TronAccount = {
   type: "Account",
   id: "",
   derivationMode: "",
@@ -48,12 +47,17 @@ const dummyAccount: Account = {
       latestDate: undefined,
     },
   },
+  tronResources: {} as any,
 };
 
 describe("Tron Accounts", () => {
   test("should always have tronResources", async () => {
-    const account = await syncAccount(bridge.accountBridge, dummyAccount, defaultSyncConfig);
+    const account = await syncAccount<Transaction, TronAccount>(
+      bridge.accountBridge,
+      dummyAccount,
+      defaultSyncConfig,
+    );
 
-    expect((account as TronAccount).tronResources).toEqual(defaultTronResources);
+    expect(account.tronResources).toEqual(defaultTronResources);
   });
 });

package/src/families/tron/synchronization.ts

@@ -0,0 +1,270 @@
+import get from "lodash/get";
+import compact from "lodash/compact";
+import BigNumber from "bignumber.js";
+import {
+  emptyHistoryCache,
+  encodeAccountId,
+  encodeTokenAccountId,
+} from "@ledgerhq/coin-framework/account/index";
+import { SubAccount, TokenAccount } from "@ledgerhq/types-live";
+import { GetAccountShape, makeSync } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { findTokenByAddressInCurrency, findTokenById } from "@ledgerhq/cryptoassets/tokens";
+import { TronAccount, TronOperation, TrongridExtraTxInfo } from "./types";
+import { getOperationsPageSize } from "../../pagination";
+import { isParentTx, txInfoToOperation } from "./utils";
+import { encodeOperationId } from "../../operation";
+import {
+  fetchCurrentBlockHeight,
+  fetchTronAccount,
+  fetchTronAccountTxs,
+  getTronResources,
+} from "./api";
+
+// the balance does not update straightaway so we should ignore recent operations if they are in pending for a bit
+const PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION = 35;
+
+export const getAccountShape: GetAccountShape<TronAccount> = async (
+  { initialAccount, currency, address, derivationMode },
+  syncConfig,
+) => {
+  const blockHeight = await fetchCurrentBlockHeight();
+  const tronAcc = await fetchTronAccount(address);
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode: derivationMode,
+  });
+
+  if (tronAcc.length === 0) {
+    const defaultTronResources = await getTronResources();
+
+    return {
+      id: accountId,
+      blockHeight,
+      balance: new BigNumber(0),
+      tronResources: defaultTronResources,
+    };
+  }
+
+  const acc = tronAcc[0];
+  const spendableBalance = acc.balance ? new BigNumber(acc.balance) : new BigNumber(0);
+  const cacheTransactionInfoById = initialAccount
+    ? {
+        ...(initialAccount?.tronResources?.cacheTransactionInfoById || {}),
+      }
+    : {};
+  const operationsPageSize = Math.min(
+    1000,
+    getOperationsPageSize(initialAccount && initialAccount.id, syncConfig),
+  );
+  // FIXME: this is not optional especially that we might already have initialAccount
+  // use minimalOperationsBuilderSync to reconciliate and KEEP REF
+  const txs = await fetchTronAccountTxs(
+    address,
+    txs => txs.length < operationsPageSize,
+    cacheTransactionInfoById,
+  );
+
+  const tronResources = await getTronResources(acc, txs, cacheTransactionInfoById);
+  const balance = spendableBalance
+    .plus(tronResources.frozen.bandwidth ? tronResources.frozen.bandwidth.amount : new BigNumber(0))
+    .plus(tronResources.frozen.energy ? tronResources.frozen.energy.amount : new BigNumber(0))
+    .plus(
+      tronResources.delegatedFrozen.bandwidth
+        ? tronResources.delegatedFrozen.bandwidth.amount
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.delegatedFrozen.energy
+        ? tronResources.delegatedFrozen.energy.amount
+        : new BigNumber(0),
+    )
+
+    .plus(
+      tronResources.unFrozen.energy
+        ? tronResources.unFrozen.energy.reduce((accum, cur) => {
+            return accum.plus(cur.amount);
+          }, new BigNumber(0))
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.unFrozen.bandwidth
+        ? tronResources.unFrozen.bandwidth.reduce((accum, cur) => {
+            return accum.plus(cur.amount);
+          }, new BigNumber(0))
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.legacyFrozen.bandwidth
+        ? tronResources.legacyFrozen.bandwidth.amount
+        : new BigNumber(0),
+    )
+    .plus(
+      tronResources.legacyFrozen.energy
+        ? tronResources.legacyFrozen.energy.amount
+        : new BigNumber(0),
+    );
+
+  const parentTxs = txs.filter(isParentTx);
+  const parentOperations: TronOperation[] = compact(
+    parentTxs.map(tx => txInfoToOperation(accountId, address, tx)),
+  );
+
+  const trc10Tokens = get(acc, "assetV2", []).reduce((accumulator, { key, value }) => {
+    const tokenInfo = findTokenById(`tron/trc10/${key}`);
+    if (tokenInfo) {
+      accumulator.push({
+        key,
+        type: "trc10",
+        tokenId: tokenInfo.id,
+        balance: value,
+      });
+    }
+    return accumulator;
+  }, []);
+
+  const trc20Tokens = get(acc, "trc20", []).reduce((accumulator, trc20) => {
+    const [[contractAddress, balance]] = Object.entries(trc20);
+    const tokenInfo = findTokenByAddressInCurrency(contractAddress, currency.id);
+    if (tokenInfo) {
+      accumulator.push({
+        key: contractAddress,
+        type: "trc20",
+        tokenId: tokenInfo.id,
+        balance,
+      });
+    }
+    return accumulator;
+  }, []);
+
+  const { blacklistedTokenIds = [] } = syncConfig;
+
+  const subAccounts: SubAccount[] = compact(
+    trc10Tokens.concat(trc20Tokens).map(({ key, tokenId, balance }) => {
+      const token = findTokenById(tokenId);
+      if (!token || blacklistedTokenIds.includes(tokenId)) return;
+      const id = encodeTokenAccountId(accountId, token);
+      const tokenTxs = txs.filter(tx => tx.tokenId === key);
+      const operations = compact(tokenTxs.map(tx => txInfoToOperation(id, address, tx)));
+      const maybeExistingSubAccount = initialAccount?.subAccounts?.find(a => a.id === id);
+      const bnBalance = new BigNumber(balance);
+      const sub: TokenAccount = {
+        type: "TokenAccount",
+        id,
+        parentId: accountId,
+        token,
+        balance: bnBalance,
+        spendableBalance: bnBalance,
+        operationsCount: operations.length,
+        operations,
+        pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
+        creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+        swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
+        balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+      };
+      return sub;
+    }),
+  );
+
+  // Filter blacklisted tokens from the initial account's subAccounts
+  // Could be use to filter out tokens that got their CAL id changed
+  const filteredInitialSubAccounts = (initialAccount?.subAccounts || []).filter(
+    subAccount => !blacklistedTokenIds.includes(subAccount.token.id),
+  );
+
+  // keep old account with emptyBalance and a history not returned by the BE fixes LIVE-12797
+  const mergedSubAccounts = mergeSubAccounts(subAccounts, filteredInitialSubAccounts);
+
+  // get 'OUT' token operations with fee
+  const subOutOperationsWithFee: TronOperation[] = subAccounts
+    .flatMap(s => s.operations)
+    .filter(o => o.type === "OUT" && o.fee.isGreaterThan(0))
+    .map(
+      (o): TronOperation => ({
+        ...o,
+        accountId,
+        value: o.fee,
+        id: encodeOperationId(accountId, o.hash, "OUT"),
+        extra: o.extra as TrongridExtraTxInfo,
+      }),
+    );
+  // add them to the parent operations and sort by date desc
+
+  /**
+   * FIXME
+   *
+   * We have a problem here as we're just concatenating ops without ever really linking them.
+   * It means no operation can be "FEES" of a subOp by example. It leads to our issues with TRC10/TRC20
+   * optimistic operation never really existing in the end.
+   */
+  const parentOpsAndSubOutOpsWithFee = parentOperations
+    .concat(subOutOperationsWithFee)
+    .sort((a, b) => b.date.valueOf() - a.date.valueOf());
+
+  return {
+    id: accountId,
+    balance,
+    spendableBalance,
+    operationsCount: parentOpsAndSubOutOpsWithFee.length,
+    operations: parentOpsAndSubOutOpsWithFee,
+    subAccounts: mergedSubAccounts,
+    tronResources,
+    blockHeight,
+  };
+};
+
+export const postSync = (initial: TronAccount, parent: TronAccount): TronAccount => {
+  function evictRecentOpsIfPending(a) {
+    a.pendingOperations.forEach(pending => {
+      const i = a.operations.findIndex(o => o.id === pending.id);
+
+      if (i !== -1) {
+        const diff = parent.blockHeight - (a.operations[i].blockHeight || 0);
+
+        if (diff < PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION) {
+          a.operations.splice(i, 1);
+        }
+      }
+    });
+  }
+
+  evictRecentOpsIfPending(parent);
+  parent.subAccounts && parent.subAccounts.forEach(evictRecentOpsIfPending);
+  return parent;
+};
+
+/**
+ * Merges two arrays of subAccounts according to specific rules:
+ * - The first array (subAccounts1) is up-to-date and should not be modified.
+ * - Old duplicates from the second array (subAccounts2) should be filtered out.
+ * - Only new subAccounts with a unique ID from the second array should be included.
+ * - The balance and spendableBalance fields of the second array's subAccounts should be set to 0.
+ *
+ * @param {Array} subAccounts1 - The first array of subAccounts, which is up-to-date and should not be modified.
+ * @param {Array} subAccounts2 - The second array of subAccounts, from which only new unique subAccounts should be included.
+ * @returns {Array} - The merged array of subAccounts.
+ */
+const mergeSubAccounts = (subAccounts1, subAccounts2) => {
+  const existingIds = new Set(subAccounts1.map(subAccount => subAccount.id));
+  const filteredSubAccounts2 = subAccounts2
+    .map(subAccount => {
+      if (existingIds.has(subAccount.id)) {
+        return null;
+      } else {
+        // Set balance and spendableBalance to 0 has if they are not here it means balance is 0
+        return {
+          ...subAccount,
+          balance: new BigNumber(0),
+          spendableBalance: new BigNumber(0),
+        };
+      }
+    })
+    .filter(subAccount => subAccount !== null);
+
+  return subAccounts1.concat(filteredSubAccounts2);
+};
+
+export const sync = makeSync({ getAccountShape, postSync });

package/src/families/tron/types.ts

@@ -212,7 +212,7 @@ export type TronResources = {
   unwithdrawnReward: BigNumber;
   lastWithdrawnRewardDate: Date | null | undefined;
   lastVotedDate: Date | null | undefined;
-  cacheTransactionInfoById: Record<string, TronTransactionInfo>;
+  cacheTransactionInfoById: Record<string, TronTransactionInfo> | undefined;
 };
 export type TronResourcesRaw = {
   frozen: {
@@ -238,7 +238,7 @@ export type TronResourcesRaw = {
   unwithdrawnReward: string;
   lastWithdrawnRewardDate: string | null | undefined;
   lastVotedDate: string | null | undefined;
-  cacheTransactionInfoById?: Record<string, TronTransactionInfoRaw>;
+  cacheTransactionInfoById: Record<string, TronTransactionInfoRaw> | undefined;
 };
 export type Vote = {
   address: string;

package/src/families/tron/utils.ts

@@ -2,7 +2,6 @@ import bs58check from "bs58check";
 import { BigNumber } from "bignumber.js";
 import get from "lodash/get";
 import { log } from "@ledgerhq/logs";
-import { extractBandwidthInfo } from "./api";
 import type {
   Transaction,
   TronOperationMode,
@@ -10,6 +9,8 @@ import type {
   TrongridExtraTxInfo,
   TronResources,
   TronOperation,
+  BandwidthInfo,
+  NetworkInfo,
 } from "./types";
 import type { Account, OperationType } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
@@ -328,6 +329,28 @@ export const txInfoToOperation = (
   return undefined;
 };
 
+export const extractBandwidthInfo = (
+  networkInfo: NetworkInfo | null | undefined,
+): BandwidthInfo => {
+  // Calculate bandwidth info :
+  if (networkInfo) {
+    const { freeNetUsed, freeNetLimit, netUsed, netLimit } = networkInfo;
+    return {
+      freeUsed: freeNetUsed,
+      freeLimit: freeNetLimit,
+      gainedUsed: netUsed,
+      gainedLimit: netLimit,
+    };
+  }
+
+  return {
+    freeUsed: new BigNumber(0),
+    freeLimit: new BigNumber(0),
+    gainedUsed: new BigNumber(0),
+    gainedLimit: new BigNumber(0),
+  };
+};
+
 export const defaultTronResources: TronResources = {
   frozen: {
     bandwidth: undefined,

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

@@ -10,7 +10,6 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "freshAddressPath": "44'/818'/0'/0/0",
     "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
     "index": 0,
-    "nfts": undefined,
     "operationsCount": 1,
     "pendingOperations": [],
     "seedIdentifier": "04de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e",
@@ -20,7 +19,6 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "used": true,
   },
   {
-    "approvals": undefined,
     "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
     "operationsCount": 1,
     "parentId": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
@@ -37,7 +35,6 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "freshAddressPath": "44'/818'/0'/0/1",
     "id": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
     "index": 1,
-    "nfts": undefined,
     "operationsCount": 1,
     "pendingOperations": [],
     "seedIdentifier": "04de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e",
@@ -47,7 +44,6 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "used": true,
   },
   {
-    "approvals": undefined,
     "id": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain+vechain%2Fvip180%2Fvtho",
     "operationsCount": 0,
     "parentId": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
@@ -64,7 +60,6 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "freshAddressPath": "44'/818'/0'/0/2",
     "id": "js:2:vechain:0xFbC8653C0b842dd33361CE8938B24e407dd4838C:vechain",
     "index": 2,
-    "nfts": undefined,
     "operationsCount": 0,
     "pendingOperations": [],
     "seedIdentifier": "04de5a8f11cc426ff5617aeffd397c5dd77b58424662f368f2cd539a8c42fd2e7d0c6245c9c3a4306f70d7f292e95642651a6832d66fd9823fa6a0af575113e94e",
@@ -74,7 +69,6 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 1`] = `
     "used": false,
   },
   {
-    "approvals": undefined,
     "id": "js:2:vechain:0xFbC8653C0b842dd33361CE8938B24e407dd4838C:vechain+vechain%2Fvip180%2Fvtho",
     "operationsCount": 0,
     "parentId": "js:2:vechain:0xFbC8653C0b842dd33361CE8938B24e407dd4838C:vechain",
@@ -93,20 +87,16 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 2`] = `
       "accountId": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain",
       "blockHash": "0x00fa5b35f158cee280b6be35b4ada7669951035a79806244aaa11e5d2764d5bd",
       "blockHeight": 16407349,
-      "contract": undefined,
       "extra": {},
       "fee": "210000000000000000",
       "hash": "0xe113f82af98a24c6f2473802f8673f0d69eed1c0f51a5a87d3cc6b8cf96ccfd6",
       "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain-0xe113f82af98a24c6f2473802f8673f0d69eed1c0f51a5a87d3cc6b8cf96ccfd6-IN",
-      "operator": undefined,
       "recipients": [
         "0x0fe6688548f0c303932bb197b0a96034f1d74dba",
       ],
       "senders": [
         "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
       ],
-      "standard": undefined,
-      "tokenId": undefined,
       "type": "IN",
       "value": "10000000000000000000",
     },
@@ -116,20 +106,16 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 2`] = `
       "accountId": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho",
       "blockHash": "0x00fa5b4ee2eca5cf65907e3695bbea044cd1f78224534dc0ba02526890055ecc",
       "blockHeight": 16407374,
-      "contract": undefined,
       "extra": {},
       "fee": "365180000000000000",
       "hash": "0x5fdd7191c4d476a8e86060d516366e87421f65667b9b3c14c33a740c04921b10",
       "id": "js:2:vechain:0x0fe6688548f0C303932bB197B0A96034f1d74dba:vechain+vechain%2Fvip180%2Fvtho-0x5fdd7191c4d476a8e86060d516366e87421f65667b9b3c14c33a740c04921b10-IN",
-      "operator": undefined,
       "recipients": [
         "0x0fe6688548f0c303932bb197b0a96034f1d74dba",
       ],
       "senders": [
         "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
       ],
-      "standard": undefined,
-      "tokenId": undefined,
       "type": "IN",
       "value": "10000000000000000000",
     },
@@ -139,20 +125,16 @@ exports[`vechain currency bridge scanAccounts vechain seed 1 2`] = `
       "accountId": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain",
       "blockHash": "0x00fa5b547b0d542ba8e62a85aa99cf355f1b2a70bd34e3949f889b0856776e05",
       "blockHeight": 16407380,
-      "contract": undefined,
       "extra": {},
       "fee": "210000000000000000",
       "hash": "0xa4096186f2d58ecc68e6ea11c9757ef5bd78b21b87d73b4618eb6fd3508431ec",
       "id": "js:2:vechain:0x02961B92B8D20A4ea12f1f1CeFA74Dd7B4355A86:vechain-0xa4096186f2d58ecc68e6ea11c9757ef5bd78b21b87d73b4618eb6fd3508431ec-IN",
-      "operator": undefined,
       "recipients": [
         "0x02961b92b8d20a4ea12f1f1cefa74dd7b4355a86",
       ],
       "senders": [
         "0xcf130b42ae31c4931298b4b1c0f1d974b8732957",
       ],
-      "standard": undefined,
-      "tokenId": undefined,
       "type": "IN",
       "value": "10000000000000000000",
     },

package/src/families/vechain/api/index.ts

@@ -1,3 +1,2 @@
-import { getAccount, getOperations } from "./sdk";
+export { getAccount, getOperations } from "./sdk";
 export * from "./sdk";
-export default { getAccount, getOperations };

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

@@ -1,14 +1,14 @@
-import type { Transaction } from "../types";
-import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
-
-import { sync, scanAccounts } from "../js-synchronisation";
-import { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import { createTransaction, prepareTransaction } from "../js-transaction";
-import getTransactionStatus from "../js-getTransactionStatus";
-import signOperation from "../js-signOperation";
-import broadcast from "../js-broadcast";
-import { estimateMaxSpendable } from "./js-estimateMaxSpendable";
+import { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
 import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { makeAccountBridgeReceive } from "../../../bridge/jsHelpers";
+import { getTransactionStatus } from "../getTransactionStatus";
+import type { Transaction, TransactionStatus } from "../types";
+import { estimateMaxSpendable } from "../estimateMaxSpendable";
+import { prepareTransaction } from "../prepareTransaction";
+import { createTransaction } from "../createTransaction";
+import { sync, scanAccounts } from "../synchronisation";
+import { signOperation } from "../signOperation";
+import { broadcast } from "../broadcast";
 
 const receive: AccountBridge<Transaction>["receive"] = makeAccountBridgeReceive();
 
@@ -18,7 +18,7 @@ const currencyBridge: CurrencyBridge = {
   hydrate: (): void => {},
 };
 
-const accountBridge: AccountBridge<Transaction> = {
+const accountBridge: AccountBridge<Transaction, Account, TransactionStatus> = {
   estimateMaxSpendable,
   createTransaction,
   updateTransaction: defaultUpdateTransaction,