@gearbox-protocol/sdk 1.13.0 → 1.14.0

package/lib/rewards/poolRewardParams.d.ts

@@ -0,0 +1,4 @@
+import { NetworkType } from "../core/constants";
+import { DieselTokenTypes } from "../tokens/gear";
+import { RangedValue } from "./range";
+export declare const poolRewardsPerBlock: Record<NetworkType, Record<DieselTokenTypes, RangedValue>>;

package/lib/rewards/poolRewardParams.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.poolRewardsPerBlock = void 0;
+var range_1 = require("./range");
+exports.poolRewardsPerBlock = {
+    Mainnet: {
+        dDAI: new range_1.RangedValue(),
+        dUSDC: new range_1.RangedValue(),
+        dWETH: new range_1.RangedValue(),
+        dWBTC: new range_1.RangedValue(),
+        dwstETH: new range_1.RangedValue(),
+    },
+    Goerli: {
+        dDAI: new range_1.RangedValue(),
+        dUSDC: new range_1.RangedValue(),
+        dWETH: new range_1.RangedValue(),
+        dWBTC: new range_1.RangedValue(),
+        dwstETH: new range_1.RangedValue(),
+    },
+};
+// poolRewardsPerBlock.Goerli.dDAI.addValue(90000, BigNumber.from(0));

package/lib/rewards/poolRewards.d.ts

@@ -0,0 +1,15 @@
+import { BigNumber, providers } from "ethers";
+import { NetworkType } from "../core/constants";
+import { TransferEvent } from "../types/@gearbox-protocol/core-v2/contracts/interfaces/IPhantomERC20";
+import { RangedValue } from "./range";
+export interface Reward {
+    address: string;
+    amount: BigNumber;
+}
+export declare class PoolRewards {
+    static computeReward(dieselToken: string, address: string, provider: providers.Provider, networkType: NetworkType, toBlock?: number): Promise<BigNumber>;
+    computeAllRewards(dieselToken: string, provider: providers.Provider, networkType: NetworkType, toBlock?: number): Promise<Array<Reward>>;
+    static computeRewardInt(toBlock: number, balance: RangedValue, totalSupply: RangedValue, rewardPerBlock: RangedValue): BigNumber;
+    protected static query(dieselToken: string, provider: providers.Provider, toBlock: number): Promise<Array<TransferEvent>>;
+    protected static getRewardsRange(dieselToken: string, networkType: NetworkType): RangedValue;
+}

package/lib/rewards/poolRewards.js

