@ledgerhq/live-common 29.2.0 → 29.3.0-next.1

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

@@ -20,7 +20,7 @@ Array [
     "index": 0,
     "name": "Algorand 1",
     "nfts": undefined,
-    "operationsCount": 131,
+    "operationsCount": 132,
     "pendingOperations": Array [],
     "seedIdentifier": "c8b672d16c497bb097a48f09a9cccf0c4c7d6391acb7a4e7cd3f236fadbef9c4",
     "starred": false,
@@ -33,7 +33,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+312769",
     "operationsCount": 11,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
@@ -45,7 +44,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+438828",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
@@ -57,7 +55,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+438837",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
@@ -69,7 +66,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+2757561",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
@@ -81,7 +77,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+27165954",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
@@ -93,7 +88,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:+137594422",
     "operationsCount": 0,
     "parentId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
@@ -192,7 +186,6 @@ Array [
   },
   Object {
     "approvals": undefined,
-    "compoundBalance": undefined,
     "id": "js:2:algorand:MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI:+312769",
     "operationsCount": 8,
     "parentId": "js:2:algorand:MECOWMKPKH2NWVZTS5V5RQDGFFYBT25KNLOPHG2KUMMNKU6FOHGJT24WBI:",
@@ -862,6 +855,31 @@ Array [
       "type": "IN",
       "value": "34000000",
     },
+    Object {
+      "accountId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
+      "blockHash": undefined,
+      "blockHeight": 26958775,
+      "contract": undefined,
+      "extra": Object {
+        "assetId": undefined,
+        "memo": undefined,
+        "rewards": "0",
+      },
+      "fee": "1000",
+      "hash": "7UVVRC3GOQAYH36MGBIKX3VR6533NWRTGI555MT5VDPZLSSD43HQ",
+      "id": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:-7UVVRC3GOQAYH36MGBIKX3VR6533NWRTGI555MT5VDPZLSSD43HQ-IN",
+      "operator": undefined,
+      "recipients": Array [
+        "ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q",
+      ],
+      "senders": Array [
+        "VMZTCZV2IDQAVZBB4BZNZHCN62U654SYK7AJ5J4U73AWOM5DHITWQ3QU7Q",
+      ],
+      "standard": undefined,
+      "tokenId": undefined,
+      "type": "IN",
+      "value": "1000",
+    },
     Object {
       "accountId": "js:2:algorand:ZC3HFULMJF53BF5ER4E2TTGPBRGH2Y4RVS32JZ6NH4RW7LN67HCE6UBS3Q:",
       "blockHash": undefined,

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

@@ -848,7 +848,6 @@ Array [
   Object {
     "approvals": undefined,
     "balance": "100",
-    "compoundBalance": undefined,
     "id": "js:2:cardano_testnet:806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d:cardano+cardano_testnet%2Fnative%2F47be64fcc8a7fe5321b976282ce4e43e4d29015f6613cfabcea28eab54657374",
     "operationsCount": 1,
     "parentId": "js:2:cardano_testnet:806499588e0c4a58f4119f7e6e096bf42c3f774a528d2acec9e82ceebf87d1ceb3d4f3622dd2c77c65cc89c123f79337db22cf8a69f122e36dab1bf5083bf82d:cardano",

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

@@ -3,9 +3,9 @@
 exports[`cosmos currency bridge scanAccounts cosmos seed 1 1`] = `
 Array [
   Object {
-    "balance": "3046789",
+    "balance": "3038644",
     "cosmosResources": Object {
-      "delegatedBalance": "1631177",
+      "delegatedBalance": "1631219",
       "withdrawAddress": "cosmos1g84934jpu3v5de5yqukkkhxmcvsw3u2ajxvpdl",
     },
     "currencyId": "cosmos",
@@ -22,7 +22,7 @@ Array [
     "index": 0,
     "name": "Cosmos 1",
     "nfts": undefined,
-    "operationsCount": 66,
+    "operationsCount": 67,
     "pendingOperations": Array [],
     "seedIdentifier": "0388459b2653519948b12492f1a0b464720110c147a8155d23d423a5cc3c21d89a",
     "starred": false,
@@ -844,6 +844,31 @@ Array [
       "type": "IN",
       "value": "1000",
     },
+    Object {
+      "accountId": "js:2:cosmos:cosmos1g84934jpu3v5de5yqukkkhxmcvsw3u2ajxvpdl:",
+      "blockHash": null,
+      "blockHeight": "14489118",
+      "contract": undefined,
+      "extra": Object {
+        "validators": Array [
+          Object {
+            "address": "cosmosvaloper196ax4vc0lwpxndu9dyhvca7jhxp70rmcvrj90c",
+            "amount": "42",
+          },
+        ],
+      },
+      "fee": "8186",
+      "hash": "81DF8F7EB136AB82E06CF257E863121274E54524FFAE29B418F3BD9D194E6865",
+      "id": "js:2:cosmos:cosmos1g84934jpu3v5de5yqukkkhxmcvsw3u2ajxvpdl:-81DF8F7EB136AB82E06CF257E863121274E54524FFAE29B418F3BD9D194E6865-DELEGATE",
+      "operator": undefined,
+      "recipients": Array [],
+      "senders": Array [],
+      "standard": undefined,
+      "tokenId": undefined,
+      "transactionSequenceNumber": 117,
+      "type": "DELEGATE",
+      "value": "8186",
+    },
     Object {
       "accountId": "js:2:cosmos:cosmos1g84934jpu3v5de5yqukkkhxmcvsw3u2ajxvpdl:",
       "blockHash": null,

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

@@ -0,0 +1,57 @@
+import BigNumber from "bignumber.js";
+import { CosmosAPI } from "./Cosmos";
+import network from "../../../network";
+jest.mock("../../../network");
+
+describe("CosmosApi", () => {
+  let cosmosApi: CosmosAPI;
+  describe("simulate", () => {
+    beforeEach(() => {
+      cosmosApi = new CosmosAPI("cosmos");
+    });
+    afterEach(() => {
+      jest.resetAllMocks();
+    });
+
+    describe("when the network call returns gas used", () => {
+      beforeEach(() => {
+        // @ts-expect-error method is mocked
+        network.mockResolvedValue({
+          data: {
+            gas_info: {
+              gas_used: 42000,
+            },
+          },
+        });
+      });
+      it("should return gas used", async () => {
+        const gas = await cosmosApi.simulate([]);
+        expect(gas).toEqual(new BigNumber(42000));
+      });
+    });
+
+    describe("when the network call does not return gas used", () => {
+      beforeEach(() => {
+        // @ts-expect-error method is mocked
+        network.mockResolvedValue({
+          data: { gas_info: {} },
+        });
+      });
+      it("should throw an error", async () => {
+        await expect(cosmosApi.simulate([])).rejects.toThrowError();
+      });
+    });
+
+    describe("when the network call fails", () => {
+      beforeEach(() => {
+        // @ts-expect-error method is mocked
+        network.mockImplementation(() => {
+          throw new Error();
+        });
+      });
+      it("should throw an error", async () => {
+        await expect(cosmosApi.simulate([])).rejects.toThrowError();
+      });
+    });
+  });
+});

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

@@ -93,7 +93,7 @@ export class CosmosAPI {
       url: `${this.defaultEndpoint}/cosmos/base/tendermint/${this.version}/blocks/latest`,
     });
 
-    return data.block.header.height;
+    return parseInt(data.block.header.height);
   };
 
   getAllBalances = async (
@@ -270,4 +270,25 @@ export class CosmosAPI {
 
     return patchOperationWithHash(operation, data.tx_response.txhash);
   };
+
+  /** Simulate a transaction on the node to get a precise estimation of gas used */
+  simulate = async (tx_bytes: number[]): Promise<BigNumber> => {
+    try {
+      const { data } = await network({
+        method: "POST",
+        url: `${this.defaultEndpoint}/cosmos/tx/${this.version}/simulate`,
+        data: {
+          tx_bytes,
+        },
+      });
+
+      if (data && data.gas_info && data.gas_info.gas_used) {
+        return new BigNumber(data.gas_info.gas_used);
+      } else {
+        throw new Error("No gas used returned from lcd");
+      }
+    } catch (e) {
+      throw new Error("Tx simulation failed");
+    }
+  };
 }

package/src/families/cosmos/chain/Osmosis.ts

@@ -14,14 +14,6 @@ class Osmosis extends CosmosBase {
     this.lcd = getEnv("API_OSMOSIS_NODE");
     this.stakingDocUrl =
       "https://support.ledger.com/hc/en-us/articles/6235986236957-Earn-Osmosis-OSMO-staking-rewards-in-Ledger-Live?docs=true";
-    this.gas = {
-      send: 100000,
-      delegate: 300000,
-      undelegate: 350000,
-      redelegate: 550000,
-      claimReward: 300000,
-      claimRewardCompound: 400000,
-    };
     this.minimalTransactionAmount = new BigNumber(10);
     this.validatorOperatorAddressPrefix = "osmovaloper";
     this.ledgerValidator = "osmovaloper17cp6fxccqxrpj4zc00w2c7u6y0umc2jajsyc5t";

package/src/families/cosmos/chain/cosmosBase.ts

@@ -1,4 +1,3 @@
-import { CosmosOperationMode } from "../types";
 import { BigNumber } from "bignumber.js";
 
 abstract class cosmosBase {
@@ -11,18 +10,6 @@ abstract class cosmosBase {
   minGasprice = 0.0025;
   minimalTransactionAmount = new BigNumber(10000);
   version = "v1beta1";
-  gas: {
-    [Key in CosmosOperationMode]: number;
-  } = {
-    // refer to https://github.com/chainapsis/keplr-wallet/blob/master/packages/stores/src/account/cosmos.ts#L113 for the gas fees
-    // TODO use simulate endpoint to evaluate tx gas instead of constant gas
-    send: 90000,
-    delegate: 250000,
-    undelegate: 250000,
-    redelegate: 300000,
-    claimReward: 180000,
-    claimRewardCompound: 400000,
-  };
   public static COSMOS_FAMILY_LEDGER_VALIDATOR_ADDRESSES: string[] = [];
 }
 

package/src/families/cosmos/js-buildTransaction.test.ts

@@ -0,0 +1,413 @@
+import { MsgDelegateEncodeObject } from "@cosmjs/stargate";
+import BigNumber from "bignumber.js";
+import { buildUnsignedPayloadTransaction } from "./js-buildTransaction";
+import { CosmosAccount, CosmosDelegationInfo, Transaction } from "./types";
+
+describe("buildTransactionWithUnsignedPayload", () => {
+  const transaction: Transaction = {} as Transaction;
+  const account: CosmosAccount = {
+    freshAddress: "accAddress",
+    currency: { units: [{ code: "atom" }, { code: "uatom" }] },
+  } as CosmosAccount;
+
+  describe("When transaction mode is send", () => {
+    beforeEach(() => {
+      transaction.mode = "send";
+    });
+
+    it("should return a MsgSend message if transaction is complete", async () => {
+      transaction.recipient = "address";
+      transaction.amount = new BigNumber(1000);
+      const [message] = (await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      )) as any[];
+      expect(message).toBeTruthy();
+      expect(message.typeUrl).toContain("MsgSend");
+      expect(message.value.toAddress).toEqual(transaction.recipient);
+      expect(message.value.fromAddress).toEqual(account.freshAddress);
+      expect(message.value.amount[0].amount).toEqual(
+        transaction.amount.toString()
+      );
+      expect(message.value.amount[0].denom).toEqual(
+        account.currency.units[1].code
+      );
+    });
+
+    it("should return no message if recipient isn't defined", async () => {
+      transaction.amount = new BigNumber(10);
+      transaction.recipient = "";
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if amount is zero", async () => {
+      transaction.amount = new BigNumber(0);
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if amount is negative", async () => {
+      transaction.amount = new BigNumber(-10);
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+  });
+
+  describe("When transaction mode is delegate", () => {
+    beforeEach(() => {
+      transaction.mode = "delegate";
+    });
+
+    it("should return a MsgDelegate message if transaction is complete", async () => {
+      transaction.amount = new BigNumber(1000);
+      transaction.validators = [
+        {
+          address: "realAddressTrustMe",
+          amount: new BigNumber(100),
+        } as CosmosDelegationInfo,
+      ];
+      const [message] = (await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      )) as MsgDelegateEncodeObject[];
+      expect(message).toBeTruthy();
+      expect(message.typeUrl).toContain("MsgDelegate");
+      expect(message.value.validatorAddress).toEqual(
+        transaction.validators[0].address
+      );
+      expect(message.value.delegatorAddress).toEqual(account.freshAddress);
+      expect(message.value.amount?.amount).toEqual(
+        transaction.amount.toString()
+      );
+      expect(message.value.amount?.denom).toEqual(
+        account.currency.units[1].code
+      );
+    });
+
+    it("should return no message if tx has a 0 amount", async () => {
+      transaction.amount = new BigNumber(0);
+      transaction.validators = [
+        { address: "realAddressTrustMe" } as CosmosDelegationInfo,
+      ];
+      const messages = (await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      )) as MsgDelegateEncodeObject[];
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if tx has a negative amount", async () => {
+      transaction.amount = new BigNumber(-1);
+      transaction.validators = [
+        { address: "realAddressTrustMe" } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validators has no address", async () => {
+      transaction.validators = [{} as CosmosDelegationInfo];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validators aren't defined", async () => {
+      transaction.validators = [];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+  });
+
+  describe("When transaction mode is undelegate", () => {
+    beforeEach(() => {
+      transaction.mode = "undelegate";
+    });
+
+    it("should return a MsgDelegate message if transaction is complete", async () => {
+      transaction.amount = new BigNumber(1000);
+      transaction.validators = [
+        {
+          address: "realAddressTrustMe",
+          amount: new BigNumber(100),
+        } as CosmosDelegationInfo,
+      ];
+      const [message] = (await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      )) as MsgDelegateEncodeObject[];
+      expect(message).toBeTruthy();
+      expect(message.typeUrl).toContain("MsgUndelegate");
+      expect(message.value.validatorAddress).toEqual(
+        transaction.validators[0].address
+      );
+      expect(message.value.delegatorAddress).toEqual(account.freshAddress);
+      expect(message.value.amount?.amount).toEqual(
+        transaction.validators[0].amount.toString()
+      );
+      expect(message.value.amount?.denom).toEqual(
+        account.currency.units[1].code
+      );
+    });
+
+    it("should return no message if validators aren't defined", async () => {
+      transaction.validators = [];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator address isn't defined", async () => {
+      transaction.validators = [
+        {
+          address: "",
+          amount: new BigNumber(100),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator amount is 0", async () => {
+      transaction.validators = [
+        {
+          address: "address",
+          amount: new BigNumber(0),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator amount is negative", async () => {
+      transaction.validators = [
+        {
+          address: "address",
+          amount: new BigNumber(-10),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+  });
+
+  describe("When transaction mode is redelegate", () => {
+    beforeEach(() => {
+      transaction.mode = "redelegate";
+    });
+
+    it("should return a MsgBeginRedelegate message if transaction is complete", async () => {
+      transaction.sourceValidator = "source";
+      transaction.validators = [
+        {
+          address: "realAddressTrustMe",
+          amount: new BigNumber(100),
+        } as CosmosDelegationInfo,
+      ];
+      const [message] = (await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      )) as any[];
+      expect(message).toBeTruthy();
+      expect(message.typeUrl).toContain("MsgBeginRedelegate");
+      expect(message.value.validatorSrcAddress).toEqual(
+        transaction.sourceValidator
+      );
+      expect(message.value.validatorDstAddress).toEqual(
+        transaction.validators[0].address
+      );
+      expect(message.value.delegatorAddress).toEqual(account.freshAddress);
+      expect(message.value.amount.amount).toEqual(
+        transaction.validators[0].amount.toString()
+      );
+      expect(message.value.amount.denom).toEqual(
+        account.currency.units[1].code
+      );
+    });
+
+    it("should return no message if sourceValidator isn't defined", async () => {
+      transaction.sourceValidator = "";
+      transaction.validators = [
+        {
+          address: "address",
+          amount: new BigNumber(100),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator address isn't defined", async () => {
+      transaction.validators = [
+        {
+          address: "",
+          amount: new BigNumber(100),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator amount is 0", async () => {
+      transaction.validators = [
+        {
+          address: "address",
+          amount: new BigNumber(0),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator amount is negative", async () => {
+      transaction.validators = [
+        {
+          address: "address",
+          amount: new BigNumber(-10),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+  });
+
+  describe("When transaction mode is claimReward", () => {
+    beforeEach(() => {
+      transaction.mode = "claimReward";
+    });
+
+    it("should return a MsgWithdrawDelegatorReward message if transaction is complete", async () => {
+      transaction.validators = [
+        {
+          address: "iAmAValidatorAddress",
+          amount: new BigNumber(1000),
+        } as CosmosDelegationInfo,
+      ];
+      const [message] = (await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      )) as any[];
+      expect(message).toBeTruthy();
+      expect(message.typeUrl).toContain("MsgWithdrawDelegatorReward");
+      expect(message.value.validatorAddress).toEqual(
+        transaction.validators[0].address
+      );
+      expect(message.value.delegatorAddress).toEqual(account.freshAddress);
+    });
+
+    it("should return no message if validator isn't defined", async () => {
+      transaction.validators = [];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+
+    it("should return no message if validator address isn't defined", async () => {
+      transaction.validators = [
+        {
+          address: "",
+          amount: new BigNumber(1000),
+        } as CosmosDelegationInfo,
+      ];
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+  });
+
+  describe("When transaction mode is claimRewardCompound", () => {
+    beforeEach(() => {
+      transaction.mode = "claimRewardCompound";
+    });
+
+    it("should return a MsgWithdrawDelegatorReward message and a MsgDelegate if transaction is complete", async () => {
+      transaction.validators = [
+        {
+          address: "iAmAValidatorAddress",
+          amount: new BigNumber(1000),
+        } as CosmosDelegationInfo,
+      ];
+      const [withDrawMessage, delegateMessage] =
+        (await buildUnsignedPayloadTransaction(account, transaction)) as any[];
+      expect(withDrawMessage).toBeTruthy();
+      expect(withDrawMessage.typeUrl).toContain("MsgWithdrawDelegatorReward");
+      expect(withDrawMessage.value.validatorAddress).toEqual(
+        transaction.validators[0].address
+      );
+      expect(withDrawMessage.value.delegatorAddress).toEqual(
+        account.freshAddress
+      );
+      expect(delegateMessage).toBeTruthy();
+      expect(delegateMessage.typeUrl).toContain("MsgDelegate");
+      expect(delegateMessage.value.validatorAddress).toEqual(
+        transaction.validators[0].address
+      );
+      expect(delegateMessage.value.delegatorAddress).toEqual(
+        account.freshAddress
+      );
+      expect(delegateMessage.value.amount.amount).toEqual(
+        transaction.validators[0].amount.toString()
+      );
+      expect(delegateMessage.value.amount.denom).toEqual(
+        account.currency.units[1].code
+      );
+    });
+  });
+
+  describe("When transaction mode isn't known", () => {
+    it("should return no message", async () => {
+      // @ts-expect-error Random mode that isn't listed in typescript type
+      transaction.mode = "RandomModeThatICreatedMyself";
+      const messages = await buildUnsignedPayloadTransaction(
+        account,
+        transaction
+      );
+      expect(messages.length).toEqual(0);
+    });
+  });
+});