@aurigami/sdk 1.4.7 → 1.5.0-dummy

package/dist/sdk.cjs.development.js

@@ -9,17 +9,18 @@ var ethers = require('ethers');
 var utils = require('ethers/lib/utils');
 var abstractSigner = require('@ethersproject/abstract-signer');
 var axios = _interopDefault(require('axios'));
+var assert = _interopDefault(require('assert'));
 var AuErc20ABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuErc20.sol/AuErc20.json'));
 var AuETHABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuETH.sol/AuETH.json'));
 var ComptrollerABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/Comptroller.sol/Comptroller.json'));
 var AuriLensABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuriLens.sol/AuriLens.json'));
 var EthRepayHelperABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/EthRepayHelper.sol/EthRepayHelper.json'));
-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 EIP20InterfaceABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json'));
+var PulpABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json'));
 var AuTokenABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuToken.sol/AuToken.json'));
 var AuriAirdropABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuriAirdrop.sol/AuriAirdrop.json'));
-var assert = _interopDefault(require('assert'));
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -979,30 +980,35 @@ var networkAddresses = {
   }],
   misc: {
     COMPTROLLER: /*#__PURE__*/"0x817af6cfAF35BdC1A634d6cC94eE9e4c68369Aeb".toLowerCase(),
-    FAKE_COMPTROLLER: /*#__PURE__*/"0x8072b287b6a95e1Db6C8404BBd78642387dFA16C".toLowerCase(),
     oracle: /*#__PURE__*/"0xC6e5185438e1730959c1eF3551059A3feC744E90".toLowerCase(),
-    AURIFAIRLAUNCH: /*#__PURE__*/"0x9F9ceE911509abC6Af899c12ED625B0A6580D6e6".toLowerCase(),
-    AURILENS: /*#__PURE__*/'0xC41a5C1625d492436600789469c1CE2eA20CEA6B'.toLowerCase(),
+    AURIFAIRLAUNCH: /*#__PURE__*/"0x6f068608573c840bB27b39458d7d87eB865e19Cc".toLowerCase(),
+    AURILENS: /*#__PURE__*/'0xFfdFfBDB966Cb84B50e62d70105f2Dbf2e0A1e70'.toLowerCase(),
     TOKENLOCK: /*#__PURE__*/'0xDACC02a4Ff16Ea3c1515AdbfdCeb7B1F448B79c8'.toLowerCase(),
     ETHREPAYHELPER: /*#__PURE__*/"0xa308A5003fA1A25BFdD9418FcEE51d48Dbe441e6".toLowerCase(),
     AURI_AIRDROP: /*#__PURE__*/"0x6C42aA5b128B62D6CCf357726D7d13F3888335EC".toLowerCase()
   },
   tokens: {
     AURORA: /*#__PURE__*/"0x8bec47865ade3b172a928df8f990bc7f2a3b9f79".toLowerCase(),
-    PLY: /*#__PURE__*/"0x981bD5832EAB9C8F607940E0e9faCBf8C09ee20a".toLowerCase(),
+    PLY: /*#__PURE__*/"0x09c9d464b58d96837f8d8b6f4d9fe4ad408d3a4f".toLowerCase(),
     stNEAR: /*#__PURE__*/"0x07f9f7f963c5cd2bbffd30ccfb964be114332e30".toLowerCase(),
     USDC: /*#__PURE__*/'0xb12bfca5a55806aaf64e99521918a4bf0fc40802'.toLowerCase(),
     WNEAR: /*#__PURE__*/'0xC42C30aC6Cc15faC9bD938618BcaA1a1FaE8501d'.toLowerCase(),
     TRI: /*#__PURE__*/'0xFa94348467f64D5A457F75F8bc40495D33c65aBB'.toLowerCase(),
     META: /*#__PURE__*/'0xc21ff01229e982d7c8b8691163b0a3cb8f357453'.toLocaleLowerCase(),
-    AURPLY: /*#__PURE__*/dummyAddress.toLowerCase()
+    PULP: /*#__PURE__*/'0x04Ac48711BCdc45b4d223fb021E09DA73c71095e'.toLowerCase(),
+    PLYUSDC: /*#__PURE__*/'0x37cae2b29c18e05ece60111fa01d3ca217046016'.toLowerCase()
   }
 };
+var PRICE_WHITELISTED = /*#__PURE__*/new Set( /*#__PURE__*/[].concat( /*#__PURE__*/networkAddresses.auTokens.map(function (t) {
+  return t.underlying;
+}), [networkAddresses.tokens.AURORA, networkAddresses.tokens.TRI, networkAddresses.tokens.META, networkAddresses.tokens.stNEAR]));
+var REWARD_CLAIM_START = 1651762800;
 var BORROW_LIMIT_BUFFER = /*#__PURE__*/new BigNumber(1);
-var REWARDCLAIMSTART = 1640995200;
 var ONE_DAY = 86400;
 var ONE_YEAR = ONE_DAY * 365;
-var AurPlyPid = 0;
+var PlyUsdcPid = 0;
+var PLYUSDCRewardTokens = ['0x09C9D464b58d96837f8d8b6f4d9fE4aD408d3A4f', '0xC42C30aC6Cc15faC9bD938618BcaA1a1FaE8501d', '0x8BEc47865aDe3B172A928df8f990Bc7f2A3b9f79', '0xFa94348467f64D5A457F75F8bc40495D33c65aBB'];
+var ALL_STAKING_POOLS = [];
 var INF = /*#__PURE__*/ethers.BigNumber.from(2).pow(256).sub(1);
 var AIRDROP_START_TIMESTAMP = 1649858400;
 var AIRDROP_END_TIMESTAMP = 1651068000;
