@ledgerhq/live-common 34.51.0 → 34.52.0-nightly.1

package/src/bridge/generic-alpaca/buildSubAccounts.test.ts

@@ -0,0 +1,537 @@
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { buildSubAccounts, mergeSubAccounts } from "./buildSubAccounts";
+import { SyncConfig, TokenAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { AssetInfo } from "@ledgerhq/coin-framework/api/types";
+
+describe("buildSubAccounts", () => {
+  it("builds sub accounts from asset operations and balances, preserving operations order", async () => {
+    const subAccounts = await buildSubAccounts({
+      accountId: "accountId",
+      allTokenAssetsBalances: [
+        {
+          value: 20n,
+          locked: 5n,
+          asset: { type: "token", assetReference: "usdc", assetOwner: "owner" },
+        },
+        { value: 30n, asset: { type: "token", assetReference: "usdt", assetOwner: "owner" } },
+      ],
+      syncConfig: { blacklistedTokenIds: [] } as unknown as SyncConfig,
+      operations: [
+        {
+          hash: "tx-hash1",
+          extra: {
+            assetReference: "usdc",
+            assetOwner: "owner",
+            ledgerOpType: "OUT",
+            assetSenders: ["owner"],
+            assetRecipients: ["other"],
+          },
+        },
+        {
+          hash: "tx-hash2",
+          extra: {
+            assetReference: "usdt",
+            assetOwner: "owner",
+            ledgerOpType: "OUT",
+            assetSenders: ["owner"],
+            assetRecipients: ["other"],
+          },
+        },
+        {
+          hash: "tx-hash3",
+          extra: {
+            assetReference: "usdc",
+            assetOwner: "owner",
+            ledgerOpType: "IN",
+            assetSenders: ["other"],
+            assetRecipients: ["owner"],
+          },
+        },
+        {
+          hash: "tx-hash4",
+          extra: {
+            assetReference: "usdt",
+            assetOwner: "owner",
+            ledgerOpType: "OUT",
+            assetSenders: ["owner"],
+            assetRecipients: ["other"],
+          },
+        },
+        {
+          senders: ["other-as-parent"],
+          recipients: ["owner-as-parent"],
+          hash: "tx-hash5",
+          extra: { assetReference: "usdt", assetOwner: "owner", ledgerOpType: "IN" },
+        },
+      ] as any,
+      getTokenFromAsset: async asset =>
+        asset.type === "token" ? ({ id: asset.assetReference } as TokenCurrency) : undefined,
+    });
+
+    expect(subAccounts).toMatchObject([
+      {
+        id: "accountId+usdc",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdc" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(15),
+        operations: [
+          {
+            id: "accountId+usdc-tx-hash1-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdc-tx-hash3-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+          },
+        ],
+        operationsCount: 2,
+      },
+      {
+        id: "accountId+usdt",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdt" },
+        balance: new BigNumber(30),
+        spendableBalance: new BigNumber(30),
+        operations: [
+          {
+            id: "accountId+usdt-tx-hash2-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdt-tx-hash4-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdt-tx-hash5-IN",
+            type: "IN",
+            senders: ["other-as-parent"],
+            recipients: ["owner-as-parent"],
+          },
+        ],
+        operationsCount: 3,
+      },
+    ]);
+  });
+
+  it.each([
+    [
+      "blacklisted tokens",
+      {
+        blacklistedTokenIds: ["other-token"],
+        getTokenFromAsset: async (asset: AssetInfo) =>
+          asset.type === "token" ? ({ id: asset.assetReference } as TokenCurrency) : undefined,
+      },
+    ],
+    [
+      "unknown tokens",
+      {
+        blacklistedTokenIds: [],
+        getTokenFromAsset: async (asset: AssetInfo) =>
+          asset.type === "token" && asset.assetReference !== "other-token"
+            ? ({ id: asset.assetReference } as TokenCurrency)
+            : undefined,
+      },
+    ],
+  ])("does not build accounts from %s", async (_s, config) => {
+    const subAccounts = await buildSubAccounts({
+      accountId: "accountId",
+      allTokenAssetsBalances: [
+        {
+          value: 20n,
+          locked: 5n,
+          asset: { type: "token", assetReference: "usdc", assetOwner: "owner" },
+        },
+        {
+          value: 30n,
+          asset: { type: "token", assetReference: "other-token", assetOwner: "owner" },
+        },
+      ],
+      syncConfig: { blacklistedTokenIds: config.blacklistedTokenIds } as unknown as SyncConfig,
+      operations: [
+        {
+          hash: "tx-hash1",
+          extra: {
+            assetReference: "usdc",
+            assetOwner: "owner",
+            ledgerOpType: "OUT",
+            assetSenders: ["owner"],
+            assetRecipients: ["other"],
+          },
+        },
+        {
+          hash: "tx-hash2",
+          extra: {
+            assetReference: "other-token",
+            assetOwner: "owner",
+            ledgerOpType: "OUT",
+            assetSenders: ["owner"],
+            assetRecipients: ["other"],
+          },
+        },
+        {
+          hash: "tx-hash3",
+          extra: {
+            assetReference: "usdc",
+            assetOwner: "owner",
+            ledgerOpType: "IN",
+            assetSenders: ["other"],
+            assetRecipients: ["owner"],
+          },
+        },
+        {
+          hash: "tx-hash4",
+          extra: {
+            assetReference: "other-token",
+            assetOwner: "owner",
+            ledgerOpType: "OUT",
+            assetSenders: ["owner"],
+            assetRecipients: ["other"],
+          },
+        },
+        {
+          senders: ["other-as-parent"],
+          recipients: ["owner-as-parent"],
+          hash: "tx-hash5",
+          extra: { assetReference: "other-token", assetOwner: "owner", ledgerOpType: "IN" },
+        },
+      ] as any,
+      getTokenFromAsset: config.getTokenFromAsset,
+    });
+
+    expect(subAccounts).toMatchObject([
+      {
+        id: "accountId+usdc",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdc" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(15),
+        operations: [
+          {
+            id: "accountId+usdc-tx-hash1-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdc-tx-hash3-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+          },
+        ],
+        operationsCount: 2,
+      },
+    ]);
+  });
+});
+
+describe("mergeSubAccounts", () => {
+  it("only keeps new sub accounts", () => {
+    const oldSubAccounts = [];
+    const newSubAccounts = [
+      {
+        id: "accountId+usdc",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdc" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(15),
+        operations: [
+          {
+            id: "accountId+usdc-tx-hash1-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdc-tx-hash3-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+          },
+        ],
+        operationsCount: 2,
+      },
+      {
+        id: "accountId+usdt",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdt" },
+        balance: new BigNumber(30),
+        spendableBalance: new BigNumber(30),
+        operations: [
+          {
+            id: "accountId+usdt-tx-hash2-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdt-tx-hash4-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdt-tx-hash5-IN",
+            type: "IN",
+            senders: ["other-as-parent"],
+            recipients: ["owner-as-parent"],
+          },
+        ],
+        operationsCount: 3,
+      },
+    ] as Array<TokenAccount>;
+    const merged = mergeSubAccounts(oldSubAccounts, newSubAccounts);
+
+    expect(merged).toEqual(newSubAccounts);
+  });
+
+  it("adds new unexisting sub accounts as is", () => {
+    const oldSubAccounts = [
+      {
+        id: "accountId+usdc",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdc" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(15),
+        operations: [
+          {
+            id: "accountId+usdc-tx-hash1-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdc-tx-hash3-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+          },
+        ],
+        operationsCount: 2,
+      },
+      {
+        id: "accountId+usdt",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdt" },
+        balance: new BigNumber(30),
+        spendableBalance: new BigNumber(30),
+        operations: [
+          {
+            id: "accountId+usdt-tx-hash2-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdt-tx-hash4-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+usdt-tx-hash5-IN",
+            type: "IN",
+            senders: ["other-as-parent"],
+            recipients: ["owner-as-parent"],
+          },
+        ],
+        operationsCount: 3,
+      },
+    ] as Array<TokenAccount>;
+    const newSubAccounts = [
+      {
+        id: "accountId+other-token",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "other-token" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(20),
+        operations: [
+          {
+            id: "accountId+other-token-tx-hash6-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+          },
+          {
+            id: "accountId+other-token-tx-hash7-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+          },
+        ],
+        operationsCount: 2,
+      },
+    ] as Array<TokenAccount>;
+    const merged = mergeSubAccounts(oldSubAccounts, newSubAccounts);
+
+    expect(merged).toEqual([...oldSubAccounts, ...newSubAccounts]);
+  });
+
+  it("updates existing sub accounts with new data", () => {
+    const oldSubAccounts = [
+      {
+        id: "accountId+usdc",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdc" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(15),
+        operations: [
+          {
+            id: "accountId+usdc-tx-hash1-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-01"),
+          },
+          {
+            id: "accountId+usdc-tx-hash3-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+            date: new Date("2019-04-02"),
+          },
+        ],
+        operationsCount: 2,
+      },
+      {
+        id: "accountId+usdt",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdt" },
+        balance: new BigNumber(30),
+        spendableBalance: new BigNumber(30),
+        operations: [
+          {
+            id: "accountId+usdt-tx-hash2-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-02"),
+          },
+          {
+            id: "accountId+usdt-tx-hash4-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-02"),
+          },
+          {
+            id: "accountId+usdt-tx-hash5-IN",
+            type: "IN",
+            senders: ["other-as-parent"],
+            recipients: ["owner-as-parent"],
+            date: new Date("2019-04-03"),
+          },
+        ],
+        operationsCount: 3,
+      },
+    ] as Array<TokenAccount>;
+    const newSubAccounts = [
+      {
+        id: "accountId+usdt",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdt" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(20),
+        operations: [
+          {
+            id: "accountId+usdt-tx-hash6-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-04"),
+          },
+        ],
+        operationsCount: 1,
+      },
+    ] as Array<TokenAccount>;
+    const merged = mergeSubAccounts(oldSubAccounts, newSubAccounts);
+
+    expect(merged).toEqual([
+      {
+        id: "accountId+usdc",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdc" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(15),
+        operations: [
+          {
+            id: "accountId+usdc-tx-hash1-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-01"),
+          },
+          {
+            id: "accountId+usdc-tx-hash3-IN",
+            type: "IN",
+            senders: ["other"],
+            recipients: ["owner"],
+            date: new Date("2019-04-02"),
+          },
+        ],
+        operationsCount: 2,
+      },
+      {
+        id: "accountId+usdt",
+        type: "TokenAccount",
+        parentId: "accountId",
+        token: { id: "usdt" },
+        balance: new BigNumber(20),
+        spendableBalance: new BigNumber(20),
+        operations: [
+          {
+            id: "accountId+usdt-tx-hash6-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-04"),
+          },
+          {
+            id: "accountId+usdt-tx-hash2-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-02"),
+          },
+          {
+            id: "accountId+usdt-tx-hash4-OUT",
+            type: "OUT",
+            senders: ["owner"],
+            recipients: ["other"],
+            date: new Date("2019-04-02"),
+          },
+          {
+            id: "accountId+usdt-tx-hash5-IN",
+            type: "IN",
+            senders: ["other-as-parent"],
+            recipients: ["owner-as-parent"],
+            date: new Date("2019-04-03"),
+          },
+        ],
+        operationsCount: 4,
+      },
+    ]);
+  });
+});

