@ledgerhq/live-common 21.5.1-btcjs.0 → 21.7.0

package/lib/exchange/swap/hooks/useSwapTransaction.test.js

@@ -0,0 +1,50 @@
+"use strict";
+exports.__esModule = true;
+var react_hooks_1 = require("@testing-library/react-hooks");
+var errors_1 = require("@ledgerhq/errors");
+var useSwapTransaction_1 = require("./useSwapTransaction");
+/**
+ * @DEV: The useSwapTransaction hook is a composition hook. It doesn't own specific
+ * logic, but it's composed of other hooks. That's why only the useFromAmountError
+ * logic is tested here, it's the only logic owned by the useSwapTransaction hook.
+ * All other lines are covered by other hooks tests.
+ */
+describe("useSwapTransaction", function () {
+    test("useFromAmountError - returns nothing when no errors are caught", function () {
+        var result = (0, react_hooks_1.renderHook)(function () {
+            return (0, useSwapTransaction_1.useFromAmountError)({ gasPrice: undefined, amount: undefined });
+        }).result;
+        expect(result.current).toBeUndefined();
+    });
+    test("useFromAmountError - returns the first error caught", function () {
+        var gasPriceError = new Error("Gas price is too high");
+        var amountError = new Error("Amount is too low");
+        var tests = [
+            {
+                input: { gasPrice: gasPriceError, amount: undefined },
+                output: gasPriceError
+            },
+            {
+                input: { gasPrice: undefined, amount: amountError },
+                output: amountError
+            },
+            {
+                input: { gasPrice: gasPriceError, amount: amountError },
+                output: gasPriceError
+            },
+        ];
+        tests.forEach(function (_a) {
+            var input = _a.input, output = _a.output;
+            var result = (0, react_hooks_1.renderHook)(function () { return (0, useSwapTransaction_1.useFromAmountError)(input); }).result;
+            expect(result.current).toEqual(output);
+        });
+    });
+    test("useFromAmountError - do not return AmountRequired error", function () {
+        var amountError = new errors_1.AmountRequired("This error will be filtered");
+        var result = (0, react_hooks_1.renderHook)(function () {
+            return (0, useSwapTransaction_1.useFromAmountError)({ gasPrice: undefined, amount: amountError });
+        }).result;
+        expect(result.current).toBeUndefined();
+    });
+});
+//# sourceMappingURL=useSwapTransaction.test.js.map

package/lib/exchange/swap/hooks/useSwapTransaction.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSwapTransaction.test.js","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useSwapTransaction.test.ts"],"names":[],"mappings":";;AAAA,4DAA0D;AAE1D,2CAAkD;AAClD,2DAA0D;AAE1D;;;;;GAKG;AACH,QAAQ,CAAC,oBAAoB,EAAE;IAC7B,IAAI,CAAC,gEAAgE,EAAE;QAC7D,IAAA,MAAM,GAAK,IAAA,wBAAU,EAAC;YAC5B,OAAA,IAAA,uCAAkB,EAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAA9D,CAA8D,CAC/D,OAFa,CAEZ;QAEF,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,qDAAqD,EAAE;QAC1D,IAAM,aAAa,GAAG,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;QACzD,IAAM,WAAW,GAAG,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACnD,IAAM,KAAK,GAAG;YACZ;gBACE,KAAK,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE;gBACrD,MAAM,EAAE,aAAa;aACtB;YACD;gBACE,KAAK,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE;gBACnD,MAAM,EAAE,WAAW;aACpB;YACD;gBACE,KAAK,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE;gBACvD,MAAM,EAAE,aAAa;aACtB;SACF,CAAC;QAEF,KAAK,CAAC,OAAO,CAAC,UAAC,EAAiB;gBAAf,KAAK,WAAA,EAAE,MAAM,YAAA;YACpB,IAAA,MAAM,GAAK,IAAA,wBAAU,EAAC,cAAM,OAAA,IAAA,uCAAkB,EAAC,KAAK,CAAC,EAAzB,CAAyB,CAAC,OAAhD,CAAiD;YAC/D,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACzC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yDAAyD,EAAE;QAC9D,IAAM,WAAW,GAAG,IAAI,uBAAc,CAAC,6BAA6B,CAAC,CAAC;QAE9D,IAAA,MAAM,GAAK,IAAA,wBAAU,EAAC;YAC5B,OAAA,IAAA,uCAAkB,EAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;QAAhE,CAAgE,CACjE,OAFa,CAEZ;QAEF,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,CAAC;IACzC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib/exchange/swap/hooks/useToState.d.ts

