@ledgerhq/coin-evm 0.6.1 → 0.7.0-next.0

package/lib/__tests__/unit/getTransactionStatus.unit.test.js

@@ -12,12 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const cryptoassets_1 = require("@ledgerhq/cryptoassets");
 const errors_1 = require("@ledgerhq/errors");
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const cryptoassets_1 = require("@ledgerhq/cryptoassets");
-const common_fixtures_1 = require("../fixtures/common.fixtures");
-const getTransactionStatus_1 = __importDefault(require("../../getTransactionStatus"));
+const fast_check_1 = __importDefault(require("fast-check"));
 const errors_2 = require("../../errors");
+const getTransactionStatus_1 = __importDefault(require("../../getTransactionStatus"));
+const common_fixtures_1 = require("../fixtures/common.fixtures");
 const recipient = "0xe2ca7390e76c5A992749bB622087310d2e63ca29"; // rambo.eth
 const testData = Buffer.from("testBufferString").toString("hex");
 const tokenAccount = (0, common_fixtures_1.makeTokenAccount)("0xkvn", (0, cryptoassets_1.getTokenById)("ethereum/erc20/usd__coin"));
@@ -53,6 +54,22 @@ const eip1559Tx = {
     maxPriorityFeePerGas: new bignumber_js_1.default(100),
     type: 2,
 };
+const erc721Nft = {
+    contract: "0xNftContract",
+    tokenId: "1",
+    amount: new bignumber_js_1.default(1),
+    currencyId: account.currency.id,
+    id: "doesn't matter",
+    standard: "ERC721",
+};
+const erc1155Nft = {
+    contract: "0xAnotherNftContract",
+    tokenId: "2",
+    amount: new bignumber_js_1.default(2),
+    currencyId: account.currency.id,
+    id: "still doesn't matter",
+    standard: "ERC1155",
+};
 const gasOptions = {
     slow: {
         maxFeePerGas: new bignumber_js_1.default(1),
@@ -88,7 +105,7 @@ describe("EVM Family", () => {
                 const res = yield (0, getTransactionStatus_1.default)(account, tx);
                 expect(res.errors).toEqual(expect.objectContaining({
                     recipient: new errors_1.InvalidAddress("", {
-                        currency: account.currency,
+                        currencyName: account.currency.name,
                     }),
                 }));
             }));
@@ -97,11 +114,11 @@ describe("EVM Family", () => {
                 const res = yield (0, getTransactionStatus_1.default)(account, tx);
                 expect(res.errors).toEqual(expect.objectContaining({
                     recipient: new errors_1.InvalidAddress("", {
-                        currency: account.currency,
+                        currencyName: account.currency.name,
                     }),
                 }));
             }));