package/src/bridge/generic-alpaca/buildSubAccounts.ts

@@ -1,16 +1,12 @@
 import BigNumber from "bignumber.js";
 import { emptyHistoryCache, encodeTokenAccountId } from "@ledgerhq/coin-framework/account/index";
-import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
-import type { Operation, SyncConfig, TokenAccount } from "@ledgerhq/types-live";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { SyncConfig, TokenAccount } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
 import { AssetInfo, Balance } from "@ledgerhq/coin-framework/api/types";
-
-export interface OperationCommon extends Operation {
-  extra: Record<string, any>;
-}
-
-export const getAssetIdFromTokenId = (tokenId: string): string => tokenId.split("/")[2];
+import { mergeOps } from "../jsHelpers";
+import { cleanedOperation } from "./utils";
+import { OperationCommon } from "./types";
 
 function buildTokenAccount({
   parentAccountId,
@@ -31,13 +27,18 @@ function buildTokenAccount({
     new BigNumber(assetBalance.locked?.toString() || "0"),
   );
 
-  const tokenOperations = operations.map(op => ({
-    ...op,
-    id: encodeOperationId(id, op.hash, op.extra?.ledgerOpType),
-    accountId: id,
-    type: op.extra?.ledgerOpType,
-    value: op.extra?.assetAmount ? new BigNumber(op.extra?.assetAmount) : op.value,
-  }));
+  const tokenOperations = operations.map(op =>
+    cleanedOperation({
+      ...op,
+      id: encodeOperationId(id, op.hash, op.extra?.ledgerOpType),
+      accountId: id,
+      type: op.extra?.ledgerOpType,
+      contract: token.contractAddress,
+      value: op.extra?.assetAmount ? new BigNumber(op.extra?.assetAmount) : op.value,
+      senders: op.extra?.assetSenders ?? op.senders,
+      recipients: op.extra?.assetRecipients ?? op.recipients,
+    }),
+  );
 
   return {
     type: "TokenAccount",
@@ -56,14 +57,12 @@ function buildTokenAccount({
 }
 
 export async function buildSubAccounts({
-  currency,
   accountId,
   allTokenAssetsBalances,
   syncConfig,
   operations,
   getTokenFromAsset,
 }: {
-  currency: CryptoCurrency;
   accountId: string;
   allTokenAssetsBalances: Balance[];
   syncConfig: SyncConfig;
@@ -71,15 +70,14 @@ export async function buildSubAccounts({
   getTokenFromAsset?: (asset: AssetInfo) => Promise<TokenCurrency | undefined>;
 }): Promise<TokenAccount[]> {
   const { blacklistedTokenIds = [] } = syncConfig;
-  const allTokens = listTokensForCryptoCurrency(currency);
   const tokenAccounts: TokenAccount[] = [];
 
-  if (allTokens.length === 0 || allTokenAssetsBalances.length === 0) {
+  if (allTokenAssetsBalances.length === 0 || !getTokenFromAsset) {
     return tokenAccounts;
   }
 
   for (const balance of allTokenAssetsBalances) {
-    const token = getTokenFromAsset && (await getTokenFromAsset(balance.asset));
+    const token = await getTokenFromAsset(balance.asset);
     // NOTE: for future tokens, will need to check over currencyName/standard(erc20,trc10,trc20, etc)/id
     if (token && !blacklistedTokenIds.includes(token.id)) {
       tokenAccounts.push(
@@ -99,3 +97,42 @@ export async function buildSubAccounts({
 
   return tokenAccounts;
 }
+
+export function mergeSubAccounts(
+  oldSubAccounts: Array<TokenAccount>,
+  newSubAccounts: Array<TokenAccount>,
+): Array<TokenAccount> {
+  if (!oldSubAccounts.length) {
+    return newSubAccounts;
+  }
+
+  const oldSubAccountsById = Object.fromEntries(
+    oldSubAccounts.map(account => [account.id, account]),
+  );
+
+  const newSubAccountsToAdd: Array<TokenAccount> = [];
+
+  for (const newSubAccount of newSubAccounts) {
+    const existingSubAccount = oldSubAccountsById[newSubAccount.id];
+
+    if (!existingSubAccount) {
+      // New sub account does not exist yet. Just add it as is.
+      newSubAccountsToAdd.push(newSubAccount);
+      continue;
+    }
+
+    // New sub account is already known, probably outdated
+    const operations = mergeOps(existingSubAccount.operations, newSubAccount.operations);
+    oldSubAccountsById[newSubAccount.id] = {
+      ...existingSubAccount,
+      balance: newSubAccount.balance,
+      spendableBalance: newSubAccount.spendableBalance,
+      operations,
+      operationsCount: operations.length,
+    };
+  }
+
+  const updatedOldSubAccounts = Object.values(oldSubAccountsById);
+
+  return [...updatedOldSubAccounts, ...newSubAccountsToAdd];
+}