@@ -0,0 +1,12 @@
+import { SwapDataType, SwapSelectorStateType, SwapTransactionType } from ".";
+import { Account } from "../../../types";
+export declare const useToState: ({ accounts, }: {
+    accounts: Account[] | undefined;
+}) => {
+    toState: SwapSelectorStateType;
+    setToAccount: SwapTransactionType["setToAccount"];
+    setToAmount: SwapTransactionType["setToAmount"];
+    setToCurrency: SwapTransactionType["setToCurrency"];
+    targetAccounts: SwapDataType["targetAccounts"];
+};
+//# sourceMappingURL=useToState.d.ts.map

package/lib/exchange/swap/hooks/useToState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToState.d.ts","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useToState.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,GAAG,CAAC;AACX,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAGzC,eAAO,MAAM,UAAU;cAGX,OAAO,EAAE,GAAG,SAAS;;aAEtB,qBAAqB;kBAChB,mBAAmB,CAAC,cAAc,CAAC;iBACpC,mBAAmB,CAAC,aAAa,CAAC;mBAChC,mBAAmB,CAAC,eAAe,CAAC;oBACnC,YAAY,CAAC,gBAAgB,CAAC;CAkE/C,CAAC"}

package/lib/exchange/swap/hooks/useToState.js

@@ -0,0 +1,73 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+exports.__esModule = true;
+exports.useToState = void 0;
+var react_1 = require("react");
+var _1 = require(".");
+var utils_1 = require("../utils");
+var useToState = function (_a) {
+    var accounts = _a.accounts;
+    var _b = __read((0, react_1.useState)(_1.selectorStateDefaultValues), 2), toState = _b[0], setToState = _b[1];
+    /* UPDATE to accounts */
+    var setToAccount = (0, react_1.useCallback)(function (currency, account, parentAccount) {
+        return setToState(__assign(__assign({}, _1.selectorStateDefaultValues), { currency: currency, account: account, parentAccount: parentAccount }));
+    }, []);
+    /* Get the list of possible target accounts given the target currency. */
+    var getTargetAccountsPairs = (0, react_1.useCallback)(function (currency) {
+        return currency &&
+            accounts &&
+            (0, utils_1.getAccountTuplesForCurrency)(currency, accounts, false);
+    }, [accounts]);
+    var targetAccounts = (0, react_1.useMemo)(function () {
+        var _a;
+        return (_a = getTargetAccountsPairs(toState.currency)) === null || _a === void 0 ? void 0 : _a.map(function (_a) {
+            var account = _a.account, subAccount = _a.subAccount;
+            return subAccount || account;
+        });
+    }, [toState.currency, getTargetAccountsPairs]);
+    var setToCurrency = (0, react_1.useCallback)(function (currency) {
+        var targetAccountsPairs = getTargetAccountsPairs(currency);
+        var accountPair = targetAccountsPairs && targetAccountsPairs[0];
+        var account = accountPair && (accountPair.subAccount || accountPair.account);
+        var parentAccount = accountPair && accountPair.subAccount && accountPair.account;
+        setToState(__assign(__assign({}, _1.selectorStateDefaultValues), { currency: currency, account: account, parentAccount: parentAccount }));
+    }, [getTargetAccountsPairs]);
+    var setToAmount = (0, react_1.useCallback)(function (amount) {
+        return setToState(function (previousState) { return (__assign(__assign({}, previousState), { amount: amount })); });
+    }, []);
+    return {
+        toState: toState,
+        setToAccount: setToAccount,
+        setToAmount: setToAmount,
+        setToCurrency: setToCurrency,
+        targetAccounts: targetAccounts
+    };
+};
+exports.useToState = useToState;
+//# sourceMappingURL=useToState.js.map

