@ledgerhq/live-common 31.0.0 → 31.1.0

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

@@ -247,21 +247,49 @@ export class CosmosAPI {
   };
 
   getTransactions = async (address: string): Promise<CosmosTx[]> => {
-    const receive = await network({
+    let receive;
+    let send;
+
+    try {
+      send = await this.getSendingTransactions(address, "ORDER_BY_DESC");
+      receive = await this.getReceivingTransactions(address, "ORDER_BY_DESC");
+    } catch (e) {
+      // FIXME: remove and always orderBy once pagination is implemented or every nodes are upgraded to 0.47
+      // See https://github.com/cosmos/cosmos-sdk/issues/15437
+      if ((e as Error).message.includes("ORDER_BY_DESC")) {
+        send = await this.getSendingTransactions(address);
+        receive = await this.getReceivingTransactions(address);
+      }
+    }
+
+    return [...receive.data.tx_responses, ...send.data.tx_responses];
+  };
+
+  private async getReceivingTransactions(
+    address: string,
+    orderBy?: "ORDER_BY_DESC" | "ORDER_BY_ASC"
+  ) {
+    return await network({
       method: "GET",
       url:
         `${this.defaultEndpoint}/cosmos/tx/${this.version}/txs?events=` +
-        encodeURI(`transfer.recipient='${address}'`),
+        encodeURI(`transfer.recipient='${address}'`) +
+        (orderBy ? `&order_by=${orderBy}` : ""),
     });
+  }
 
-    const send = await network({
+  private async getSendingTransactions(
+    address: string,
+    orderBy?: "ORDER_BY_DESC" | "ORDER_BY_ASC"
+  ) {
+    return await network({
       method: "GET",
       url:
         `${this.defaultEndpoint}/cosmos/tx/${this.version}/txs?events=` +
-        encodeURI(`message.sender='${address}'`),
+        encodeURI(`message.sender='${address}'`) +
+        (orderBy ? `&order_by=${orderBy}` : ""),
     });
-    return [...receive.data.tx_responses, ...send.data.tx_responses];
-  };
+  }
 
   broadcast = async ({
     signedOperation: { operation, signature },

package/src/families/cosmos/helpers.ts

@@ -1,9 +1,6 @@
-type Message = {
-  type: string;
-  attributes: { [key: string]: any };
-};
+import { CosmosMessage } from "./types";
 
-export const getMainMessage = (messages: Message[]): Message => {
+export const getMainMessage = (messages: CosmosMessage[]): CosmosMessage => {
   const messagePriorities: string[] = [
     "unbond",
     "redelegate",

package/src/families/cosmos/helpers.unit.test.ts

@@ -5,11 +5,11 @@ describe("getMainMessage", () => {
     const exec = getMainMessage([
       {
         type: "delegate",
-        attributes: {},
+        attributes: [],
       },
       {
         type: "withdraw_rewards",
-        attributes: {},
+        attributes: [],
       },
     ]);
     expect(exec.type).toEqual("delegate");
@@ -20,11 +20,11 @@ describe("getMainMessage", () => {
       getMainMessage([
         {
           type: "unbond",
-          attributes: {},
+          attributes: [],
         },
         {
           type: "transfer",
-          attributes: {},
+          attributes: [],
         },
       ]).type
     ).toEqual("unbond");
@@ -33,14 +33,14 @@ describe("getMainMessage", () => {
   it("should return first transfer message with multiple transfer messages", () => {
     const firstTransfer = {
       type: "transfer",
-      attributes: {},
+      attributes: [],
     };
     expect(
       getMainMessage([
         firstTransfer,
         {
           type: "transfer",
-          attributes: {},
+          attributes: [],
         },
       ])
     ).toEqual(firstTransfer);
@@ -51,11 +51,11 @@ describe("getMainMessage", () => {
       getMainMessage([
         {
           type: "delegate",
-          attributes: {},
+          attributes: [],
         },
         {
           type: "redelegate",
-          attributes: {},
+          attributes: [],
         },
       ]).type
     ).toEqual("redelegate");

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

@@ -4,11 +4,12 @@ import {
   makeScanAccounts,
   GetAccountShape,
   mergeOps,
+  AccountShapeInfo,
 } from "../../bridge/jsHelpers";
 import { encodeAccountId } from "../../account";
 import { CosmosAPI } from "./api/Cosmos";
 import { encodeOperationId } from "../../operation";
-import { CosmosDelegationInfo } from "./types";
+import { CosmosDelegationInfo, CosmosMessage, CosmosTx } from "./types";
 import type { Operation, OperationType } from "@ledgerhq/types-live";
 import { getMainMessage } from "./helpers";
 
@@ -30,10 +31,13 @@ const getBlankOperation = (tx, fees, id) => ({
   transactionSequenceNumber: parseInt(tx.tx.auth_info.signer_infos[0].sequence),
 });
 
-const txToOps = (info: any, id: string, txs: any): Operation[] => {
+const txToOps = (
+  info: AccountShapeInfo,
+  accountId: string,
+  txs: CosmosTx[]
+): Operation[] => {
   const { address, currency } = info;
   const ops: Operation[] = [];
-
   for (const tx of txs) {
     let fees = new BigNumber(0);
 
@@ -41,22 +45,33 @@ const txToOps = (info: any, id: string, txs: any): Operation[] => {
       if (elem.denom === currency.units[1].code) fees = fees.plus(elem.amount);
     });
 
-    const op: Operation = getBlankOperation(tx, fees, id);
+    const op: Operation = getBlankOperation(tx, fees, accountId);
 
-    const messages = tx.logs.map((log) => log.events).flat(1);
+    const messages: CosmosMessage[] = tx.logs.map((log) => log.events).flat(1);
 
-    const message = getMainMessage(messages);
+    const mainMessage = getMainMessage(messages);
 
-    if (message == null) {
+    if (mainMessage === undefined) {
+      // happens when we don't know this message type in our implementation, example : proposal_vote
       continue;
     }
 
-    // parse attributes as key:value
+    const correspondingMessages = messages.filter(
+      (m) => m.type === mainMessage.type
+    );
+
+    if (correspondingMessages.length === 0) {
+      continue;
+    }
+
+    // TODO: This mechanism should be removed
     const attributes: { [id: string]: any } = {};
-    message.attributes.forEach((item) => (attributes[item.key] = item.value));
+    mainMessage.attributes.forEach(
+      (item) => (attributes[item.key] = item.value)
+    );
 
     // https://docs.cosmos.network/v0.42/modules/staking/07_events.html
-    switch (message.type) {
+    switch (mainMessage.type) {
       case "transfer":
         if (attributes.sender && attributes.recipient && attributes.amount) {
           op.senders.push(attributes.sender);
@@ -77,25 +92,52 @@ const txToOps = (info: any, id: string, txs: any): Operation[] => {
         }
         break;
 
-      case "withdraw_rewards":
-        if (
-          (attributes.amount &&
-            attributes.amount.indexOf(currency.units[1].code) != -1) ||
-          // handle specifc case with empty amount value like
-          // tx DF458FE6A82C310837D7A33735FA5298BCF71B0BFF7A4134641AAE30F6F1050
-          attributes.amount === ""
-        ) {
-          op.type = "REWARD";
-          const reward = message.attributes
-            .find((attr) => attr.key === "amount")
-            .value.replace("uatom", "");
-          op.value = new BigNumber(reward || 0);
-          op.extra.validators.push({
-            address: attributes.validator,
-            amount: attributes.amount.replace(currency.units[1].code, "") || 0,
+      case "withdraw_rewards": {
+        op.type = "REWARD";
+
+        const rewardShards: { amount: BigNumber; address: string }[] = [];
+
+        let txRewardValue = new BigNumber(0);
+
+        for (const message of correspondingMessages) {
+          const validatorAttribute = message.attributes.find(
+            (attr) => attr.key === "validator"
+          );
+
+          if (validatorAttribute == null) {
+            continue;
+          }
+
+          const validatorAddress = validatorAttribute.value;
+
+          let messageRewardValue = new BigNumber(0);
+          const amountAttributes = message.attributes.filter(
+            (attribute) =>
+              attribute.key === "amount" &&
+              attribute.value.includes(currency.units[1].code)
+          );
+
+          amountAttributes.forEach((amountAttribute) => {
+            messageRewardValue = messageRewardValue.plus(
+              new BigNumber(
+                amountAttribute.value.replace(currency.units[1].code, "")
+              )
+            );
           });
+
+          rewardShards.push({
+            amount: messageRewardValue,
+            address: validatorAddress,
+          });
+
+          txRewardValue = txRewardValue.plus(messageRewardValue);
         }
+
+        op.value = txRewardValue;
+        op.extra.validators = rewardShards;
+
         break;
+      }
 
       case "delegate":
         if (
@@ -144,12 +186,17 @@ const txToOps = (info: any, id: string, txs: any): Operation[] => {
         break;
     }
 
+    if (tx.tx.body.memo != null) {
+      op.extra.memo = tx.tx.body.memo;
+    }
+
+    // Dirty, to remove after attributes map is gone
     if (!["IN", "OUT"].includes(op.type)) {
       op.senders = [];
       op.recipients = [];
     }
 
-    op.id = encodeOperationId(id, tx.txhash, op.type);
+    op.id = encodeOperationId(accountId, tx.txhash, op.type);
 
     if (op.type) {
       ops.push(op);

package/src/families/cosmos/js-synchronisation.unit.test.ts

@@ -0,0 +1,339 @@
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { Operation, SyncConfig } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { AccountShapeInfo } from "../../bridge/jsHelpers";
+import { CosmosAPI } from "./api/Cosmos";
+import { getAccountShape } from "./js-synchronisation";
+import { CosmosAccount, CosmosTx } from "./types";
+import * as jsHelpers from "../../bridge/jsHelpers";
+
+jest.mock("./api/Cosmos");
+jest.mock("../../account");
+jest.mock("../../bridge/jsHelpers");
+
+const infoMock = {
+  currency: {
+    units: [{}, { code: "uatom" }],
+  } as CryptoCurrency,
+  address: "address",
+  index: 0,
+} as AccountShapeInfo;
+
+const baseAccountInfoMock = {
+  txs: [],
+  delegations: [],
+  unbondings: [],
+  balances: new BigNumber(0),
+};
+
+const baseTxMock = {
+  logs: [],
+  txhash: "2",
+  tx: {
+    auth_info: {
+      signer_infos: [{ sequence: "seq" }],
+      fee: { amount: [{ denom: "uatom", amount: new BigNumber(0) }] },
+    },
+  },
+};
+
+const syncConfig = {} as SyncConfig;
+
+function mockAccountInfo(
+  partialMock: Partial<{
+    delegations: any;
+    unbondings: any;
+    balances: BigNumber;
+    txs: any[];
+  }>
+) {
+  // @ts-expect-error mocked
+  CosmosAPI.mockReturnValueOnce({
+    getAccountInfo: jest
+      .fn()
+      .mockResolvedValue({ ...baseAccountInfoMock, ...partialMock }),
+  });
+}
+
+function mockCosmosTx(tx: Partial<CosmosTx>) {
+  return {
+    logs: [
+      {
+        type: "withdraw_rewards",
+        events: [
+          {
+            type: "withdraw_rewards",
+            attributes: [
+              {
+                key: "amount",
+                value: "10uatom",
+              },
+              {
+                key: "validator",
+                value: "validatorAddressHehe",
+              },
+            ],
+          },
+        ],
+        attributes: [],
+      },
+    ],
+    txhash: "2",
+    tx: {
+      auth_info: {
+        signer_infos: [{ sequence: "seq" }],
+        fee: { amount: [{ denom: "uatom", amount: new BigNumber(0) }] },
+      },
+      body: {},
+    },
+    ...tx,
+  } as unknown as CosmosTx;
+}
+
+describe("getAccountShape", () => {
+  let mergeOpsSpy: jest.SpyInstance;
+  beforeEach(() => {
+    // @ts-expect-error mocked
+    CosmosAPI.mockClear();
+    mergeOpsSpy = jest
+      .spyOn(jsHelpers, "mergeOps")
+      .mockImplementation(
+        (existing: Operation[], newlyFetched: Operation[]): Operation[] => [
+          ...existing,
+          ...newlyFetched,
+        ]
+      );
+  });
+
+  afterEach(() => {
+    mergeOpsSpy.mockReset();
+  });
+
+  it("should sum up delegations to balance", async () => {
+    mockAccountInfo({
+      balances: new BigNumber(1),
+      delegations: [{ amount: new BigNumber(2) }],
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect(account.balance).toEqual(new BigNumber(3));
+  });
+
+  it("should sum up delegation balances and assign it in cosmosResources delegatedBalances", async () => {
+    mockAccountInfo({
+      delegations: [{ amount: new BigNumber(1) }, { amount: new BigNumber(2) }],
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect((account as CosmosAccount).cosmosResources.delegatedBalance).toEqual(
+      new BigNumber(3)
+    );
+  });
+
+  it("should sum up unbondings to balance", async () => {
+    mockAccountInfo({
+      balances: new BigNumber(2),
+      unbondings: [{ amount: new BigNumber(3) }],
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect(account.balance).toEqual(new BigNumber(5));
+  });
+
+  it("estimate spendable balance correctly", async () => {
+    // Shouldn't it be 97 ?
+    mockAccountInfo({
+      balances: new BigNumber(100),
+      unbondings: [{ amount: new BigNumber(1) }],
+      delegations: [{ amount: new BigNumber(2) }],
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect(account.spendableBalance).toEqual(new BigNumber(100));
+  });
+
+  it("should reduce balance to 0 if spendable balance is negative", async () => {
+    mockAccountInfo({
+      balances: new BigNumber(-10),
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect(account.spendableBalance).toEqual(new BigNumber(0));
+  });
+
+  it("should sum up pendingRewards and insert it in cosmosResources", async () => {
+    mockAccountInfo({
+      delegations: [
+        {
+          pendingRewards: new BigNumber(1),
+        },
+        {
+          pendingRewards: new BigNumber(2),
+        },
+      ],
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect(
+      (account as CosmosAccount).cosmosResources.pendingRewardsBalance
+    ).toEqual(new BigNumber(3));
+  });
+
+  it("set spendable balance to 0 if spendable balance is negative in initial account", async () => {
+    mockAccountInfo({});
+    const account = await getAccountShape(
+      {
+        ...infoMock,
+        initialAccount: {
+          spendableBalance: new BigNumber(-10),
+        } as CosmosAccount,
+      },
+      syncConfig
+    );
+    expect(account.spendableBalance).toEqual(new BigNumber(0));
+  });
+
+  it("should estimate operations count correctly", async () => {
+    mockAccountInfo({});
+    const account = await getAccountShape(
+      {
+        ...infoMock,
+        initialAccount: {
+          operations: [{}, {}],
+        } as CosmosAccount,
+      },
+      syncConfig
+    );
+    expect(account.operationsCount).toEqual(2);
+  });
+
+  it("should merge old operations with newly fetched ones", async () => {
+    const existingOperations = [{ hash: "3", id: "3" }];
+    mockAccountInfo({});
+    await getAccountShape(
+      {
+        ...infoMock,
+        initialAccount: {
+          operations: existingOperations,
+        } as CosmosAccount,
+      },
+      syncConfig
+    );
+    expect(mergeOpsSpy.mock.calls[0][0]).toEqual(existingOperations);
+  });
+
+  it("should add newly fetched operations", async () => {
+    mockAccountInfo({ txs: [mockCosmosTx({})] });
+    await getAccountShape(infoMock, syncConfig);
+    expect(mergeOpsSpy.mock.calls[0][1]).toBeTruthy();
+  });
+
+  it("should assign memo correctly", async () => {
+    const memo = "i am a memo :)";
+    mockAccountInfo({
+      txs: [
+        mockCosmosTx({
+          tx: {
+            body: { memo },
+            auth_info: baseTxMock.tx.auth_info,
+          },
+        } as Partial<CosmosTx>),
+      ],
+    });
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect((account.operations as Operation[])[0].extra.memo).toEqual(memo);
+  });
+
+  it("should list claim reward operations correctly with multiple delegations", async () => {
+    mockAccountInfo({
+      txs: [
+        mockCosmosTx({
+          logs: [
+            {
+              type: "withdraw_rewards",
+              events: [
+                {
+                  type: "withdraw_rewards",
+                  attributes: [
+                    {
+                      key: "amount",
+                      value: "3uatom",
+                    },
+                    {
+                      key: "validator",
+                      value: "validatorAddressNumeroUno",
+                    },
+                  ],
+                },
+              ],
+              attributes: [],
+            },
+          ],
+        } as Partial<CosmosTx>),
+      ],
+    });
+
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect((account.operations as Operation[])[0].value).toEqual(
+      new BigNumber(3)
+    );
+    expect((account.operations as Operation[])[0].extra.validators).toEqual([
+      {
+        address: "validatorAddressNumeroUno",
+        amount: new BigNumber(3),
+      },
+    ]);
+  });
+
+  it("should list claim reward operations correctly with multiple delegations", async () => {
+    mockAccountInfo({
+      txs: [
+        mockCosmosTx({
+          logs: [
+            {
+              type: "withdraw_rewards",
+              events: [
+                {
+                  type: "withdraw_rewards",
+                  attributes: [
+                    {
+                      key: "amount",
+                      value: "10uatom",
+                    },
+                    {
+                      key: "validator",
+                      value: "validatorAddressHehe",
+                    },
+                  ],
+                },
+                {
+                  type: "withdraw_rewards",
+                  attributes: [
+                    {
+                      key: "amount",
+                      value: "5uatom",
+                    },
+                    {
+                      key: "validator",
+                      value: "validatorAddressTwo",
+                    },
+                  ],
+                },
+              ],
+              attributes: [],
+            },
+          ],
+        } as Partial<CosmosTx>),
+      ],
+    });
+
+    const account = await getAccountShape(infoMock, syncConfig);
+    expect((account.operations as Operation[])[0].value).toEqual(
+      new BigNumber(15)
+    );
+    expect((account.operations as Operation[])[0].extra.validators).toEqual([
+      {
+        address: "validatorAddressHehe",
+        amount: new BigNumber(10),
+      },
+      {
+        address: "validatorAddressTwo",
+        amount: new BigNumber(5),
+      },
+    ]);
+  });
+});

package/src/families/cosmos/react.ts

@@ -26,7 +26,7 @@ import useMemoOnce from "../../hooks/useMemoOnce";
 import cryptoFactory from "./chain/chain";
 
 export function useCosmosFamilyPreloadData(
-  currencyId: string
+  currencyId?: string
 ): CosmosPreloadData {
   const getCurrent = getCurrentCosmosPreloadData;
   const getUpdates = getCosmosPreloadDataUpdates;
@@ -36,11 +36,13 @@ export function useCosmosFamilyPreloadData(
     const sub = getUpdates().subscribe(setState);
     return () => sub.unsubscribe();
   }, [getCurrent, getUpdates]);
-  return (
-    state[currencyId] ?? {
-      validators: [], // NB initial state because UI need to work even if it's currently "loading", typically after clear cache
-    }
-  );
+  return currencyId
+    ? state[currencyId] ?? {
+        validators: [], // NB initial state because UI need to work even if it's currently "loading", typically after clear cache
+      }
+    : {
+        validators: [], // NB initial state because UI need to work even if it's currently "loading", typically after clear cache
+      };
 }
 
 export function useCosmosFamilyMappedDelegations(

package/src/families/cosmos/types.ts

@@ -37,10 +37,7 @@ export type CosmosTx = {
   code: number;
   codespace: string;
   data: string;
-  events: {
-    type: string;
-    attributes: { index: boolean; key: string; value: string }[];
-  }[];
+  events: CosmosMessage[];
   gas_used: string;
   gas_wanted: string;
   height: string;
@@ -52,6 +49,11 @@ export type CosmosTx = {
   txhash: string;
 };
 
+export type CosmosMessage = {
+  type: string;
+  attributes: { key: string; value: string; index?: boolean }[];
+};
+
 export type CosmosResources = {
   delegations: CosmosDelegation[];
   redelegations: CosmosRedelegation[];