@gearbox-protocol/sdk 1.6.6 → 1.7.0

package/lib/watchers/creditAccountWatcher.d.ts

@@ -0,0 +1,30 @@
+import { providers, Signer } from "ethers";
+import { CreditAccountData } from "../core/creditAccount";
+import { CreditManagerData } from "../core/creditManager";
+export declare type CreditAccountHash = string;
+export interface CreditManagerUpdate {
+    updated: Array<CreditAccountHash>;
+    deleted: Array<CreditAccountHash>;
+}
+export declare class CreditAccountWatcher {
+    static IERC20: import("../types/@openzeppelin/contracts/token/ERC20/IERC20").IERC20Interface;
+    static creditManagerInterface: import("../types/contracts/interfaces/ICreditManagerV2.sol/ICreditManagerV2").ICreditManagerV2Interface;
+    static creditFacadeInterface: import("../types/contracts/interfaces/ICreditFacade.sol/ICreditFacade").ICreditFacadeInterface;
+    /**
+     * Gets hashes of all opened credit accounts at toBlock (or "latest" by default)
+     * @param creditManager CreditManagerData of desired CreditManager to check
+     * @param provider Ethers provider or signer to get an access
+     * @param toBlock Optional. Set the last block you;d like to get opened accounts
+     * @returns Arrays of hashes for opened accounts
+     */
+    static getOpenAccounts(creditManager: CreditManagerData, provider: providers.Provider | Signer, toBlock?: number): Promise<Array<CreditAccountHash>>;
+    static batchCreditAccountLoad(accs: Array<CreditAccountHash>, dataCompressor: string, signer: Signer | providers.Provider, atBlock?: number): Promise<Array<CreditAccountData>>;
+    /**
+     * 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
+     */
+    static detectChanges(logs: Array<providers.Log>, creditManagers: Array<CreditManagerData>): CreditManagerUpdate;
+    static trackDirectTransfers(freshLogs: Array<providers.Log>, tokensToTrack: Array<string>, accounts: Array<CreditAccountData>): Array<CreditAccountHash>;
+}

package/lib/watchers/creditAccountWatcher.js