-            it("should detect the recipient not being an EIP55 address and have an warning", () => __awaiter(void 0, void 0, void 0, function* () {
+            it("should detect the recipient not being an EIP55 address and have a warning", () => __awaiter(void 0, void 0, void 0, function* () {
                 const tx = Object.assign(Object.assign({}, eip1559Tx), { recipient: recipient.toLowerCase() });
                 const res = yield (0, getTransactionStatus_1.default)(account, tx);
                 expect(res.warnings).toEqual(expect.objectContaining({
@@ -137,133 +154,102 @@ describe("EVM Family", () => {
             }));
         });
         describe("Gas", () => {
-            it("should detect missing fees in a 1559 tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const tx = Object.assign(Object.assign({}, eip1559Tx), { maxFeePerGas: undefined });
-                const res = yield (0, getTransactionStatus_1.default)(account, tx);
-                expect(res.errors).toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.FeeNotLoaded(),
-                }));
-            }));
-            it("should detect missing fees in a legacy tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const tx = Object.assign(Object.assign({}, legacyTx), { gasPrice: undefined });
-                const res = yield (0, getTransactionStatus_1.default)(account, tx);
-                expect(res.errors).toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.FeeNotLoaded(),
-                }));
-            }));
-            it("should detect a gasLimit = 0 in a 1559 tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const tx = Object.assign(Object.assign({}, eip1559Tx), { gasLimit: new bignumber_js_1.default(0) });
-                const res = yield (0, getTransactionStatus_1.default)(account, tx);
-                expect(res.errors).toEqual(expect.objectContaining({
-                    gasLimit: new errors_1.FeeNotLoaded(),
-                }));
-            }));
-            it("should detect a gasLimit = 0 in a legacy tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const tx = Object.assign(Object.assign({}, legacyTx), { gasLimit: new bignumber_js_1.default(0) });
-                const res = yield (0, getTransactionStatus_1.default)(account, tx);
-                expect(res.errors).toEqual(expect.objectContaining({
-                    gasLimit: new errors_1.FeeNotLoaded(),
-                }));
-            }));
-            it("should detect gas limit being too low in a tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const tx = Object.assign(Object.assign({}, eip1559Tx), { gasLimit: new bignumber_js_1.default(20000) }); // min should be 21000
-                const res = yield (0, getTransactionStatus_1.default)(account, tx);
-                expect(res.errors).toEqual(expect.objectContaining({
-                    gasLimit: new errors_1.GasLessThanEstimate(),
-                }));
-            }));
-            it("should detect gas being too high in a 1559 tx for the account balance and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const notEnoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2099999) }), eip1559Tx);
-                const enoughhBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100000) }), eip1559Tx);
-                expect(notEnoughBalanceResponse.errors).toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-                expect(enoughhBalanceResponse.errors).not.toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-            }));
-            it("should detect a maxPriorityFee = 0 in a 1559 tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100000) }), Object.assign(Object.assign({}, eip1559Tx), { maxPriorityFeePerGas: new bignumber_js_1.default(0) }));
-                expect(res.errors).toEqual(expect.objectContaining({
-                    maxPriorityFee: new errors_1.PriorityFeeTooLow(),
-                }));
-            }));
-            it("should detect gas being too high in a legacy tx for the account balance and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const notEnoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2099999) }), legacyTx);
-                const enoughhBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100001) }), legacyTx);
-                expect(notEnoughBalanceResponse.errors).toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-                expect(enoughhBalanceResponse.errors).not.toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-            }));
-            it("should not detect gas being too high in a 1559 tx when there is no recipient and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const notEnoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2099999) }), Object.assign(Object.assign({}, eip1559Tx), { recipient: "" }));
-                const enoughhBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100000) }), Object.assign(Object.assign({}, eip1559Tx), { recipient: "" }));
-                expect(notEnoughBalanceResponse.errors).not.toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-                expect(enoughhBalanceResponse.errors).not.toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-            }));
-            it("should not detect gas being too high in a legacy tx when there is no recipient and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const notEnoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2099999) }), Object.assign(Object.assign({}, legacyTx), { recipient: "" }));
-                const enoughhBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100001) }), Object.assign(Object.assign({}, legacyTx), { recipient: "" }));
-                expect(notEnoughBalanceResponse.errors).not.toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-                expect(enoughhBalanceResponse.errors).not.toEqual(expect.objectContaining({
-                    gasPrice: new errors_1.NotEnoughGas(),
-                }));
-            }));
-            it("should detect maxFeePerGas being greater than max gasOptions maxFeePerGas and error", () => __awaiter(void 0, void 0, void 0, function* () {
-                const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxFeePerGas: new bignumber_js_1.default(5) }));
-                expect(response.errors).toEqual(expect.objectContaining({
-                    maxPriorityFee: new errors_1.PriorityFeeHigherThanMaxFee(),
-                }));
-            }));
-            it("should detect customGasLimit being lower than gasLimit and warn", () => __awaiter(void 0, void 0, void 0, function* () {
-                const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { customGasLimit: eip1559Tx.gasLimit.minus(1) }));
-                expect(response.warnings).toEqual(expect.objectContaining({
-                    gasLimit: new errors_1.GasLessThanEstimate(),
-                }));
-            }));
-            it("should detect maxPriorityFeePerGas being greater than max gasOptions maxPriorityFeePerGas and warn", () => __awaiter(void 0, void 0, void 0, function* () {
-                const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxPriorityFeePerGas: new bignumber_js_1.default(4) }));
-                expect(response.warnings).toEqual(expect.objectContaining({
-                    maxPriorityFee: new errors_1.PriorityFeeTooHigh(),
-                }));
-            }));
-            it("should detect maxPriorityFeePerGas being lower than min gasOptions maxPriorityFeePerGas and warn", () => __awaiter(void 0, void 0, void 0, function* () {
-                const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxPriorityFeePerGas: new bignumber_js_1.default(0.5) }));
-                expect(response.warnings).toEqual(expect.objectContaining({
-                    maxPriorityFee: new errors_1.PriorityFeeTooLow(),
-                }));
-            }));
-            it("should detect maxFeePerGas being lower than recommanded next base fee and warn", () => __awaiter(void 0, void 0, void 0, function* () {
-                const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxFeePerGas: new bignumber_js_1.default(1) }));
-                expect(response.warnings).toEqual(expect.objectContaining({
-                    maxFee: new errors_1.MaxFeeTooLow(),
-                }));
-            }));
+            describe("Common", () => {
+                describe.each([
+                    { type: "Legacy", defaultTx: legacyTx },
+                    { type: "EIP1559", defaultTx: eip1559Tx },
+                ])("Transaction Type: $type", ({ defaultTx }) => {
+                    it("should detect missing fees and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const tx = Object.assign(Object.assign({}, defaultTx), { gasPrice: undefined, maxFeePerGas: undefined });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.errors).toEqual(expect.objectContaining({
+                            gasPrice: new errors_1.FeeNotLoaded(),
+                        }));
+                    }));
+                    it("should detect a gasLimit = 0 and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const tx = Object.assign(Object.assign({}, defaultTx), { gasLimit: new bignumber_js_1.default(0) });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.errors).toEqual(expect.objectContaining({
+                            gasLimit: new errors_1.FeeNotLoaded(),
+                        }));
+                    }));
+                    it("should detect gas being too high for the account balance and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const notEnoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2099999) }), defaultTx);
+                        const enoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100001) }), defaultTx);
+                        expect(notEnoughBalanceResponse.errors).toEqual(expect.objectContaining({
+                            gasPrice: new errors_1.NotEnoughGas(),
+                        }));
+                        expect(enoughBalanceResponse.errors).not.toEqual(expect.objectContaining({
+                            gasPrice: new errors_1.NotEnoughGas(),
+                        }));
+                    }));
+                    it("should not detect gas being too high when there is no recipient and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const notEnoughBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2099999) }), Object.assign(Object.assign({}, defaultTx), { recipient: "" }));
+                        const enoughhBalanceResponse = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100001) }), Object.assign(Object.assign({}, defaultTx), { recipient: "" }));
+                        expect(notEnoughBalanceResponse.errors).not.toEqual(expect.objectContaining({
+                            gasPrice: new errors_1.NotEnoughGas(),
+                        }));
+                        expect(enoughhBalanceResponse.errors).not.toEqual(expect.objectContaining({
+                            gasPrice: new errors_1.NotEnoughGas(),
+                        }));
+                    }));
+                    it("should detect gas limit being too low in a tx and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const tx = Object.assign(Object.assign({}, defaultTx), { gasLimit: new bignumber_js_1.default(20000) }); // min should be 21000
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.errors).toEqual(expect.objectContaining({
+                            gasLimit: new errors_1.GasLessThanEstimate(),
+                        }));
+                    }));
+                });
+            });
+            describe("Specific", () => {
+                describe("Transaction Type: EIP1559", () => {
+                    it("should detect a maxPriorityFee = 0 and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { balance: new bignumber_js_1.default(2100000) }), Object.assign(Object.assign({}, eip1559Tx), { maxPriorityFeePerGas: new bignumber_js_1.default(0) }));
+                        expect(res.errors).toEqual(expect.objectContaining({
+                            maxPriorityFee: new errors_1.PriorityFeeTooLow(),
+                        }));
+                    }));
+                    it("should detect maxFeePerGas being greater than max gasOptions maxFeePerGas and error", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxFeePerGas: new bignumber_js_1.default(5) }));
+                        expect(response.errors).toEqual(expect.objectContaining({
+                            maxPriorityFee: new errors_1.PriorityFeeHigherThanMaxFee(),
+                        }));
+                    }));
+                    it("should detect customGasLimit being lower than gasLimit and warn", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { customGasLimit: eip1559Tx.gasLimit.minus(1) }));
+                        expect(response.warnings).toEqual(expect.objectContaining({
+                            gasLimit: new errors_1.GasLessThanEstimate(),
+                        }));
+                    }));
+                    it("should detect maxPriorityFeePerGas being greater than max gasOptions maxPriorityFeePerGas and warn", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxPriorityFeePerGas: new bignumber_js_1.default(4) }));
+                        expect(response.warnings).toEqual(expect.objectContaining({
+                            maxPriorityFee: new errors_1.PriorityFeeTooHigh(),
+                        }));
+                    }));
+                    it("should detect maxPriorityFeePerGas being lower than min gasOptions maxPriorityFeePerGas and warn", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxPriorityFeePerGas: new bignumber_js_1.default(0.5) }));
+                        expect(response.warnings).toEqual(expect.objectContaining({
+                            maxPriorityFee: new errors_1.PriorityFeeTooLow(),
+                        }));
+                    }));
+                    it("should detect maxFeePerGas being lower than recommanded next base fee and warn", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const response = yield (0, getTransactionStatus_1.default)(account, Object.assign(Object.assign({}, eip1559Tx), { gasOptions, maxFeePerGas: new bignumber_js_1.default(1) }));
+                        expect(response.warnings).toEqual(expect.objectContaining({
+                            maxFee: new errors_1.MaxFeeTooLow(),
+                        }));
+                    }));
+                });
+            });
         });
         describe("Nft", () => {
             describe("ERC721", () => {
-                const nft = {
-                    contract: "0xNftContract",
-                    tokenId: "1",
-                    amount: new bignumber_js_1.default(1),
-                    currencyId: account.currency.id,
-                    id: "doesn't matter",
-                    standard: "ERC721",
-                };
                 it("should detect a transaction for an ERC721 nft not owned by the account and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
                     const tx = Object.assign(Object.assign({}, eip1559Tx), { mode: "erc721", nft: {
                             collectionName: "",
-                            contract: nft.contract,
-                            tokenId: nft.tokenId,
+                            contract: erc721Nft.contract,
+                            tokenId: erc721Nft.tokenId,
                             quantity: new bignumber_js_1.default(1),
                         } });
                     const res = yield (0, getTransactionStatus_1.default)(account, tx);
@@ -271,21 +257,26 @@ describe("EVM Family", () => {
                         amount: new errors_2.NotOwnedNft(),
                     }));
                 }));
+                it("should detect a transaction for an ERC721 nft owned by the account but it does not have enough balance to pay for gas and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                    const tx = Object.assign(Object.assign({}, eip1559Tx), { mode: "erc721", nft: {
+                            collectionName: "",
+                            contract: erc721Nft.contract,
+                            tokenId: erc721Nft.tokenId,
+                            quantity: new bignumber_js_1.default(1),
+                        } });
+                    const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { nfts: [erc721Nft] }), tx);
+                    expect(res.errors).toEqual(expect.objectContaining({
+                        amount: new errors_1.NotEnoughBalanceInParentAccount(),
+                        gasPrice: new errors_1.NotEnoughGas(),
+                    }));
+                }));
             });
             describe("ERC1155", () => {
-                const nft = {
-                    contract: "0xAnotherNftContract",
-                    tokenId: "2",
-                    amount: new bignumber_js_1.default(2),
-                    currencyId: account.currency.id,
-                    id: "still doesn't matter",
-                    standard: "ERC1155",
-                };
                 it("should detect a transaction for an ERC1155 nft not owned by the account and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
                     const tx = Object.assign(Object.assign({}, eip1559Tx), { mode: "erc1155", nft: {
                             collectionName: "",
-                            contract: nft.contract,
-                            tokenId: nft.tokenId,
+                            contract: erc1155Nft.contract,
+                            tokenId: erc1155Nft.tokenId,
                             quantity: new bignumber_js_1.default(1),
                         } });
                     const res = yield (0, getTransactionStatus_1.default)(account, tx);
@@ -296,11 +287,11 @@ describe("EVM Family", () => {
                 it("should detect a transaction for an ERC1155 where the quantity is 0 or below and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
                     const tx = Object.assign(Object.assign({}, eip1559Tx), { mode: "erc1155", nft: {
                             collectionName: "",
-                            contract: nft.contract,
-                            tokenId: nft.tokenId,
+                            contract: erc1155Nft.contract,
+                            tokenId: erc1155Nft.tokenId,
                             quantity: new bignumber_js_1.default(0),
                         } });
-                    const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { nfts: [nft] }), tx);
+                    const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { nfts: [erc1155Nft] }), tx);
                     expect(res.errors).toEqual(expect.objectContaining({
                         amount: new errors_2.QuantityNeedsToBePositive(),
                     }));
@@ -308,15 +299,197 @@ describe("EVM Family", () => {
                 it("should detect a transaction for an ERC1155 nft but the account doesn't own enough of it and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
                     const tx = Object.assign(Object.assign({}, eip1559Tx), { mode: "erc1155", nft: {
                             collectionName: "",
-                            contract: nft.contract,
-                            tokenId: nft.tokenId,
+                            contract: erc1155Nft.contract,
+                            tokenId: erc1155Nft.tokenId,
                             quantity: new bignumber_js_1.default(3),
                         } });
-                    const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { nfts: [nft] }), tx);
+                    const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { nfts: [erc1155Nft] }), tx);
                     expect(res.errors).toEqual(expect.objectContaining({
                         amount: new errors_2.NotEnoughNftOwned(),
                     }));
                 }));
