@aurigami/sdk 1.2.5 → 1.3.0

package/README.md

@@ -1,3 +1,8 @@
 # Aurigami SDK
 
 
+## Airdrop lottery
+
+Create list of whitelisted addresses and place it in `aridrop_misc/whitelist.txt`, see `whitelist.example.txt` for example.
+
+Please update the constants in the `src/constants.ts`.

package/dist/airdrop-lottery.d.ts

@@ -0,0 +1,14 @@
+import { BlockchainEntity, BlockchainEntityRead } from "./BlockchainEntity";
+import { NetworkConnection } from "./types";
+export declare class AirdropRead extends BlockchainEntityRead {
+    private _whitelistedAddresses;
+    private keepTrackers;
+    constructor(networkConnection: NetworkConnection);
+    countWhitelistedAddresses(): number;
+    isWhitelisted(user: string): boolean;
+    hasCompletedChallenge(user: string): Promise<boolean>;
+}
+export declare class Airdrop extends BlockchainEntity {
+    constructor();
+    read(networkConnection: NetworkConnection): AirdropRead;
+}

package/dist/constants.d.ts

@@ -20,3 +20,6 @@ export declare const ONE_DAY = 86400;
 export declare const ONE_YEAR: number;
 export declare const AurPlyPid = 0;
 export declare const INF: ethers.BigNumber;
+export declare const AIRDROP_START_TIMESTAMP = 1649858400;
+export declare const AIRDROP_END_TIMESTAMP = 1651068000;
+export declare const AIRDROP_KEEP_THRESHOLD: number;

package/dist/helpers.d.ts

@@ -1,3 +1,4 @@
+import { Provider } from "@ethersproject/abstract-provider";
 import BigNumber from "bignumber.js";
 import { Address } from "./types";
 export declare function formatObject(object: Object): string;
@@ -7,3 +8,5 @@ export declare const getCurrentTimestamp: () => number;
 export declare function validateAndParseAddress(address: Address): Address;
 export declare function getDecimal(address: Address): number;
 export declare function calcLMRewardApr(rewardsValue: BigNumber, totalStakeValue: BigNumber, frequencyPerYear: number): BigNumber;
+export declare function getBlockTimestamp(provider: Provider, blockNumber: number): Promise<number>;
+export declare function getBlockBeforeTimestamp(provider: Provider, timestamp: number, startBlock?: number): Promise<number>;

package/dist/index.d.ts

@@ -8,3 +8,5 @@ export * from './priceFetcher';
 export * from './token';
 export * from './tokenAmount';
 export * from './types';
+export * from './airdrop-lottery';
+export * from './transfer-event-query';

package/dist/sdk.cjs.development.js

@@ -17,6 +17,8 @@ var axios = _interopDefault(require('axios'));
 var TokenLockABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/TokenLock.sol/TokenLock.json'));
 var AuriFairLaunchABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json'));
 var FaucetABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json'));
+var FileSystem = require('fs');
+var AuTokenABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json'));
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -980,6 +982,9 @@ var ONE_DAY = 86400;
 var ONE_YEAR = ONE_DAY * 365;
 var AurPlyPid = 0;
 var INF = /*#__PURE__*/ethers.BigNumber.from(2).pow(256).sub(1);