@@ -0,0 +1,255 @@
+"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 };
+    }
+};
+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() {
+    }
+    /**
+     * Gets hashes of all opened credit accounts at toBlock (or "latest" by default)
+     * @param creditManager CreditManagerData of desired CreditManager to check
+     * @param provider Ethers provider or signer to get an access
+     * @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, creditFacade, cf, _a, openEvents, closeEvents, liquidateEvents, liquidateExpiredEvents;
+            return __generator(this, function (_b) {
+                switch (_b.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();
+                        creditFacade = creditManager.creditFacade;
+                        cf = types_1.ICreditFacade__factory.connect(creditFacade, provider);
+                        return [4 /*yield*/, Promise.all([
+                                cf.queryFilter(cf.filters.OpenCreditAccount(), undefined, toBlock),
+                                cf.queryFilter(cf.filters.CloseCreditAccount(), undefined, toBlock),
+                                cf.queryFilter(cf.filters.LiquidateCreditAccount(), undefined, toBlock),
+                                cf.queryFilter(cf.filters.LiquidateExpiredCreditAccount(), undefined, toBlock),
+                            ])];
+                    case 1:
+                        _a = _b.sent(), openEvents = _a[0], closeEvents = _a[1], liquidateEvents = _a[2], liquidateExpiredEvents = _a[3];
+                        openEvents.forEach(function (e) {
+                            addToEvents(e, e.args.onBehalfOf, "add");
+                        });
+                        closeEvents.forEach(function (e) {
+                            addToEvents(e, e.args.borrower, "delete");
+                        });
+                        liquidateEvents.forEach(function (e) {
+                            addToEvents(e, e.args.borrower, "delete");
+                        });
+                        liquidateExpiredEvents.forEach(function (e) {
+                            addToEvents(e, e.args.borrower, "delete");
+                        });
+                        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);
+                            })];
+                }
+            });
+        });
+    };
+    CreditAccountWatcher.batchCreditAccountLoad = function (accs, dataCompressor, signer, atBlock) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dcmc, chunkSize, calls, i, chunk, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        dcmc = new multicall_1.MultiCallContract(dataCompressor, types_1.IDataCompressor__factory.createInterface(), signer);
+                        chunkSize = 1000;
+                        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(":"),
+                                };
+                            });
+                        }
+                        return [4 /*yield*/, Promise.all(calls.map(function (c) { return dcmc.call(c, { blockTag: atBlock }); }))];
+                    case 1:
+                        data = _a.sent();
+                        return [2 /*return*/, data.flat().map(function (c) { return 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; });
+        var cfs = creditManagers.map(function (c) { return c.creditFacade; });
+        var cfToCm = creditManagers.reduce(function (acc, item) {
+            acc[item.creditFacade] = item.address;
+            return acc;
+        }, {});
+        var trackers = {};
+        cms.forEach(function (cm) {
+            trackers[cm] = {
+                updated: new Set(),
+                deleted: new Set(),
+            };
+        });
+        for (var _i = 0, logs_1 = logs; _i < logs_1.length; _i++) {
+            var log = logs_1[_i];
+            var logAddr = log.address.toLowerCase();
+            if (cms.includes(logAddr)) {
+                var _a = CreditAccountWatcher.creditManagerInterface.parseLog(log), name = _a.name, args = _a.args;
+                if (name === "ExecuteOrder") {
+                    var borrower = args.borrower;
+                    if (!borrower)
+                        throw new Error("Cant parser event ".concat(log));
+                    /// Excludes credit facade which represents borrower in multicall
+                    if (!cfs.includes(borrower.toLowerCase())) {
+                        trackers[logAddr].updated.add(borrower);
+                    }
+                }
+            }
+            else if (cfs.includes(logAddr)) {
+                var _b = CreditAccountWatcher.creditFacadeInterface.parseLog(log), name = _b.name, args = _b.args;
+                switch (name) {
+                    case "OpenCreditAccount":
+                    case "AddCollateral": {
+                        var onBehalfOf = args.onBehalfOf;
+                        if (!onBehalfOf)
+                            throw new Error("Cant parser event ".concat(log));
+                        trackers[cfToCm[logAddr]].updated.add(onBehalfOf);
+                        break;
+                    }
+                    case "DecreaseBorrowedAmount":
+                    case "IncreaseBorrowedAmount":
+                    case "TokenDisabled":
+                    case "TokenEnabled":
+                    case "MultiCallStarted": {
+                        var borrower = args.borrower;
+                        if (!borrower)
+                            throw new Error("Cant parser event ".concat(log));
+                        trackers[cfToCm[logAddr]].updated.add(borrower);
+                        break;
+                    }
+                    case "CloseCreditAccount":
+                    case "LiquidateCreditAccount":
+                    case "LiquidateExpiredCreditAccount": {
+                        var borrower = args.borrower;
+                        if (!borrower)
+                            throw new Error("Cant parser event ".concat(log));
+                        trackers[cfToCm[logAddr]].updated.delete(borrower);
+                        trackers[cfToCm[logAddr]].deleted.add(borrower);
+                        break;
+                    }
+                    case "TransferAccount": {
+                        var oldOwner = args.oldOwner, newOwner = args.newOwner;
+                        if (!oldOwner || !newOwner)
+                            throw new Error("Cant parser event ".concat(log));
+                        trackers[cfToCm[logAddr]].updated.delete(oldOwner);
+                        trackers[cfToCm[logAddr]].updated.add(newOwner);
+                        trackers[cfToCm[logAddr]].deleted.add(oldOwner);
+                    }
+                }
+            }
+        }
+        var result = {
+            updated: [],
+            deleted: [],
+        };
+        cms.forEach(function (cm) {
+            trackers[cm].updated.forEach(function (borrower) {
+                result.updated.push(creditAccount_1.CreditAccountData.hash(cm, borrower));
+            });
+            trackers[cm].deleted.forEach(function (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) {
+            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];
+            if (tkns.includes(log.address.toLocaleLowerCase())) {
+                var _a = CreditAccountWatcher.IERC20.parseLog(log), name = _a.name, args = _a.args;
+                if (name === "Transfer" &&
+                    accAddresses.includes(args.to.toLowerCase())) {
+                    modified.add(accToCa[args.to.toLowerCase()].hash());
+                }
+            }
+        }
+        return Array.from(modified);
+    };
+    CreditAccountWatcher.IERC20 = types_1.IERC20__factory.createInterface();
+    CreditAccountWatcher.creditManagerInterface = types_1.ICreditManagerV2__factory.createInterface();
+    CreditAccountWatcher.creditFacadeInterface = types_1.ICreditFacade__factory.createInterface();
+    return CreditAccountWatcher;
+}());
+exports.CreditAccountWatcher = CreditAccountWatcher;