@@ -1063,7 +1069,7 @@ function _getQuery() {
 
 var decimalRecords = {
   '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': 18,
-  '0x981bd5832eab9c8f607940e0e9facbf8c09ee20a': 18,
+  '0x09c9d464b58d96837f8d8b6f4d9fe4ad408d3a4f': 18,
   '0x3195949f267702723bc614cae037cdc8d1e94786': 8,
   '0xfa94348467f64d5a457f75f8bc40495d33c65abb': 18,
   '0x07f9f7f963c5cd2bbffd30ccfb964be114332e30': 24,
@@ -1081,7 +1087,9 @@ var decimalRecords = {
   '0xae4fac24dcdae0132c6d04f564dcf059616e9423': 8,
   '0xce4166363e3a584dac84a47bcd3414b43efcdd1c': 8,
   '0xf4eb217ba2454613b15dbdea6e5f22276410e89e': 8,
-  '0xc21ff01229e982d7c8b8691163b0a3cb8f357453': 24
+  '0xc21ff01229e982d7c8b8691163b0a3cb8f357453': 24,
+  '0x04ac48711bcdc45b4d223fb021e09da73c71095e': 18,
+  '0x37cae2b29c18e05ece60111fa01d3ca217046016': 18
 };
 
 function formatObject(object) {
@@ -1104,7 +1112,9 @@ function validateAndParseAddress(address) {
   }
 }
 function getDecimal(address) {
-  return decimalRecords[address.toLowerCase()];
+  var addressLowercase = address.toLowerCase();
+  assert(decimalRecords[addressLowercase] != undefined, "Decimal not found for " + address);
+  return decimalRecords[addressLowercase];
 }
 function calcLMRewardApr(rewardsValue, totalStakeValue, frequencyPerYear) {
   if (totalStakeValue.lte(0)) {
@@ -1191,7 +1201,7 @@ var Token = function Token(address, decimals) {
   this.decimals = decimals;
 };
 var PLYToken = /*#__PURE__*/new Token(networkAddresses.tokens.PLY, /*#__PURE__*/getDecimal(networkAddresses.tokens.PLY));
-var AURPLYToken = /*#__PURE__*/new Token(networkAddresses.tokens.AURPLY, /*#__PURE__*/getDecimal(networkAddresses.tokens.AURPLY));
+var PLYUSDCToken = /*#__PURE__*/new Token(networkAddresses.tokens.PLYUSDC, /*#__PURE__*/getDecimal(networkAddresses.tokens.PLYUSDC));
 
 var TokenAmount = /*#__PURE__*/function () {
   function TokenAmount(token, amount, isRaw) {
@@ -2242,15 +2252,15 @@ function fetchLPPositions(_x3, _x4) {
 
 function _fetchLPPositions() {
   _fetchLPPositions = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(LPAddress, provider) {
-    var promises, LPContract, values;
+    var LPContract, promises, values;
     return runtime_1.wrap(function _callee3$(_context3) {
       while (1) {
         switch (_context3.prev = _context3.next) {
           case 0:
-            promises = [];
             LPContract = new ethers.Contract(LPAddress, IUniswapV2PairABI.abi, provider);
+            promises = [];
             promises.push(LPContract.token0());
-            promises.push(LPContract.toekn1());
+            promises.push(LPContract.token1());
             promises.push(LPContract.getReserves());
             promises.push(LPContract.totalSupply());
             _context3.next = 8;
@@ -2281,50 +2291,91 @@ function fetchLPPrice(_x5, _x6) {
 }
 
 function _fetchLPPrice() {
-  _fetchLPPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(address, provider) {
-    var LPInfo, token0Price, reserveUSD, token1Price, _reserveUSD;
+  _fetchLPPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(address, provider) {
+    var LPInfo, LPDecimal, fetchLPPriceBy, _fetchLPPriceBy;
 
-    return runtime_1.wrap(function _callee4$(_context4) {
+    return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context4.prev = _context4.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
-            _context4.next = 2;
+            _fetchLPPriceBy = function _fetchLPPriceBy3() {
+              _fetchLPPriceBy = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(tokenReverse) {
+                var tokenPrice, tokenDecimal, reserveUSD;
+                return runtime_1.wrap(function _callee4$(_context4) {
+                  while (1) {
+                    switch (_context4.prev = _context4.next) {
+                      case 0:
+                        if (!tokenReverse.reserve.isZero()) {
+                          _context4.next = 2;
+                          break;
+                        }
+
+                        return _context4.abrupt("return", new BigNumber(0));
+
+                      case 2:
+                        _context4.next = 4;
+                        return _fetchPrice(tokenReverse.address, provider);
+
+                      case 4:
+                        tokenPrice = _context4.sent;
+                        tokenDecimal = getDecimal(tokenReverse.address);
+                        reserveUSD = tokenPrice.multipliedBy(tokenReverse.reserve.toString()).multipliedBy(2);
+                        return _context4.abrupt("return", reserveUSD.multipliedBy(decimalFactor(LPDecimal)).dividedBy(new BigNumber(LPInfo.totalSupply.toString())).dividedBy(decimalFactor(tokenDecimal)));
+
+                      case 8:
+                      case "end":
+                        return _context4.stop();
+                    }
+                  }
+                }, _callee4);
+              }));
+              return _fetchLPPriceBy.apply(this, arguments);
+            };
+
+            fetchLPPriceBy = function _fetchLPPriceBy2(_x20) {
+              return _fetchLPPriceBy.apply(this, arguments);
+            };
+
+            _context5.next = 4;
             return fetchLPPositions(address, provider);
 
-          case 2:
-            LPInfo = _context4.sent;
-            _context4.prev = 3;
-            _context4.next = 6;
-            return fetchPrice(LPInfo.token0, provider);
+          case 4:
+            LPInfo = _context5.sent;
+            LPDecimal = getDecimal(address);
+            _context5.prev = 6;
+            _context5.next = 9;
+            return fetchLPPriceBy({
+              address: LPInfo.token0,
+              reserve: LPInfo.reserve0
+            });
 
-          case 6:
-            token0Price = _context4.sent;
-            reserveUSD = token0Price.multipliedBy(LPInfo.reserve0.toString()).multipliedBy(2);
-            return _context4.abrupt("return", reserveUSD.multipliedBy(decimalFactor(18)).dividedBy(new BigNumber(LPInfo.totalSupply.toString())));
+          case 9:
+            return _context5.abrupt("return", _context5.sent);
+
+          case 12:
+            _context5.prev = 12;
+            _context5.t0 = _context5["catch"](6);
+            _context5.prev = 14;
+            _context5.next = 17;
+            return fetchLPPriceBy({
+              address: LPInfo.token1,
+              reserve: LPInfo.reserve1
+            });
 
-          case 11:
-            _context4.prev = 11;
-            _context4.t0 = _context4["catch"](3);
-            _context4.prev = 13;
-            _context4.next = 16;
-            return fetchPrice(LPInfo.token1, provider);
-
-          case 16:
-            token1Price = _context4.sent;
-            _reserveUSD = token1Price.multipliedBy(LPInfo.reserve1.toString()).multipliedBy(2);
-            return _context4.abrupt("return", _reserveUSD.multipliedBy(decimalFactor(18)).dividedBy(new BigNumber(LPInfo.totalSupply.toString())));
-
-          case 21:
-            _context4.prev = 21;
-            _context4.t1 = _context4["catch"](13);
+          case 17:
+            return _context5.abrupt("return", _context5.sent);
+
+          case 20:
+            _context5.prev = 20;
+            _context5.t1 = _context5["catch"](14);
             throw Error("Unable to fetch price for both tokens of LP " + address);
 
-          case 24:
+          case 23:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
       }
-    }, _callee4, null, [[3, 11], [13, 21]]);
+    }, _callee5, null, [[6, 12], [14, 20]]);
   }));
   return _fetchLPPrice.apply(this, arguments);
 }
@@ -2338,26 +2389,26 @@ function fetchPriceFromOracle(_x7, _x8, _x9) {
 }
 
 function _fetchPriceFromOracle() {
-  _fetchPriceFromOracle = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(auTokenAddress, underlyingDecimal, provider) {
+  _fetchPriceFromOracle = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(auTokenAddress, underlyingDecimal, provider) {
     var oracleContract, rawPrice;
-    return runtime_1.wrap(function _callee5$(_context5) {
+    return runtime_1.wrap(function _callee6$(_context6) {
       while (1) {
-        switch (_context5.prev = _context5.next) {
+        switch (_context6.prev = _context6.next) {
           case 0:
             oracleContract = new ethers.Contract(networkAddresses.misc.oracle, OracleABI.abi, provider);
-            _context5.next = 3;
+            _context6.next = 3;
             return oracleContract.getUnderlyingPrice(auTokenAddress);
 
           case 3:
-            rawPrice = _context5.sent;
-            return _context5.abrupt("return", processPriceFromOracle(rawPrice, underlyingDecimal));
+            rawPrice = _context6.sent;
+            return _context6.abrupt("return", processPriceFromOracle(rawPrice, underlyingDecimal));
 
           case 5:
           case "end":
-            return _context5.stop();
+            return _context6.stop();
         }
       }
-    }, _callee5);
+    }, _callee6);
   }));
   return _fetchPriceFromOracle.apply(this, arguments);
 }
@@ -2367,11 +2418,11 @@ function fetchUnderlyingTokensPrices(_x10) {
 }
 
 function _fetchUnderlyingTokensPrices() {
-  _fetchUnderlyingTokensPrices = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(provider) {
+  _fetchUnderlyingTokensPrices = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(provider) {
     var auriLens, auTokenAddresses, underlyingDecimals, rawPrices;
-    return runtime_1.wrap(function _callee6$(_context6) {
+    return runtime_1.wrap(function _callee7$(_context7) {
       while (1) {
-        switch (_context6.prev = _context6.next) {
+        switch (_context7.prev = _context7.next) {
           case 0:
             auriLens = new ethers.Contract(networkAddresses.misc.AURILENS, AuriLensABI.abi, provider);
             auTokenAddresses = networkAddresses.auTokens.map(function (auToken) {
@@ -2380,12 +2431,12 @@ function _fetchUnderlyingTokensPrices() {
             underlyingDecimals = networkAddresses.auTokens.map(function (auToken) {
               return getDecimal(auToken.underlying);
             });
-            _context6.next = 5;
+            _context7.next = 5;
             return auriLens.auTokenUnderlyingPriceAll(auTokenAddresses);
 
           case 5:
-            rawPrices = _context6.sent;
-            return _context6.abrupt("return", rawPrices.map(function (res, ind) {
+            rawPrices = _context7.sent;
+            return _context7.abrupt("return", rawPrices.map(function (res, ind) {
               return {
                 auToken: res.auToken,
                 underlyingPrice: processPriceFromOracle(res.underlyingPrice, underlyingDecimals[ind])
@@ -2394,10 +2445,10 @@ function _fetchUnderlyingTokensPrices() {
 
           case 7:
           case "end":
-            return _context6.stop();
+            return _context7.stop();
         }
       }
-    }, _callee6);
+    }, _callee7);
   }));
   return _fetchUnderlyingTokensPrices.apply(this, arguments);
 }
@@ -2407,33 +2458,33 @@ function fetchStNEARPrice() {
 }
 
 function _fetchStNEARPrice() {
-  _fetchStNEARPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7() {
+  _fetchStNEARPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8() {
     var ratioPromise, nearPricePromise, _yield$Promise$all, ratioRes, nearPrice, ratio;
 
-    return runtime_1.wrap(function _callee7$(_context7) {
+    return runtime_1.wrap(function _callee8$(_context8) {
       while (1) {
-        switch (_context7.prev = _context7.next) {
+        switch (_context8.prev = _context8.next) {
           case 0:
             ratioPromise = axios.get("https://validators.narwallets.com/metrics_json").then(function (res) {
               return res.data;
             });
             nearPricePromise = fetchPriceFromCoingeckoAPI('near');
-            _context7.next = 4;
+            _context8.next = 4;
             return Promise.all([ratioPromise, nearPricePromise]);
 
           case 4:
-            _yield$Promise$all = _context7.sent;
+            _yield$Promise$all = _context8.sent;
             ratioRes = _yield$Promise$all[0];
             nearPrice = _yield$Promise$all[1];
             ratio = new BigNumber(ratioRes.st_near_price);
-            return _context7.abrupt("return", ratio.multipliedBy(nearPrice));
+            return _context8.abrupt("return", ratio.multipliedBy(nearPrice));
 
           case 9:
           case "end":
-            return _context7.stop();
+            return _context8.stop();
         }
       }
-    }, _callee7);
+    }, _callee8);
   }));
   return _fetchStNEARPrice.apply(this, arguments);
 }
@@ -2443,105 +2494,176 @@ function shouldFetchFromCoingecko(address) {
   return address == networkAddresses.tokens.AURORA || address == networkAddresses.tokens.TRI || address == networkAddresses.tokens.META;
 }
 
-function fetchPrice(_x11, _x12) {
-  return _fetchPrice.apply(this, arguments);
+function _fetchPrice(_x11, _x12) {
+  return _fetchPrice2.apply(this, arguments);
 }
 
-function _fetchPrice() {
-  _fetchPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(address, provider) {
+function _fetchPrice2() {
+  _fetchPrice2 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(address, provider) {
     var matchingAuToken;
-    return runtime_1.wrap(function _callee8$(_context8) {
+    return runtime_1.wrap(function _callee9$(_context9) {
       while (1) {
-        switch (_context8.prev = _context8.next) {
+        switch (_context9.prev = _context9.next) {
           case 0:
-            if (!( isSameAddress(address, networkAddresses.tokens.PLY))) {
-              _context8.next = 2;
-              break;
-            }
-
-            return _context8.abrupt("return", new BigNumber(0));
+            assert(PRICE_WHITELISTED.has(address.toLocaleLowerCase()));
 
-          case 2:
             if (!isSameAddress(address, networkAddresses.tokens.stNEAR)) {
-              _context8.next = 4;
+              _context9.next = 3;
               break;
             }
 
-            return _context8.abrupt("return", fetchStNEARPrice());
+            return _context9.abrupt("return", fetchStNEARPrice());
 
-          case 4:
+          case 3:
             if (!shouldFetchFromCoingecko(address)) {
-              _context8.next = 6;
+              _context9.next = 5;
               break;
             }
 
-            return _context8.abrupt("return", fetchPriceFromCoingecko(address));
+            return _context9.abrupt("return", fetchPriceFromCoingecko(address));
 
-          case 6:
+          case 5:
             matchingAuToken = networkAddresses.auTokens.find(function (auToken) {
               return isSameAddress(auToken.underlying, address);
             });
 
             if (!(matchingAuToken !== undefined)) {
-              _context8.next = 11;
+              _context9.next = 10;
               break;
             }
 
-            return _context8.abrupt("return", fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider));
+            return _context9.abrupt("return", fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider));
+
+          case 10:
+            throw Error("Unable to fetch price for " + address);
 
           case 11:
-            if (!isSameAddress(address, networkAddresses.tokens.AURPLY)) {
-              _context8.next = 15;
+          case "end":
+            return _context9.stop();
+        }
+      }
+    }, _callee9);
+  }));
+  return _fetchPrice2.apply(this, arguments);
+}
+
+function fetchPrice(_x13, _x14) {
+  return _fetchPrice3.apply(this, arguments);
+}
+
+function _fetchPrice3() {
+  _fetchPrice3 = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(address, provider) {
+    return runtime_1.wrap(function _callee10$(_context10) {
+      while (1) {
+        switch (_context10.prev = _context10.next) {
+          case 0:
+            if (!isSameAddress(address, networkAddresses.tokens.PLYUSDC)) {
+              _context10.next = 4;
+              break;
+            }
+
+            return _context10.abrupt("return", fetchLPPrice(address, provider));
+
+          case 4:
+            if (!isSameAddress(address, networkAddresses.tokens.PLY)) {
+              _context10.next = 6;
               break;
             }
 
-            return _context8.abrupt("return", fetchLPPrice(address, provider));
+            return _context10.abrupt("return", fetchPLYPrice(provider));
 
-          case 15:
-            return _context8.abrupt("return", fetchPriceFromCoingecko(address));
+          case 6:
+            return _context10.abrupt("return", _fetchPrice(address, provider));
 
-          case 16:
+          case 7:
           case "end":
-            return _context8.stop();
+            return _context10.stop();
         }
       }
-    }, _callee8);
+    }, _callee10);
   }));
-  return _fetchPrice.apply(this, arguments);
+  return _fetchPrice3.apply(this, arguments);
+}
+
+function fetchPLYPrice(_x15) {
+  return _fetchPLYPrice.apply(this, arguments);
 }
 
-function fetchValuation(_x13, _x14) {
+function _fetchPLYPrice() {
+  _fetchPLYPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(provider) {
+    var LPInfo, plyAddress, plyDecimal, usdcAddress, usdcDecimal;
+    return runtime_1.wrap(function _callee11$(_context11) {
+      while (1) {
+        switch (_context11.prev = _context11.next) {
+          case 0:
+            _context11.next = 2;
+            return fetchLPPositions(networkAddresses.tokens.PLYUSDC, provider);
+
+          case 2:
+            LPInfo = _context11.sent;
+
+            if (!LPInfo.reserve1.isZero()) {
+              _context11.next = 5;
+              break;
+            }
+
+            return _context11.abrupt("return", new BigNumber(0));
+
+          case 5:
+            plyAddress = LPInfo.token0;
+            assert(isSameAddress(plyAddress, networkAddresses.tokens.PLY));
+            plyDecimal = getDecimal(plyAddress);
+            usdcAddress = LPInfo.token1;
+            assert(isSameAddress(usdcAddress, networkAddresses.tokens.USDC));
+            usdcDecimal = getDecimal(usdcAddress);
+            _context11.next = 13;
+            return fetchPrice(usdcAddress, provider);
+
+          case 13:
+            return _context11.abrupt("return", _context11.sent.multipliedBy(LPInfo.reserve1.toString()).multipliedBy(decimalFactor(plyDecimal)).dividedBy(decimalFactor(usdcDecimal)).dividedBy(LPInfo.reserve0.toString()));
+
+          case 14:
+          case "end":
+            return _context11.stop();
+        }
+      }
+    }, _callee11);
+  }));
+  return _fetchPLYPrice.apply(this, arguments);
+}
+
+function fetchValuation(_x16, _x17) {
   return _fetchValuation.apply(this, arguments);
 }
 
 function _fetchValuation() {
-  _fetchValuation = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(tokenAmount, provider) {
+  _fetchValuation = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(tokenAmount, provider) {
     var price;
-    return runtime_1.wrap(function _callee9$(_context9) {
+    return runtime_1.wrap(function _callee12$(_context12) {
       while (1) {
-        switch (_context9.prev = _context9.next) {
+        switch (_context12.prev = _context12.next) {
           case 0:
             if (!(tokenAmount.rawAmount() == "0")) {
-              _context9.next = 2;
+              _context12.next = 2;
               break;
             }
 
-            return _context9.abrupt("return", new BigNumber(0));
+            return _context12.abrupt("return", new BigNumber(0));
 
           case 2:
-            _context9.next = 4;
+            _context12.next = 4;
             return fetchPrice(tokenAmount.token.address, provider);
 
           case 4:
-            price = _context9.sent;
-            return _context9.abrupt("return", calcValuation(tokenAmount, price));
+            price = _context12.sent;
+            return _context12.abrupt("return", calcValuation(tokenAmount, price));
 
           case 6:
           case "end":
-            return _context9.stop();
+            return _context12.stop();
         }
       }
-    }, _callee9);
+    }, _callee12);
   }));
   return _fetchValuation.apply(this, arguments);
 }
@@ -2549,6 +2671,39 @@ function _fetchValuation() {
 function calcValuation(tokenAmount, price) {
   return new BigNumber(tokenAmount.formattedAmount()).multipliedBy(price);
 }
+function valuateToken(_x18, _x19) {
+  return _valuateToken.apply(this, arguments);
+}
+
+function _valuateToken() {
+  _valuateToken = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13(tokenAmount, provider) {
+    var tokenValuation;
+    return runtime_1.wrap(function _callee13$(_context13) {
+      while (1) {
+        switch (_context13.prev = _context13.next) {
+          case 0:
+            _context13.next = 2;
+            return fetchValuation(tokenAmount, provider);
+
+          case 2:
+            tokenValuation = _context13.sent;
+            return _context13.abrupt("return", {
+              tokenAmount: tokenAmount,
+              currencyAmount: {
+                currency: "USD",
+                amount: tokenValuation.toFixed(DECIMAL_PRECISION)
+              }
+            });
+
+          case 4:
+          case "end":
+            return _context13.stop();
+        }
+      }
+    }, _callee13);
+  }));
+  return _valuateToken.apply(this, arguments);
+}
 
 var MoneyMarketRead = /*#__PURE__*/function (_BlockchainEntityRead) {
   _inheritsLoose(MoneyMarketRead, _BlockchainEntityRead);
@@ -3231,77 +3386,285 @@ var MoneyMarket = /*#__PURE__*/function (_BlockchainEntity) {
   return MoneyMarket;
 }(BlockchainEntity);
 
-var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
-  _inheritsLoose(SdkRead, _BlockchainEntityRead);
+var PapermillRead = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(PapermillRead, _BlockchainEntityRead);
 
-  function SdkRead(networkConnection) {
+  function PapermillRead(networkConnection) {
     var _this;
 
     _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    var plyAddress = networkAddresses.tokens.PLY;
+    var pulpAddress = networkAddresses.tokens.PULP;
+    _this.plyToken = new Token(plyAddress, getDecimal(plyAddress));
+    _this.pulpToken = new Token(pulpAddress, getDecimal(pulpAddress));
     _this._comptroller = new ethers.Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider);
-    _this._tokenLock = new ethers.Contract(networkAddresses.misc.TOKENLOCK, TokenLockABI.abi, networkConnection.provider);
     _this._auriFairLaunch = new ethers.Contract(networkAddresses.misc.AURIFAIRLAUNCH, AuriFairLaunchABI.abi, networkConnection.provider);
     _this._auriLens = new ethers.Contract(networkAddresses.misc.AURILENS, AuriLensABI.abi, networkConnection.provider);
-    _this._fakeComptroller = new ethers.Contract(networkAddresses.misc.FAKE_COMPTROLLER, ComptrollerABI.abi, networkConnection.provider);
+    _this._ply = new ethers.Contract(plyAddress, EIP20InterfaceABI.abi, networkConnection.provider);
+    _this._pulp = new ethers.Contract(pulpAddress, PulpABI.abi, networkConnection.provider);
     return _this;
   }
 
-  var _proto = SdkRead.prototype;
+  var _proto = PapermillRead.prototype;
 
-  _proto.getLockingDetails = /*#__PURE__*/function () {
-    var _getLockingDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
-      var currentTime, currentWeek, denominator, promises, values;
+  _proto.getPlyBalance = /*#__PURE__*/function () {
+    var _getPlyBalance = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(userAddress) {
+      var plyBalance;
       return runtime_1.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this._ply.balanceOf(userAddress);
+
+            case 2:
+              plyBalance = _context.sent;
+              return _context.abrupt("return", new TokenAmount(this.plyToken, plyBalance.toString()));
+
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function getPlyBalance(_x) {
+      return _getPlyBalance.apply(this, arguments);
+    }
+
+    return getPlyBalance;
+  }();
+
+  _proto.getPulpBalance = /*#__PURE__*/function () {
+    var _getPulpBalance = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(userAddress) {
+      var pulpBalance;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this._pulp.balanceOf(userAddress);
+
+            case 2:
+              pulpBalance = _context2.sent;
+              return _context2.abrupt("return", new TokenAmount(this.pulpToken, pulpBalance.toString()));
+
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function getPulpBalance(_x2) {
+      return _getPulpBalance.apply(this, arguments);
+    }
+
+    return getPulpBalance;
+  }();
+
+  _proto.getUnclaimedPlyReward = /*#__PURE__*/function () {
+    var _getUnclaimedPlyReward = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(userAddress) {
+      var rewardBalancesMetadata;
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this._auriLens.callStatic.claimRewards(this._comptroller.address, this._auriFairLaunch.address, ALL_STAKING_POOLS, {
+                from: userAddress
+              });
+
+            case 2:
+              rewardBalancesMetadata = _context3.sent;
+              return _context3.abrupt("return", new TokenAmount(this.plyToken, rewardBalancesMetadata.plyAccrured.toString()));
+
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function getUnclaimedPlyReward(_x3) {
+      return _getUnclaimedPlyReward.apply(this, arguments);
+    }
+
+    return getUnclaimedPlyReward;
+  }();
+
+  _proto.getLockingDetails = /*#__PURE__*/function () {
+    var _getLockingDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(userAddress) {
+      var currentTime, currentWeek, denominator, promises, values, percentLockCurrentWeek, percentLockNextWeek, totalRewards, _yield$this$_pulp$cal, pulpAmountCurrentWeek, plyAmountCurrentWeek, plyAmountNextWeek, pulpAmountNextWeek, currentUnlockPortion, nextUnlockPortion;
+
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
             case 0:
               currentTime = getCurrentTimestamp();
-              currentWeek = ethers.BigNumber.from(currentTime - REWARDCLAIMSTART).div(7 * ONE_DAY).toNumber();
-              denominator = 10000;
+              currentWeek = ethers.BigNumber.from(currentTime - REWARD_CLAIM_START).div(7 * ONE_DAY).toNumber();
+              denominator = ethers.BigNumber.from(10000);
               promises = [];
-              promises.push(this._tokenLock.percentageLock(currentWeek));
-              promises.push(this._tokenLock.percentageLock(currentWeek + 1)["catch"](function (err) {
-                return denominator;
-              }));
-              _context.next = 8;
-              return Promise.all(promises).then(function (res) {
-                return res.map(function (v) {
-                  return v.toString();
-                });
-              });
+              promises.push(this._auriLens.getPercentLock(this._pulp.address, userAddress, currentWeek));
+              promises.push(this._auriLens.getPercentLock(this._pulp.address, userAddress, currentWeek + 1));
+              promises.push(this.getUnclaimedPlyReward(userAddress));
+              _context4.next = 9;
+              return Promise.all(promises);
 
-            case 8:
-              values = _context.sent;
-              return _context.abrupt("return", {
-                vestingStart: REWARDCLAIMSTART,
-                currentUnlockPortion: new BigNumber(denominator).minus(values[0]).div(denominator).toNumber(),
-                nextUnlockPortion: new BigNumber(denominator).minus(values[1]).div(denominator).toNumber()
+            case 9:
+              values = _context4.sent;
+              percentLockCurrentWeek = ethers.BigNumber.from(values[0]);
+              percentLockNextWeek = ethers.BigNumber.from(values[1]);
+              totalRewards = values[2];
+              _context4.next = 15;
+              return this._pulp.calcLockAmount(userAddress, totalRewards.rawAmount());
+
+            case 15:
+              _yield$this$_pulp$cal = _context4.sent;
+              pulpAmountCurrentWeek = _yield$this$_pulp$cal[0];
+              plyAmountCurrentWeek = _yield$this$_pulp$cal[1];
+              plyAmountNextWeek = percentLockNextWeek.mul(totalRewards.rawAmount()).div(denominator);
+              pulpAmountNextWeek = ethers.BigNumber.from(totalRewards.rawAmount()).sub(plyAmountNextWeek);
+              currentUnlockPortion = denominator.sub(percentLockCurrentWeek).toString();
+              nextUnlockPortion = denominator.sub(percentLockNextWeek).toString();
+              return _context4.abrupt("return", {
+                vestingStart: REWARD_CLAIM_START,
+                currentUnlockPortion: new BigNumber(currentUnlockPortion).dividedBy(100).toNumber(),
+                accruedPly: totalRewards,
+                currentPly: new TokenAmount(this.plyToken, plyAmountCurrentWeek.toString()),
+                currentPulp: new TokenAmount(this.pulpToken, pulpAmountCurrentWeek.toString()),
+                nextUnlockPortion: new BigNumber(nextUnlockPortion).dividedBy(100).toNumber(),
+                nextPly: new TokenAmount(this.plyToken, plyAmountNextWeek.toString()),
+                nextPulp: new TokenAmount(this.pulpToken, pulpAmountNextWeek.toString())
               });
 
-            case 10:
+            case 23:
             case "end":
-              return _context.stop();
+              return _context4.stop();
           }
         }
-      }, _callee, this);
+      }, _callee4, this);
     }));
 
-    function getLockingDetails() {
+    function getLockingDetails(_x4) {
       return _getLockingDetails.apply(this, arguments);
     }
 
     return getLockingDetails;
   }();
 
+  return PapermillRead;
+}(BlockchainEntityRead);
+var PapermillReadWrite = /*#__PURE__*/function (_PapermillRead) {
+  _inheritsLoose(PapermillReadWrite, _PapermillRead);
+
+  function PapermillReadWrite(networkConnection) {
+    return _PapermillRead.call(this, networkConnection) || this;
+  }
+
+  var _proto2 = PapermillReadWrite.prototype;
+
+  _proto2.redeem = /*#__PURE__*/function () {
+    var _redeem = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(recipient, amount) {
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return", this._pulp.redeem(recipient, amount.rawAmount()));
+
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function redeem(_x5, _x6) {
+      return _redeem.apply(this, arguments);
+    }
+
+    return redeem;
+  }();
+
+  _proto2.selfRedeem = /*#__PURE__*/function () {
+    var _selfRedeem = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(amount) {
+      var msgSender;
+      return runtime_1.wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              _context6.next = 2;
+              return this._networkConnection.signer.getAddress();
+
+            case 2:
+              msgSender = _context6.sent;
+              return _context6.abrupt("return", this.redeem(msgSender, amount));
+
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
+
+    function selfRedeem(_x7) {
+      return _selfRedeem.apply(this, arguments);
+    }
+
+    return selfRedeem;
+  }();
+
+  return PapermillReadWrite;
+}(PapermillRead);
+var Papermill = /*#__PURE__*/function (_BlockchainEntity) {
+  _inheritsLoose(Papermill, _BlockchainEntity);
+
+  function Papermill() {
+    return _BlockchainEntity.call(this) || this;
+  }
+
+  var _proto3 = Papermill.prototype;
+
+  _proto3.read = function read(networkConnection) {
+    return new PapermillRead(networkConnection);
+  };
+
+  _proto3.readWrite = function readWrite(networkConnection) {
+    return new PapermillReadWrite(networkConnection);
+  };
+
+  return Papermill;
+}(BlockchainEntity);
+
+var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(SdkRead, _BlockchainEntityRead);
+
+  function SdkRead(networkConnection) {
+    var _this;
+
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    _this._comptroller = new ethers.Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider);
+    _this._auriFairLaunch = new ethers.Contract(networkAddresses.misc.AURIFAIRLAUNCH, AuriFairLaunchABI.abi, networkConnection.provider);
+    _this._auriLens = new ethers.Contract(networkAddresses.misc.AURILENS, AuriLensABI.abi, networkConnection.provider);
+    return _this;
+  }
+
+  var _proto = SdkRead.prototype;
+
   _proto.getUserDetails = /*#__PURE__*/function () {
-    var _getUserDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(userAddress) {
+    var _getUserDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(userAddress) {
       var _this2 = this;
 
-      var marketCount, userMarketDetails, assetsIn, promises, totalBorrowLimit, pricePromises, _loop2, _iterator, _step, underlyingPrices, depositValues, _loop, i, accountLiquidity, rewardBalancesMetadata, lockedAmount, values, borrowedvaluation, bufferedBorrowLimit, minimumBorrowLimitAllowed, borrowableAmount, auToken, moneyMarket, borrowLimitMargin, maxWithdrawCap;
+      var marketCount, userMarketDetails, assetsIn, promises, totalBorrowLimit, pricePromises, _loop2, _iterator, _step, underlyingPrices, depositValues, _loop, i, accountLiquidity, borrowedvaluation, bufferedBorrowLimit, minimumBorrowLimitAllowed, borrowableAmount, auToken, moneyMarket, borrowLimitMargin, maxWithdrawCap;
 
-      return runtime_1.wrap(function _callee2$(_context2) {
+      return runtime_1.wrap(function _callee$(_context) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context.prev = _context.next) {
             case 0:
               marketCount = networkAddresses.auTokens.length;
               userMarketDetails = [];
@@ -3337,15 +3700,15 @@ var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
               promises.push(this._comptroller.getAssetsIn(userAddress).then(function (res) {
                 assetsIn = res;
               }));
-              _context2.next = 10;
+              _context.next = 10;
               return Promise.all(promises);
 
             case 10:
-              _context2.next = 12;
+              _context.next = 12;
               return Promise.all(pricePromises);
 
             case 12:
-              underlyingPrices = _context2.sent;
+              underlyingPrices = _context.sent;
               depositValues = [];
 
               _loop = function _loop() {
@@ -3370,20 +3733,11 @@ var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
                 if (userMarketDetails[index].isCollateral) return p.plus(v.multipliedBy(userMarketDetails[index].collateralRatio));
                 return p;
               }, new BigNumber(0));
-              promises = new Array(3);
-              promises[0] = this._fakeComptroller.getAccountLiquidity(userAddress);
-              promises[1] = this._auriLens.callStatic.claimAndGetRewardBalancesMetadata(this._comptroller.address, this._auriFairLaunch.address, [], {
-                from: userAddress
-              });
-              promises[2] = this._tokenLock.lockedAmounts(userAddress);
-              _context2.next = 23;
-              return Promise.all(promises);
+              _context.next = 19;
+              return this._comptroller.getAccountLiquidity(userAddress);
 
-            case 23:
-              values = _context2.sent;
-              accountLiquidity = values[0];
-              rewardBalancesMetadata = values[1];
-              lockedAmount = values[2];
+            case 19:
+              accountLiquidity = _context.sent;
               borrowedvaluation = totalBorrowLimit.minus(new BigNumber(accountLiquidity[0].toString()).div(decimalFactor(18)));
 
               if (borrowedvaluation.lt("0.00001")) {
@@ -3407,26 +3761,33 @@ var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
                 userMarketDetails[i].maxWithdrawableAmount = userMarketDetails[i].isCollateral && maxWithdrawCap.lt(userMarketDetails[i].depositBalance.formattedAmount()) ? new TokenAmount(moneyMarket.underlying, maxWithdrawCap.toFixed(24), false) : new TokenAmount(moneyMarket.underlying, userMarketDetails[i].depositBalance.rawAmount());
               }
 
-              return _context2.abrupt("return", {
-                markets: userMarketDetails,
-                borrowLimit: {
-                  currency: "USD",
-                  amount: bufferedBorrowLimit.toFixed(DECIMAL_PRECISION)
-                },
-                accruedPly: new TokenAmount(PLYToken, rewardBalancesMetadata.plyAccrued.toString()),
-                lockedPly: new TokenAmount(PLYToken, lockedAmount.toString()),
-                borrowableAmount: {
-                  currency: "USD",
-                  amount: borrowableAmount.toFixed(DECIMAL_PRECISION)
-                }
+              _context.t0 = userMarketDetails;
+              _context.t1 = {
+                currency: "USD",
+                amount: bufferedBorrowLimit.toFixed(DECIMAL_PRECISION)
+              };
+              _context.next = 30;
+              return new PapermillRead(this._networkConnection).getLockingDetails(userAddress);
+
+            case 30:
+              _context.t2 = _context.sent;
+              _context.t3 = {
+                currency: "USD",
+                amount: borrowableAmount.toFixed(DECIMAL_PRECISION)
+              };
+              return _context.abrupt("return", {
+                markets: _context.t0,
+                borrowLimit: _context.t1,
+                userLockingDetails: _context.t2,
+                borrowableAmount: _context.t3
               });
 
-            case 34:
+            case 33:
             case "end":
-              return _context2.stop();
+              return _context.stop();
           }
         }
-      }, _callee2, this);
+      }, _callee, this);
     }));
 
     function getUserDetails(_x) {
@@ -3436,76 +3797,92 @@ var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
     return getUserDetails;
   }();
 
-  _proto.getPlyAuroraPoolDetails = /*#__PURE__*/function () {
-    var _getPlyAuroraPoolDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
-      var stakedLiquidity, rewardPerSecond, promises, rewardPerSecondValuation, totalStakeValuation;
-      return runtime_1.wrap(function _callee3$(_context3) {
+  _proto.getPlyUsdcPoolDetails = /*#__PURE__*/function () {
+    var _getPlyUsdcPoolDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2() {
+      var stakedLiquidity, rewardPerSeconds, stakedLiquidityAmount, promises, _i, rewardTokenAddress, rewardToken, rewardPerSecond, rewardPerSecondValuation, totalStakeValuation;
+
+      return runtime_1.wrap(function _callee2$(_context2) {
         while (1) {
-          switch (_context3.prev = _context3.next) {
+          switch (_context2.prev = _context2.next) {
             case 0:
-              promises = [];
-              promises.push(this._auriFairLaunch.getPoolInfo(AurPlyPid).then(function (res) {
+              _context2.next = 2;
+              return this._auriFairLaunch.getPoolInfo(PlyUsdcPid).then(function (res) {
                 stakedLiquidity = res.totalStake;
-                rewardPerSecond = res.rewardPerSecond;
-              }));
-              _context3.next = 4;
-              return Promise.all(promises);
+                rewardPerSeconds = res.rewardPerSeconds;
+              });
 
-            case 4:
+            case 2:
+              stakedLiquidityAmount = new TokenAmount(PLYUSDCToken, stakedLiquidity.toString());
               promises = [];
-              promises.push(fetchValuation(new TokenAmount(PLYToken, rewardPerSecond.toString()), this._networkConnection.provider).then(function (res) {
-                return rewardPerSecondValuation = res;
-              }));
-              promises.push(fetchValuation(new TokenAmount(AURPLYToken, stakedLiquidity.toString()), this._networkConnection.provider).then(function (res) {
-                return totalStakeValuation = res;
-              }));
-              _context3.next = 9;
+
+              for (_i = 0; _i < rewardPerSeconds.length; _i++) {
+                rewardTokenAddress = PLYUSDCRewardTokens[_i];
+                rewardToken = new Token(rewardTokenAddress, getDecimal(rewardTokenAddress));
+                rewardPerSecond = rewardPerSeconds[_i];
+                promises.push(fetchValuation(new TokenAmount(rewardToken, rewardPerSecond.toString()), this._networkConnection.provider));
+              }
+
+              _context2.next = 7;
               return Promise.all(promises);
 
-            case 9:
-              return _context3.abrupt("return", {
-                totalStakedLiquidity: new TokenAmount(AURPLYToken, stakedLiquidity.toString()),
+            case 7:
+              rewardPerSecondValuation = _context2.sent.reduce(function (p, v) {
+                return p.plus(v);
+              }, new BigNumber(0));
+              _context2.next = 10;
+              return fetchValuation(stakedLiquidityAmount, this._networkConnection.provider);
+
+            case 10:
+              totalStakeValuation = _context2.sent;
+              return _context2.abrupt("return", {
+                totalStakedLiquidity: {
+                  tokenAmount: stakedLiquidityAmount,
+                  currencyAmount: {
+                    currency: "USD",
+                    amount: totalStakeValuation.toFixed(DECIMAL_PRECISION)
+                  }
+                },
                 apy: calcLMRewardApr(rewardPerSecondValuation, totalStakeValuation, ONE_DAY * 365).toFixed(DECIMAL_PRECISION)
               });
 
-            case 10:
+            case 12:
             case "end":
-              return _context3.stop();
+              return _context2.stop();
           }
         }
-      }, _callee3, this);
+      }, _callee2, this);
     }));
 
-    function getPlyAuroraPoolDetails() {
-      return _getPlyAuroraPoolDetails.apply(this, arguments);
+    function getPlyUsdcPoolDetails() {
+      return _getPlyUsdcPoolDetails.apply(this, arguments);
     }
 
-    return getPlyAuroraPoolDetails;
+    return getPlyUsdcPoolDetails;
   }();
 
   _proto.getTokenPrice = /*#__PURE__*/function () {
-    var _getTokenPrice = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(token) {
+    var _getTokenPrice = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(token) {
       var price;
-      return runtime_1.wrap(function _callee4$(_context4) {
+      return runtime_1.wrap(function _callee3$(_context3) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
-              _context4.next = 2;
+              _context3.next = 2;
               return fetchPrice(token.address, this._networkConnection.provider);
 
             case 2:
-              price = _context4.sent;
-              return _context4.abrupt("return", {
+              price = _context3.sent;
+              return _context3.abrupt("return", {
                 currency: "USD",
                 amount: price.toFixed(DECIMAL_PRECISION)
               });
 
             case 4:
             case "end":
-              return _context4.stop();
+              return _context3.stop();
           }
         }
-      }, _callee4, this);
+      }, _callee3, this);
     }));
 
     function getTokenPrice(_x2) {
@@ -3516,25 +3893,26 @@ var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
   }();
 
   _proto.stakeBalanceOf = /*#__PURE__*/function () {
-    var _stakeBalanceOf = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(user) {
-      var userInfo;
-      return runtime_1.wrap(function _callee5$(_context5) {
+    var _stakeBalanceOf = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(user) {
+      var userInfo, stakeAmount;
+      return runtime_1.wrap(function _callee4$(_context4) {
         while (1) {
-          switch (_context5.prev = _context5.next) {
+          switch (_context4.prev = _context4.next) {
             case 0:
-              _context5.next = 2;
-              return this._auriFairLaunch.getUserInfo(AurPlyPid, user);
+              _context4.next = 2;
+              return this._auriFairLaunch.getUserInfo(PlyUsdcPid, user);
 
             case 2:
-              userInfo = _context5.sent;
-              return _context5.abrupt("return", new TokenAmount(AURPLYToken, userInfo.amount.toString()));
+              userInfo = _context4.sent;
+              stakeAmount = new TokenAmount(PLYUSDCToken, userInfo.amount.toString());
+              return _context4.abrupt("return", valuateToken(stakeAmount, this._networkConnection.provider));
 
-            case 4:
+            case 5:
             case "end":
-              return _context5.stop();
+              return _context4.stop();
           }
         }
-      }, _callee5, this);
+      }, _callee4, this);
     }));
 
     function stakeBalanceOf(_x3) {
@@ -3544,6 +3922,36 @@ var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
     return stakeBalanceOf;
   }();
 
+  _proto.LpBalanceOf = /*#__PURE__*/function () {
+    var _LpBalanceOf = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(user) {
+      var lpERC20, balance;
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              lpERC20 = new ethers.Contract(networkAddresses.tokens.PLYUSDC, EIP20InterfaceABI.abi, this._networkConnection.provider);
+              _context5.next = 3;
+              return lpERC20.balanceOf(user);
+
+            case 3:
+              balance = _context5.sent;
+              return _context5.abrupt("return", valuateToken(new TokenAmount(PLYUSDCToken, balance.toString()), this._networkConnection.provider));
+
+            case 5:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function LpBalanceOf(_x4) {
+      return _LpBalanceOf.apply(this, arguments);
+    }
+
+    return LpBalanceOf;
+  }();
+
   _proto.calcHypotheticalStats = function calcHypotheticalStats(_ref) {
     var userMarketDetail = _ref.userMarketDetail,
         currentBorrowLimit = _ref.currentBorrowLimit,
@@ -3599,7 +4007,7 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
         while (1) {
           switch (_context6.prev = _context6.next) {
             case 0:
-              return _context6.abrupt("return", this._auriLens.connect(this._networkConnection.signer).claimRewards(this._comptroller.address, this._auriFairLaunch.address, [AurPlyPid]));
+              return _context6.abrupt("return", this._auriLens.connect(this._networkConnection.signer).claimRewards(this._comptroller.address, this._auriFairLaunch.address, ALL_STAKING_POOLS));
 
             case 1:
             case "end":
@@ -3622,7 +4030,7 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
         while (1) {
           switch (_context7.prev = _context7.next) {
             case 0:
-              return _context7.abrupt("return", this._auriFairLaunch.connect(this._networkConnection.signer).deposit(AurPlyPid, amount.rawAmount()));
+              return _context7.abrupt("return", this._auriFairLaunch.connect(this._networkConnection.signer).deposit(PlyUsdcPid, amount.rawAmount()));
 
             case 1:
             case "end":
@@ -3632,7 +4040,7 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
       }, _callee7, this);
     }));
 
-    function stake(_x4) {
+    function stake(_x5) {
       return _stake.apply(this, arguments);
     }
 
@@ -3645,7 +4053,7 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
         while (1) {
           switch (_context8.prev = _context8.next) {
             case 0:
-              return _context8.abrupt("return", this._auriFairLaunch.connect(this._networkConnection.signer).withdraw(AurPlyPid, amount.rawAmount()));
+              return _context8.abrupt("return", this._auriFairLaunch.connect(this._networkConnection.signer).withdraw(PlyUsdcPid, amount.rawAmount()));
 
             case 1:
             case "end":
@@ -3655,7 +4063,7 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
       }, _callee8, this);
     }));
 
-    function unstake(_x5) {
+    function unstake(_x6) {
       return _unstake.apply(this, arguments);
     }
 
@@ -106916,12 +107324,11 @@ BigNumber.config({
 exports.AIRDROP_END_TIMESTAMP = AIRDROP_END_TIMESTAMP;
 exports.AIRDROP_KEEP_THRESHOLD = AIRDROP_KEEP_THRESHOLD;
 exports.AIRDROP_START_TIMESTAMP = AIRDROP_START_TIMESTAMP;
+exports.ALL_STAKING_POOLS = ALL_STAKING_POOLS;
 exports.AURORA_CHAINID = AURORA_CHAINID;
-exports.AURPLYToken = AURPLYToken;
 exports.Airdrop = Airdrop;
 exports.AirdropRead = AirdropRead;
 exports.AirdropReadWrite = AirdropReadWrite;
-exports.AurPlyPid = AurPlyPid;
 exports.BORROW_LIMIT_BUFFER = BORROW_LIMIT_BUFFER;
 exports.BORROW_NEAR_REWARDS_PER_WEEK = BORROW_NEAR_REWARDS_PER_WEEK;
 exports.BlockchainEntity = BlockchainEntity;
@@ -106937,7 +107344,14 @@ exports.MoneyMarketReadWrite = MoneyMarketReadWrite;
 exports.ONE_DAY = ONE_DAY;
 exports.ONE_YEAR = ONE_YEAR;
 exports.PLYToken = PLYToken;
-exports.REWARDCLAIMSTART = REWARDCLAIMSTART;
+exports.PLYUSDCRewardTokens = PLYUSDCRewardTokens;
+exports.PLYUSDCToken = PLYUSDCToken;
+exports.PRICE_WHITELISTED = PRICE_WHITELISTED;
+exports.Papermill = Papermill;
+exports.PapermillRead = PapermillRead;
+exports.PapermillReadWrite = PapermillReadWrite;
+exports.PlyUsdcPid = PlyUsdcPid;
+exports.REWARD_CLAIM_START = REWARD_CLAIM_START;
 exports.SDK = SDK;
 exports.SdkRead = SdkRead;
 exports.SdkReadWrite = SdkReadWrite;
@@ -106959,6 +107373,7 @@ exports.dummyUserMarketDetails = dummyUserMarketDetails;
 exports.dummyZeroTokenAmount = dummyZeroTokenAmount;
 exports.fetchLPPositions = fetchLPPositions;
 exports.fetchLPPrice = fetchLPPrice;
+exports.fetchPLYPrice = fetchPLYPrice;
 exports.fetchPrice = fetchPrice;
 exports.fetchPriceFromCoingecko = fetchPriceFromCoingecko;
 exports.fetchPriceFromCoingeckoAPI = fetchPriceFromCoingeckoAPI;
@@ -106974,4 +107389,5 @@ exports.getDecimal = getDecimal;
 exports.isSameAddress = isSameAddress;
 exports.networkAddresses = networkAddresses;
 exports.validateAndParseAddress = validateAndParseAddress;
+exports.valuateToken = valuateToken;
 //# sourceMappingURL=sdk.cjs.development.js.map