+                it("should detect a transaction for an ERC1155 nft owned by the account but it does not have enough balance to pay for gas and have an error", () => __awaiter(void 0, void 0, void 0, function* () {
+                    const tx = Object.assign(Object.assign({}, eip1559Tx), { mode: "erc1155", nft: {
+                            collectionName: "",
+                            contract: erc1155Nft.contract,
+                            tokenId: erc1155Nft.tokenId,
+                            quantity: new bignumber_js_1.default(1),
+                        } });
+                    const res = yield (0, getTransactionStatus_1.default)(Object.assign(Object.assign({}, account), { nfts: [erc1155Nft] }), tx);
+                    expect(res.errors).toEqual(expect.objectContaining({
+                        amount: new errors_1.NotEnoughBalanceInParentAccount(),
+                        gasPrice: new errors_1.NotEnoughGas(),
+                    }));
+                }));
+            });
+        });
+        describe("Fee Ratio", () => {
+            /**
+             * Helper function to narrow down the type of transaction and set the
+             * specific field depending on the type of transaction
+             */
+            const specifyTx = ({ tx, specificField, }) => {
+                if (tx.type === 2) {
+                    return Object.assign(Object.assign({}, tx), { maxFeePerGas: new bignumber_js_1.default(specificField) });
+                }
+                else {
+                    return Object.assign(Object.assign({}, tx), { gasPrice: new bignumber_js_1.default(specificField) });
+                }
+            };
+            describe.each([
+                { type: "Legacy", defaultTx: legacyTx },
+                { type: "EIP1559", defaultTx: eip1559Tx },
+            ])("Transaction Type: $type", ({ defaultTx }) => {
+                describe("when fees are too high compared to the amount (fees are more than 10% of the amount)", () => {
+                    it("should have a warning", () => __awaiter(void 0, void 0, void 0, function* () {
+                        yield fast_check_1.default.assert(fast_check_1.default.asyncProperty(fast_check_1.default
+                            .record({
+                            amount: fast_check_1.default.integer({ min: 1 }),
+                            gasLimit: fast_check_1.default.integer({ min: 1 }),
+                            specificField: fast_check_1.default.integer({ min: 1 }),
+                        })
+                            .filter(({ amount, gasLimit, specificField }) => (0, bignumber_js_1.default)(gasLimit)
+                            .multipliedBy((0, bignumber_js_1.default)(specificField))
+                            .times(10)
+                            .gt((0, bignumber_js_1.default)(amount))), ({ amount, gasLimit, specificField }) => __awaiter(void 0, void 0, void 0, function* () {
+                            const tx = specifyTx({
+                                tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), data: undefined }),
+                                specificField,
+                            });
+                            const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                            expect(res.warnings).toEqual(expect.objectContaining({
+                                feeTooHigh: new errors_1.FeeTooHigh(),
+                            }));
+                        })));
+                    }));
+                    /**
+                     * Note: This is to test the lower bound of the x*y*r=a equation
+                     * with x = gasPrice, y = gasLimit, a = amount, r = ratio
+                     * This test would pass for r = 10 but would fail for r = 9
+                     */
+                    it("should have a warning for lower bound", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const amount = 990;
+                        const gasLimit = 11;
+                        const specificField = 10;
+                        const tx = specifyTx({
+                            tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), data: undefined }),
+                            specificField,
+                        });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.warnings).toEqual(expect.objectContaining({
+                            feeTooHigh: new errors_1.FeeTooHigh(),
+                        }));
+                    }));
+                });
+                describe("when fees are not too high compared to the amount (fees are less than or equal to 10% of the amount)", () => {
+                    it("should not have a warning", () => __awaiter(void 0, void 0, void 0, function* () {
+                        yield fast_check_1.default.assert(fast_check_1.default.asyncProperty(fast_check_1.default
+                            .record({
+                            amount: fast_check_1.default.integer({ min: 1 }),
+                            gasLimit: fast_check_1.default.integer({ min: 1 }),
+                            specificField: fast_check_1.default.integer({ min: 1 }),
+                        })
+                            .filter(({ amount, specificField, gasLimit }) => (0, bignumber_js_1.default)(specificField)
+                            .multipliedBy((0, bignumber_js_1.default)(gasLimit))
+                            .times(10)
+                            .lt((0, bignumber_js_1.default)(amount))), ({ amount, specificField, gasLimit }) => __awaiter(void 0, void 0, void 0, function* () {
+                            const tx = specifyTx({
+                                tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), data: undefined }),
+                                specificField,
+                            });
+                            const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                            expect(res.warnings).toEqual(expect.not.objectContaining({
+                                feeTooHigh: new errors_1.FeeTooHigh(),
+                            }));
+                        })));
+                    }));
+                    /**
+                     * Note: This is to test the upper bound of the x*y*r=a equation
+                     * with x = gasPrice, y = gasLimit, a = amount, r = ratio
+                     * This test would pass for r = 10 but would fail for r = 11
+                     */
+                    it("should not have a warning for upper bound", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const amount = 100;
+                        const gasLimit = 1;
+                        const specificField = 10;
+                        const tx = specifyTx({
+                            tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), data: undefined }),
+                            specificField,
+                        });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.warnings).toEqual(expect.not.objectContaining({
+                            feeTooHigh: new errors_1.FeeTooHigh(),
+                        }));
+                    }));
+                });
+                describe("when tx has data", () => {
+                    it("should not have a warning", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const amount = 1;
+                        const gasLimit = 1;
+                        const specificField = 1;
+                        const tx = specifyTx({
+                            tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit) }),
+                            specificField,
+                        });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.warnings).toEqual(expect.not.objectContaining({
+                            feeTooHigh: new errors_1.FeeTooHigh(),
+                        }));
+                    }));
+                });
+                describe("when tx is nft tx", () => {
+                    it("should not have a warning for ERC721 NFT", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const amount = 1;
+                        const gasLimit = 1;
+                        const specificField = 1;
+                        const tx = specifyTx({
+                            tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), mode: "erc721", nft: {
+                                    collectionName: "",
+                                    contract: erc721Nft.contract,
+                                    tokenId: erc721Nft.tokenId,
+                                    quantity: new bignumber_js_1.default(1),
+                                } }),
+                            specificField,
+                        });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.warnings).toEqual(expect.not.objectContaining({
+                            feeTooHigh: new errors_1.FeeTooHigh(),
+                        }));
+                    }));
+                    it("should not have a warning for ERC1155 NFT", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const amount = 1;
+                        const gasLimit = 1;
+                        const specificField = 1;
+                        const tx = specifyTx({
+                            tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), mode: "erc1155", nft: {
+                                    collectionName: "",
+                                    contract: erc1155Nft.contract,
+                                    tokenId: erc1155Nft.tokenId,
+                                    quantity: new bignumber_js_1.default(1),
+                                } }),
+                            specificField,
+                        });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.warnings).toEqual(expect.not.objectContaining({
+                            feeTooHigh: new errors_1.FeeTooHigh(),
+                        }));
+                    }));
+                });
+                describe("when tx is token tx", () => {
+                    it("should not have a warning", () => __awaiter(void 0, void 0, void 0, function* () {
+                        const amount = 1;
+                        const gasLimit = 1;
+                        const specificField = 1;
+                        const tx = specifyTx({
+                            tx: Object.assign(Object.assign({}, defaultTx), { amount: new bignumber_js_1.default(amount), gasLimit: new bignumber_js_1.default(gasLimit), subAccountId: tokenAccount.id }),
+                            specificField,
+                        });
+                        const res = yield (0, getTransactionStatus_1.default)(account, tx);
+                        expect(res.warnings).toEqual(expect.not.objectContaining({
+                            feeTooHigh: new errors_1.FeeTooHigh(),
+                        }));
+                    }));
+                });
             });
         });
         describe("Global return", () => {