package/lib/watchers/creditAccountWatcher.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/watchers/creditAccountWatcher.spec.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var constants_1 = require("../core/constants");
+var types_1 = require("../types");
+var creditAccountWatcher_1 = require("./creditAccountWatcher");
+var CREDIT_MANAGER_ADDRESS = constants_1.DUMB_ADDRESS;
+var CREDIT_FACADE_ADDRESS = "0xcb9a588a47dd0393af3d0d5f86e6f1c8fd252c48";
+var BORROWER = "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266";
+var expectedHash = "".concat(CREDIT_MANAGER_ADDRESS.toLowerCase(), ":").concat(BORROWER.toLowerCase());
+var creditManagerInterface = types_1.ICreditManagerV2__factory.createInterface();
+var creditFacadeInterface = types_1.ICreditFacade__factory.createInterface();
+var cmDumb = {
+    address: CREDIT_MANAGER_ADDRESS.toLowerCase(),
+    creditFacade: CREDIT_FACADE_ADDRESS.toLowerCase(),
+};
+var encode = function (abiType, value) {
+    return ethers_1.utils.defaultAbiCoder.encode([abiType], [value]);
+};
+var makeLog = function (address, topics, data) {
+    if (data === void 0) { data = constants_1.ADDRESS_0X0; }
+    return {
+        blockNumber: 0,
+        blockHash: "",
+        transactionIndex: 0,
+        removed: false,
+        address: address,
+        data: data,
+        topics: topics,
+        transactionHash: "",
+        logIndex: 0,
+    };
+};
+var openLog = makeLog(CREDIT_FACADE_ADDRESS, [
+    creditFacadeInterface.getEventTopic("OpenCreditAccount"),
+    encode("address", BORROWER),
+    encode("address", constants_1.DUMB_ADDRESS),
+], ethers_1.utils.defaultAbiCoder.encode(["uint256", "uint16"], [10, 10]));
+var closeLog = makeLog(CREDIT_FACADE_ADDRESS, [
+    creditFacadeInterface.getEventTopic("CloseCreditAccount"),
+    encode("address", BORROWER),
+    encode("address", constants_1.DUMB_ADDRESS),
+    encode("address", constants_1.DUMB_ADDRESS),
+]);
+describe("CreditAccountTracker test", function () {
+    it("detects update events correctly", function () {
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([openLog], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        var log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("IncreaseBorrowedAmount"),
+            encode("address", BORROWER),
+        ], ethers_1.utils.defaultAbiCoder.encode(["uint256"], [10]));
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("DecreaseBorrowedAmount"),
+            encode("address", BORROWER),
+        ], ethers_1.utils.defaultAbiCoder.encode(["uint256"], [10]));
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("AddCollateral"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ], ethers_1.utils.defaultAbiCoder.encode(["uint256"], [10]));
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("MultiCallStarted"),
+            encode("address", BORROWER),
+        ]);
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("TokenEnabled"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("TokenDisabled"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        log = makeLog(CREDIT_MANAGER_ADDRESS, [
+            creditManagerInterface.getEventTopic("ExecuteOrder"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+    });
+    //
+    // DELETED
+    //
+    it("detects delete events correctly", function () {
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([closeLog], [cmDumb])).to.be.eql({
+            updated: [],
+            deleted: [expectedHash],
+        });
+        var log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("LiquidateCreditAccount"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+            encode("address", constants_1.DUMB_ADDRESS),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ], ethers_1.utils.defaultAbiCoder.encode(["uint256"], [10]));
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [],
+            deleted: [expectedHash],
+        });
+        log = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("LiquidateExpiredCreditAccount"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+            encode("address", constants_1.DUMB_ADDRESS),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ], ethers_1.utils.defaultAbiCoder.encode(["uint256"], [10]));
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([log], [cmDumb])).to.be.eql({
+            updated: [],
+            deleted: [expectedHash],
+        });
+    });
+    it("doesn't make duplicated", function () {
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([openLog, openLog, openLog], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [],
+        });
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([closeLog, closeLog, closeLog], [cmDumb])).to.be.eql({
+            updated: [],
+            deleted: [expectedHash],
+        });
+    });
+    it("updates accounts were created and deleted in the batch", function () {
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([openLog, closeLog], [cmDumb])).to.be.eql({
+            updated: [],
+            deleted: [expectedHash],
+        });
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([openLog, closeLog, openLog], [cmDumb])).to.be.eql({
+            updated: [expectedHash],
+            deleted: [expectedHash],
+        });
+    });
+    it("TransferAccount works correctly", function () {
+        var transferLog = makeLog(CREDIT_FACADE_ADDRESS, [
+            creditFacadeInterface.getEventTopic("TransferAccount"),
+            encode("address", BORROWER),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditAccountWatcher_1.CreditAccountWatcher.detectChanges([openLog, transferLog], [cmDumb])).to.be.eql({
+            updated: [
+                "".concat(CREDIT_MANAGER_ADDRESS.toLowerCase(), ":").concat(constants_1.DUMB_ADDRESS.toLowerCase()),
+            ],
+            deleted: [expectedHash],
+        });
+    });
+});

