@ledgerhq/live-common 24.0.0 → 24.1.0

package/src/api/Ethereum.ts

@@ -72,26 +72,38 @@ export type Tx = {
     time: string;
   };
 };
+
 export type ERC20BalancesInput = Array<{
   address: string;
   contract: string;
 }>;
+
 export type ERC20BalanceOutput = Array<{
   address: string;
   contract: string;
   balance: BigNumber;
 }>;
+
 export type NFTMetadataInput = Readonly<
   Array<{
     contract: string;
     tokenId: string;
   }>
 >;
+
 export type NFTCollectionMetadataInput = Readonly<
   Array<{
     contract: string;
   }>
 >;
+
+export type BlockByHashOutput = {
+  hash: string;
+  height: number;
+  time: string;
+  txs: string[];
+};
+
 export type API = {
   getTransactions: (
     address: string,
@@ -133,6 +145,7 @@ export type API = {
     medium: BigNumber;
     high: BigNumber;
   }>;
+  getBlockByHash: (blockHash: string) => Promise<BlockByHashOutput | undefined>;
 };
 export const apiForCurrency = (currency: CryptoCurrency): API => {
   const baseURL = blockchainBaseURL(currency);
@@ -328,5 +341,23 @@ export const apiForCurrency = (currency: CryptoCurrency): API => {
         maxAge: 30 * 1000,
       }
     ),
+
+    async getBlockByHash(blockHash) {
+      if (!blockHash) {
+        return undefined;
+      }
+
+      try {
+        const { data }: { data: BlockByHashOutput[] } = await network({
+          method: "GET",
+          url: `${baseURL}/blocks/${blockHash}`,
+          transformResponse: JSONBigNumber.parse,
+        });
+
+        return data[0];
+      } catch (e) {
+        return undefined;
+      }
+    },
   };
 };

package/src/bridge/jsHelpers.ts

@@ -172,9 +172,11 @@ export const makeSync =
   ({
     getAccountShape,
     postSync = (_, a) => a,
+    shouldMergeOps = true,
   }: {
     getAccountShape: GetAccountShape;
     postSync?: (initial: Account, synced: Account) => Account;
+    shouldMergeOps?: boolean;
   }): AccountBridge<any>["sync"] =>
   (initial, syncConfig): Observable<AccountUpdater> =>
     Observable.create((o) => {
@@ -205,10 +207,14 @@ export const makeSync =
             },
             syncConfig
           );