package/lib/exchange/swap/hooks/useToState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToState.js","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useToState.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAAuD;AACvD,sBAKW;AAEX,kCAAuD;AAEhD,IAAM,UAAU,GAAG,UAAC,EAI1B;QAHC,QAAQ,cAAA;IAUF,IAAA,KAAA,OAAwB,IAAA,gBAAQ,EACpC,6BAA0B,CAC3B,IAAA,EAFM,OAAO,QAAA,EAAE,UAAU,QAEzB,CAAC;IAEF,wBAAwB;IACxB,IAAM,YAAY,GAAwC,IAAA,mBAAW,EACnE,UAAC,QAAQ,EAAE,OAAO,EAAE,aAAa;QAC/B,OAAA,UAAU,uBACL,6BAA0B,KAC7B,QAAQ,UAAA,EACR,OAAO,SAAA,EACP,aAAa,eAAA,IACb;IALF,CAKE,EACJ,EAAE,CACH,CAAC;IAEF,yEAAyE;IACzE,IAAM,sBAAsB,GAAG,IAAA,mBAAW,EACxC,UAAC,QAAQ;QACP,OAAA,QAAQ;YACR,QAAQ;YACR,IAAA,mCAA2B,EAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC;IAFtD,CAEsD,EACxD,CAAC,QAAQ,CAAC,CACX,CAAC;IACF,IAAM,cAAc,GAAG,IAAA,eAAO,EAC5B;;QACE,OAAA,MAAA,sBAAsB,CAAC,OAAO,CAAC,QAAQ,CAAC,0CAAE,GAAG,CAC3C,UAAC,EAAuB;gBAArB,OAAO,aAAA,EAAE,UAAU,gBAAA;YAAO,OAAA,UAAU,IAAI,OAAO;QAArB,CAAqB,CACnD,CAAA;KAAA,EACH,CAAC,OAAO,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAC3C,CAAC;IAEF,IAAM,aAAa,GAAyC,IAAA,mBAAW,EACrE,UAAC,QAAQ;QACP,IAAM,mBAAmB,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;QAC7D,IAAM,WAAW,GAAG,mBAAmB,IAAI,mBAAmB,CAAC,CAAC,CAAC,CAAC;QAClE,IAAM,OAAO,GACX,WAAW,IAAI,CAAC,WAAW,CAAC,UAAU,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;QACjE,IAAM,aAAa,GACjB,WAAW,IAAI,WAAW,CAAC,UAAU,IAAI,WAAW,CAAC,OAAO,CAAC;QAE/D,UAAU,uBACL,6BAA0B,KAC7B,QAAQ,UAAA,EACR,OAAO,SAAA,EACP,aAAa,eAAA,IACb,CAAC;IACL,CAAC,EACD,CAAC,sBAAsB,CAAC,CACzB,CAAC;IAEF,IAAM,WAAW,GAAuC,IAAA,mBAAW,EACjE,UAAC,MAAM;QACL,OAAA,UAAU,CAAC,UAAC,aAAa,IAAK,OAAA,uBAAM,aAAa,KAAE,MAAM,EAAE,MAAM,IAAG,EAAtC,CAAsC,CAAC;IAArE,CAAqE,EACvE,EAAE,CACH,CAAC;IAEF,OAAO;QACL,OAAO,SAAA;QACP,YAAY,cAAA;QACZ,WAAW,aAAA;QACX,aAAa,eAAA;QACb,cAAc,gBAAA;KACf,CAAC;AACJ,CAAC,CAAC;AA3EW,QAAA,UAAU,cA2ErB"}

package/lib/exchange/swap/hooks/useToState.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useToState.test.d.ts.map

package/lib/exchange/swap/hooks/useToState.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToState.test.d.ts","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useToState.test.ts"],"names":[],"mappings":""}