package/lib/watchers/creditManagerWatcher.d.ts

@@ -0,0 +1,8 @@
+import { providers, Signer } from "ethers";
+import { CreditManagerData } from "../core/creditManager";
+export declare class CreditManagerWatcher {
+    static creditManagerInterface: import("../types/contracts/interfaces/ICreditManagerV2.sol/ICreditManagerV2").ICreditManagerV2Interface;
+    static creditConfiguratorInterface: import("../types/contracts/interfaces/ICreditConfigurator.sol/ICreditConfigurator").ICreditConfiguratorInterface;
+    static getV2CreditManagers(dataCompressor: string, signer: Signer | providers.Provider, atBlock?: number): Promise<Record<string, CreditManagerData>>;
+    static detectConfigChanges(freshLogs: Array<providers.Log>, creditManagers: Array<CreditManagerData>): boolean;
+}

package/lib/watchers/creditManagerWatcher.js

@@ -0,0 +1,86 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditManagerWatcher = void 0;
+var creditManager_1 = require("../core/creditManager");
+var types_1 = require("../types");
+var CreditManagerWatcher = /** @class */ (function () {
+    function CreditManagerWatcher() {
+    }
+    CreditManagerWatcher.getV2CreditManagers = function (dataCompressor, signer, atBlock) {
+        return __awaiter(this, void 0, void 0, function () {
+            var creditManagers, creditManagersPayload;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        creditManagers = {};
+                        return [4 /*yield*/, types_1.IDataCompressor__factory.connect(dataCompressor, signer).getCreditManagersList({ blockTag: atBlock })];
+                    case 1:
+                        creditManagersPayload = _a.sent();
+                        creditManagersPayload
+                            .filter(function (c) { return c.version === 2; })
+                            .forEach(function (c) {
+                            creditManagers[c.addr.toLowerCase()] = new creditManager_1.CreditManagerData(c);
+                        });
+                        return [2 /*return*/, creditManagers];
+                }
+            });
+        });
+    };
+    CreditManagerWatcher.detectConfigChanges = function (freshLogs, creditManagers) {
+        var cms = creditManagers.map(function (c) { return c.address; });
+        var ccs = creditManagers.map(function (c) { return c.creditConfigurator; });
+        for (var _i = 0, freshLogs_1 = freshLogs; _i < freshLogs_1.length; _i++) {
+            var log = freshLogs_1[_i];
+            if (cms.includes(log.address.toLowerCase())) {
+                var name = CreditManagerWatcher.creditManagerInterface.parseLog(log).name;
+                if (name === "NewConfigurator") {
+                    return true;
+                }
+            }
+            if (ccs.includes(log.address.toLowerCase())) {
+                return true;
+            }
+        }
+        return false;
+    };
+    CreditManagerWatcher.creditManagerInterface = types_1.ICreditManagerV2__factory.createInterface();
+    CreditManagerWatcher.creditConfiguratorInterface = types_1.ICreditConfigurator__factory.createInterface();
+    return CreditManagerWatcher;
+}());
+exports.CreditManagerWatcher = CreditManagerWatcher;