+
           o.next((acc) => {
             const a = needClear ? clearAccount(acc) : acc;
             // FIXME reconsider doing mergeOps here. work is redundant for impl like eth
-            const operations = mergeOps(a.operations, shape.operations || []);
+            const operations = shouldMergeOps
+              ? mergeOps(a.operations, shape.operations || [])
+              : shape.operations || [];
+
             return recalculateAccountBalanceHistories(
               postSync(a, {
                 ...a,

package/src/families/bitcoin/js-synchronisation.ts

@@ -1,26 +1,14 @@
-import { $Shape } from "utility-types";
-import type {
-  TX,
-  Currency,
-  Input as WalletInput,
-  Output as WalletOutput,
-} from "./wallet-btc";
+import type { Currency, Output as WalletOutput } from "./wallet-btc";
 import { DerivationModes as WalletDerivationModes } from "./wallet-btc";
 import { BigNumber } from "bignumber.js";
 import Btc from "@ledgerhq/hw-app-btc";
 import { log } from "@ledgerhq/logs";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import type {
-  Account,
-  Operation,
-  OperationType,
-  DerivationMode,
-} from "../../types";
+import type { Account, Operation, DerivationMode } from "../../types";
 import type { GetAccountShape } from "../../bridge/jsHelpers";
 import { makeSync, makeScanAccounts, mergeOps } from "../../bridge/jsHelpers";
 import { findCurrencyExplorer } from "../../api/Ledger";
 import { encodeAccountId } from "../../account";
-import { encodeOperationId } from "../../operation";
 import {
   isSegwitDerivationMode,
   isNativeSegwitDerivationMode,
@@ -30,6 +18,7 @@ import { BitcoinOutput } from "./types";
 import { perCoinLogic } from "./logic";
 import wallet from "./wallet-btc";
 import { getAddressWithBtcInstance } from "./hw-getAddress";
+import { mapTxToOperations } from "./logic";
 
 // Map LL's DerivationMode to wallet-btc's
 const toWalletDerivationMode = (
@@ -89,164 +78,6 @@ const deduplicateOperations = (
   return out;
 };
 
-const mapTxToOperations = (
-  tx: TX,
-  currencyId: string,
-  accountId: string,
-  accountAddresses: Set<string>,
-  changeAddresses: Set<string>
-): $Shape<Operation[]> => {
-  const operations: Operation[] = [];
-  const txId = tx.id;
-  const fee = new BigNumber(tx.fees);
-  const blockHeight = tx.block?.height;
-  const blockHash = tx.block?.hash;
-  const date = new Date(tx.block?.time || tx.received_at);
-  const senders = new Set<string>();
-  const recipients: string[] = [];
-  let type: OperationType = "OUT";
-  let value = new BigNumber(0);
-  const hasFailed = false;
-  const accountInputs: WalletInput[] = [];
-  const accountOutputs: WalletOutput[] = [];
-  const syncReplaceAddress = perCoinLogic[currencyId]?.syncReplaceAddress;
-
-  for (const input of tx.inputs) {
-    if (input.address) {
-      senders.add(
-        syncReplaceAddress ? syncReplaceAddress(input.address) : input.address
-      );
-
-      if (input.value) {
-        if (accountAddresses.has(input.address)) {
-          // This address is part of the account
-          value = value.plus(input.value);
-          accountInputs.push(input);
-        }
-      }
-    }
-  }
-
-  // All inputs of a same transaction have the same sequence
-  const transactionSequenceNumber =
-    (accountInputs.length > 0 && accountInputs[0].sequence) || undefined;
-
-  const hasSpentNothing = value.eq(0);
-  // Change output is always the last one
-  const changeOutputIndex = tx.outputs
-    .map((o) => o.output_index)
-    .reduce((p, c) => (p > c ? p : c));
-
-  for (const output of tx.outputs) {
-    if (output.address) {
-      if (!accountAddresses.has(output.address)) {
-        // The output doesn't belong to this account
-        if (
-          accountInputs.length > 0 && // It's a SEND operation
-          (tx.outputs.length === 1 || // The transaction has only 1 output
-            output.output_index < changeOutputIndex) // The output isn't the change output
-        ) {
-          recipients.push(
-            syncReplaceAddress
-              ? syncReplaceAddress(output.address)
-              : output.address
-          );
-        }
-      } else {
-        // The output belongs to this account
-        accountOutputs.push(output);
-
-        if (!changeAddresses.has(output.address)) {
-          // The output isn't a change output of this account
-          recipients.push(
-            syncReplaceAddress
-              ? syncReplaceAddress(output.address)
-              : output.address
-          );
-        } else {
-          // The output is a change output of this account,
-          // we count it as a recipient only in some special cases
-          if (
-            (recipients.length === 0 &&
-              output.output_index >= changeOutputIndex) ||
-            hasSpentNothing
-          ) {
-            recipients.push(
-              syncReplaceAddress
-                ? syncReplaceAddress(output.address)
-                : output.address
-            );
-          }
-        }
-      }
-    }
-  }
-
-  if (accountInputs.length > 0) {
-    // It's a SEND operation
-    for (const output of accountOutputs) {
-      if (changeAddresses.has(output.address)) {
-        value = value.minus(output.value);
-      }
-    }
-
-    type = "OUT";
-    operations.push({
-      id: encodeOperationId(accountId, txId, type),
-      hash: txId,
-      type,
-      value,
-      fee,
-      senders: Array.from(senders),
-      recipients,
-      blockHeight,
-      blockHash,
-      transactionSequenceNumber,
-      accountId,
-      date,
-      hasFailed,
-      extra: {},
-    });
-  }
-
-  if (accountOutputs.length > 0) {
-    // It's a RECEIVE operation
-    const filterChangeAddresses = !!accountInputs.length;
-    let accountOutputCount = 0;
-    let finalAmount = new BigNumber(0);
-
-    for (const output of accountOutputs) {
-      if (!filterChangeAddresses || !changeAddresses.has(output.address)) {
-        finalAmount = finalAmount.plus(output.value);
-        accountOutputCount += 1;
-      }
-    }
-
-    if (accountOutputCount > 0) {
-      value = finalAmount;
-      type = "IN";
-      operations.push({
-        id: encodeOperationId(accountId, txId, type),
-        hash: txId,
-        type,
-        value,
-        fee,
-        senders: Array.from(senders),
-        recipients,
-        blockHeight,
-        blockHash,
-        transactionSequenceNumber,
-        accountId,
-        date,
-        hasFailed,
-        extra: {},
-      });
-    }
-  }
-
-  return operations;
-};
-
 const getAccountShape: GetAccountShape = async (info) => {
   const {
     transport,

package/src/families/bitcoin/logic.ts

@@ -9,6 +9,15 @@ import type {
   NetworkInfo,
   UtxoStrategy,
 } from "./types";
+import { $Shape } from "utility-types";
+import type {
+  TX,
+  Input as WalletInput,
+  Output as WalletOutput,
+} from "./wallet-btc";
+import { BigNumber } from "bignumber.js";
+import { encodeOperationId } from "../../operation";
+import type { Operation, OperationType } from "../../types";
 
 // correspond ~ to min relay fees but determined empirically for a tx to be accepted by network
 const minFees = {
@@ -176,3 +185,163 @@ export const perCoinLogic: Record<
     }),
   },
 };
+
+export const mapTxToOperations = (
+  tx: TX,
+  currencyId: string,
+  accountId: string,
+  accountAddresses: Set<string>,
+  changeAddresses: Set<string>
+): $Shape<Operation[]> => {
+  const operations: Operation[] = [];
+  const txId = tx.id;
+  const fee = new BigNumber(tx.fees);
+  const blockHeight = tx.block?.height;
+  const blockHash = tx.block?.hash;
+  const date = new Date(tx.block?.time || tx.received_at);
+  const senders = new Set<string>();
+  const recipients: string[] = [];
+  let type: OperationType = "OUT";
+  let value = new BigNumber(0);
+  const hasFailed = false;
+  const accountInputs: WalletInput[] = [];
+  const accountOutputs: WalletOutput[] = [];
+  const syncReplaceAddress = perCoinLogic[currencyId]?.syncReplaceAddress;
+
+  for (const input of tx.inputs) {
+    if (input.address) {
+      senders.add(
+        syncReplaceAddress ? syncReplaceAddress(input.address) : input.address
+      );
+
+      if (input.value) {
+        if (accountAddresses.has(input.address)) {
+          // This address is part of the account
+          value = value.plus(input.value);
+          accountInputs.push(input);
+        }
+      }
+    }
+  }
+
+  // All inputs of a same transaction have the same sequence
+  const transactionSequenceNumber =
+    (accountInputs.length > 0 && accountInputs[0].sequence) || undefined;
+
+  const hasSpentNothing = value.eq(0);
+
+  // Change output is always the last one
+  const changeOutputIndex =
+    tx.outputs.length === 0
+      ? 0
+      : tx.outputs.map((o) => o.output_index).reduce((p, c) => (p > c ? p : c));
+
+  for (const output of tx.outputs) {
+    if (output.address) {
+      if (!accountAddresses.has(output.address)) {
+        // The output doesn't belong to this account
+        if (
+          accountInputs.length > 0 && // It's a SEND operation
+          (tx.outputs.length === 1 || // The transaction has only 1 output
+            output.output_index < changeOutputIndex) // The output isn't the change output
+        ) {
+          recipients.push(
+            syncReplaceAddress
+              ? syncReplaceAddress(output.address)
+              : output.address
+          );
+        }
+      } else {
+        // The output belongs to this account
+        accountOutputs.push(output);
+
+        if (!changeAddresses.has(output.address)) {
+          // The output isn't a change output of this account
+          recipients.push(
+            syncReplaceAddress
+              ? syncReplaceAddress(output.address)
+              : output.address
+          );
+        } else {
+          // The output is a change output of this account,
+          // we count it as a recipient only in some special cases
+          if (
+            (recipients.length === 0 &&
+              output.output_index >= changeOutputIndex) ||
+            hasSpentNothing
+          ) {
+            recipients.push(
+              syncReplaceAddress
+                ? syncReplaceAddress(output.address)
+                : output.address
+            );
+          }
+        }
+      }
+    }
+  }
+
+  if (accountInputs.length > 0) {
+    // It's a SEND operation
+    for (const output of accountOutputs) {
+      if (changeAddresses.has(output.address)) {
+        value = value.minus(output.value);
+      }
+    }
+
+    type = "OUT";
+    operations.push({
+      id: encodeOperationId(accountId, txId, type),
+      hash: txId,
+      type,
+      value,
+      fee,
+      senders: Array.from(senders),
+      recipients,
+      blockHeight,
+      blockHash,
+      transactionSequenceNumber,
+      accountId,
+      date,
+      hasFailed,
+      extra: {},
+    });
+  }
+
+  if (accountOutputs.length > 0) {
+    // It's a RECEIVE operation
+    const filterChangeAddresses = !!accountInputs.length;
+    let accountOutputCount = 0;
+    let finalAmount = new BigNumber(0);
+
+    for (const output of accountOutputs) {
+      if (!filterChangeAddresses || !changeAddresses.has(output.address)) {
+        finalAmount = finalAmount.plus(output.value);
+        accountOutputCount += 1;
+      }
+    }
+
+    if (accountOutputCount > 0) {
+      value = finalAmount;
+      type = "IN";
+      operations.push({
+        id: encodeOperationId(accountId, txId, type),
+        hash: txId,
+        type,
+        value,
+        fee,
+        senders: Array.from(senders),
+        recipients,
+        blockHeight,
+        blockHash,
+        transactionSequenceNumber,
+        accountId,
+        date,
+        hasFailed,
+        extra: {},
+      });
+    }
+  }
+
+  return operations;
+};

package/src/families/bitcoin/xpub.txs.txNoOutput.unit.test.ts

@@ -0,0 +1,37 @@
+import { mapTxToOperations } from "./logic";
+
+describe("testing transaction without output", () => {
+  it("Parse zcash transaction without output", async () => {
+    const tx = {
+      id: "0b9f98d07eb418fa20573112d3cba6b871d429a06c724a7888ff0886be5213d1",
+      inputs: [
+        {
+          output_hash:
+            "2772f3963856f3eb38cb706ec8c2b62fcdeb2ce10f32cf7160afb3873be6f60d",
+          output_index: 0,
+          value: "5000000000",
+          address: "2NCDBM9DAuMrD1T8XDHMxvbTmLutP7at4AB",
+          sequence: 4294967294,
+        },
+      ],
+      outputs: [],
+      block: {
+        hash: "305d4b8d4a6d6ecca0a3dd0216f8ecd090978ed346d1845883c8aa4529d72fc8",
+        height: 120,
+        time: "2021-07-28T13:34:38Z",
+      },
+      account: 0,
+      index: 0,
+      address: "mwXTtHo8Yy3aNKUUZLkBDrTcKT9qG9TqLb",
+      received_at: "2021-07-28T13:34:38Z",
+    };
+    const out = mapTxToOperations(
+      tx,
+      "zcash",
+      "zcash 1",
+      new Set<string>(),
+      new Set<string>()
+    );
+    expect(out.length).toEqual(0);
+  }, 30000);
+});

package/src/families/cosmos/api/Cosmos.ts

@@ -128,6 +128,10 @@ const getDelegations = async (
     url: `${defaultEndpoint}/cosmos/staking/v1beta1/delegations/${address}`,
   });
 
+  data1.delegation_responses = data1.delegation_responses.filter(
+    (d) => d.balance.amount !== "0"
+  );
+
   let status = "unbonded";
   const statusMap = {
     BOND_STATUS_UNBONDED: "unbonded",

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

@@ -49,6 +49,9 @@ describe("cosmos/react", () => {
       );
       const delegations = account.cosmosResources?.delegations;
       invariant(delegations, "cosmos: delegations is required");
+      expect(
+        account.cosmosResources?.delegations?.some((d) => d.amount[0] === 0)
+      ).toBe(false);
       expect(Array.isArray(result.current)).toBe(true);
       expect(result.current.length).toBe(
         (delegations as CosmosDelegation[]).length

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

@@ -47,7 +47,11 @@ const broadcast = async ({
 };
 
 const scanAccounts = makeScanAccounts({ getAccountShape });
-const sync = makeSync({ getAccountShape, postSync: postSyncPatch });
+const sync = makeSync({
+  getAccountShape,
+  postSync: postSyncPatch,
+  shouldMergeOps: false,
+});
 
 const createTransaction = (): Transaction => ({
   family: "ethereum",

package/src/families/ethereum/datasets/ethereum2.ts

@@ -0,0 +1,20 @@
+import { AccountRaw } from "../../../types";
+
+export const ethereum2: AccountRaw = {
+  id: "js:2:ethereum:0x789d2f10826BF8f3a56Ec524359bBA4e738Af5bF:",
+  seedIdentifier: "0x789d2f10826BF8f3a56Ec524359bBA4e738Af5bF",
+  name: "Ethereum legacy xpub6Bem...JyAdpYZy",
+  derivationMode: "",
+  index: 0,
+  freshAddress: "0x789d2f10826BF8f3a56Ec524359bBA4e738Af5bF",
+  freshAddressPath: "44'/60'/0'/0/0",
+  freshAddresses: [],
+  pendingOperations: [],
+  operations: [],
+  currencyId: "ethereum",
+  unitMagnitude: 18,
+  balance: "",
+  blockHeight: 0,
+  lastSyncDate: "",
+  xpub: "",
+};

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

@@ -2,10 +2,16 @@ import "../../__tests__/test-helpers/setup";
 import { reduce } from "rxjs/operators";
 import { fromAccountRaw } from "../../account";
 import { getAccountCurrency } from "../../account/helpers";
-import type { Account, SubAccount } from "../../types";
+import type { Account, OperationRaw, SubAccount } from "../../types";
 import { getAccountBridge } from "../../bridge";
 import { makeBridgeCacheSystem } from "../../bridge/cache";
 import { ethereum1 } from "./datasets/ethereum1";
+import { ethereum2 } from "./datasets/ethereum2";
+import { encodeOperationId } from "../../operation";
+import {
+  getCryptoCurrencyById,
+  listTokensForCryptoCurrency,
+} from "@ledgerhq/cryptoassets";
 
 describe("blacklistedTokenIds functionality", () => {
   const account = fromAccountRaw(ethereum1);
@@ -83,3 +89,59 @@ describe("blacklistedTokenIds functionality", () => {
     ).toBeTruthy();
   });
 });
+
+describe("sync on reorg", () => {
+  test("should sync from scratch if stableoperations latest blockhash is not on chain", async () => {
+    const opHash = "NotImportant";
+    const accountId = ethereum2.id;
+    const opType = "OUT";
+    const opId = encodeOperationId(accountId, opHash, opType);
+    const blockHeight = 10042069;
+    const currency = getCryptoCurrencyById(ethereum2.currencyId);
+    const syncHash =
+      JSON.stringify([]) +
+      "_" +
+      listTokensForCryptoCurrency(currency, {
+        withDelisted: true,
+      }).length;
+
+    const operation: OperationRaw = {
+      id: opId,
+      hash: opHash,
+      type: opType,
+      value: "1",
+      fee: "string",
+      senders: ["0x789d2f10826BF8f3a56Ec524359bBA4e738Af5bF"],
+      recipients: ["0xdA9EDcC3CF66bc18050dB55D376407Cf85e0617B"],
+      blockHeight: blockHeight - 81, // 80 is defined today as the threshold number of confirmation to be safe for a reorg. @see SAFE_REORG_THRESHOLD
+      blockHash:
+        "0x00000000000000000000000000000000000Th1sH4shSh0u1dN0t3x1sTOnCh4iN",
+      transactionSequenceNumber: 1,
+      date: "May-11-2020 01:50:10 UTC",
+      extra: {},
+      accountId,
+    };
+
+    const account = fromAccountRaw({
+      ...ethereum2,
+      blockHeight,
+      syncHash,
+      operations: [operation],
+      operationsCount: 1,
+    });
+    const bridge = getAccountBridge(account);
+    const syncPromise = await bridge
+      .sync(account, {
+        paginationConfig: {},
+        blacklistedTokenIds: [],
+      })
+      .pipe(reduce((a, f: (arg0: Account) => Account) => f(a), account))
+      .toPromise();
+    // expect not to throw ok if you reach this point
+    // + expect operations to be from full sync instead of incremental
+    // so the fake op should be removed
+    expect(syncPromise.operations.map((o) => o.id)).not.toContain(opId);
+    // To this date (June 20th 2022) this account has 160 ops, we should at least get them all
+    expect(syncPromise.operations.length >= 160).toBe(true);
+  });
+});