package/lib/exchange/swap/hooks/useToState.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var react_hooks_1 = require("@testing-library/react-hooks");
+var cryptoassets_1 = require("@ledgerhq/cryptoassets");
+var _1 = require(".");
+var account_1 = require("../../../mock/account");
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var BTC = (0, cryptoassets_1.getCryptoCurrencyById)("bitcoin");
+var ETH = (0, cryptoassets_1.getCryptoCurrencyById)("ethereum");
+var USDT = (0, cryptoassets_1.getTokenById)("ethereum/erc20/usd_tether__erc20_");
+var accounts = [
+    (0, account_1.genAccount)("mocked-account-1", { currency: BTC }),
+    (0, account_1.genAccount)("mocked-account-2", { currency: ETH }),
+];
+var subAccount = (0, account_1.genTokenAccount)(1, accounts[1], USDT);
+describe("useToState", function () {
+    var defaultProps = { accounts: accounts };
+    it("should initialize a blank state", function () {
+        var result = (0, react_hooks_1.renderHook)(_1.useToState, { initialProps: defaultProps }).result;
+        expect(result.current.toState).toMatchObject(_1.selectorStateDefaultValues);
+    });
+    it("should set the account", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, currency, account, parentAccount, result;
+        return __generator(this, function (_b) {
+            _a = __read([USDT, subAccount, accounts[1]], 3), currency = _a[0], account = _a[1], parentAccount = _a[2];
+            result = (0, react_hooks_1.renderHook)(_1.useToState, { initialProps: defaultProps }).result;
+            (0, react_hooks_1.act)(function () { return result.current.setToAccount(currency, account, parentAccount); });
+            expect(result.current.toState).toMatchObject({
+                account: account,
+                parentAccount: parentAccount,
+                currency: currency
+            });
+            return [2 /*return*/];
+        });
+    }); });
+    it("should set the amount", function () {
+        var amount = new bignumber_js_1["default"](10);
+        var result = (0, react_hooks_1.renderHook)(_1.useToState, { initialProps: defaultProps }).result;
+        (0, react_hooks_1.act)(function () { return result.current.setToAmount(amount); });
+        expect(result.current.toState.amount).toBe(amount);
+    });
+    it("should set the currency", function () {
+        var result = (0, react_hooks_1.renderHook)(_1.useToState, { initialProps: defaultProps }).result;
+        (0, react_hooks_1.act)(function () { return result.current.setToCurrency(BTC); });
+        expect(result.current.toState).toMatchObject({
+            account: accounts[0],
+            parentAccount: null,
+            currency: BTC
+        });
+    });
+});
+//# sourceMappingURL=useToState.test.js.map

package/lib/exchange/swap/hooks/useToState.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToState.test.js","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useToState.test.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4DAA+D;AAC/D,uDAA6E;AAC7E,sBAA2D;AAC3D,iDAAoE;AAEpE,8DAAqC;AAErC,IAAM,GAAG,GAAG,IAAA,oCAAqB,EAAC,SAAS,CAAC,CAAC;AAC7C,IAAM,GAAG,GAAG,IAAA,oCAAqB,EAAC,UAAU,CAAC,CAAC;AAC9C,IAAM,IAAI,GAAG,IAAA,2BAAY,EAAC,mCAAmC,CAAC,CAAC;AAE/D,IAAM,QAAQ,GAAc;IAC1B,IAAA,oBAAU,EAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;IACjD,IAAA,oBAAU,EAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;CAClD,CAAC;AACF,IAAM,UAAU,GAAG,IAAA,yBAAe,EAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAEzD,QAAQ,CAAC,YAAY,EAAE;IACrB,IAAM,YAAY,GAAG,EAAE,QAAQ,UAAA,EAAE,CAAC;IAElC,EAAE,CAAC,iCAAiC,EAAE;QAC5B,IAAA,MAAM,GAAK,IAAA,wBAAU,EAAC,aAAU,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC,OAA3D,CAA4D;QAC1E,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC,6BAA0B,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,wBAAwB,EAAE;;;YACrB,KAAA,OAAqC,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAA,EAAnE,QAAQ,QAAA,EAAE,OAAO,QAAA,EAAE,aAAa,QAAA,CAAoC;YACnE,MAAM,GAAK,IAAA,wBAAU,EAAC,aAAU,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC,OAA3D,CAA4D;YAC1E,IAAA,iBAAG,EAAC,cAAM,OAAA,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,aAAa,CAAC,EAA7D,CAA6D,CAAC,CAAC;YACzE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC;gBAC3C,OAAO,SAAA;gBACP,aAAa,eAAA;gBACb,QAAQ,UAAA;aACT,CAAC,CAAC;;;SACJ,CAAC,CAAC;IAEH,EAAE,CAAC,uBAAuB,EAAE;QAC1B,IAAM,MAAM,GAAG,IAAI,yBAAS,CAAC,EAAE,CAAC,CAAC;QACzB,IAAA,MAAM,GAAK,IAAA,wBAAU,EAAC,aAAU,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC,OAA3D,CAA4D;QAC1E,IAAA,iBAAG,EAAC,cAAM,OAAA,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,EAAlC,CAAkC,CAAC,CAAC;QAC9C,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yBAAyB,EAAE;QACpB,IAAA,MAAM,GAAK,IAAA,wBAAU,EAAC,aAAU,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC,OAA3D,CAA4D;QAC1E,IAAA,iBAAG,EAAC,cAAM,OAAA,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,EAAjC,CAAiC,CAAC,CAAC;QAC7C,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,aAAa,CAAC;YAC3C,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;YACpB,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,GAAG;SACd,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/lib/exchange/swap/hooks/useUpdateMaxAmount.d.ts