@@ -0,0 +1,199 @@
+"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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolRewards = void 0;
+var ethers_1 = require("ethers");
+var constants_1 = require("../core/constants");
+var token_1 = require("../tokens/token");
+var types_1 = require("../types");
+var poolRewardParams_1 = require("./poolRewardParams");
+var range_1 = require("./range");
+var PoolRewards = /** @class */ (function () {
+    function PoolRewards() {
+    }
+    PoolRewards.computeReward = function (dieselToken, address, provider, networkType, toBlock) {
+        return __awaiter(this, void 0, void 0, function () {
+            var toBlockQuery, _a, query, balanceRange, totalSupplyRange, rewardPerBlock, addrLC, totalSupply, balance;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = toBlock;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, provider.getBlockNumber()];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        toBlockQuery = _a;
+                        return [4 /*yield*/, PoolRewards.query(dieselToken, provider, toBlockQuery)];
+                    case 3:
+                        query = _b.sent();
+                        balanceRange = new range_1.RangedValue();
+                        totalSupplyRange = new range_1.RangedValue();
+                        rewardPerBlock = PoolRewards.getRewardsRange(dieselToken, networkType);
+                        addrLC = address.toLowerCase();
+                        totalSupply = ethers_1.BigNumber.from(0);
+                        balance = ethers_1.BigNumber.from(0);
+                        query.forEach(function (e) {
+                            var from = e.args.from.toLowerCase();
+                            if (from === constants_1.ADDRESS_0X0) {
+                                totalSupply = totalSupply.add(e.args.value);
+                                totalSupplyRange.addValue(e.blockNumber, totalSupply);
+                            }
+                            else if (from === addrLC) {
+                                balance = balance.sub(e.args.value);
+                                balanceRange.addValue(e.blockNumber, balance);
+                            }
+                            var to = e.args.to.toLowerCase();
+                            if (to === constants_1.ADDRESS_0X0) {
+                                totalSupply = totalSupply.sub(e.args.value);
+                                totalSupplyRange.addValue(e.blockNumber, totalSupply);
+                            }
+                            else if (to === addrLC) {
+                                balance = balance.add(e.args.value);
+                                balanceRange.addValue(e.blockNumber, balance);
+                            }
+                        });
+                        return [2 /*return*/, PoolRewards.computeRewardInt(toBlockQuery, balanceRange, totalSupplyRange, rewardPerBlock)];
+                }
+            });
+        });
+    };
+    PoolRewards.prototype.computeAllRewards = function (dieselToken, provider, networkType, toBlock) {
+        return __awaiter(this, void 0, void 0, function () {
+            var toBlockQuery, _a, query, totalSupplyRange, rewardPerBlock, balancesRange, totalSupply, balances;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = toBlock;
+                        if (_a) return [3 /*break*/, 2];
+                        return [4 /*yield*/, provider.getBlockNumber()];
+                    case 1:
+                        _a = (_b.sent());
+                        _b.label = 2;
+                    case 2:
+                        toBlockQuery = _a;
+                        return [4 /*yield*/, PoolRewards.query(dieselToken, provider, toBlockQuery)];
+                    case 3:
+                        query = _b.sent();
+                        totalSupplyRange = new range_1.RangedValue();
+                        rewardPerBlock = PoolRewards.getRewardsRange(dieselToken, networkType);
+                        balancesRange = {};
+                        totalSupply = ethers_1.BigNumber.from(0);
+                        balances = {};
+                        query.forEach(function (e) {
+                            var from = e.args.from.toLowerCase();
+                            if (from === constants_1.ADDRESS_0X0) {
+                                totalSupply = totalSupply.add(e.args.value);
+                                totalSupplyRange.addValue(e.blockNumber, totalSupply);
+                            }
+                            else {
+                                balances[from] = balances[from].sub(e.args.value);
+                                balancesRange[from].addValue(e.blockNumber, balances[from]);
+                            }
+                            var to = e.args.to.toLowerCase();
+                            if (to === constants_1.ADDRESS_0X0) {
+                                totalSupply = totalSupply.sub(e.args.value);
+                                totalSupplyRange.addValue(e.blockNumber, totalSupply);
+                            }
+                            else {
+                                if (!balances[to]) {
+                                    balances[to] = ethers_1.BigNumber.from(0);
+                                    balancesRange[to] = new range_1.RangedValue();
+                                }
+                                balances[to] = balances[to].add(e.args.value);
+                                balancesRange[to].addValue(e.blockNumber, balances[to]);
+                            }
+                        });
+                        return [2 /*return*/, Object.keys(balances).map(function (address) { return ({
+                                address: address,
+                                amount: PoolRewards.computeRewardInt(toBlockQuery, balancesRange[address], totalSupplyRange, rewardPerBlock),
+                            }); })];
+                }
+            });
+        });
+    };
+    PoolRewards.computeRewardInt = function (toBlock, balance, totalSupply, rewardPerBlock) {
+        var keys = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], balance.keys, true), totalSupply.keys, true), rewardPerBlock.keys, true), [
+            toBlock,
+        ], false))).sort(function (a, b) { return (a > b ? 1 : -1); });
+        var total = ethers_1.BigNumber.from(0);
+        var balancesArr = balance.getValues(keys);
+        var totalSupplyArr = totalSupply.getValues(keys);
+        var rewardsArr = rewardPerBlock.getValues(keys);
+        for (var i = 0; i < keys.length; i++) {
+            var curBlock = keys[i];
+            var nextBlock = i === keys.length - 1 ? toBlock : keys[i + 1];
+            total = total.add(balancesArr[i]
+                .mul(nextBlock - curBlock)
+                .mul(rewardsArr[i])
+                .div(totalSupplyArr[i]));
+        }
+        return total;
+    };
+    PoolRewards.query = function (dieselToken, provider, toBlock) {
+        return __awaiter(this, void 0, void 0, function () {
+            var token;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        token = types_1.IERC20__factory.connect(dieselToken, provider);
+                        return [4 /*yield*/, token.queryFilter(token.filters.Transfer(), 0, toBlock)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    PoolRewards.getRewardsRange = function (dieselToken, networkType) {
+        var rewardPerBlock = poolRewardParams_1.poolRewardsPerBlock[networkType][token_1.tokenSymbolByAddress[dieselToken.toLowerCase()]];
+        if (!rewardPerBlock)
+            throw new Error("Unknown diesel token ".concat(dieselToken));
+        return rewardPerBlock;
+    };
+    return PoolRewards;
+}());
+exports.PoolRewards = PoolRewards;

package/lib/rewards/poolRewards.spec.d.ts

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

package/lib/rewards/poolRewards.spec.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var poolRewards_1 = require("./poolRewards");
+var range_1 = require("./range");
+describe("PoolRewards test", function () {
+    it("computeReward works correctly", function () {
+        var balances = new range_1.RangedValue();
+        balances.addValue(1000, ethers_1.BigNumber.from(100));
+        balances.addValue(2000, ethers_1.BigNumber.from(200));
+        balances.addValue(3000, ethers_1.BigNumber.from(0));
+        var totalSupply = new range_1.RangedValue();
+        totalSupply.addValue(500, ethers_1.BigNumber.from(100));
+        totalSupply.addValue(1000, ethers_1.BigNumber.from(200));
+        totalSupply.addValue(1500, ethers_1.BigNumber.from(250));
+        totalSupply.addValue(2000, ethers_1.BigNumber.from(400));
+        totalSupply.addValue(3000, ethers_1.BigNumber.from(100));
+        var rewards = new range_1.RangedValue();
+        rewards.addValue(500, ethers_1.BigNumber.from(20));
+        // Block: ----- 500 ------ 1000 ----- 1500 ----- 2000 ------ 2500 ----- 3000
+        //
+        // Balances:     0          100 ----------------  200 ------------------ 0
+        // Total supply  100        200   --    250       300                    100
+        // Rewards:      20
+        //                           10 ------  8         10 -------------------- 0
+        // Total: 10 * 500 + 8*500 + 10 * 1000 = 19000
+        var result = poolRewards_1.PoolRewards.computeRewardInt(3000, balances, totalSupply, rewards);
+        (0, chai_1.expect)(result.toNumber()).to.be.eq(19000);
+    });
+});

package/lib/rewards/range.d.ts

@@ -0,0 +1,12 @@
+import { BigNumber } from "ethers";
+export declare class RangedValue {
+    protected initialValue: BigNumber;
+    protected data: Map<number, BigNumber>;
+    protected _keys: Array<number>;
+    constructor(initialValue?: BigNumber);
+    addValue(from: number, value: BigNumber): void;
+    getValue(at: number): BigNumber;
+    getValues(sortedKeys: Array<number>): Array<BigNumber>;
+    protected getMapValue(index: number): BigNumber;
+    get keys(): Array<number>;
+}

package/lib/rewards/range.js

@@ -0,0 +1,75 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangedValue = void 0;
+var ethers_1 = require("ethers");
+var RangedValue = /** @class */ (function () {
+    function RangedValue(initialValue) {
+        this.data = new Map();
+        this._keys = [];
+        this.initialValue = initialValue || ethers_1.BigNumber.from(0);
+    }
+    RangedValue.prototype.addValue = function (from, value) {
+        this.data.set(from, value);
+        this._keys = __spreadArray(__spreadArray([], this._keys, true), [from], false).sort(function (a, b) { return (a > b ? 1 : -1); });
+    };
+    RangedValue.prototype.getValue = function (at) {
+        for (var _i = 0, _a = __spreadArray([], this._keys, true).reverse(); _i < _a.length; _i++) {
+            var index = _a[_i];
+            if (at >= index) {
+                var value = this.data.get(index);
+                if (!value)
+                    throw new Error("Unexpectedly cant find a value with index ".concat(index));
+                return value;
+            }
+        }
+        return this.initialValue;
+    };
+    RangedValue.prototype.getValues = function (sortedKeys) {
+        var lastElm = this._keys.length - 1;
+        var ownKeyIndex = lastElm;
+        var result = [];
+        for (var _i = 0, _a = __spreadArray([], sortedKeys, true).reverse(); _i < _a.length; _i++) {
+            var sk = _a[_i];
+            if (sk < this._keys[0]) {
+                result.push(this.initialValue);
+            }
+            else if (sk > this._keys[lastElm]) {
+                result.push(this.getMapValue(this._keys[lastElm]));
+            }
+            else {
+                if (sk < this._keys[ownKeyIndex]) {
+                    for (; ownKeyIndex >= 0; ownKeyIndex--) {
+                        if (sk >= this._keys[ownKeyIndex])
+                            break;
+                    }
+                }
+                result.push(this.getMapValue(this._keys[ownKeyIndex]));
+            }
+        }
+        return result.reverse();
+    };
+    RangedValue.prototype.getMapValue = function (index) {
+        var value = this.data.get(index);
+        if (!value)
+            throw new Error("Can get value for ".concat(index));
+        return value;
+    };
+    Object.defineProperty(RangedValue.prototype, "keys", {
+        get: function () {
+            return this._keys;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return RangedValue;
+}());
+exports.RangedValue = RangedValue;

package/lib/rewards/range.spec.d.ts

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

package/lib/rewards/range.spec.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var chai_1 = require("chai");
+var ethers_1 = require("ethers");
+var range_1 = require("./range");
+describe("RangedValue test", function () {
+    it("addValue and getValue works correctly", function () {
+        var r = new range_1.RangedValue(ethers_1.BigNumber.from(5));
+        (0, chai_1.expect)(r.getValue(5).toNumber()).to.be.eq(5);
+        r.addValue(100, ethers_1.BigNumber.from(8));
+        r.addValue(10, ethers_1.BigNumber.from(18));
+        (0, chai_1.expect)(r.getValue(9).toNumber()).to.be.eq(5);
+        (0, chai_1.expect)(r.getValue(10).toNumber()).to.be.eq(18);
+        (0, chai_1.expect)(r.getValue(1000).toNumber()).to.be.eq(8);
+        (0, chai_1.expect)(r.keys).to.be.eql([10, 100]);
+    });
+    it("getValues works correctly", function () {
+        var r = new range_1.RangedValue();
+        r.addValue(4, ethers_1.BigNumber.from(3));
+        r.addValue(2, ethers_1.BigNumber.from(5));
+        r.addValue(10, ethers_1.BigNumber.from(1));
+        r.addValue(6, ethers_1.BigNumber.from(8));
+        r.addValue(8, ethers_1.BigNumber.from(7));
+        var keys = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        var expected = [0, 0, 5, 5, 3, 3, 8, 8, 7, 7, 1, 1];
+        var result = r.getValues(keys).map(function (e) { return e.toNumber(); });
+        (0, chai_1.expect)(result).to.be.eql(expected);
+    });
+});

package/package.json

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