package/lib/watchers/creditManagerWatcher.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/watchers/creditManagerWatcher.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var constants_1 = require("../core/constants");
+var types_1 = require("../types");
+var creditManagerWatcher_1 = require("./creditManagerWatcher");
+var CREDIT_MANAGER_ADDRESS = constants_1.DUMB_ADDRESS;
+var CREDIT_CONFIGIURATOR_ADDRESS = "0xcb9a588a47dd0393af3d0d5f86e6f1c8fd252c48";
+var cmDumb = {
+    address: CREDIT_MANAGER_ADDRESS.toLowerCase(),
+    creditConfigurator: CREDIT_CONFIGIURATOR_ADDRESS.toLowerCase(),
+};
+var encode = function (abiType, value) {
+    return ethers_1.utils.defaultAbiCoder.encode([abiType], [value]);
+};
+var makeLog = function (address, topics, data) {
+    if (data === void 0) { data = constants_1.ADDRESS_0X0; }
+    return {
+        blockNumber: 0,
+        blockHash: "",
+        transactionIndex: 0,
+        removed: false,
+        address: address,
+        data: data,
+        topics: topics,
+        transactionHash: "",
+        logIndex: 0,
+    };
+};
+describe("CreditManagerTracker test", function () {
+    it("detects CreditManager events correctly", function () {
+        var creditManagerInterface = types_1.ICreditManagerV2__factory.createInterface();
+        var log = makeLog(CREDIT_MANAGER_ADDRESS, [
+            creditManagerInterface.getEventTopic("NewConfigurator"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_MANAGER_ADDRESS, [
+            creditManagerInterface.getEventTopic("ExecuteOrder"),
+            encode("address", constants_1.DUMB_ADDRESS),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(false);
+    });
+    it("detects CreditConfigurator events correctly", function () {
+        var ccInterface = types_1.ICreditConfigurator__factory.createInterface();
+        var log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("TokenLiquidationThresholdUpdated"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ], encode("uint16", 122));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("TokenAllowed"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("TokenForbidden"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("ContractAllowed"),
+            encode("address", constants_1.DUMB_ADDRESS),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("ContractForbidden"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("LimitsUpdated")], ethers_1.utils.defaultAbiCoder.encode(["uint256", "uint256"], [50, 200]));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("FeesUpdated")], ethers_1.utils.defaultAbiCoder.encode(["uint16", "uint16", "uint16", "uint16", "uint16"], [50, 50, 50, 50, 50]));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("PriceOracleUpgraded"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("CreditFacadeUpgraded"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [
+            ccInterface.getEventTopic("CreditConfiguratorUpgraded"),
+            encode("address", constants_1.DUMB_ADDRESS),
+        ]);
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("IncreaseDebtForbiddenModeChanged")], encode("bool", true));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("LimitPerBlockUpdated")], encode("uint128", 122));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("AddedToUpgradeable")], encode("address", constants_1.DUMB_ADDRESS));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("RemovedFromUpgradeable")], encode("address", constants_1.DUMB_ADDRESS));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("ExpirationDateUpdated")], encode("uint40", Math.floor(Date.now() / 1000)));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("MaxEnabledTokensUpdated")], encode("uint8", 14));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("EmergencyLiquidatorAdded")], encode("address", constants_1.DUMB_ADDRESS));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+        log = makeLog(CREDIT_CONFIGIURATOR_ADDRESS, [ccInterface.getEventTopic("EmergencyLiquidatorRemoved")], encode("address", constants_1.DUMB_ADDRESS));
+        (0, chai_1.expect)(creditManagerWatcher_1.CreditManagerWatcher.detectConfigChanges([log], [cmDumb])).to.be.eq(true);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "1.6.6",
+  "version": "1.7.0",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",