@@ -0,0 +1,15 @@
+import { SwapTransactionType, SwapDataType, SwapSelectorStateType } from "./useSwapTransaction";
+import { Transaction } from "../../../generated/types";
+import BigNumber from "bignumber.js";
+export declare const ZERO: BigNumber;
+export declare const useUpdateMaxAmount: ({ setFromAmount, account, parentAccount, transaction, feesStrategy, }: {
+    setFromAmount: SwapTransactionType["setFromAmount"];
+    account: SwapSelectorStateType["account"];
+    parentAccount: SwapSelectorStateType["parentAccount"];
+    transaction: SwapTransactionType["transaction"];
+    feesStrategy: Transaction["feesStrategy"];
+}) => {
+    isMaxEnabled: SwapDataType["isMaxEnabled"];
+    toggleMax: SwapTransactionType["toggleMax"];
+};
+//# sourceMappingURL=useUpdateMaxAmount.d.ts.map

package/lib/exchange/swap/hooks/useUpdateMaxAmount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateMaxAmount.d.ts","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useUpdateMaxAmount.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,mBAAmB,EACnB,YAAY,EACZ,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,eAAO,MAAM,IAAI,WAAmB,CAAC;AAErC,eAAO,MAAM,kBAAkB;mBAOd,mBAAmB,CAAC,eAAe,CAAC;aAC1C,qBAAqB,CAAC,SAAS,CAAC;mBAC1B,qBAAqB,CAAC,eAAe,CAAC;iBACxC,mBAAmB,CAAC,aAAa,CAAC;kBACjC,WAAW,CAAC,cAAc,CAAC;;kBAE3B,YAAY,CAAC,cAAc,CAAC;eAC/B,mBAAmB,CAAC,WAAW,CAAC;CAuC5C,CAAC"}

package/lib/{families/bitcoin/getAccountNetworkInfo.js → exchange/swap/hooks/useUpdateMaxAmount.js}

