@ledgerhq/live-common 34.3.0-windows-certificate.0 → 35.0.0-next.6

package/lib-es/families/cosmos/buildTransaction.unit.test.js

@@ -0,0 +1,738 @@
+import BigNumber from "bignumber.js";
+import { buildTransaction, txToMessages } from "./buildTransaction";
+import { MsgDelegate, MsgUndelegate, MsgBeginRedelegate, } from "cosmjs-types/cosmos/staking/v1beta1/tx";
+import { cosmos } from "@keplr-wallet/cosmos";
+import { MsgWithdrawDelegatorReward } from "cosmjs-types/cosmos/distribution/v1beta1/tx";
+import { TxBody, TxRaw } from "cosmjs-types/cosmos/tx/v1beta1/tx";
+import { Fee } from "@keplr-wallet/proto-types/cosmos/tx/v1beta1/tx";
+const veryBigNumber = new BigNumber(3333300000000000000000);
+describe("txToMessages", () => {
+    const transaction = {};
+    const account = {
+        freshAddress: "accAddress",
+        currency: { units: [{ code: "atom" }, { code: "uatom" }] },
+    };
+    describe("When transaction mode is send", () => {
+        beforeEach(() => {
+            transaction.mode = "send";
+        });
+        describe("Amino", () => {
+            it("should return a MsgSend message if transaction is complete", () => {
+                transaction.recipient = "address";
+                transaction.amount = new BigNumber(1000);
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [aminoMsg] = aminoMsgs;
+                expect(aminoMsg).toBeTruthy();
+                expect(aminoMsg.type).toContain("MsgSend");
+                expect(aminoMsg.value.to_address).toEqual(transaction.recipient);
+                expect(aminoMsg.value.from_address).toEqual(account.freshAddress);
+                expect(aminoMsg.value.amount[0].amount).toEqual(transaction.amount.toFixed());
+                expect(aminoMsg.value.amount[0].denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                transaction.recipient = "address";
+                transaction.amount = veryBigNumber;
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [aminoMsg] = aminoMsgs;
+                expect(aminoMsg.value.amount[0].amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if recipient isn't defined", () => {
+                transaction.amount = new BigNumber(10);
+                transaction.recipient = "";
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if amount is zero", () => {
+                transaction.amount = new BigNumber(0);
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if amount is negative", () => {
+                transaction.amount = new BigNumber(-10);
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if amount is negative", () => {
+                transaction.amount = new BigNumber(-10);
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+        });
+        describe("Proto", () => {
+            it("should return a MsgSend message if transaction is complete", () => {
+                transaction.recipient = "address";
+                transaction.amount = new BigNumber(1000);
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [protoMsg] = protoMsgs;
+                const value = cosmos.bank.v1beta1.MsgSend.decode(protoMsg.value);
+                expect(protoMsg).toBeTruthy();
+                expect(protoMsg.typeUrl).toContain("MsgSend");
+                expect(value.toAddress).toEqual(transaction.recipient);
+                expect(value.fromAddress).toEqual(account.freshAddress);
+                expect(value.amount[0].amount).toEqual(transaction.amount.toFixed());
+                expect(value.amount[0].denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                var _a;
+                transaction.recipient = "address";
+                transaction.amount = veryBigNumber;
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [protoMsg] = protoMsgs;
+                const value = cosmos.bank.v1beta1.MsgSend.decode(protoMsg.value);
+                expect((_a = value.amount[0].amount) === null || _a === void 0 ? void 0 : _a.includes("e")).toEqual(false);
+            });
+            it("should return no message if recipient isn't defined", () => {
+                transaction.amount = new BigNumber(10);
+                transaction.recipient = "";
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if amount is zero", () => {
+                transaction.amount = new BigNumber(0);
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if amount is negative", () => {
+                transaction.amount = new BigNumber(-10);
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+        });
+    });
+    describe("When transaction mode is delegate", () => {
+        beforeEach(() => {
+            transaction.mode = "delegate";
+        });
+        describe("Amino", () => {
+            it("should return a MsgDelegate message if transaction is complete", () => {
+                var _a, _b;
+                transaction.amount = new BigNumber(1000);
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.type).toContain("MsgDelegate");
+                expect(message.value.validator_address).toEqual(transaction.validators[0].address);
+                expect(message.value.delegator_address).toEqual(account.freshAddress);
+                expect((_a = message.value.amount) === null || _a === void 0 ? void 0 : _a.amount).toEqual(transaction.amount.toFixed());
+                expect((_b = message.value.amount) === null || _b === void 0 ? void 0 : _b.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                var _a;
+                transaction.recipient = "address";
+                transaction.amount = veryBigNumber;
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect((_a = message.value.amount) === null || _a === void 0 ? void 0 : _a.amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if tx has a 0 amount", () => {
+                transaction.amount = new BigNumber(0);
+                transaction.validators = [{ address: "realAddressTrustMe" }];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if tx has a negative amount", () => {
+                transaction.amount = new BigNumber(-1);
+                transaction.validators = [{ address: "realAddressTrustMe" }];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validators has no address", () => {
+                transaction.validators = [{}];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validators aren't defined", () => {
+                transaction.validators = [];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+        });
+        describe("Proto", () => {
+            it("should return a MsgDelegate message if transaction is complete", () => {
+                var _a, _b;
+                transaction.amount = new BigNumber(1000);
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.typeUrl).toContain("MsgDelegate");
+                const value = MsgDelegate.decode(message.value);
+                expect(value.validatorAddress).toEqual(transaction.validators[0].address);
+                expect(value.delegatorAddress).toEqual(account.freshAddress);
+                expect((_a = value.amount) === null || _a === void 0 ? void 0 : _a.amount).toEqual(transaction.amount.toFixed());
+                expect((_b = value.amount) === null || _b === void 0 ? void 0 : _b.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                var _a;
+                transaction.amount = veryBigNumber;
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                const value = MsgDelegate.decode(message.value);
+                expect((_a = value.amount) === null || _a === void 0 ? void 0 : _a.amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if tx has a 0 amount", () => {
+                transaction.amount = new BigNumber(0);
+                transaction.validators = [{ address: "realAddressTrustMe" }];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if tx has a negative amount", () => {
+                transaction.amount = new BigNumber(-1);
+                transaction.validators = [{ address: "realAddressTrustMe" }];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validators has no address", () => {
+                transaction.validators = [{}];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validators aren't defined", () => {
+                transaction.validators = [];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+        });
+    });
+    describe("When transaction mode is undelegate", () => {
+        beforeEach(() => {
+            transaction.mode = "undelegate";
+        });
+        describe("Amino", () => {
+            it("should return a MsgUndelegate message if transaction is complete", () => {
+                var _a, _b;
+                transaction.amount = new BigNumber(1000);
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.type).toContain("MsgUndelegate");
+                expect(message.value.validator_address).toEqual(transaction.validators[0].address);
+                expect(message.value.delegator_address).toEqual(account.freshAddress);
+                expect((_a = message.value.amount) === null || _a === void 0 ? void 0 : _a.amount).toEqual(transaction.validators[0].amount.toFixed());
+                expect((_b = message.value.amount) === null || _b === void 0 ? void 0 : _b.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                var _a;
+                transaction.amount = veryBigNumber;
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect((_a = message.value.amount) === null || _a === void 0 ? void 0 : _a.amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if validators aren't defined", () => {
+                transaction.validators = [];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator address isn't defined", () => {
+                transaction.validators = [
+                    {
+                        address: "",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is 0", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(0),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is negative", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(-10),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+        });
+        describe("Proto", () => {
+            it("should return a MsgUndelegate message if transaction is complete", () => {
+                var _a, _b;
+                transaction.amount = new BigNumber(1000);
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.typeUrl).toContain("MsgUndelegate");
+                const value = MsgUndelegate.decode(message.value);
+                expect(value.validatorAddress).toEqual(transaction.validators[0].address);
+                expect(value.delegatorAddress).toEqual(account.freshAddress);
+                expect((_a = value.amount) === null || _a === void 0 ? void 0 : _a.amount).toEqual(transaction.validators[0].amount.toFixed());
+                expect((_b = value.amount) === null || _b === void 0 ? void 0 : _b.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                var _a;
+                transaction.amount = veryBigNumber;
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                const value = MsgUndelegate.decode(message.value);
+                expect((_a = value.amount) === null || _a === void 0 ? void 0 : _a.amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if validators aren't defined", () => {
+                transaction.validators = [];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator address isn't defined", () => {
+                transaction.validators = [
+                    {
+                        address: "",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is 0", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(0),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is negative", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(-10),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+        });
+    });
+    describe("When transaction mode is redelegate", () => {
+        beforeEach(() => {
+            transaction.mode = "redelegate";
+        });
+        describe("Amino", () => {
+            it("should return a MsgBeginRedelegate message if transaction is complete", () => {
+                transaction.sourceValidator = "source";
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.type).toContain("MsgBeginRedelegate");
+                expect(message.value.validator_src_address).toEqual(transaction.sourceValidator);
+                expect(message.value.validator_dst_address).toEqual(transaction.validators[0].address);
+                expect(message.value.delegator_address).toEqual(account.freshAddress);
+                expect(message.value.amount.amount).toEqual(transaction.validators[0].amount.toFixed());
+                expect(message.value.amount.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                transaction.sourceValidator = "source";
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect(message.value.amount.amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if sourceValidator isn't defined", () => {
+                transaction.sourceValidator = "";
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator address isn't defined", () => {
+                transaction.validators = [
+                    {
+                        address: "",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is 0", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(0),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is negative", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(-10),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+        });
+        describe("Proto", () => {
+            it("should return a MsgBeginRedelegate message if transaction is complete", () => {
+                var _a, _b;
+                transaction.sourceValidator = "source";
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.typeUrl).toContain("MsgBeginRedelegate");
+                const value = MsgBeginRedelegate.decode(message.value);
+                expect(value.validatorSrcAddress).toEqual(transaction.sourceValidator);
+                expect(value.validatorDstAddress).toEqual(transaction.validators[0].address);
+                expect(value.delegatorAddress).toEqual(account.freshAddress);
+                expect((_a = value.amount) === null || _a === void 0 ? void 0 : _a.amount).toEqual(transaction.validators[0].amount.toFixed());
+                expect((_b = value.amount) === null || _b === void 0 ? void 0 : _b.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                var _a;
+                transaction.sourceValidator = "source";
+                transaction.validators = [
+                    {
+                        address: "realAddressTrustMe",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                expect(message).toBeTruthy();
+                const value = MsgBeginRedelegate.decode(message.value);
+                expect((_a = value.amount) === null || _a === void 0 ? void 0 : _a.amount.includes("e")).toEqual(false);
+            });
+            it("should return no message if sourceValidator isn't defined", () => {
+                transaction.sourceValidator = "";
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator address isn't defined", () => {
+                transaction.validators = [
+                    {
+                        address: "",
+                        amount: new BigNumber(100),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is 0", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(0),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator amount is negative", () => {
+                transaction.validators = [
+                    {
+                        address: "address",
+                        amount: new BigNumber(-10),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+        });
+    });
+    describe("When transaction mode is claimReward", () => {
+        beforeEach(() => {
+            transaction.mode = "claimReward";
+        });
+        describe("Amino", () => {
+            it("should return a MsgWithdrawDelegationReward message if transaction is complete", () => {
+                transaction.validators = [
+                    {
+                        address: "iAmAValidatorAddress",
+                        amount: new BigNumber(1000),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [message] = aminoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.type).toContain("MsgWithdrawDelegationReward");
+                expect(message.value.validator_address).toEqual(transaction.validators[0].address);
+                expect(message.value.delegator_address).toEqual(account.freshAddress);
+            });
+            it("should return no message if validator isn't defined", () => {
+                transaction.validators = [];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator address isn't defined", () => {
+                transaction.validators = [
+                    {
+                        address: "",
+                        amount: new BigNumber(1000),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+        });
+        describe("Proto", () => {
+            it("should return a MsgWithdrawDelegatorReward message if transaction is complete", () => {
+                transaction.validators = [
+                    {
+                        address: "iAmAValidatorAddress",
+                        amount: new BigNumber(1000),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [message] = protoMsgs;
+                expect(message).toBeTruthy();
+                expect(message.typeUrl).toContain("MsgWithdrawDelegatorReward");
+                const value = MsgWithdrawDelegatorReward.decode(message.value);
+                expect(value.validatorAddress).toEqual(transaction.validators[0].address);
+                expect(value.delegatorAddress).toEqual(account.freshAddress);
+            });
+            it("should return no message if validator isn't defined", () => {
+                transaction.validators = [];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+            it("should return no message if validator address isn't defined", () => {
+                transaction.validators = [
+                    {
+                        address: "",
+                        amount: new BigNumber(1000),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+        });
+    });
+    describe("When transaction mode is claimRewardCompound", () => {
+        beforeEach(() => {
+            transaction.mode = "claimRewardCompound";
+        });
+        describe("Amino", () => {
+            it("should return a MsgWithdrawDelegationReward message and a MsgDelegate if transaction is complete", () => {
+                transaction.validators = [
+                    {
+                        address: "iAmAValidatorAddress",
+                        amount: new BigNumber(1000),
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [withDrawMessage, delegateMessage] = aminoMsgs;
+                expect(withDrawMessage).toBeTruthy();
+                expect(withDrawMessage.type).toContain("MsgWithdrawDelegationReward");
+                expect(withDrawMessage.value.validator_address).toEqual(transaction.validators[0].address);
+                expect(withDrawMessage.value.delegator_address).toEqual(account.freshAddress);
+                expect(delegateMessage).toBeTruthy();
+                expect(delegateMessage.type).toContain("MsgDelegate");
+                expect(delegateMessage.value.validator_address).toEqual(transaction.validators[0].address);
+                expect(delegateMessage.value.delegator_address).toEqual(account.freshAddress);
+                expect(delegateMessage.value.amount.amount).toEqual(transaction.validators[0].amount.toFixed());
+                expect(delegateMessage.value.amount.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should not include exponential part on big numbers", () => {
+                transaction.validators = [
+                    {
+                        address: "iAmAValidatorAddress",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { aminoMsgs } = txToMessages(account, transaction);
+                const [, delegateMessage] = aminoMsgs;
+                expect(delegateMessage.value.amount.amount.includes("e")).toEqual(false);
+            });
+        });
+        describe("Proto", () => {
+            it("should return a MsgWithdrawDelegatorReward message and a MsgDelegate if transaction is complete", () => {
+                var _a, _b;
+                transaction.validators = [
+                    {
+                        address: "iAmAValidatorAddress",
+                        amount: new BigNumber(1000),
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [withDrawMessage, delegateMessage] = protoMsgs;
+                expect(withDrawMessage).toBeTruthy();
+                expect(withDrawMessage.typeUrl).toContain("MsgWithdrawDelegatorReward");
+                const withDrawMessageValue = MsgWithdrawDelegatorReward.decode(withDrawMessage.value);
+                expect(withDrawMessageValue.validatorAddress).toEqual(transaction.validators[0].address);
+                expect(withDrawMessageValue.delegatorAddress).toEqual(account.freshAddress);
+                expect(delegateMessage).toBeTruthy();
+                expect(delegateMessage.typeUrl).toContain("MsgDelegate");
+                const delegateMessageValue = MsgDelegate.decode(delegateMessage.value);
+                expect(delegateMessageValue.validatorAddress).toEqual(transaction.validators[0].address);
+                expect(delegateMessageValue.delegatorAddress).toEqual(account.freshAddress);
+                expect((_a = delegateMessageValue.amount) === null || _a === void 0 ? void 0 : _a.amount).toEqual(transaction.validators[0].amount.toFixed());
+                expect((_b = delegateMessageValue.amount) === null || _b === void 0 ? void 0 : _b.denom).toEqual(account.currency.units[1].code);
+            });
+            it("should return a MsgWithdrawDelegatorReward message and a MsgDelegate if transaction is complete", () => {
+                var _a;
+                transaction.validators = [
+                    {
+                        address: "iAmAValidatorAddress",
+                        amount: veryBigNumber,
+                    },
+                ];
+                const { protoMsgs } = txToMessages(account, transaction);
+                const [, delegateMessage] = protoMsgs;
+                const delegateMessageValue = MsgDelegate.decode(delegateMessage.value);
+                expect((_a = delegateMessageValue.amount) === null || _a === void 0 ? void 0 : _a.amount.includes("e")).toEqual(false);
+            });
+        });
+    });
+    describe("When transaction mode isn't known", () => {
+        describe("Amino", () => {
+            it("should return no message", () => {
+                // @ts-expect-error Random mode that isn't listed in typescript type
+                transaction.mode = "RandomModeThatICreatedMyself";
+                const { aminoMsgs } = txToMessages(account, transaction);
+                expect(aminoMsgs.length).toEqual(0);
+            });
+        });
+        describe("Proto", () => {
+            it("should return no message", () => {
+                // @ts-expect-error Random mode that isn't listed in typescript type
+                transaction.mode = "RandomModeThatICreatedMyself";
+                const { protoMsgs } = txToMessages(account, transaction);
+                expect(protoMsgs.length).toEqual(0);
+            });
+        });
+    });
+});
+describe("buildTransaction", () => {
+    let bodyFromPartialSpy;
+    let feeFromPartialSpy;
+    let txRawEncodeSpy;
+    const defaultInfos = {
+        memo: "test",
+        pubKey: "pubkey",
+        sequence: "1",
+        protoMsgs: [],
+        pubKeyType: "type",
+        signature: new Uint8Array(),
+        feeAmount: undefined,
+        gasLimit: undefined,
+    };
+    beforeEach(() => {
+        bodyFromPartialSpy = jest.spyOn(TxBody, "fromPartial");
+        feeFromPartialSpy = jest.spyOn(Fee, "fromPartial");
+        txRawEncodeSpy = jest.spyOn(TxRaw, "encode");
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it("should set memo", () => {
+        buildTransaction(Object.assign(Object.assign({}, defaultInfos), { memo: "toto" }));
+        expect(bodyFromPartialSpy).toHaveBeenCalledWith(expect.objectContaining({
+            memo: "toto",
+        }));
+    });
+    it("should set gasLimit", () => {
+        buildTransaction(Object.assign(Object.assign({}, defaultInfos), { gasLimit: "10" }));
+        expect(feeFromPartialSpy).toHaveBeenCalledWith(expect.objectContaining({
+            gasLimit: "10",
+        }));
+    });
+    it("should set messages", () => {
+        buildTransaction(Object.assign(Object.assign({}, defaultInfos), { protoMsgs: [
+                {
+                    typeUrl: "typeUrl",
+                    value: new Uint8Array(),
+                },
+            ] }));
+        expect(bodyFromPartialSpy).toHaveBeenCalledWith(expect.objectContaining({
+            messages: [
+                {
+                    typeUrl: "typeUrl",
+                    value: new Uint8Array(),
+                },
+            ],
+        }));
+    });
+    it("should set signature", () => {
+        const signature = new Uint8Array([8]);
+        buildTransaction(Object.assign(Object.assign({}, defaultInfos), { signature }));
+        expect(txRawEncodeSpy).toHaveBeenCalledWith(expect.objectContaining({ signatures: [signature] }));
+    });
+});
+//# sourceMappingURL=buildTransaction.unit.test.js.map