@gearbox-protocol/sdk 1.22.4 → 1.23.0

package/lib/watchers/creditAccountWatcher.js

@@ -1,48 +1,14 @@
 "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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreditAccountWatcher = void 0;
-var creditAccount_1 = require("../core/creditAccount");
-var types_1 = require("../types");
-var multicall_1 = require("../utils/multicall");
-var CreditAccountWatcher = /** @class */ (function () {
-    function CreditAccountWatcher() {
-    }
+const creditAccount_1 = require("../core/creditAccount");
+const types_1 = require("../types");
+const multicall_1 = require("../utils/multicall");
+class CreditAccountWatcher {
+    static IERC20 = types_1.IERC20__factory.createInterface();
+    static creditManagerInterface = types_1.ICreditManagerV2__factory.createInterface();
+    static creditConfiguratorInterface = types_1.ICreditConfigurator__factory.createInterface();
+    static creditFacadeInterface = types_1.ICreditFacade__factory.createInterface();
     /**
      * Gets hashes of all opened credit accounts at toBlock (or "latest" by default)
      * @param creditManager CreditManagerData of desired CreditManager to check
@@ -50,173 +16,113 @@ var CreditAccountWatcher = /** @class */ (function () {
      * @param toBlock Optional. Set the last block you;d like to get opened accounts
      * @returns Arrays of hashes for opened accounts
      */
-    CreditAccountWatcher.getOpenAccounts = function (creditManager, provider, toBlock) {
-        return __awaiter(this, void 0, void 0, function () {
-            var eventsByDate, addToEvents, accounts, cm, ccAddrs, cfUpgraded, _loop_1, _i, cfUpgraded_1, creditFacade;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (creditManager.version !== 2)
-                            throw new Error("Works for V2 only");
-                        eventsByDate = [];
-                        addToEvents = function (e, address, operation) {
-                            eventsByDate.push({
-                                time: e.blockNumber * 100000 + e.logIndex,
-                                address: address,
-                                operation: operation,
-                            });
-                        };
-                        accounts = new Set();
-                        cm = types_1.ICreditManagerV2__factory.connect(creditManager.address, provider);
-                        return [4 /*yield*/, cm.queryFilter(cm.filters.NewConfigurator(), undefined, toBlock)];
-                    case 1:
-                        ccAddrs = (_a.sent()).map(function (e) { return e.args.newConfigurator; });
-                        return [4 /*yield*/, Promise.all(ccAddrs.map(function (ccAddr) { return __awaiter(_this, void 0, void 0, function () {
-                                var cc, cfUpgradedEvents;
-                                return __generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            cc = types_1.ICreditConfigurator__factory.connect(ccAddr, provider);
-                                            return [4 /*yield*/, cc.queryFilter(cc.filters.CreditFacadeUpgraded(), undefined, toBlock)];
-                                        case 1:
-                                            cfUpgradedEvents = _a.sent();
-                                            return [2 /*return*/, cfUpgradedEvents.map(function (e) { return e.args.newCreditFacade; })];
-                                    }
-                                });
-                            }); }))];
-                    case 2:
-                        cfUpgraded = (_a.sent()).flat();
-                        _loop_1 = function (creditFacade) {
-                            var cf, topics, logs;
-                            return __generator(this, function (_b) {
-                                switch (_b.label) {
-                                    case 0:
-                                        cf = types_1.ICreditFacade__factory.connect(creditFacade, provider);
-                                        topics = {
-                                            OpenCreditAccount: cf.interface.getEventTopic("OpenCreditAccount"),
-                                            CloseCreditAccount: cf.interface.getEventTopic("CloseCreditAccount"),
-                                            LiquidateCreditAccount: cf.interface.getEventTopic("LiquidateCreditAccount"),
-                                            LiquidateExpiredCreditAccount: cf.interface.getEventTopic("LiquidateExpiredCreditAccount"),
-                                            TransferAccount: cf.interface.getEventTopic("TransferAccount"),
-                                        };
-                                        return [4 /*yield*/, cf.queryFilter({
-                                                address: cf.address,
-                                                topics: [Object.values(topics)],
-                                            }, undefined, toBlock)];
-                                    case 1:
-                                        logs = _b.sent();
-                                        logs.forEach(function (log) {
-                                            var e = cf.interface.parseLog(log);
-                                            switch (log.topics[0]) {
-                                                case topics.OpenCreditAccount:
-                                                    addToEvents(log, e.args.onBehalfOf, "add");
-                                                    break;
-                                                case topics.CloseCreditAccount:
-                                                case topics.LiquidateCreditAccount:
-                                                case topics.LiquidateExpiredCreditAccount:
-                                                    addToEvents(log, e.args.borrower, "delete");
-                                                    break;
-                                                case topics.TransferAccount:
-                                                    addToEvents(log, e.args.oldOwner, "delete");
-                                                    addToEvents(log, log.args.newOwner, "add");
-                                                    break;
-                                            }
-                                        });
-                                        return [2 /*return*/];
-                                }
-                            });
-                        };
-                        _i = 0, cfUpgraded_1 = cfUpgraded;
-                        _a.label = 3;
-                    case 3:
-                        if (!(_i < cfUpgraded_1.length)) return [3 /*break*/, 6];
-                        creditFacade = cfUpgraded_1[_i];
-                        return [5 /*yield**/, _loop_1(creditFacade)];
-                    case 4:
-                        _a.sent();
-                        _a.label = 5;
-                    case 5:
-                        _i++;
-                        return [3 /*break*/, 3];
-                    case 6:
-                        eventsByDate
-                            .sort(function (a, b) {
-                            return a.time > b.time ? 1 : -1;
-                        })
-                            .forEach(function (e) {
-                            if (e.operation === "add") {
-                                accounts.add(e.address);
-                            }
-                            else {
-                                accounts.delete(e.address);
-                            }
-                        });
-                        return [2 /*return*/, Array.from(accounts.values()).map(function (borrower) {
-                                return creditAccount_1.CreditAccountData.hash(creditManager.address, borrower);
-                            })];
-                }
+    static async getOpenAccounts(creditManager, provider, toBlock) {
+        if (creditManager.version !== 2)
+            throw new Error("Works for V2 only");
+        const eventsByDate = [];
+        const addToEvents = (e, address, operation) => {
+            eventsByDate.push({
+                time: e.blockNumber * 100000 + e.logIndex,
+                address,
+                operation,
             });
-        });
-    };
-    CreditAccountWatcher.batchCreditAccountLoad = function (accs, dataCompressor, signer, options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function () {
-            var chunkSize, atBlock, dcmc, calls, i, chunk, data, _i, calls_1, c, result;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        chunkSize = 1000;
-                        if (typeof options === "object") {
-                            atBlock = options.atBlock;
-                            chunkSize = (_a = options.chunkSize) !== null && _a !== void 0 ? _a : 1000;
-                        }
-                        else {
-                            atBlock = options;
-                        }
-                        dcmc = new multicall_1.MultiCallContract(dataCompressor, types_1.IDataCompressor__factory.createInterface(), signer);
-                        calls = [];
-                        for (i = 0; i < accs.length; i++) {
-                            chunk = accs.slice(i * chunkSize, (i + 1) * chunkSize);
-                            calls[i] = chunk.map(function (c) {
-                                return {
-                                    method: "getCreditAccountData(address,address)",
-                                    params: c.split(":"),
-                                };
-                            });
-                        }
-                        data = [];
-                        _i = 0, calls_1 = calls;
-                        _b.label = 1;
-                    case 1:
-                        if (!(_i < calls_1.length)) return [3 /*break*/, 4];
-                        c = calls_1[_i];
-                        return [4 /*yield*/, dcmc.call(c, { blockTag: atBlock, gasLimit: 300e6 })];
-                    case 2:
-                        result = _b.sent();
-                        data.push(result);
-                        _b.label = 3;
-                    case 3:
-                        _i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, data.flat().map(function (c) { return new creditAccount_1.CreditAccountData(c); })];
+        };
+        const accounts = new Set();
+        const cm = types_1.ICreditManagerV2__factory.connect(creditManager.address, provider);
+        // get all historical creditConfigurators for this cm
+        const ccAddrs = (await cm.queryFilter(cm.filters.NewConfigurator(), undefined, toBlock)).map(e => e.args.newConfigurator);
+        // get all historical creditFacades for this cm
+        const cfUpgraded = (await Promise.all(ccAddrs.map(async (ccAddr) => {
+            const cc = types_1.ICreditConfigurator__factory.connect(ccAddr, provider);
+            const cfUpgradedEvents = await cc.queryFilter(cc.filters.CreditFacadeUpgraded(), undefined, toBlock);
+            return cfUpgradedEvents.map(e => e.args.newCreditFacade);
+        }))).flat();
+        for (const creditFacade of cfUpgraded) {
+            const cf = types_1.ICreditFacade__factory.connect(creditFacade, provider);
+            const topics = {
+                OpenCreditAccount: cf.interface.getEventTopic("OpenCreditAccount"),
+                CloseCreditAccount: cf.interface.getEventTopic("CloseCreditAccount"),
+                LiquidateCreditAccount: cf.interface.getEventTopic("LiquidateCreditAccount"),
+                LiquidateExpiredCreditAccount: cf.interface.getEventTopic("LiquidateExpiredCreditAccount"),
+                TransferAccount: cf.interface.getEventTopic("TransferAccount"),
+            };
+            const logs = await cf.queryFilter({
+                address: cf.address,
+                topics: [Object.values(topics)],
+            }, undefined, toBlock);
+            logs.forEach(log => {
+                const e = cf.interface.parseLog(log);
+                switch (log.topics[0]) {
+                    case topics.OpenCreditAccount:
+                        addToEvents(log, e.args.onBehalfOf, "add");
+                        break;
+                    case topics.CloseCreditAccount:
+                    case topics.LiquidateCreditAccount:
+                    case topics.LiquidateExpiredCreditAccount:
+                        addToEvents(log, e.args.borrower, "delete");
+                        break;
+                    case topics.TransferAccount:
+                        addToEvents(log, e.args.oldOwner, "delete");
+                        addToEvents(log, log.args.newOwner, "add");
+                        break;
                 }
             });
+        }
+        eventsByDate
+            .sort((a, b) => {
+            return a.time > b.time ? 1 : -1;
+        })
+            .forEach(e => {
+            if (e.operation === "add") {
+                accounts.add(e.address);
+            }
+            else {
+                accounts.delete(e.address);
+            }
         });
-    };
+        return Array.from(accounts.values()).map(borrower => creditAccount_1.CreditAccountData.hash(creditManager.address, borrower));
+    }
+    static async batchCreditAccountLoad(accs, dataCompressor, signer, options) {
+        let chunkSize = 1000;
+        let atBlock;
+        if (typeof options === "object") {
+            atBlock = options.atBlock;
+            chunkSize = options.chunkSize ?? 1000;
+        }
+        else {
+            atBlock = options;
+        }
+        const dcmc = new multicall_1.MultiCallContract(dataCompressor, types_1.IDataCompressor__factory.createInterface(), signer);
+        const calls = [];
+        for (let i = 0; i < accs.length; i++) {
+            const chunk = accs.slice(i * chunkSize, (i + 1) * chunkSize);
+            calls[i] = chunk.map(c => {
+                return {
+                    method: "getCreditAccountData(address,address)",
+                    params: c.split(":"),
+                };
+            });
+        }
+        const data = [];
+        for (let c of calls) {
+            const result = await dcmc.call(c, { blockTag: atBlock, gasLimit: 300e6 });
+            data.push(result);
+        }
+        return data.flat().map(c => new creditAccount_1.CreditAccountData(c));
+    }
     /**
      * Tracks block logs and detects whichj acccounts were changed (created / modified) and which were deleted
      * @param logs Logs from last N blocks
      * @param creditManagers Array of CreditManager data which account it should track
      * @returns CreditManagerUpdate which contains updated (created / modified) and deleted accounts
      */
-    CreditAccountWatcher.detectChanges = function (logs, creditManagers) {
-        var cms = creditManagers.map(function (c) { return c.address.toLowerCase(); });
-        var cfToCm = {};
-        var ccToCm = {};
+    static detectChanges(logs, creditManagers) {
+        const cms = creditManagers.map(c => c.address.toLowerCase());
+        const cfToCm = {};
+        const ccToCm = {};
         // maps credit manager addr to credit configurator addresses
-        var trackers = {};
-        creditManagers.forEach(function (cm) {
+        const trackers = {};
+        creditManagers.forEach(cm => {
             trackers[cm.address.toLowerCase()] = {
                 updated: new Set(),
                 deleted: new Set(),
@@ -224,40 +130,39 @@ var CreditAccountWatcher = /** @class */ (function () {
             ccToCm[cm.creditConfigurator.toLowerCase()] = cm.address.toLowerCase();
             cfToCm[cm.creditFacade.toLowerCase()] = cm.address.toLowerCase();
         });
-        for (var _i = 0, logs_1 = logs; _i < logs_1.length; _i++) {
-            var log = logs_1[_i];
-            var logAddr = log.address.toLowerCase();
+        for (let log of logs) {
+            const logAddr = log.address.toLowerCase();
             if (cms.includes(logAddr)) {
-                var _a = CreditAccountWatcher.creditManagerInterface.parseLog(log), name = _a.name, args = _a.args;
+                const { name, args } = CreditAccountWatcher.creditManagerInterface.parseLog(log);
                 if (name === "ExecuteOrder") {
-                    var borrower = args.borrower;
+                    const { borrower } = args;
                     if (!borrower)
-                        throw new Error("Cant parser event ".concat(log));
+                        throw new Error(`Cant parser event ${log}`);
                     /// Excludes credit facade which represents borrower in multicall
                     if (!(borrower.toLowerCase() in cfToCm)) {
                         trackers[logAddr].updated.add(borrower);
                     }
                 }
                 else if (name === "NewConfigurator") {
-                    var newConfigurator = args.newConfigurator.toLowerCase();
+                    const newConfigurator = args.newConfigurator.toLowerCase();
                     ccToCm[newConfigurator] = logAddr;
                 }
             }
             else if (logAddr in ccToCm) {
-                var _b = CreditAccountWatcher.creditConfiguratorInterface.parseLog(log), name = _b.name, args = _b.args;
+                const { name, args } = CreditAccountWatcher.creditConfiguratorInterface.parseLog(log);
                 if (name === "CreditFacadeUpgraded") {
-                    var newCreditFacade = args.newCreditFacade.toLowerCase();
+                    const newCreditFacade = args.newCreditFacade.toLowerCase();
                     cfToCm[newCreditFacade] = ccToCm[logAddr];
                 }
             }
             else if (logAddr in cfToCm) {
-                var _c = CreditAccountWatcher.creditFacadeInterface.parseLog(log), name = _c.name, args = _c.args;
+                const { name, args } = CreditAccountWatcher.creditFacadeInterface.parseLog(log);
                 switch (name) {
                     case "OpenCreditAccount":
                     case "AddCollateral": {
-                        var onBehalfOf = args.onBehalfOf;
+                        const { onBehalfOf } = args;
                         if (!onBehalfOf)
-                            throw new Error("Cant parser event ".concat(log));
+                            throw new Error(`Cant parser event ${log}`);
                         trackers[cfToCm[logAddr]].updated.add(onBehalfOf);
                         break;
                     }
@@ -266,26 +171,26 @@ var CreditAccountWatcher = /** @class */ (function () {
                     case "TokenDisabled":
                     case "TokenEnabled":
                     case "MultiCallStarted": {
-                        var borrower = args.borrower;
+                        const { borrower } = args;
                         if (!borrower)
-                            throw new Error("Cant parser event ".concat(log));
+                            throw new Error(`Cant parser event ${log}`);
                         trackers[cfToCm[logAddr]].updated.add(borrower);
                         break;
                     }
                     case "CloseCreditAccount":
                     case "LiquidateCreditAccount":
                     case "LiquidateExpiredCreditAccount": {
-                        var borrower = args.borrower;
+                        const { borrower } = args;
                         if (!borrower)
-                            throw new Error("Cant parser event ".concat(log));
+                            throw new Error(`Cant parser event ${log}`);
                         trackers[cfToCm[logAddr]].updated.delete(borrower);
                         trackers[cfToCm[logAddr]].deleted.add(borrower);
                         break;
                     }
                     case "TransferAccount": {
-                        var oldOwner = args.oldOwner, newOwner = args.newOwner;
+                        const { oldOwner, newOwner } = args;
                         if (!oldOwner || !newOwner)
-                            throw new Error("Cant parser event ".concat(log));
+                            throw new Error(`Cant parser event ${log}`);
                         trackers[cfToCm[logAddr]].updated.delete(oldOwner);
                         trackers[cfToCm[logAddr]].updated.add(newOwner);
                         trackers[cfToCm[logAddr]].deleted.add(oldOwner);
@@ -293,33 +198,32 @@ var CreditAccountWatcher = /** @class */ (function () {
                 }
             }
         }
-        var result = {
+        const result = {
             updated: [],
             deleted: [],
         };
-        cms.forEach(function (cm) {
-            trackers[cm].updated.forEach(function (borrower) {
+        cms.forEach(cm => {
+            trackers[cm].updated.forEach(borrower => {
                 result.updated.push(creditAccount_1.CreditAccountData.hash(cm, borrower));
             });
-            trackers[cm].deleted.forEach(function (borrower) {
+            trackers[cm].deleted.forEach(borrower => {
                 result.deleted.push(creditAccount_1.CreditAccountData.hash(cm, borrower));
             });
         });
         return result;
-    };
-    CreditAccountWatcher.trackDirectTransfers = function (freshLogs, tokensToTrack, accounts) {
-        var tkns = tokensToTrack.map(function (t) { return t.toLowerCase(); });
-        var accAddresses = [];
-        var accToCa = {};
-        var modified = new Set();
-        accounts.forEach(function (ca) {
+    }
+    static trackDirectTransfers(freshLogs, tokensToTrack, accounts) {
+        const tkns = tokensToTrack.map(t => t.toLowerCase());
+        const accAddresses = [];
+        const accToCa = {};
+        const modified = new Set();
+        accounts.forEach(ca => {
             accAddresses.push(ca.addr);
             accToCa[ca.addr] = ca;
         });
-        for (var _i = 0, freshLogs_1 = freshLogs; _i < freshLogs_1.length; _i++) {
-            var log = freshLogs_1[_i];
+        for (let log of freshLogs) {
             if (tkns.includes(log.address.toLocaleLowerCase())) {
-                var _a = CreditAccountWatcher.IERC20.parseLog(log), name = _a.name, args = _a.args;
+                const { name, args } = CreditAccountWatcher.IERC20.parseLog(log);
                 if (name === "Transfer" &&
                     accAddresses.includes(args.to.toLowerCase())) {
                     modified.add(accToCa[args.to.toLowerCase()].hash());
@@ -327,11 +231,6 @@ var CreditAccountWatcher = /** @class */ (function () {
             }
         }
         return Array.from(modified);
-    };
-    CreditAccountWatcher.IERC20 = types_1.IERC20__factory.createInterface();
-    CreditAccountWatcher.creditManagerInterface = types_1.ICreditManagerV2__factory.createInterface();
-    CreditAccountWatcher.creditConfiguratorInterface = types_1.ICreditConfigurator__factory.createInterface();
-    CreditAccountWatcher.creditFacadeInterface = types_1.ICreditFacade__factory.createInterface();
-    return CreditAccountWatcher;
-}());
+    }
+}
 exports.CreditAccountWatcher = CreditAccountWatcher;