@ledgerhq/live-common 24.0.0 → 24.1.0-next.0

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/hw/extractOnboardingState.test.ts

@@ -0,0 +1,251 @@
+import {
+  extractOnboardingState,
+  OnboardingStep,
+} from "./extractOnboardingState";
+
+describe("@hw/extractOnboardingState", () => {
+  describe("extractOnboardingState", () => {
+    describe("When the flag bytes are incorrect", () => {
+      it("should throw an error", () => {
+        const incompleteFlagsBytes = Buffer.from([0, 0]);
+        // DeviceExtractOnboardingStateError is not of type Error,
+        // so cannot check in toThrow(DeviceExtractOnboardingStateError)
+        expect(() => extractOnboardingState(incompleteFlagsBytes)).toThrow();
+      });
+    });
+
+    describe("When the device is onboarded", () => {
+      it("should return a device state that is onboarded", () => {
+        const flagsBytes = Buffer.from([1 << 2, 0, 0, 0]);
+
+        const onboardingState = extractOnboardingState(flagsBytes);
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.isOnboarded).toBe(true);
+      });
+    });
+
+    describe("When the device is in recovery mode", () => {
+      it("should return a device state that is in recovery mode", () => {
+        const flagsBytes = Buffer.from([1, 0, 0, 0]);
+
+        const onboardingState = extractOnboardingState(flagsBytes);
+
+        expect(onboardingState).not.toBeNull();
+        expect(onboardingState?.isInRecoveryMode).toBe(true);
+      });
+    });
+
+    describe("When the device is not onboarded and in normal mode", () => {
+      let flagsBytes: Buffer;
+
+      beforeEach(() => {
+        flagsBytes = Buffer.from([0, 0, 0, 0]);
+      });
+
+      describe("and the user is on the welcome screen", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 0;
+        });
+
+        it("should return an onboarding step that is set at the welcome screen", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.WelcomeScreen
+          );
+        });
+      });
+
+      describe("and the user is choosing what kind of setup they want", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 1;
+        });
+
+        it("should return an onboarding step that is set at the setup choice", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.SetupChoice
+          );
+        });
+      });
+
+      describe("and the user is setting their pin", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 2;
+        });
+
+        it("should return an onboarding step that is set at setting the pin", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.Pin
+          );
+        });
+      });
+
+      describe("and the user is generating a new seed", () => {
+        describe("and the seed phrase type is set to 24 words", () => {
+          beforeEach(() => {
+            // 24-words seed
+            flagsBytes[2] |= 0 << 5;
+          });
+
+          it("should return a device state with the correct seed phrase type", () => {
+            const onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("24-words");
+          });
+
+          describe("and the user is writing the seed word i", () => {
+            beforeEach(() => {
+              flagsBytes[3] = 3;
+            });
+
+            it("should return an onboarding step that is set at writting the seed phrase", () => {
+              const onboardingState = extractOnboardingState(flagsBytes);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(
+                OnboardingStep.NewDevice
+              );
+            });
+
+            it("should return a device state with the index of the current seed word being written", () => {
+              const byte3 = flagsBytes[2];
+              for (let wordIndex = 0; wordIndex < 24; wordIndex++) {
+                flagsBytes[2] = byte3 | wordIndex;
+
+                const onboardingState = extractOnboardingState(flagsBytes);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentSeedWordIndex).toBe(wordIndex);
+              }
+            });
+          });
+
+          describe("and the user is confirming the seed word i", () => {
+            beforeEach(() => {
+              flagsBytes[3] = 4;
+            });
+
+            it("should return an onboarding step that is set at confirming the seed phrase", () => {
+              const onboardingState = extractOnboardingState(flagsBytes);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(
+                OnboardingStep.NewDeviceConfirming
+              );
+            });
+
+            it("should return a device state with the index of the current seed word being confirmed", () => {
+              const byte3 = flagsBytes[2];
+              for (let wordIndex = 0; wordIndex < 24; wordIndex++) {
+                flagsBytes[2] = byte3 | wordIndex;
+
+                const onboardingState = extractOnboardingState(flagsBytes);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentSeedWordIndex).toBe(wordIndex);
+              }
+            });
+          });
+        });
+      });
+
+      describe("and the user is recovering a seed", () => {
+        describe("and the seed phrase type is set to X words", () => {
+          it("should return a device state with the correct seed phrase type", () => {
+            const byte3 = flagsBytes[2];
+
+            // 24-words
+            flagsBytes[2] = byte3 | (0 << 5);
+            let onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("24-words");
+
+            // 18-words
+            flagsBytes[2] = byte3 | (1 << 5);
+            onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("18-words");
+
+            // 12-words
+            flagsBytes[2] = byte3 | (2 << 5);
+            onboardingState = extractOnboardingState(flagsBytes);
+
+            expect(onboardingState).not.toBeNull();
+            expect(onboardingState?.seedPhraseType).toBe("12-words");
+          });
+
+          describe("and the user is confirming (seed recovery) the seed word i", () => {
+            beforeEach(() => {
+              // 24-words seed
+              flagsBytes[2] |= 0 << 5;
+
+              flagsBytes[3] = 5;
+            });
+
+            it("should return an onboarding step that is set at confirming the restored seed phrase", () => {
+              const onboardingState = extractOnboardingState(flagsBytes);
+
+              expect(onboardingState).not.toBeNull();
+              expect(onboardingState?.currentOnboardingStep).toBe(
+                OnboardingStep.RestoreSeed
+              );
+            });
+
+            it("should return a device state with the index of the current seed word being confirmed", () => {
+              const byte3 = flagsBytes[2];
+              for (let wordIndex = 0; wordIndex < 24; wordIndex++) {
+                flagsBytes[2] = byte3 | wordIndex;
+
+                const onboardingState = extractOnboardingState(flagsBytes);
+
+                expect(onboardingState).not.toBeNull();
+                expect(onboardingState?.currentSeedWordIndex).toBe(wordIndex);
+              }
+            });
+          });
+        });
+      });
+
+      describe("and the user is on the safety warning screen", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 6;
+        });
+
+        it("should return an onboarding step that is set at the safety warning screen", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.SafetyWarning
+          );
+        });
+      });
+
+      describe("and the user finished the onboarding process", () => {
+        beforeEach(() => {
+          flagsBytes[3] = 7;
+        });
+
+        it("should return an onboarding step that is set at ready", () => {
+          const onboardingState = extractOnboardingState(flagsBytes);
+
+          expect(onboardingState).not.toBeNull();
+          expect(onboardingState?.currentOnboardingStep).toBe(
+            OnboardingStep.Ready
+          );
+        });
+      });
+    });
+  });
+});