@@ -55,70 +55,52 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
-exports.getAccountNetworkInfo = exports.avoidDups = void 0;
-var flow_1 = __importDefault(require("lodash/flow"));
-var bignumber_js_1 = require("bignumber.js");
-var wallet_1 = require("./wallet");
-var speeds = ["fast", "medium", "slow"];
-function avoidDups(nums) {
-    nums = nums.slice(0);
-    for (var i = nums.length - 2; i >= 0; i--) {
-        if (nums[i + 1].gte(nums[i])) {
-            nums[i] = nums[i + 1].plus(1);
-        }
-    }
-    return nums;
-}
-exports.avoidDups = avoidDups;
-function getAccountNetworkInfo(account) {
-    return __awaiter(this, void 0, void 0, function () {
-        var walletAccount, rawFees, feesPerByte, feeItems;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, (0, wallet_1.getWalletAccount)(account)];
-                case 1:
-                    walletAccount = _a.sent();
-                    return [4 /*yield*/, walletAccount.xpub.explorer.getFees()];
-                case 2:
-                    rawFees = _a.sent();
-                    feesPerByte = (0, flow_1["default"])([
-                        // Remove the 'last_updated' key
-                        Object.entries,
-                        function (entries) { return entries.filter(function (_a) {
-                            var _b = __read(_a, 1), key = _b[0];
-                            return !isNaN(key);
-                        }); },
-                        // Reconstruct the array with only the values
-                        Object.fromEntries,
-                        Object.values,
-                        // Safety against invalid data
-                        function (f) { return f.filter(function (f) { return f != null && typeof f === "number"; }); },
-                        // Normalize values
-                        function (f) {
-                            return f.map(function (f) {
-                                return new bignumber_js_1.BigNumber(f).div(1000).integerValue(bignumber_js_1.BigNumber.ROUND_CEIL);
-                            });
-                        },
-                        avoidDups,
-                    ])(rawFees);
-                    if (feesPerByte.length !== 3) {
-                        throw new Error("cardinality of feesPerByte should be exactly 3");
-                    }
-                    feeItems = {
-                        items: feesPerByte.map(function (feePerByte, i) { return ({
-                            key: String(i),
-                            speed: speeds[i],
-                            feePerByte: feePerByte
-                        }); }),
-                        defaultFeePerByte: feesPerByte[Math.floor(feesPerByte.length / 2)] || new bignumber_js_1.BigNumber(0)
-                    };
-                    return [2 /*return*/, {
-                            family: "bitcoin",
-                            feeItems: feeItems
-                        }];
+exports.useUpdateMaxAmount = exports.ZERO = void 0;
+var react_1 = require("react");
+var bridge_1 = require("../../../bridge");
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+exports.ZERO = new bignumber_js_1["default"](0);
+var useUpdateMaxAmount = function (_a) {
+    var setFromAmount = _a.setFromAmount, account = _a.account, parentAccount = _a.parentAccount, transaction = _a.transaction, feesStrategy = _a.feesStrategy;
+    var _b = __read((0, react_1.useState)(false), 2), isMaxEnabled = _b[0], setMax = _b[1];
+    var toggleMax = (0, react_1.useCallback)(function () {
+        return setMax(function (previous) {
+            if (previous) {
+                setFromAmount(exports.ZERO);
             }
+            return !previous;
         });
-    });
-}
-exports.getAccountNetworkInfo = getAccountNetworkInfo;
-//# sourceMappingURL=getAccountNetworkInfo.js.map
+    }, [setFromAmount]);
+    /* UPDATE from amount to the estimate max spendable on account
+       change when the amount feature is enabled */
+    (0, react_1.useEffect)(function () {
+        var updateAmountUsingMax = function () { return __awaiter(void 0, void 0, void 0, function () {
+            var bridge, amount;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!account)
+                            return [2 /*return*/];
+                        bridge = (0, bridge_1.getAccountBridge)(account, parentAccount);
+                        return [4 /*yield*/, bridge.estimateMaxSpendable({
+                                account: account,
+                                parentAccount: parentAccount,
+                                transaction: transaction
+                            })];
+                    case 1:
+                        amount = _a.sent();
+                        setFromAmount(amount);
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        if (isMaxEnabled) {
+            updateAmountUsingMax();
+        }
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [setFromAmount, isMaxEnabled, account, parentAccount, feesStrategy]);
+    return { isMaxEnabled: isMaxEnabled, toggleMax: toggleMax };
+};
+exports.useUpdateMaxAmount = useUpdateMaxAmount;
+//# sourceMappingURL=useUpdateMaxAmount.js.map

package/lib/exchange/swap/hooks/useUpdateMaxAmount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateMaxAmount.js","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useUpdateMaxAmount.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAAyD;AACzD,0CAAmD;AAQnD,8DAAqC;AAExB,QAAA,IAAI,GAAG,IAAI,yBAAS,CAAC,CAAC,CAAC,CAAC;AAE9B,IAAM,kBAAkB,GAAG,UAAC,EAYlC;QAXC,aAAa,mBAAA,EACb,OAAO,aAAA,EACP,aAAa,mBAAA,EACb,WAAW,iBAAA,EACX,YAAY,kBAAA;IAWN,IAAA,KAAA,OAAyB,IAAA,gBAAQ,EAA+B,KAAK,CAAC,IAAA,EAArE,YAAY,QAAA,EAAE,MAAM,QAAiD,CAAC;IAE7E,IAAM,SAAS,GAAqC,IAAA,mBAAW,EAC7D;QACE,OAAA,MAAM,CAAC,UAAC,QAAQ;YACd,IAAI,QAAQ,EAAE;gBACZ,aAAa,CAAC,YAAI,CAAC,CAAC;aACrB;YACD,OAAO,CAAC,QAAQ,CAAC;QACnB,CAAC,CAAC;IALF,CAKE,EACJ,CAAC,aAAa,CAAC,CAChB,CAAC;IAEF;mDAC+C;IAC/C,IAAA,iBAAS,EACP;QACE,IAAM,oBAAoB,GAAG;;;;;wBAC3B,IAAI,CAAC,OAAO;4BAAE,sBAAO;wBACf,MAAM,GAAG,IAAA,yBAAgB,EAAC,OAAO,EAAE,aAAa,CAAC,CAAC;wBACzC,qBAAM,MAAM,CAAC,oBAAoB,CAAC;gCAC/C,OAAO,SAAA;gCACP,aAAa,eAAA;gCACb,WAAW,aAAA;6BACZ,CAAC,EAAA;;wBAJI,MAAM,GAAG,SAIb;wBACF,aAAa,CAAC,MAAM,CAAC,CAAC;;;;aACvB,CAAC;QAEF,IAAI,YAAY,EAAE;YAChB,oBAAoB,EAAE,CAAC;SACxB;IACH,CAAC;IACD,uDAAuD;IACvD,CAAC,aAAa,EAAE,YAAY,EAAE,OAAO,EAAE,aAAa,EAAE,YAAY,CAAC,CACpE,CAAC;IAEF,OAAO,EAAE,YAAY,cAAA,EAAE,SAAS,WAAA,EAAE,CAAC;AACrC,CAAC,CAAC;AArDW,QAAA,kBAAkB,sBAqD7B"}

package/lib/exchange/swap/hooks/useUpdateMaxAmount.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useUpdateMaxAmount.test.d.ts.map

package/lib/exchange/swap/hooks/useUpdateMaxAmount.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateMaxAmount.test.d.ts","sourceRoot":"","sources":["../../../../src/exchange/swap/hooks/useUpdateMaxAmount.test.ts"],"names":[],"mappings":""}

package/lib/exchange/swap/hooks/useUpdateMaxAmount.test.js

@@ -0,0 +1,217 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var react_hooks_1 = require("@testing-library/react-hooks");
+var cryptoassets_1 = require("@ledgerhq/cryptoassets");
+var utils_1 = require("ts-jest/utils");
+var useUpdateMaxAmount_1 = require("./useUpdateMaxAmount");
+var account_1 = require("../../../mock/account");
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var mock_1 = __importDefault(require("../../../families/ethereum/bridge/mock"));
+var support_1 = require("../../../account/support");
+// Needs to be mocked since userSupportedCurrencies is initially empty.
+jest.mock("../../../account/support");
+var mockedCheckAccount = (0, utils_1.mocked)(support_1.checkAccountSupported);
+// Mock to use a custom estimate value and test the result.
+jest.mock("../../../families/ethereum/bridge/mock");
+var mockedEstimateMaxSpendable = (0, utils_1.mocked)(mock_1["default"].accountBridge.estimateMaxSpendable, true);
+var ETH = (0, cryptoassets_1.getCryptoCurrencyById)("ethereum");
+var USDT = (0, cryptoassets_1.getTokenById)("ethereum/erc20/usd_tether__erc20_");
+var parentAccount = (0, account_1.genAccount)("parent-account", {
+    currency: ETH
+});
+var account = (0, account_1.genTokenAccount)(1, parentAccount, USDT);
+describe("updateAmountUsingMax", function () {
+    var setFromAmount = jest.fn();
+    var defaultProps = {
+        setFromAmount: setFromAmount,
+        account: account,
+        parentAccount: parentAccount,
+        transaction: { amount: new bignumber_js_1["default"](1) },
+        feesStrategy: "slow"
+    };
+    beforeAll(function () {
+        mockedCheckAccount.mockImplementation(function () { return null; });
+    });
+    afterAll(function () {
+        mockedCheckAccount.mockReset();
+    });
+    beforeEach(function () {
+        setFromAmount.mockClear();
+    });
+    var wait = function () { return new Promise(function (resolve) { return setTimeout(resolve, 500); }); };
+    it("should toggle the amount", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var amount, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    amount = new bignumber_js_1["default"](0.5);
+                    mockedEstimateMaxSpendable.mockResolvedValue(amount);
+                    result = (0, react_hooks_1.renderHook)(useUpdateMaxAmount_1.useUpdateMaxAmount, {
+                        initialProps: defaultProps
+                    }).result;
+                    expect(result.current.isMaxEnabled).toBe(false);
+                    expect(setFromAmount).toBeCalledTimes(0);
+                    (0, react_hooks_1.act)(function () { return result.current.toggleMax(); });
+                    expect(result.current.isMaxEnabled).toBe(true);
+                    // Lest resort solution, since waitFor and other helpers will not work here.
+                    return [4 /*yield*/, wait()];
+                case 1:
+                    // Lest resort solution, since waitFor and other helpers will not work here.
+                    _a.sent();
+                    expect(setFromAmount).toBeCalledTimes(1);
+                    expect(setFromAmount.mock.calls[0][0]).toBe(amount);
+                    setFromAmount.mockClear();
+                    (0, react_hooks_1.act)(function () { return result.current.toggleMax(); });
+                    expect(result.current.isMaxEnabled).toBe(false);
+                    return [4 /*yield*/, wait()];
+                case 2:
+                    _a.sent();
+                    expect(setFromAmount).toBeCalledTimes(1);
+                    expect(setFromAmount.mock.calls[0][0]).toBe(useUpdateMaxAmount_1.ZERO);
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it("should update the max amount whenever the dependencies change", function () { return __awaiter(void 0, void 0, void 0, function () {
+        var _a, result, rerender, feesGenerator, propsVariants, idx, propsVariants_1, propsVariants_1_1, props, amount, e_1_1;
+        var e_1, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    _a = (0, react_hooks_1.renderHook)(useUpdateMaxAmount_1.useUpdateMaxAmount, {
+                        initialProps: defaultProps
+                    }), result = _a.result, rerender = _a.rerender;
+                    feesGenerator = (function feesGenerator() {
+                        var feesArray, index;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    feesArray = ["medium", "fast", "custom", "slow"];
+                                    index = 0;
+                                    _a.label = 1;
+                                case 1:
+                                    if (!true) return [3 /*break*/, 3];
+                                    return [4 /*yield*/, feesArray[index]];
+                                case 2:
+                                    _a.sent();
+                                    index = (index + 1) % feesArray.length;
+                                    return [3 /*break*/, 1];
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    })();
+                    propsVariants = [
+                        __assign(__assign({}, defaultProps), { account: __assign({}, account) }),
+                        __assign(__assign({}, defaultProps), { parentAccount: __assign({}, parentAccount) }),
+                        __assign(__assign({}, defaultProps), { feesStrategy: feesGenerator.next().value }),
+                    ];
+                    // Updating dependencies when the toggle is off should not do anything.
+                    propsVariants.forEach(rerender);
+                    expect(setFromAmount).toBeCalledTimes(0);
+                    mockedEstimateMaxSpendable.mockResolvedValue(new bignumber_js_1["default"](0));
+                    (0, react_hooks_1.act)(function () { return result.current.toggleMax(); });
+                    return [4 /*yield*/, wait()];
+                case 1:
+                    _c.sent();
+                    idx = 1;
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, 8, 9, 14]);
+                    propsVariants_1 = __asyncValues(propsVariants);
+                    _c.label = 3;
+                case 3: return [4 /*yield*/, propsVariants_1.next()];
+                case 4:
+                    if (!(propsVariants_1_1 = _c.sent(), !propsVariants_1_1.done)) return [3 /*break*/, 7];
+                    props = propsVariants_1_1.value;
+                    amount = new bignumber_js_1["default"](idx);
+                    setFromAmount.mockReset();
+                    mockedEstimateMaxSpendable.mockResolvedValue(amount);
+                    rerender(props);
+                    return [4 /*yield*/, wait()];
+                case 5:
+                    _c.sent();
+                    expect(setFromAmount).toBeCalledTimes(1);
+                    expect(setFromAmount.mock.calls[0][0]).toBe(amount);
+                    idx += 1;
+                    _c.label = 6;
+                case 6: return [3 /*break*/, 3];
+                case 7: return [3 /*break*/, 14];
+                case 8:
+                    e_1_1 = _c.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 14];
+                case 9:
+                    _c.trys.push([9, , 12, 13]);
+                    if (!(propsVariants_1_1 && !propsVariants_1_1.done && (_b = propsVariants_1["return"]))) return [3 /*break*/, 11];
+                    return [4 /*yield*/, _b.call(propsVariants_1)];
+                case 10:
+                    _c.sent();
+                    _c.label = 11;
+                case 11: return [3 /*break*/, 13];
+                case 12:
+                    if (e_1) throw e_1.error;
+                    return [7 /*endfinally*/];
+                case 13: return [7 /*endfinally*/];
+                case 14: return [2 /*return*/];
+            }
+        });
+    }); });
+});
+//# sourceMappingURL=useUpdateMaxAmount.test.js.map