+var AIRDROP_START_TIMESTAMP = 1649858400;
+var AIRDROP_END_TIMESTAMP = 1651068000;
+var AIRDROP_KEEP_THRESHOLD = 7 * 86400;
 
 var decimalRecords = {
   '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': 18,
@@ -1032,6 +1037,116 @@ function calcLMRewardApr(rewardsValue, totalStakeValue, frequencyPerYear) {
 
   return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
 }
+function getBlockTimestamp(_x, _x2) {
+  return _getBlockTimestamp.apply(this, arguments);
+}
+
+function _getBlockTimestamp() {
+  _getBlockTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(provider, blockNumber) {
+    var block;
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return provider.getBlock(blockNumber);
+
+          case 2:
+            block = _context.sent;
+            return _context.abrupt("return", block.timestamp);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _getBlockTimestamp.apply(this, arguments);
+}
+
+function getBlockBeforeTimestamp(_x3, _x4, _x5) {
+  return _getBlockBeforeTimestamp.apply(this, arguments);
+}
+
+function _getBlockBeforeTimestamp() {
+  _getBlockBeforeTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(provider, timestamp, startBlock) {
+    var blockThreshold, K, leftBlock, rightBlock, size, promises, i, blockTimestamps, nextLeftBlock, _i, _i2;
+
+    return runtime_1.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            blockThreshold = 50 * 10;
+            K = 8;
+            leftBlock = startBlock || 1;
+            _context2.next = 5;
+            return provider.getBlockNumber();
+
+          case 5:
+            rightBlock = _context2.sent;
+            _context2.next = 8;
+            return getBlockTimestamp(provider, rightBlock);
+
+          case 8:
+            _context2.t0 = _context2.sent;
+            _context2.t1 = timestamp;
+
+            if (!(_context2.t0 < _context2.t1)) {
+              _context2.next = 12;
+              break;
+            }
+
+            return _context2.abrupt("return", rightBlock);
+
+          case 12:
+            if (!(rightBlock - leftBlock >= blockThreshold)) {
+              _context2.next = 25;
+              break;
+            }
+
+            size = Math.floor((rightBlock - leftBlock + 1) / K);
+            promises = [];
+
+            for (i = 1; i < K; i++) {
+              promises.push(getBlockTimestamp(provider, leftBlock + i * size));
+            }
+
+            _context2.next = 18;
+            return Promise.all(promises);
+
+          case 18:
+            blockTimestamps = _context2.sent;
+            nextLeftBlock = leftBlock;
+
+            for (_i = 1; _i < K; _i++) {
+              if (blockTimestamps[_i - 1] <= timestamp) {
+                nextLeftBlock = leftBlock + _i * size;
+              }
+            }
+
+            for (_i2 = K - 1; _i2 >= 1; _i2--) {
+              if (blockTimestamps[_i2 - 1] > timestamp) {
+                rightBlock = leftBlock + _i2 * size - 1;
+              }
+            }
+
+            leftBlock = nextLeftBlock;
+            _context2.next = 12;
+            break;
+
+          case 25:
+            return _context2.abrupt("return", leftBlock);
+
+          case 26:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getBlockBeforeTimestamp.apply(this, arguments);
+}
 
 var Token = function Token(address, decimals) {
   this.address = address.toLowerCase();
@@ -3560,13 +3675,425 @@ var dummyUserMarketDetails = {
   underlyingPrice: "1"
 };
 
+var TransferEventQuery = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(TransferEventQuery, _BlockchainEntityRead);
+
+  function TransferEventQuery(tokenAddr, networkConnection) {
+    var _this;
+
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    _this.auToken = new ethers.Contract(tokenAddr, AuTokenABI.abi, _this._networkConnection.provider);
+    return _this;
+  }
+
+  var _proto = TransferEventQuery.prototype;
+
+  _proto.queryERC20TransfersOf = /*#__PURE__*/function () {
+    var _queryERC20TransfersOf = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(address, fromBlock, toBlock) {
+      var _this2 = this;
+
+      var filters, events, results;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              filters = [this.auToken.filters.Transfer(address, null), this.auToken.filters.Transfer(null, address)];
+              _context.next = 3;
+              return Promise.all(filters.map(function (filter) {
+                return _this2.auToken.queryFilter(filter, fromBlock, toBlock);
+              }));
+
+            case 3:
+              events = _context.sent.flat();
+              results = events.map(function (event) {
+                return {
+                  from: event.args[0],
+                  to: event.args[1],
+                  amount: event.args[2],
+                  blockNumber: event.blockNumber
+                };
+              });
+              results.sort(function (a, b) {
+                return a.blockNumber - b.blockNumber;
+              });
+              return _context.abrupt("return", results);
+
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function queryERC20TransfersOf(_x, _x2, _x3) {
+      return _queryERC20TransfersOf.apply(this, arguments);
+    }
+
+    return queryERC20TransfersOf;
+  }();
+
+  _proto.queryERC20BalanceAt = /*#__PURE__*/function () {
+    var _queryERC20BalanceAt = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(address, endBlock) {
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", this.auToken.balanceOf(address, {
+                blockTag: endBlock + 1
+              }));
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function queryERC20BalanceAt(_x4, _x5) {
+      return _queryERC20BalanceAt.apply(this, arguments);
+    }
+
+    return queryERC20BalanceAt;
+  }();
+
+  return TransferEventQuery;
+}(BlockchainEntityRead);
+
+var AirdropSettings = /*#__PURE__*/function () {
+  function AirdropSettings() {
+    this.airdropStartBlock = 0;
+    this.airdropEndBlock = 0;
+    this.airdropStartTimestamp = AIRDROP_START_TIMESTAMP;
+    this.airdropEndTimestamp = AIRDROP_END_TIMESTAMP;
+    this.airdropThreshold = AIRDROP_KEEP_THRESHOLD;
+  }
+
+  AirdropSettings.getSettings = /*#__PURE__*/function () {
+    var _getSettings = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(provider) {
+      var settings;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!this._instance) {
+                _context.next = 2;
+                break;
+              }
+
+              return _context.abrupt("return", this._instance);
+
+            case 2:
+              settings = new AirdropSettings();
+              _context.next = 5;
+              return getBlockBeforeTimestamp(provider, settings.airdropStartTimestamp, 63317969);
+
+            case 5:
+              settings.airdropStartBlock = _context.sent;
+              _context.next = 8;
+              return getBlockBeforeTimestamp(provider, settings.airdropEndTimestamp, settings.airdropStartBlock);
+
+            case 8:
+              settings.airdropEndBlock = _context.sent;
+              this._instance = settings;
+              return _context.abrupt("return", settings);
+
+            case 11:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function getSettings(_x) {
+      return _getSettings.apply(this, arguments);
+    }
+
+    return getSettings;
+  }();
+
+  return AirdropSettings;
+}();
+
+var AirdropAuTokenKeepTracker = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(AirdropAuTokenKeepTracker, _BlockchainEntityRead);
+
+  function AirdropAuTokenKeepTracker(networkConnection, airdropAuTokenInfo) {
+    var _this;
+
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    _this._transferQuery = new TransferEventQuery(airdropAuTokenInfo.address, networkConnection);
+    _this._airdropAuTokenInfo = airdropAuTokenInfo;
+    _this._airdropAuTokenInfo.exchangeRate = _this._airdropAuTokenInfo.exchangeRate.add(_this._airdropAuTokenInfo.exchangeRate.div(50));
+    return _this;
+  }
+
+  var _proto = AirdropAuTokenKeepTracker.prototype;
+
+  _proto._toUnderlyingValue = function _toUnderlyingValue(auTokenAmount) {
+    return auTokenAmount.mul(this._airdropAuTokenInfo.exchangeRate).div(ethers.BigNumber.from(10).pow(18));
+  };
+
+  _proto.isEligible = /*#__PURE__*/function () {
+    var _isEligible = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(address) {
+      var settings, minDeposit, balance, BELOW, ABOVE, flag, lastEligibleBalanceTimestamp, events, _iterator, _step, _step$value, from, to, amount, blockNumber, _timestamp, timestamp;
+
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return AirdropSettings.getSettings(this._networkConnection.provider);
+
+            case 2:
+              settings = _context2.sent;
+              minDeposit = this._airdropAuTokenInfo.underlying.minDeposit;
+              _context2.next = 6;
+              return this._transferQuery.queryERC20BalanceAt(address, settings.airdropStartBlock - 1);
+
+            case 6:
+              balance = _context2.sent;
+              BELOW = false, ABOVE = true;
+              flag = BELOW;
+              lastEligibleBalanceTimestamp = 0;
+
+              if (this._toUnderlyingValue(balance).gte(minDeposit)) {
+                lastEligibleBalanceTimestamp = settings.airdropStartTimestamp;
+                flag = ABOVE;
+              }
+
+              _context2.next = 13;
+              return this._transferQuery.queryERC20TransfersOf(address, settings.airdropStartBlock, settings.airdropEndBlock);
+
+            case 13:
+              events = _context2.sent;
+              _iterator = _createForOfIteratorHelperLoose(events);
+
+            case 15:
+              if ((_step = _iterator()).done) {
+                _context2.next = 33;
+                break;
+              }
+
+              _step$value = _step.value, from = _step$value.from, to = _step$value.to, amount = _step$value.amount, blockNumber = _step$value.blockNumber;
+
+              if (from == address) {
+                balance = balance.sub(amount);
+              }
+
+              if (to == address) {
+                balance = balance.add(amount);
+              }
+
+              if (!(this._toUnderlyingValue(balance).gte(minDeposit) != flag)) {
+                _context2.next = 31;
+                break;
+              }
+
+              flag = !flag;
+              _context2.next = 23;
+              return this._networkConnection.provider.getBlock(blockNumber);
+
+            case 23:
+              _timestamp = _context2.sent.timestamp;
+
+              if (!(flag == BELOW)) {
+                _context2.next = 30;
+                break;
+              }
+
+              if (!(_timestamp - lastEligibleBalanceTimestamp >= settings.airdropThreshold)) {
+                _context2.next = 27;
+                break;
+              }
+
+              return _context2.abrupt("return", true);
+
+            case 27:
+              lastEligibleBalanceTimestamp = 0;
+              _context2.next = 31;
+              break;
+
+            case 30:
+              lastEligibleBalanceTimestamp = _timestamp;
+
+            case 31:
+              _context2.next = 15;
+              break;
+
+            case 33:
+              if (!(flag == ABOVE)) {
+                _context2.next = 36;
+                break;
+              }
+
+              timestamp = Math.min(settings.airdropEndTimestamp, getCurrentTimestamp());
+              return _context2.abrupt("return", timestamp - lastEligibleBalanceTimestamp >= settings.airdropThreshold);
+
+            case 36:
+              return _context2.abrupt("return", false);
+
+            case 37:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function isEligible(_x2) {
+      return _isEligible.apply(this, arguments);
+    }
+
+    return isEligible;
+  }();
+
+  return AirdropAuTokenKeepTracker;
+}(BlockchainEntityRead);
+
+var AirdropRead = /*#__PURE__*/function (_BlockchainEntityRead2) {
+  _inheritsLoose(AirdropRead, _BlockchainEntityRead2);
+
+  function AirdropRead(networkConnection) {
+    var _this2;
+
+    _this2 = _BlockchainEntityRead2.call(this, networkConnection) || this;
+    _this2.keepTrackers = [];
+    _this2._whitelistedAddresses = new Set(FileSystem.readFileSync("airdrop_misc/whitelist.txt").toString().trim().split('\n'));
+    var auTokens = JSON.parse(FileSystem.readFileSync("airdrop_misc/auTokensInfo.json").toString());
+
+    for (var auToken in auTokens) {
+      var _auTokens$auToken = auTokens[auToken],
+          address = _auTokens$auToken.address,
+          exchangeRate = _auTokens$auToken.exchangeRate,
+          deploymentBlock = _auTokens$auToken.deploymentBlock,
+          underlying = _auTokens$auToken.underlying;
+      var airdropInfo = {
+        address: address,
+        exchangeRate: ethers.BigNumber.from(exchangeRate),
+        deploymentBlock: parseInt(deploymentBlock),
+        underlying: {
+          minDeposit: ethers.BigNumber.from(underlying.minDeposit)
+        }
+      };
+
+      _this2.keepTrackers.push(new AirdropAuTokenKeepTracker(networkConnection, airdropInfo));
+    }
+
+    return _this2;
+  }
+
+  var _proto2 = AirdropRead.prototype;
+
+  _proto2.countWhitelistedAddresses = function countWhitelistedAddresses() {
+    return this._whitelistedAddresses.size;
+  };
+
+  _proto2.isWhitelisted = function isWhitelisted(user) {
+    return this._whitelistedAddresses.has(user);
+  };
+
+  _proto2.hasCompletedChallenge = /*#__PURE__*/function () {
+    var _hasCompletedChallenge = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(user) {
+      var settings;
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return AirdropSettings.getSettings(this._networkConnection.provider);
+
+            case 2:
+              settings = _context4.sent;
+
+              if (!(getCurrentTimestamp() < settings.airdropStartTimestamp)) {
+                _context4.next = 5;
+                break;
+              }
+
+              return _context4.abrupt("return", false);
+
+            case 5:
+              if (this.isWhitelisted(user)) {
+                _context4.next = 7;
+                break;
+              }
+
+              return _context4.abrupt("return", false);
+
+            case 7:
+              _context4.next = 9;
+              return Promise.all(this.keepTrackers.map( /*#__PURE__*/function () {
+                var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(keepTracker) {
+                  return runtime_1.wrap(function _callee3$(_context3) {
+                    while (1) {
+                      switch (_context3.prev = _context3.next) {
+                        case 0:
+                          return _context3.abrupt("return", keepTracker.isEligible(user));
+
+                        case 1:
+                        case "end":
+                          return _context3.stop();
+                      }
+                    }
+                  }, _callee3);
+                }));
+
+                return function (_x4) {
+                  return _ref.apply(this, arguments);
+                };
+              }()));
+
+            case 9:
+              return _context4.abrupt("return", _context4.sent.includes(true));
+
+            case 10:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function hasCompletedChallenge(_x3) {
+      return _hasCompletedChallenge.apply(this, arguments);
+    }
+
+    return hasCompletedChallenge;
+  }();
+
+  return AirdropRead;
+}(BlockchainEntityRead);
+var Airdrop = /*#__PURE__*/function (_BlockchainEntity) {
+  _inheritsLoose(Airdrop, _BlockchainEntity);
+
+  function Airdrop() {
+    return _BlockchainEntity.call(this) || this;
+  }
+
+  var _proto3 = Airdrop.prototype;
+
+  _proto3.read = function read(networkConnection) {
+    return new AirdropRead(networkConnection);
+  };
+
+  return Airdrop;
+}(BlockchainEntity);
+
 ethers.ethers.utils.Logger.setLogLevel(utils.Logger.levels.ERROR);
 BigNumber.config({
   DECIMAL_PLACES: 50
 });
 
+exports.AIRDROP_END_TIMESTAMP = AIRDROP_END_TIMESTAMP;
+exports.AIRDROP_KEEP_THRESHOLD = AIRDROP_KEEP_THRESHOLD;
+exports.AIRDROP_START_TIMESTAMP = AIRDROP_START_TIMESTAMP;
 exports.AURORA_CHAINID = AURORA_CHAINID;
 exports.AURPLYToken = AURPLYToken;
+exports.Airdrop = Airdrop;
+exports.AirdropRead = AirdropRead;
 exports.AurPlyPid = AurPlyPid;
 exports.BORROW_LIMIT_BUFFER = BORROW_LIMIT_BUFFER;
 exports.BlockchainEntity = BlockchainEntity;
@@ -3587,6 +4114,7 @@ exports.SdkRead = SdkRead;
 exports.SdkReadWrite = SdkReadWrite;
 exports.Token = Token;
 exports.TokenAmount = TokenAmount;
+exports.TransferEventQuery = TransferEventQuery;
 exports.calcLMRewardApr = calcLMRewardApr;
 exports.calcValuation = calcValuation;
 exports.decimalFactor = decimalFactor;
@@ -3610,6 +4138,8 @@ exports.fetchStNEARPrice = fetchStNEARPrice;
 exports.fetchUnderlyingTokensPrices = fetchUnderlyingTokensPrices;
 exports.fetchValuation = fetchValuation;
 exports.formatObject = formatObject;
+exports.getBlockBeforeTimestamp = getBlockBeforeTimestamp;
+exports.getBlockTimestamp = getBlockTimestamp;
 exports.getCurrentTimestamp = getCurrentTimestamp;
 exports.getDecimal = getDecimal;
 exports.isSameAddress = isSameAddress;