@aurigami/sdk 0.1.5 → 0.2.2

package/dist/sdk.cjs.development.js

@@ -4,8 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
+var abstractSigner = require('@ethersproject/abstract-signer');
 var BigNumber = _interopDefault(require('bignumber.js'));
-var ethers$2 = require('ethers');
+var ethers$1 = require('ethers');
+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 TokenLockABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/TokenLock.sol/TokenLock.json'));
+var AuriFairLaunchABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json'));
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -59,6 +65,44 @@ function _setPrototypeOf(o, p) {
   return _setPrototypeOf(o, p);
 }
 
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
 function createCommonjsModule(fn, module) {
 	return module = { exports: {} }, fn(module, module.exports), module.exports;
 }
@@ -819,14 +863,18 @@ try {
 }
 });
 
-var BlockchainEntityRead = function BlockchainEntityRead(providerOrSigner) {
-  this._providerOrSigner = providerOrSigner;
+var BlockchainEntityRead = function BlockchainEntityRead(networkConnection) {
+  this._networkConnection = networkConnection;
 };
 var BlockchainEntityReadWrite = /*#__PURE__*/function (_BlockchainEntityRead) {
   _inheritsLoose(BlockchainEntityReadWrite, _BlockchainEntityRead);
 
-  function BlockchainEntityReadWrite(signer) {
-    return _BlockchainEntityRead.call(this, signer) || this;
+  function BlockchainEntityReadWrite(networkConnection) {
+    if (!(networkConnection.signer instanceof abstractSigner.Signer)) {
+      throw Error("Signer is not provided when constructing BlockchainEntityReadWrite");
+    }
+
+    return _BlockchainEntityRead.call(this, networkConnection) || this;
   }
 
   return BlockchainEntityReadWrite;
@@ -836,36 +884,153 @@ var BlockchainEntity = /*#__PURE__*/function () {
 
   var _proto = BlockchainEntity.prototype;
 
-  _proto.read = function read(provider) {
-    return new BlockchainEntityRead(provider);
+  _proto.read = function read(networkConnection) {
+    return new BlockchainEntityRead(networkConnection);
   };
 
-  _proto.readWrite = function readWrite(signer) {
-    return new BlockchainEntityReadWrite(signer);
+  _proto.readWrite = function readWrite(networkConnection) {
+    return new BlockchainEntityReadWrite(networkConnection);
   };
 
   return BlockchainEntity;
 }();
 
-var Token = function Token(address, decimals, expiry) {
-  this.address = address.toLowerCase();
-  this.decimals = decimals;
-  this.expiry = expiry;
+var ethers = /*#__PURE__*/require('ethers');
+
+var AVAX_DEFAULT_PROVIDER_URL = 'https://api.avax.network/ext/bc/C/rpc';
+var AVAX_DEFAULT_PROVIDER = /*#__PURE__*/new ethers.providers.JsonRpcProvider(AVAX_DEFAULT_PROVIDER_URL);
+var dummyAddress = "0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE";
+var ETHAddress = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var dummyPrivateKey = '1111111111111111111111111111111111111111111111111111111111111111';
+var AVAX_DEFAULT_SIGNER = /*#__PURE__*/new ethers.Wallet(dummyPrivateKey);
+var AURORA_CHAINID = 1313161554;
+var DECIMAL_PRECISION = 6;
+var networkAddresses = {
+  auTokens: [{
+    address: '0x7967532568bef9ec96cfad6badea4c63add5888a',
+    underlying: '0x9738319d4b8a95a9b3cfd99419dbf859904f23d8'
+  }, {
+    address: '0x96AAD2c3fde982627d531f45D1Bebd8bE3b86f60',
+    underlying: ETHAddress
+  }, {
+    address: '0xccf005cfc3669d806a03f0617885648c397c456e',
+    underlying: '0x959bf9bf41062e9cac0e60cacbaa441fbc8946c6'
+  }, {
+    address: '0x55a4c111c007f39326edf22cfd63bbbb21a35b35',
+    underlying: '0x1c67cb984abdf7f0a6bce2fd5d5e662e0b983369'
+  }, {
+    address: '0x77b088236c071ab5bd4e0bd21240b093275adffc',
+    underlying: '0x675c7e1d48f88329c6b4cd3867db5f10a69cda18'
+  }, {
+    address: '0xaa68274f87fd9ae940f1dec31b643486838481c1',
+    underlying: '0x7a80df8230c5aa711e2702a275ab31aeb32754bf'
+  }, {
+    address: '0x6970167dfaa2aaa67404204102cbbd18b405eca9',
+    underlying: '0x1dc7d4990b1edb9a88f3fa7d899864b69ee2c428'
+  }, {
+    address: '0x9630a6c5b729194972199805075fd76707a9713a',
+    underlying: '0x6f8a1daa158e08f75711a64e5a3073e959d688a6'
+  }],
+  misc: {
+    COMPTROLLER: "0xb51028d4f3fc69e3f9e3118ce067a4562c595aad",
+    oracle: "0xf1ebfaa2af93f4d82215fd7817c1835853c62fb8",
+    AURIFAIRLAUNCH: "0x7942874a9ef8059c5de259625a883dc61f03320d",
+    AURILENS: '0xa2635a23a7688cd3acdd07713c4943b2f0f9082c'
+  },
+  tokens: {
+    AURORA: "0x7a80df8230c5aa711e2702a275ab31aeb32754bf",
+    PLY: "0x6f8a1daa158e08f75711a64e5a3073e959d688a6",
+    AURPLY: dummyAddress
+  }
+};
+var BORROW_LIMIT_BUFFER = /*#__PURE__*/new BigNumber(0.95);
+var REWARDCLAIMSTART = 1673280000;
+var ONE_DAY = 86400;
+var AurPlyPid = 1;
+
+var decimalRecords = {
+  '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': 18,
+  '0x9738319d4b8a95a9b3cfd99419dbf859904f23d8': 18,
+  '0x1dc7d4990b1edb9a88f3fa7d899864b69ee2c428': 18,
+  '0x1c67cb984abdf7f0a6bce2fd5d5e662e0b983369': 18,
+  '0x675c7e1d48f88329c6b4cd3867db5f10a69cda18': 18,
+  '0xaa68274f87fd9ae940f1dec31b643486838481c1': 8,
+  '0x96AAD2c3fde982627d531f45D1Bebd8bE3b86f60': 8,
+  '0x6970167dfaa2aaa67404204102cbbd18b405eca9': 8,
+  '0x6f8a1daa158e08f75711a64e5a3073e959d688a6': 18,
+  '0xccf005cfc3669d806a03f0617885648c397c456e': 8,
+  '0x959bf9bf41062e9cac0e60cacbaa441fbc8946c6': 18,
+  '0x7a80df8230c5aa711e2702a275ab31aeb32754bf': 18,
+  '0x9630a6c5b729194972199805075fd76707a9713a': 8,
+  '0x77b088236c071ab5bd4e0bd21240b093275adffc': 8,
+  '0x7967532568bef9ec96cfad6badea4c63add5888a': 8,
+  '0x55a4c111c007f39326edf22cfd63bbbb21a35b35': 8
 };
 
 function formatObject(object) {
   return JSON.stringify(object, null, '  ');
 }
-var decimalFactor = function decimalFactor(decimal) {
-  return ethers$2.BigNumber.from(10).pow(decimal).toString();
+function decimalFactor(decimal) {
+  return ethers$1.BigNumber.from(10).pow(decimal).toString();
+}
+var isSameAddress = function isSameAddress(address1, address2) {
+  return address1.toLowerCase() == address2.toLowerCase();
 };
+var getCurrentTimestamp = /*#__PURE__*/function () {
+  var _ref = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(provider) {
+    var latestBlockNumber, currentTime;
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return provider.getBlockNumber();
+
+          case 2:
+            latestBlockNumber = _context.sent;
+            _context.next = 5;
+            return provider.getBlock(latestBlockNumber);
+
+          case 5:
+            currentTime = _context.sent.timestamp;
+            return _context.abrupt("return", currentTime);
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function getCurrentTimestamp(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
 function validateAndParseAddress(address) {
   try {
-    return ethers$2.utils.getAddress(address);
+    return ethers$1.utils.getAddress(address);
   } catch (error) {
-    throw new Error("Invalid address " + address);
+    throw new Error("Invalid address: " + address);
   }
 }
+function getDecimal(address) {
+  return decimalRecords[address.toLowerCase()];
+}
+function calcLMRewardApr(rewardsValue, totalStakeValue, frequencyPerYear) {
+  if (totalStakeValue.lte(0)) {
+    return new BigNumber('999999999');
+  }
+
+  return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
+}
+
+var Token = function Token(address, decimals) {
+  this.address = address.toLowerCase();
+  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 TokenAmount = /*#__PURE__*/function () {
   function TokenAmount(token, amount, isRaw) {
@@ -895,214 +1060,245 @@ var TokenAmount = /*#__PURE__*/function () {
   return TokenAmount;
 }();
 
-var dummyToken = /*#__PURE__*/new Token('0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e', 6);
-var dummyPly = /*#__PURE__*/new Token('0x8729438eb15e2c8b576fcc6aecda6a148776c0f5', 18);
-var dummyPlyAurora = /*#__PURE__*/new Token('0xE530dC2095Ef5653205CF5ea79F8979a7028065c', 18);
-var dummyTokenAmount = /*#__PURE__*/new TokenAmount(dummyToken, '123.456', false);
-var dummyZeroTokenAmount = /*#__PURE__*/new TokenAmount(dummyToken, '0');
-var dummyTokenAmount2 = /*#__PURE__*/new TokenAmount(dummyToken, '456.123', false);
-var dummyTokenAmount3 = /*#__PURE__*/new TokenAmount(dummyToken, '1000.123', false);
-var dummyMarketAddress = '0xbeb5d47a3f720ec0a390d04b4d41ed7d9688bc7f';
-var dummyUserMarketDetails = {
-  market: dummyMarketAddress,
-  depositBalance: dummyTokenAmount2,
-  borrowBalance: dummyZeroTokenAmount,
-  isCollateral: true,
-  maxWithdrawableAmount: dummyTokenAmount
-};
-
-var ethers = /*#__PURE__*/require('ethers');
+var MoneyMarketRead = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(MoneyMarketRead, _BlockchainEntityRead);
 
-var DOLLAR = /*#__PURE__*/new Token('0x0000000000000000000000000000000000000001', 2);
-var AVAX_DEFAULT_PROVIDER_URL = 'https://api.avax.network/ext/bc/C/rpc';
-var AVAX_DEFAULT_PROVIDER = /*#__PURE__*/new ethers.providers.JsonRpcProvider(AVAX_DEFAULT_PROVIDER_URL);
-var dummyPrivateKey = '1111111111111111111111111111111111111111111111111111111111111111';
-var AVAX_DEFAULT_SIGNER = /*#__PURE__*/new ethers.Wallet(dummyPrivateKey);
+  function MoneyMarketRead(networkConnection, auToken, underlyingAsset) {
+    var _this;
 
-var ethers$1 = /*#__PURE__*/require('ethers');
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
 
-var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
-  _inheritsLoose(SdkRead, _BlockchainEntityRead);
+    if (isSameAddress(underlyingAsset, ETHAddress)) {
+      _this.auToken = new ethers$1.Contract(auToken, AuETHABI.abi, networkConnection.provider);
+    } else {
+      _this.auToken = new ethers$1.Contract(auToken, AuErc20ABI.abi, networkConnection.provider);
+    }
 
-  function SdkRead(providerOrSigner) {
-    return _BlockchainEntityRead.call(this, providerOrSigner) || this;
+    _this.underlying = new Token(underlyingAsset, getDecimal(underlyingAsset));
+    _this._comptroller = new ethers$1.Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider);
+    return _this;
   }
 
-  var _proto = SdkRead.prototype;
+  var _proto = MoneyMarketRead.prototype;
 
-  _proto.getLockingDetails = /*#__PURE__*/function () {
-    var _getLockingDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+  _proto.getTotalTokenBorrowed = /*#__PURE__*/function () {
+    var _getTotalTokenBorrowed = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
       return runtime_1.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
-              return _context.abrupt("return", {
-                vestingStart: 1673280000,
-                currentUnlockPortion: 0.17,
-                nextUnlockPortion: 0.19
-              });
+              _context.t0 = TokenAmount;
+              _context.t1 = this.underlying;
+              _context.next = 4;
+              return this.auToken.totalBorrows();
 
-            case 1:
+            case 4:
+              _context.t2 = _context.sent.toString();
+              return _context.abrupt("return", new _context.t0(_context.t1, _context.t2));
+
+            case 6:
             case "end":
               return _context.stop();
           }
         }
-      }, _callee);
+      }, _callee, this);
     }));
 
-    function getLockingDetails() {
-      return _getLockingDetails.apply(this, arguments);
+    function getTotalTokenBorrowed() {
+      return _getTotalTokenBorrowed.apply(this, arguments);
     }
 
-    return getLockingDetails;
+    return getTotalTokenBorrowed;
   }();
 
-  _proto.getUserDetails = /*#__PURE__*/function () {
-    var _getUserDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(userAddress) {
+  _proto.getTotalTokenDeposited = /*#__PURE__*/function () {
+    var _getTotalTokenDeposited = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2() {
+      var _this2 = this;
+
+      var promises, totalBorrow, totalCash;
       return runtime_1.wrap(function _callee2$(_context2) {
         while (1) {
           switch (_context2.prev = _context2.next) {
             case 0:
-              return _context2.abrupt("return", {
-                markets: [dummyUserMarketDetails],
-                borrowLimit: dummyTokenAmount3,
-                accruedPly: new TokenAmount(dummyPly, '100.12', false),
-                lockedPly: new TokenAmount(dummyPly, '200.12', false),
-                borrowableAmount: dummyTokenAmount2
-              });
-
-            case 1:
+              promises = [];
+              promises.push(this.getTotalTokenBorrowed().then(function (res) {
+                totalBorrow = res;
+              }));
+              promises.push(this.auToken.getCash().then(function (res) {
+                totalCash = new TokenAmount(_this2.underlying, res.toString());
+              }));
+              _context2.next = 5;
+              return Promise.all(promises);
+
+            case 5:
+              return _context2.abrupt("return", new TokenAmount(this.underlying, ethers$1.BigNumber.from(totalCash.rawAmount).add(totalBorrow.rawAmount()).toString()));
+
+            case 6:
             case "end":
               return _context2.stop();
           }
         }
-      }, _callee2);
+      }, _callee2, this);
     }));
 
-    function getUserDetails(_x) {
-      return _getUserDetails.apply(this, arguments);
+    function getTotalTokenDeposited() {
+      return _getTotalTokenDeposited.apply(this, arguments);
     }
 
-    return getUserDetails;
+    return getTotalTokenDeposited;
   }();
 
-  _proto.getPlyAuroraPoolDetails = /*#__PURE__*/function () {
-    var _getPlyAuroraPoolDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
+  _proto.getDepositAPY = /*#__PURE__*/function () {
+    var _getDepositAPY = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
+      var supplyRatePerTimestamp;
       return runtime_1.wrap(function _callee3$(_context3) {
         while (1) {
           switch (_context3.prev = _context3.next) {
             case 0:
-              return _context3.abrupt("return", {
-                totalStakedLiquidity: new TokenAmount(dummyPlyAurora, '12.1', false),
-                apy: 1.21
-              });
+              _context3.next = 2;
+              return this.auToken.supplyRatePerTimestamp();
 
-            case 1:
+            case 2:
+              supplyRatePerTimestamp = _context3.sent;
+              return _context3.abrupt("return", new BigNumber(supplyRatePerTimestamp.toString()).multipliedBy(60 * 60 * 24 * 365).div(decimalFactor(18)));
+
+            case 4:
             case "end":
               return _context3.stop();
           }
         }
-      }, _callee3);
+      }, _callee3, this);
     }));
 
-    function getPlyAuroraPoolDetails() {
-      return _getPlyAuroraPoolDetails.apply(this, arguments);
+    function getDepositAPY() {
+      return _getDepositAPY.apply(this, arguments);
     }
 
-    return getPlyAuroraPoolDetails;
+    return getDepositAPY;
   }();
 
-  _proto.getTokenPrice = /*#__PURE__*/function () {
-    var _getTokenPrice = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(token) {
+  _proto.getBorrowAPY = /*#__PURE__*/function () {
+    var _getBorrowAPY = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
+      var borrowRatePerTimestamp;
       return runtime_1.wrap(function _callee4$(_context4) {
         while (1) {
           switch (_context4.prev = _context4.next) {
             case 0:
-              if (!(token.address == dummyToken.address)) {
-                _context4.next = 2;
-                break;
-              }
-
-              return _context4.abrupt("return", new TokenAmount(DOLLAR, '1', false));
+              _context4.next = 2;
+              return this.auToken.borrowRatePerTimestamp();
 
             case 2:
-              return _context4.abrupt("return", new TokenAmount(DOLLAR, '12.1', false));
+              borrowRatePerTimestamp = _context4.sent;
+              return _context4.abrupt("return", new BigNumber(borrowRatePerTimestamp.toString()).multipliedBy(60 * 60 * 24 * 365).div(decimalFactor(18)));
 
-            case 3:
+            case 4:
             case "end":
               return _context4.stop();
           }
         }
-      }, _callee4);
+      }, _callee4, this);
     }));
 
-    function getTokenPrice(_x2) {
-      return _getTokenPrice.apply(this, arguments);
+    function getBorrowAPY() {
+      return _getBorrowAPY.apply(this, arguments);
     }
 
-    return getTokenPrice;
+    return getBorrowAPY;
   }();
 
-  _proto.stakeBalanceOf = /*#__PURE__*/function () {
-    var _stakeBalanceOf = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(user) {
+  _proto.getCollateralRatio = /*#__PURE__*/function () {
+    var _getCollateralRatio = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
       return runtime_1.wrap(function _callee5$(_context5) {
         while (1) {
           switch (_context5.prev = _context5.next) {
             case 0:
-              return _context5.abrupt("return", new TokenAmount(dummyPlyAurora, '103.4', false));
+              return _context5.abrupt("return", this._comptroller.markets(this.auToken.address).then(function (res) {
+                return new BigNumber(res.collateralFactorMantissa.toString()).div(decimalFactor(18));
+              }));
 
             case 1:
             case "end":
               return _context5.stop();
           }
         }
-      }, _callee5);
+      }, _callee5, this);
     }));
 
-    function stakeBalanceOf(_x3) {
-      return _stakeBalanceOf.apply(this, arguments);
+    function getCollateralRatio() {
+      return _getCollateralRatio.apply(this, arguments);
     }
 
-    return stakeBalanceOf;
+    return getCollateralRatio;
   }();
 
-  return SdkRead;
-}(BlockchainEntityRead);
-var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
-  _inheritsLoose(SdkReadWrite, _SdkRead);
-
-  function SdkReadWrite() {
-    var _this;
-
-    _this = _SdkRead.apply(this, arguments) || this;
-    _this.dummyTransaction = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6() {
+  _proto.getDetails = /*#__PURE__*/function () {
+    var _getDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6() {
+      var promises, totalDeposited, totalBorrowed, depositAPY, borrowAPY, collateralRatio;
       return runtime_1.wrap(function _callee6$(_context6) {
         while (1) {
           switch (_context6.prev = _context6.next) {
             case 0:
-              return _context6.abrupt("return", {});
+              promises = [];
+              promises.push(this.getTotalTokenDeposited().then(function (res) {
+                totalDeposited = res;
+              }));
+              promises.push(this.getTotalTokenBorrowed().then(function (res) {
+                totalBorrowed = res;
+              }));
+              promises.push(this.getDepositAPY().then(function (res) {
+                depositAPY = res.toNumber();
+              }));
+              promises.push(this.getBorrowAPY().then(function (res) {
+                borrowAPY = res.toNumber();
+              }));
+              promises.push(this.getCollateralRatio().then(function (res) {
+                collateralRatio = res.toNumber();
+              }));
+              _context6.next = 8;
+              return Promise.all(promises);
+
+            case 8:
+              return _context6.abrupt("return", {
+                auTokenAddress: this.auToken.address,
+                totalTokenDeposited: totalDeposited,
+                totalTokenBorrowed: totalBorrowed,
+                depositApy: depositAPY,
+                depositPlyApy: 0.18,
+                borrowApy: borrowAPY,
+                borrowPlyApy: 0.18,
+                collateralRatio: collateralRatio
+              });
 
-            case 1:
+            case 9:
             case "end":
               return _context6.stop();
           }
         }
-      }, _callee6);
+      }, _callee6, this);
     }));
-    return _this;
-  }
 
-  var _proto2 = SdkReadWrite.prototype;
+    function getDetails() {
+      return _getDetails.apply(this, arguments);
+    }
 
-  _proto2.claim = /*#__PURE__*/function () {
-    var _claim = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7() {
+    return getDetails;
+  }();
+
+  _proto.getUserBorrowBalance = /*#__PURE__*/function () {
+    var _getUserBorrowBalance = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(userAddress) {
+      var totalBorrow;
       return runtime_1.wrap(function _callee7$(_context7) {
         while (1) {
           switch (_context7.prev = _context7.next) {
             case 0:
-              return _context7.abrupt("return", this.dummyTransaction());
+              _context7.next = 2;
+              return this.auToken.callStatic.borrowBalanceCurrent(userAddress);
 
-            case 1:
+            case 2:
+              totalBorrow = _context7.sent;
+              return _context7.abrupt("return", new TokenAmount(this.underlying, totalBorrow.toString()));
+
+            case 4:
             case "end":
               return _context7.stop();
           }
@@ -1110,22 +1306,28 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
       }, _callee7, this);
     }));
 
-    function claim() {
-      return _claim.apply(this, arguments);
+    function getUserBorrowBalance(_x) {
+      return _getUserBorrowBalance.apply(this, arguments);
     }
 
-    return claim;
+    return getUserBorrowBalance;
   }();
 
-  _proto2.stake = /*#__PURE__*/function () {
-    var _stake = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(amount) {
+  _proto.getUserDepositBalance = /*#__PURE__*/function () {
+    var _getUserDepositBalance = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(userAddress) {
+      var totalDeposit;
       return runtime_1.wrap(function _callee8$(_context8) {
         while (1) {
           switch (_context8.prev = _context8.next) {
             case 0:
-              return _context8.abrupt("return", this.dummyTransaction());
+              _context8.next = 2;
+              return this.auToken.callStatic.balanceOfUnderlying(userAddress);
 
-            case 1:
+            case 2:
+              totalDeposit = _context8.sent;
+              return _context8.abrupt("return", new TokenAmount(this.underlying, totalDeposit.toString()));
+
+            case 4:
             case "end":
               return _context8.stop();
           }
@@ -1133,22 +1335,43 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
       }, _callee8, this);
     }));
 
-    function stake(_x4) {
-      return _stake.apply(this, arguments);
+    function getUserDepositBalance(_x2) {
+      return _getUserDepositBalance.apply(this, arguments);
     }
 
-    return stake;
+    return getUserDepositBalance;
   }();
 
-  _proto2.unstake = /*#__PURE__*/function () {
-    var _unstake = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(amount) {
+  return MoneyMarketRead;
+}(BlockchainEntityRead);
+var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
+  _inheritsLoose(MoneyMarketReadWrite, _MoneyMarketRead);
+
+  function MoneyMarketReadWrite() {
+    return _MoneyMarketRead.apply(this, arguments) || this;
+  }
+
+  var _proto2 = MoneyMarketReadWrite.prototype;
+
+  _proto2.deposit = /*#__PURE__*/function () {
+    var _deposit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(amount) {
       return runtime_1.wrap(function _callee9$(_context9) {
         while (1) {
           switch (_context9.prev = _context9.next) {
             case 0:
-              return _context9.abrupt("return", this.dummyTransaction());
+              if (!isSameAddress(amount.token.address, ETHAddress)) {
+                _context9.next = 4;
+                break;
+              }
 
-            case 1:
+              return _context9.abrupt("return", this.auToken.connect(this._networkConnection.signer).mint({
+                value: amount.rawAmount()
+              }));
+
+            case 4:
+              return _context9.abrupt("return", this.auToken.connect(this._networkConnection.signer).mint(amount.rawAmount()));
+
+            case 5:
             case "end":
               return _context9.stop();
           }
@@ -1156,148 +1379,168 @@ var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
       }, _callee9, this);
     }));
 
-    function unstake(_x5) {
-      return _unstake.apply(this, arguments);
+    function deposit(_x3) {
+      return _deposit.apply(this, arguments);
     }
 
-    return unstake;
+    return deposit;
   }();
 
-  return SdkReadWrite;
-}(SdkRead);
-var SDK = /*#__PURE__*/function (_BlockchainEntity) {
-  _inheritsLoose(SDK, _BlockchainEntity);
+  _proto2.borrow = /*#__PURE__*/function () {
+    var _borrow = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(amount) {
+      return runtime_1.wrap(function _callee10$(_context10) {
+        while (1) {
+          switch (_context10.prev = _context10.next) {
+            case 0:
+              return _context10.abrupt("return", this.auToken.connect(this._networkConnection.signer).borrow(amount.rawAmount()));
 
-  function SDK() {
-    return _BlockchainEntity.call(this) || this;
-  }
+            case 1:
+            case "end":
+              return _context10.stop();
+          }
+        }
+      }, _callee10, this);
+    }));
 
-  var _proto3 = SDK.prototype;
+    function borrow(_x4) {
+      return _borrow.apply(this, arguments);
+    }
 
-  _proto3.read = function read(provider) {
-    return new SdkRead(provider);
-  };
+    return borrow;
+  }();
 
-  SDK.defaultProvider = function defaultProvider() {
-    return new ethers$1.providers.JsonRpcProvider(AVAX_DEFAULT_PROVIDER_URL);
-  };
+  _proto2.withdraw = /*#__PURE__*/function () {
+    var _withdraw = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(amount) {
+      return runtime_1.wrap(function _callee11$(_context11) {
+        while (1) {
+          switch (_context11.prev = _context11.next) {
+            case 0:
+              return _context11.abrupt("return", this.auToken.connect(this._networkConnection.signer).redeemUnderlying(amount.rawAmount()));
 
-  return SDK;
-}(BlockchainEntity);
+            case 1:
+            case "end":
+              return _context11.stop();
+          }
+        }
+      }, _callee11, this);
+    }));
 
-var abi = [
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "underlying_",
-				type: "address"
-			},
-			{
-				internalType: "contract ComptrollerInterface",
-				name: "comptroller_",
-				type: "address"
-			},
-			{
-				internalType: "contract InterestRateModel",
-				name: "interestRateModel_",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "initialExchangeRateMantissa_",
-				type: "uint256"
-			},
-			{
-				internalType: "string",
-				name: "name_",
-				type: "string"
-			},
-			{
-				internalType: "string",
-				name: "symbol_",
-				type: "string"
-			},
-			{
-				internalType: "uint8",
-				name: "decimals_",
-				type: "uint8"
-			},
-			{
-				internalType: "address payable",
-				name: "admin_",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "implementation_",
-				type: "address"
-			},
-			{
-				internalType: "bytes",
-				name: "becomeImplementationData",
-				type: "bytes"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "constructor"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "cashPrior",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "interestAccumulated",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "borrowIndex",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "totalBorrows",
-				type: "uint256"
-			}
-		],
-		name: "AccrueInterest",
-		type: "event"
-	},
+    function withdraw(_x5) {
+      return _withdraw.apply(this, arguments);
+    }
+
+    return withdraw;
+  }();
+
+  _proto2.repay = /*#__PURE__*/function () {
+    var _repay = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(amount) {
+      return runtime_1.wrap(function _callee12$(_context12) {
+        while (1) {
+          switch (_context12.prev = _context12.next) {
+            case 0:
+              if (!isSameAddress(amount.token.address, ETHAddress)) {
+                _context12.next = 4;
+                break;
+              }
+
+              return _context12.abrupt("return", this.auToken.connect(this._networkConnection.signer).repayBorrow({
+                value: amount.rawAmount()
+              }));
+
+            case 4:
+              return _context12.abrupt("return", this.auToken.connect(this._networkConnection.signer).repayBorrow(amount.rawAmount()));
+
+            case 5:
+            case "end":
+              return _context12.stop();
+          }
+        }
+      }, _callee12, this);
+    }));
+
+    function repay(_x6) {
+      return _repay.apply(this, arguments);
+    }
+
+    return repay;
+  }();
+
+  _proto2.enableCollateral = /*#__PURE__*/function () {
+    var _enableCollateral = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13() {
+      return runtime_1.wrap(function _callee13$(_context13) {
+        while (1) {
+          switch (_context13.prev = _context13.next) {
+            case 0:
+              return _context13.abrupt("return", this._comptroller.connect(this._networkConnection.signer).enterMarkets([this.auToken.address]));
+
+            case 1:
+            case "end":
+              return _context13.stop();
+          }
+        }
+      }, _callee13, this);
+    }));
+
+    function enableCollateral() {
+      return _enableCollateral.apply(this, arguments);
+    }
+
+    return enableCollateral;
+  }();
+
+  _proto2.disableCollateral = /*#__PURE__*/function () {
+    var _disableCollateral = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee14() {
+      return runtime_1.wrap(function _callee14$(_context14) {
+        while (1) {
+          switch (_context14.prev = _context14.next) {
+            case 0:
+              return _context14.abrupt("return", this._comptroller.connect(this._networkConnection.signer).exitMarket(this.auToken.address));
+
+            case 1:
+            case "end":
+              return _context14.stop();
+          }
+        }
+      }, _callee14, this);
+    }));
+
+    function disableCollateral() {
+      return _disableCollateral.apply(this, arguments);
+    }
+
+    return disableCollateral;
+  }();
+
+  return MoneyMarketReadWrite;
+}(MoneyMarketRead);
+var MoneyMarket = /*#__PURE__*/function (_BlockchainEntity) {
+  _inheritsLoose(MoneyMarket, _BlockchainEntity);
+
+  function MoneyMarket(address, underlying) {
+    var _this3;
+
+    _this3 = _BlockchainEntity.call(this) || this;
+    _this3.address = validateAndParseAddress(address);
+    _this3.underlying = validateAndParseAddress(underlying);
+    return _this3;
+  }
+
+  var _proto3 = MoneyMarket.prototype;
+
+  _proto3.read = function read(networkConnection) {
+    return new MoneyMarketRead(networkConnection, this.address, this.underlying);
+  };
+
+  return MoneyMarket;
+}(BlockchainEntity);
+
+var abi = [
 	{
-		anonymous: false,
 		inputs: [
-			{
-				indexed: true,
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			},
-			{
-				indexed: true,
-				internalType: "address",
-				name: "spender",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
-			}
 		],
-		name: "Approval",
-		type: "event"
+		payable: false,
+		stateMutability: "nonpayable",
+		type: "constructor"
 	},
 	{
 		anonymous: false,
@@ -1305,54 +1548,17 @@ var abi = [
 			{
 				indexed: false,
 				internalType: "address",
-				name: "borrower",
+				name: "feed",
 				type: "address"
 			},
 			{
 				indexed: false,
-				internalType: "uint256",
-				name: "borrowAmount",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "accountBorrows",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "totalBorrows",
-				type: "uint256"
-			}
-		],
-		name: "Borrow",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "error",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "info",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "detail",
-				type: "uint256"
+				internalType: "string",
+				name: "symbol",
+				type: "string"
 			}
 		],
-		name: "Failure",
+		name: "FeedSet",
 		type: "event"
 	},
 	{
@@ -1361,35 +1567,17 @@ var abi = [
 			{
 				indexed: false,
 				internalType: "address",
-				name: "liquidator",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "address",
-				name: "borrower",
+				name: "oldAdmin",
 				type: "address"
 			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "repayAmount",
-				type: "uint256"
-			},
 			{
 				indexed: false,
 				internalType: "address",
-				name: "qiTokenCollateral",
+				name: "newAdmin",
 				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "seizeTokens",
-				type: "uint256"
 			}
 		],
-		name: "LiquidateBorrow",
+		name: "NewAdmin",
 		type: "event"
 	},
 	{
@@ -1398,520 +1586,30 @@ var abi = [
 			{
 				indexed: false,
 				internalType: "address",
-				name: "minter",
+				name: "asset",
 				type: "address"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "mintAmount",
+				name: "previousPriceMantissa",
 				type: "uint256"
 			},
 			{
 				indexed: false,
 				internalType: "uint256",
-				name: "mintTokens",
+				name: "requestedPriceMantissa",
 				type: "uint256"
-			}
-		],
-		name: "Mint",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "oldAdmin",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "address",
-				name: "newAdmin",
-				type: "address"
-			}
-		],
-		name: "NewAdmin",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "contract ComptrollerInterface",
-				name: "oldComptroller",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "contract ComptrollerInterface",
-				name: "newComptroller",
-				type: "address"
-			}
-		],
-		name: "NewComptroller",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "oldImplementation",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "address",
-				name: "newImplementation",
-				type: "address"
-			}
-		],
-		name: "NewImplementation",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "contract InterestRateModel",
-				name: "oldInterestRateModel",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "contract InterestRateModel",
-				name: "newInterestRateModel",
-				type: "address"
-			}
-		],
-		name: "NewMarketInterestRateModel",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "oldPendingAdmin",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "address",
-				name: "newPendingAdmin",
-				type: "address"
-			}
-		],
-		name: "NewPendingAdmin",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "oldProtocolSeizeShareMantissa",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "newProtocolSeizeShareMantissa",
-				type: "uint256"
-			}
-		],
-		name: "NewProtocolSeizeShare",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "oldReserveFactorMantissa",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "newReserveFactorMantissa",
-				type: "uint256"
-			}
-		],
-		name: "NewReserveFactor",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "redeemer",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "redeemAmount",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "redeemTokens",
-				type: "uint256"
-			}
-		],
-		name: "Redeem",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "payer",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "address",
-				name: "borrower",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "repayAmount",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "accountBorrows",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "totalBorrows",
-				type: "uint256"
-			}
-		],
-		name: "RepayBorrow",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "benefactor",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "addAmount",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "newTotalReserves",
-				type: "uint256"
-			}
-		],
-		name: "ReservesAdded",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: false,
-				internalType: "address",
-				name: "admin",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "reduceAmount",
-				type: "uint256"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "newTotalReserves",
-				type: "uint256"
-			}
-		],
-		name: "ReservesReduced",
-		type: "event"
-	},
-	{
-		anonymous: false,
-		inputs: [
-			{
-				indexed: true,
-				internalType: "address",
-				name: "from",
-				type: "address"
-			},
-			{
-				indexed: true,
-				internalType: "address",
-				name: "to",
-				type: "address"
-			},
-			{
-				indexed: false,
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
-			}
-		],
-		name: "Transfer",
-		type: "event"
-	},
-	{
-		payable: true,
-		stateMutability: "payable",
-		type: "fallback"
-	},
-	{
-		constant: false,
-		inputs: [
-		],
-		name: "_acceptAdmin",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "uint256",
-				name: "addAmount",
-				type: "uint256"
-			}
-		],
-		name: "_addReserves",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "uint256",
-				name: "reduceAmount",
-				type: "uint256"
-			}
-		],
-		name: "_reduceReserves",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "contract ComptrollerInterface",
-				name: "newComptroller",
-				type: "address"
-			}
-		],
-		name: "_setComptroller",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "address",
-				name: "implementation_",
-				type: "address"
-			},
-			{
-				internalType: "bool",
-				name: "allowResign",
-				type: "bool"
-			},
-			{
-				internalType: "bytes",
-				name: "becomeImplementationData",
-				type: "bytes"
-			}
-		],
-		name: "_setImplementation",
-		outputs: [
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "contract InterestRateModel",
-				name: "newInterestRateModel",
-				type: "address"
-			}
-		],
-		name: "_setInterestRateModel",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "address payable",
-				name: "newPendingAdmin",
-				type: "address"
-			}
-		],
-		name: "_setPendingAdmin",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "uint256",
-				name: "newProtocolSeizeShareMantissa",
-				type: "uint256"
-			}
-		],
-		name: "_setProtocolSeizeShare",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-			{
-				internalType: "uint256",
-				name: "newReserveFactorMantissa",
-				type: "uint256"
-			}
-		],
-		name: "_setReserveFactor",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
-	},
-	{
-		constant: true,
-		inputs: [
-		],
-		name: "accrualBlockTimestamp",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
-		],
-		name: "accrueInterest",
-		outputs: [
+			},
 			{
+				indexed: false,
 				internalType: "uint256",
-				name: "",
+				name: "newPriceMantissa",
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
+		name: "PricePosted",
+		type: "event"
 	},
 	{
 		constant: true,
@@ -1920,7 +1618,7 @@ var abi = [
 		name: "admin",
 		outputs: [
 			{
-				internalType: "address payable",
+				internalType: "address",
 				name: "",
 				type: "address"
 			}
@@ -1934,16 +1632,11 @@ var abi = [
 		inputs: [
 			{
 				internalType: "address",
-				name: "owner",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "spender",
+				name: "asset",
 				type: "address"
 			}
 		],
-		name: "allowance",
+		name: "assetPrices",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -1956,41 +1649,36 @@ var abi = [
 		type: "function"
 	},
 	{
-		constant: false,
+		constant: true,
 		inputs: [
 			{
-				internalType: "address",
-				name: "spender",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "amount",
-				type: "uint256"
+				internalType: "string",
+				name: "symbol",
+				type: "string"
 			}
 		],
-		name: "approve",
+		name: "getFeed",
 		outputs: [
 			{
-				internalType: "bool",
+				internalType: "contract AggregatorV2V3Interface",
 				name: "",
-				type: "bool"
+				type: "address"
 			}
 		],
 		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
 		constant: true,
 		inputs: [
 			{
-				internalType: "address",
-				name: "owner",
+				internalType: "contract QiToken",
+				name: "qiToken",
 				type: "address"
 			}
 		],
-		name: "balanceOf",
+		name: "getUnderlyingPrice",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2003,42 +1691,32 @@ var abi = [
 		type: "function"
 	},
 	{
-		constant: false,
+		constant: true,
 		inputs: [
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			}
 		],
-		name: "balanceOfUnderlying",
+		name: "isPriceOracle",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "bool",
 				name: "",
-				type: "uint256"
+				type: "bool"
 			}
 		],
 		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
 		constant: false,
 		inputs: [
 			{
-				internalType: "uint256",
-				name: "borrowAmount",
-				type: "uint256"
+				internalType: "address",
+				name: "newAdmin",
+				type: "address"
 			}
 		],
-		name: "borrow",
+		name: "setAdmin",
 		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
 		],
 		payable: false,
 		stateMutability: "nonpayable",
@@ -2049,222 +1727,259 @@ var abi = [
 		inputs: [
 			{
 				internalType: "address",
-				name: "account",
+				name: "asset",
 				type: "address"
-			}
-		],
-		name: "borrowBalanceCurrent",
-		outputs: [
+			},
 			{
 				internalType: "uint256",
-				name: "",
+				name: "price",
 				type: "uint256"
 			}
 		],
+		name: "setDirectPrice",
+		outputs: [
+		],
 		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
+		constant: false,
 		inputs: [
+			{
+				internalType: "string",
+				name: "symbol",
+				type: "string"
+			},
 			{
 				internalType: "address",
-				name: "account",
+				name: "feed",
 				type: "address"
 			}
 		],
-		name: "borrowBalanceStored",
+		name: "setFeed",
 		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
 		],
 		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
+		constant: false,
 		inputs: [
-		],
-		name: "borrowIndex",
-		outputs: [
+			{
+				internalType: "contract QiToken",
+				name: "qiToken",
+				type: "address"
+			},
 			{
 				internalType: "uint256",
-				name: "",
+				name: "underlyingPriceMantissa",
 				type: "uint256"
 			}
 		],
+		name: "setUnderlyingPrice",
+		outputs: [
+		],
 		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
-	},
+	}
+];
+var OracleABI = {
+	abi: abi
+};
+
+var _format = "hh-sol-artifact-1";
+var contractName = "IUniswapV2Pair";
+var sourceName = "contracts/interfaces/IUniswapV2Pair.sol";
+var abi$1 = [
 	{
-		constant: true,
+		anonymous: false,
 		inputs: [
-		],
-		name: "borrowRatePerTimestamp",
-		outputs: [
 			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				indexed: false,
 				internalType: "uint256",
-				name: "",
+				name: "value",
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
+		name: "Approval",
+		type: "event"
 	},
 	{
-		constant: true,
+		anonymous: false,
 		inputs: [
-		],
-		name: "comptroller",
-		outputs: [
 			{
-				internalType: "contract ComptrollerInterface",
-				name: "",
+				indexed: true,
+				internalType: "address",
+				name: "sender",
 				type: "address"
-			}
-		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		constant: true,
-		inputs: [
-		],
-		name: "decimals",
-		outputs: [
+			},
 			{
-				internalType: "uint8",
-				name: "",
-				type: "uint8"
-			}
-		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		constant: false,
-		inputs: [
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
 			{
-				internalType: "bytes",
-				name: "data",
-				type: "bytes"
-			}
-		],
-		name: "delegateToImplementation",
-		outputs: [
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
+			},
 			{
-				internalType: "bytes",
-				name: "",
-				type: "bytes"
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
+		name: "Burn",
+		type: "event"
 	},
 	{
-		constant: true,
+		anonymous: false,
 		inputs: [
 			{
-				internalType: "bytes",
-				name: "data",
-				type: "bytes"
-			}
-		],
-		name: "delegateToViewImplementation",
-		outputs: [
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
 			{
-				internalType: "bytes",
-				name: "",
-				type: "bytes"
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1",
+				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
+		name: "Mint",
+		type: "event"
 	},
 	{
-		constant: false,
+		anonymous: false,
 		inputs: [
-		],
-		name: "exchangeRateCurrent",
-		outputs: [
 			{
+				indexed: true,
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				indexed: false,
 				internalType: "uint256",
-				name: "",
+				name: "amount0In",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1In",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount0Out",
+				type: "uint256"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "amount1Out",
 				type: "uint256"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
-		type: "function"
+		name: "Swap",
+		type: "event"
 	},
 	{
-		constant: true,
+		anonymous: false,
 		inputs: [
-		],
-		name: "exchangeRateStored",
-		outputs: [
 			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
+				indexed: false,
+				internalType: "uint112",
+				name: "reserve0",
+				type: "uint112"
+			},
+			{
+				indexed: false,
+				internalType: "uint112",
+				name: "reserve1",
+				type: "uint112"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
+		name: "Sync",
+		type: "event"
 	},
 	{
-		constant: true,
+		anonymous: false,
 		inputs: [
 			{
+				indexed: true,
 				internalType: "address",
-				name: "account",
+				name: "from",
 				type: "address"
-			}
-		],
-		name: "getAccountSnapshot",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
 			},
 			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
 			},
 			{
+				indexed: false,
 				internalType: "uint256",
-				name: "",
+				name: "value",
 				type: "uint256"
-			},
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "DOMAIN_SEPARATOR",
+		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "bytes32",
 				name: "",
-				type: "uint256"
+				type: "bytes32"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "getCash",
+		name: "MINIMUM_LIQUIDITY",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2272,47 +1987,61 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "pure",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "implementation",
+		name: "PERMIT_TYPEHASH",
 		outputs: [
 			{
-				internalType: "address",
+				internalType: "bytes32",
 				name: "",
-				type: "address"
+				type: "bytes32"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "pure",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
 		],
-		name: "interestRateModel",
+		name: "allowance",
 		outputs: [
 			{
-				internalType: "contract InterestRateModel",
+				internalType: "uint256",
 				name: "",
-				type: "address"
+				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
 		],
-		name: "isQiToken",
+		name: "approve",
 		outputs: [
 			{
 				internalType: "bool",
@@ -2320,30 +2049,18 @@ var abi = [
 				type: "bool"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "borrower",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "repayAmount",
-				type: "uint256"
-			},
-			{
-				internalType: "contract QiTokenInterface",
-				name: "qiTokenCollateral",
+				name: "owner",
 				type: "address"
 			}
 		],
-		name: "liquidateBorrow",
+		name: "balanceOf",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2351,110 +2068,108 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "uint256",
-				name: "mintAmount",
-				type: "uint256"
+				internalType: "address",
+				name: "to",
+				type: "address"
 			}
 		],
-		name: "mint",
+		name: "burn",
 		outputs: [
 			{
 				internalType: "uint256",
-				name: "",
+				name: "amount0",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "amount1",
 				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "name",
+		name: "decimals",
 		outputs: [
 			{
-				internalType: "string",
+				internalType: "uint8",
 				name: "",
-				type: "string"
+				type: "uint8"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "pure",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "pendingAdmin",
+		name: "factory",
 		outputs: [
 			{
-				internalType: "address payable",
+				internalType: "address",
 				name: "",
 				type: "address"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "protocolSeizeShareMantissa",
+		name: "getReserves",
 		outputs: [
 			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
+				internalType: "uint112",
+				name: "reserve0",
+				type: "uint112"
+			},
+			{
+				internalType: "uint112",
+				name: "reserve1",
+				type: "uint112"
+			},
+			{
+				internalType: "uint32",
+				name: "blockTimestampLast",
+				type: "uint32"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "uint256",
-				name: "redeemTokens",
-				type: "uint256"
-			}
-		],
-		name: "redeem",
-		outputs: [
+				internalType: "address",
+				name: "",
+				type: "address"
+			},
 			{
-				internalType: "uint256",
+				internalType: "address",
 				name: "",
-				type: "uint256"
+				type: "address"
 			}
 		],
-		payable: false,
+		name: "initialize",
+		outputs: [
+		],
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
-			{
-				internalType: "uint256",
-				name: "redeemAmount",
-				type: "uint256"
-			}
 		],
-		name: "redeemUnderlying",
+		name: "kLast",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2462,62 +2177,51 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "uint256",
-				name: "repayAmount",
-				type: "uint256"
+				internalType: "address",
+				name: "to",
+				type: "address"
 			}
 		],
-		name: "repayBorrow",
+		name: "mint",
 		outputs: [
 			{
 				internalType: "uint256",
-				name: "",
+				name: "liquidity",
 				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
-			{
-				internalType: "address",
-				name: "borrower",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "repayAmount",
-				type: "uint256"
-			}
 		],
-		name: "repayBorrowBehalf",
+		name: "name",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "string",
 				name: "",
-				type: "uint256"
+				type: "string"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "pure",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
 		],
-		name: "reserveFactorMantissa",
+		name: "nonces",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2525,30 +2229,57 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "liquidator",
+				name: "owner",
 				type: "address"
 			},
 			{
 				internalType: "address",
-				name: "borrower",
+				name: "spender",
 				type: "address"
 			},
 			{
 				internalType: "uint256",
-				name: "seizeTokens",
+				name: "value",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "deadline",
 				type: "uint256"
+			},
+			{
+				internalType: "uint8",
+				name: "v",
+				type: "uint8"
+			},
+			{
+				internalType: "bytes32",
+				name: "r",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
 			}
 		],
-		name: "seize",
+		name: "permit",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "price0CumulativeLast",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2556,15 +2287,13 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "supplyRatePerTimestamp",
+		name: "price1CumulativeLast",
 		outputs: [
 			{
 				internalType: "uint256",
@@ -2572,28 +2301,53 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
-				internalType: "contract EIP20NonStandardInterface",
-				name: "token",
+				internalType: "address",
+				name: "to",
 				type: "address"
 			}
 		],
-		name: "sweepToken",
+		name: "skim",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "amount0Out",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "amount1Out",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "bytes",
+				name: "data",
+				type: "bytes"
+			}
+		],
+		name: "swap",
 		outputs: [
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
 		name: "symbol",
@@ -2604,60 +2358,47 @@ var abi = [
 				type: "string"
 			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "pure",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "totalBorrows",
+		name: "sync",
 		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
 		],
-		payable: false,
-		stateMutability: "view",
+		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 		],
-		name: "totalBorrowsCurrent",
+		name: "token0",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "address",
 				name: "",
-				type: "uint256"
+				type: "address"
 			}
 		],
-		payable: false,
-		stateMutability: "nonpayable",
+		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
-		name: "totalReserves",
+		name: "token1",
 		outputs: [
 			{
-				internalType: "uint256",
+				internalType: "address",
 				name: "",
-				type: "uint256"
+				type: "address"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: true,
 		inputs: [
 		],
 		name: "totalSupply",
@@ -2668,21 +2409,19 @@ var abi = [
 				type: "uint256"
 			}
 		],
-		payable: false,
 		stateMutability: "view",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "dst",
+				name: "to",
 				type: "address"
 			},
 			{
 				internalType: "uint256",
-				name: "amount",
+				name: "value",
 				type: "uint256"
 			}
 		],
@@ -2694,26 +2433,24 @@ var abi = [
 				type: "bool"
 			}
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
 	},
 	{
-		constant: false,
 		inputs: [
 			{
 				internalType: "address",
-				name: "src",
+				name: "from",
 				type: "address"
 			},
 			{
 				internalType: "address",
-				name: "dst",
+				name: "to",
 				type: "address"
 			},
 			{
 				internalType: "uint256",
-				name: "amount",
+				name: "value",
 				type: "uint256"
 			}
 		],
@@ -2725,113 +2462,553 @@ var abi = [
 				type: "bool"
 			}
 		],
-		payable: false,
 		stateMutability: "nonpayable",
 		type: "function"
-	},
-	{
-		constant: true,
-		inputs: [
-		],
-		name: "underlying",
-		outputs: [
-			{
-				internalType: "address",
-				name: "",
-				type: "address"
-			}
-		],
-		payable: false,
-		stateMutability: "view",
-		type: "function"
 	}
 ];
-var AuToken = {
-	abi: abi
+var bytecode = "0x";
+var deployedBytecode = "0x";
+var linkReferences = {
+};
+var deployedLinkReferences = {
+};
+var IUniswapV2PairABI = {
+	_format: _format,
+	contractName: contractName,
+	sourceName: sourceName,
+	abi: abi$1,
+	bytecode: bytecode,
+	deployedBytecode: deployedBytecode,
+	linkReferences: linkReferences,
+	deployedLinkReferences: deployedLinkReferences
 };
 
-var MoneyMarketRead = /*#__PURE__*/function (_BlockchainEntityRead) {
-  _inheritsLoose(MoneyMarketRead, _BlockchainEntityRead);
+var abi$2 = [
+];
+var dummyABI = {
+	abi: abi$2
+};
+
+var axios = /*#__PURE__*/require('axios');
+
+function fetchPriceFromCoingecko(_x) {
+  return _fetchPriceFromCoingecko.apply(this, arguments);
+}
+
+function _fetchPriceFromCoingecko() {
+  _fetchPriceFromCoingecko = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(id) {
+    var price;
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return axios.get("https://api.coingecko.com/api/v3/simple/price?ids=" + id + "&vs_currencies=usd").then(function (res) {
+              return res.data;
+            });
+
+          case 2:
+            price = _context.sent;
+            return _context.abrupt("return", new BigNumber(price[id].usd));
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _fetchPriceFromCoingecko.apply(this, arguments);
+}
+
+function fetchBasicTokenPrice(_x2) {
+  return _fetchBasicTokenPrice.apply(this, arguments);
+}
+
+function _fetchBasicTokenPrice() {
+  _fetchBasicTokenPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(address) {
+    return runtime_1.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!isSameAddress(address, networkAddresses.tokens.AURORA)) {
+              _context2.next = 4;
+              break;
+            }
+
+            return _context2.abrupt("return", fetchPriceFromCoingecko('aurora-near'));
+
+          case 4:
+            throw Error("Unknown token " + address + " in fetchBasicTokenPrice");
+
+          case 5:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _fetchBasicTokenPrice.apply(this, arguments);
+}
+
+function fetchLPPositions(_x3, _x4) {
+  return _fetchLPPositions.apply(this, arguments);
+}
+
+function _fetchLPPositions() {
+  _fetchLPPositions = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(LPAddress, provider) {
+    var promises, LPContract, values;
+    return runtime_1.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            promises = [];
+            LPContract = new ethers$1.Contract(LPAddress, IUniswapV2PairABI.abi, provider);
+            promises.push(LPContract.token0());
+            promises.push(LPContract.toekn1());
+            promises.push(LPContract.getReserves());
+            promises.push(LPContract.totalSupply());
+            _context3.next = 8;
+            return Promise.all(promises);
+
+          case 8:
+            values = _context3.sent;
+            return _context3.abrupt("return", {
+              token0: values[0],
+              token1: values[1],
+              reserve0: values[2]._reserve0,
+              reserve1: values[2]._reserve1,
+              totalSupply: values[3]
+            });
+
+          case 10:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _fetchLPPositions.apply(this, arguments);
+}
+
+function fetchLPPrice(_x5, _x6) {
+  return _fetchLPPrice.apply(this, arguments);
+}
+
+function _fetchLPPrice() {
+  _fetchLPPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(address, provider) {
+    var LPInfo, token0Price, reserveUSD, token1Price, _reserveUSD;
+
+    return runtime_1.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return fetchLPPositions(address, provider);
+
+          case 2:
+            LPInfo = _context4.sent;
+            _context4.prev = 3;
+            _context4.next = 6;
+            return fetchPrice(LPInfo.token0, provider);
+
+          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 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);
+            throw Error("Unable to fetch price for both tokens of LP " + address);
+
+          case 24:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4, null, [[3, 11], [13, 21]]);
+  }));
+  return _fetchLPPrice.apply(this, arguments);
+}
+
+function processPriceFromOracle(rawPrice, underlyingDecimal) {
+  return new BigNumber(rawPrice.toString()).div(decimalFactor(36 - underlyingDecimal));
+}
 
-  function MoneyMarketRead(providerOrSigner, auToken) {
+function fetchPriceFromOracle(_x7, _x8, _x9) {
+  return _fetchPriceFromOracle.apply(this, arguments);
+}
+
+function _fetchPriceFromOracle() {
+  _fetchPriceFromOracle = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(auTokenAddress, underlyingDecimal, provider) {
+    var oracleContract, rawPrice;
+    return runtime_1.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            oracleContract = new ethers$1.Contract(networkAddresses.misc.oracle, OracleABI.abi, provider);
+            _context5.next = 3;
+            return oracleContract.getUnderlyingPrice(auTokenAddress);
+
+          case 3:
+            rawPrice = _context5.sent;
+            return _context5.abrupt("return", processPriceFromOracle(rawPrice, underlyingDecimal));
+
+          case 5:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _fetchPriceFromOracle.apply(this, arguments);
+}
+
+function fetchUnderlyingTokensPrices(_x10) {
+  return _fetchUnderlyingTokensPrices.apply(this, arguments);
+}
+
+function _fetchUnderlyingTokensPrices() {
+  _fetchUnderlyingTokensPrices = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(provider) {
+    var auriLens, auTokenAddresses, underlyingDecimals, rawPrices;
+    return runtime_1.wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            auriLens = new ethers$1.Contract(networkAddresses.misc.AURILENS, dummyABI.abi, provider);
+            auTokenAddresses = networkAddresses.auTokens.map(function (auToken) {
+              return auToken.address;
+            });
+            underlyingDecimals = networkAddresses.auTokens.map(function (auToken) {
+              return getDecimal(auToken.underlying);
+            });
+            _context6.next = 5;
+            return auriLens.auTokenUnderlyingPriceAll(auTokenAddresses);
+
+          case 5:
+            rawPrices = _context6.sent;
+            return _context6.abrupt("return", rawPrices.map(function (res, ind) {
+              return {
+                auToken: res.auToken,
+                underlyingPrice: processPriceFromOracle(res.underlyingPrice, underlyingDecimals[ind])
+              };
+            }));
+
+          case 7:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6);
+  }));
+  return _fetchUnderlyingTokensPrices.apply(this, arguments);
+}
+
+function fetchPrice(_x11, _x12) {
+  return _fetchPrice.apply(this, arguments);
+}
+
+function _fetchPrice() {
+  _fetchPrice = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(address, provider) {
+    var matchingAuToken;
+    return runtime_1.wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            matchingAuToken = networkAddresses.auTokens.find(function (auToken) {
+              return isSameAddress(auToken.underlying, address);
+            });
+
+            if (!(matchingAuToken !== undefined)) {
+              _context7.next = 5;
+              break;
+            }
+
+            return _context7.abrupt("return", fetchPriceFromOracle(matchingAuToken.address, getDecimal(address), provider));
+
+          case 5:
+            if (!isSameAddress(address, networkAddresses.misc.AUPLYLP)) {
+              _context7.next = 9;
+              break;
+            }
+
+            return _context7.abrupt("return", fetchLPPrice(address, provider));
+
+          case 9:
+            return _context7.abrupt("return", fetchBasicTokenPrice(address));
+
+          case 10:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7);
+  }));
+  return _fetchPrice.apply(this, arguments);
+}
+
+function fetchValuation(_x13, _x14, _x15) {
+  return _fetchValuation.apply(this, arguments);
+}
+
+function _fetchValuation() {
+  _fetchValuation = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(tokenAmount, provider, price) {
+    return runtime_1.wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            return _context8.abrupt("return", new BigNumber(0));
+
+          case 1:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee8);
+  }));
+  return _fetchValuation.apply(this, arguments);
+}
+
+var SdkRead = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(SdkRead, _BlockchainEntityRead);
+
+  function SdkRead(networkConnection) {
     var _this;
 
-    _this = _BlockchainEntityRead.call(this, providerOrSigner) || this;
-    _this._auToken = new ethers$2.Contract(auToken, AuToken.abi, providerOrSigner);
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    _this._comptroller = new ethers$1.Contract(networkAddresses.misc.COMPTROLLER, ComptrollerABI.abi, networkConnection.provider);
+    _this._tokenLock = new ethers$1.Contract(networkAddresses.misc.TOKENLOCK, TokenLockABI.abi, networkConnection.provider);
+    _this._auriFairLaunch = new ethers$1.Contract(networkAddresses.misc.AURIFAIRLAUNCH, AuriFairLaunchABI.abi, networkConnection.provider);
+    _this._auriLens = new ethers$1.Contract(networkAddresses.misc.AURILENS, dummyABI.abi, networkConnection.provider);
     return _this;
   }
 
-  var _proto = MoneyMarketRead.prototype;
+  var _proto = SdkRead.prototype;
 
-  _proto.getDetails = /*#__PURE__*/function () {
-    var _getDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+  _proto.getLockingDetails = /*#__PURE__*/function () {
+    var _getLockingDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
+      var currentTime, currentWeek, denominator, promises, values;
       return runtime_1.wrap(function _callee$(_context) {
         while (1) {
           switch (_context.prev = _context.next) {
             case 0:
+              _context.next = 2;
+              return getCurrentTimestamp(this._networkConnection.provider);
+
+            case 2:
+              currentTime = _context.sent;
+              currentWeek = ethers$1.BigNumber.from(currentTime - REWARDCLAIMSTART).div(7 * ONE_DAY).toNumber();
+              denominator = 10000;
+              promises = [];
+              promises.push(this._tokenLock.percentageLock(currentWeek));
+              promises.push(this._tokenLock.percentageLock(currentWeek + 1)["catch"](function (err) {
+                return denominator;
+              }));
+              _context.next = 10;
+              return Promise.all(promises).then(function (res) {
+                return res.map(function (v) {
+                  return v.toString();
+                });
+              });
+
+            case 10:
+              values = _context.sent;
               return _context.abrupt("return", {
-                auTokenAddress: '0x1111111111111111111111111111111111111111',
-                totalTokenDeposited: dummyTokenAmount,
-                totalTokenBorrowed: dummyTokenAmount2,
-                depositApy: 0.1234,
-                depositPlyApy: 0.2345,
-                borrowApy: 0.24,
-                borrowPlyApy: 0.18,
-                collateralRatio: 0.7
+                vestingStart: REWARDCLAIMSTART,
+                currentUnlockPortion: new BigNumber(values[0]).div(denominator).toNumber(),
+                nextUnlockPortion: new BigNumber(values[1]).div(denominator).toNumber()
               });
 
-            case 1:
+            case 12:
             case "end":
               return _context.stop();
           }
         }
-      }, _callee);
+      }, _callee, this);
     }));
 
-    function getDetails() {
-      return _getDetails.apply(this, arguments);
+    function getLockingDetails() {
+      return _getLockingDetails.apply(this, arguments);
     }
 
-    return getDetails;
+    return getLockingDetails;
   }();
 
-  return MoneyMarketRead;
-}(BlockchainEntityRead);
-var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
-  _inheritsLoose(MoneyMarketReadWrite, _MoneyMarketRead);
+  _proto.getUserDetails = /*#__PURE__*/function () {
+    var _getUserDetails = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(userAddress) {
+      var _this2 = this;
 
-  function MoneyMarketReadWrite() {
-    var _this2;
+      var marketCount, userMarketDetails, assetsIn, collateralRatio, promises, totalBorrowLimit, pricePromises, _loop2, _iterator, _step, underlyingPrices, depositValuationPromises, _loop, i, depositValues, accountLiquidity, rewardBalancesMetadata, lockedAmount, values, borrowedvaluation, bufferedBorrowLimit, borrowableAmount, auToken, moneyMarket;
 
-    _this2 = _MoneyMarketRead.apply(this, arguments) || this;
-    _this2.dummyTransaction = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2() {
       return runtime_1.wrap(function _callee2$(_context2) {
         while (1) {
           switch (_context2.prev = _context2.next) {
             case 0:
-              return _context2.abrupt("return", {});
+              marketCount = networkAddresses.auTokens.length;
+              userMarketDetails = [];
+              promises = [];
+              totalBorrowLimit = new BigNumber(0);
+              pricePromises = [];
+
+              _loop2 = function _loop2() {
+                var auToken = _step.value;
+                var userMarketDetail = {};
+                userMarketDetails.push(userMarketDetail);
+                userMarketDetail.market = auToken.underlying;
+                var moneyMarket = new MoneyMarketRead(_this2._networkConnection, auToken.address, auToken.underlying);
+                promises.push(moneyMarket.getUserDepositBalance(userAddress).then(function (res) {
+                  userMarketDetail.depositBalance = res;
+                }));
+                promises.push(moneyMarket.getUserBorrowBalance(userAddress).then(function (res) {
+                  userMarketDetail.borrowBalance = res;
+                }));
+                promises.push(moneyMarket.getCollateralRatio().then(function (res) {
+                  collateralRatio[i] = res;
+                }));
+                pricePromises.push(fetchPrice(moneyMarket.underlying.address, _this2._networkConnection.provider));
+              };
+
+              for (_iterator = _createForOfIteratorHelperLoose(networkAddresses.auTokens); !(_step = _iterator()).done;) {
+                _loop2();
+              }
 
-            case 1:
+              promises.push(this._comptroller.getAssetsIn(userAddress).then(function (res) {
+                assetsIn = res;
+              }));
+              _context2.next = 10;
+              return Promise.all(promises);
+
+            case 10:
+              _context2.next = 12;
+              return Promise.all(pricePromises);
+
+            case 12:
+              underlyingPrices = _context2.sent;
+              depositValuationPromises = [];
+
+              _loop = function _loop() {
+                var auToken = networkAddresses.auTokens[i];
+
+                if (assetsIn.filter(function (auAddress) {
+                  isSameAddress(auToken.address, auAddress);
+                }).length > 0) {
+                  userMarketDetails[i].isCollateral = true;
+                }
+
+                depositValuationPromises.push(fetchValuation(userMarketDetails[i].depositBalance, _this2._networkConnection.provider, underlyingPrices[i]));
+              };
+
+              for (i = 0; i < marketCount; i++) {
+                _loop();
+              }
+
+              _context2.next = 18;
+              return Promise.all(depositValuationPromises);
+
+            case 18:
+              depositValues = _context2.sent;
+              totalBorrowLimit = depositValues.reduce(function (p, v, index) {
+                if (userMarketDetails[index].isCollateral) return p.plus(v.multipliedBy(collateralRatio[index]));
+                return p;
+              });
+              promises = [];
+              promises.push(this._comptroller.getAccountLiquidity(userAddress));
+              promises.push(this._auriLens.getRewardBalancesMetadata(this._comptroller.address, userAddress));
+              promises.push(this._tokenLock.lockedAmounts(userAddress));
+              _context2.next = 26;
+              return Promise.all(promises);
+
+            case 26:
+              values = _context2.sent;
+              accountLiquidity = values[0];
+              rewardBalancesMetadata = values[1];
+              lockedAmount = values[2];
+              borrowedvaluation = totalBorrowLimit.minus(new BigNumber(accountLiquidity[1].toString()).div(decimalFactor(18)));
+              bufferedBorrowLimit = totalBorrowLimit.multipliedBy(BORROW_LIMIT_BUFFER);
+
+              if (bufferedBorrowLimit.lte(borrowedvaluation)) {
+                borrowableAmount = new BigNumber(0);
+              } else {
+                borrowableAmount = bufferedBorrowLimit.minus(borrowedvaluation);
+              }
+
+              for (i = 0; i < marketCount; i++) {
+                auToken = networkAddresses.auTokens[i];
+                moneyMarket = new MoneyMarketRead(this._networkConnection, auToken.address, auToken.underlying);
+                userMarketDetails[i].maxWithdrawableAmount = new TokenAmount(moneyMarket.underlying, borrowableAmount.div(underlyingPrices[i]).toFixed(18));
+              }
+
+              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)
+                }
+              });
+
+            case 35:
             case "end":
               return _context2.stop();
           }
         }
-      }, _callee2);
+      }, _callee2, this);
     }));
-    return _this2;
-  }
 
-  var _proto2 = MoneyMarketReadWrite.prototype;
+    function getUserDetails(_x) {
+      return _getUserDetails.apply(this, arguments);
+    }
 
-  _proto2.deposit = /*#__PURE__*/function () {
-    var _deposit = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(amount) {
+    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) {
         while (1) {
           switch (_context3.prev = _context3.next) {
             case 0:
-              return _context3.abrupt("return", this.dummyTransaction());
+              promises = [];
+              promises.push(this._auriFairLaunch.getPoolInfo(AurPlyPid).then(function (res) {
+                stakedLiquidity = res.totalStake;
+                rewardPerSecond = res.rewardPerSecond;
+              }));
+              _context3.next = 4;
+              return Promise.all(promises);
+
+            case 4:
+              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;
+              }));
+              return _context3.abrupt("return", {
+                totalStakedLiquidity: new TokenAmount(AURPLYToken, stakedLiquidity.toString()),
+                apy: calcLMRewardApr(rewardPerSecondValuation, totalStakeValuation, ONE_DAY * 365).toFixed(DECIMAL_PRECISION)
+              });
 
-            case 1:
+            case 8:
             case "end":
               return _context3.stop();
           }
@@ -2839,22 +3016,31 @@ var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
       }, _callee3, this);
     }));
 
-    function deposit(_x) {
-      return _deposit.apply(this, arguments);
+    function getPlyAuroraPoolDetails() {
+      return _getPlyAuroraPoolDetails.apply(this, arguments);
     }
 
-    return deposit;
+    return getPlyAuroraPoolDetails;
   }();
 
-  _proto2.borrow = /*#__PURE__*/function () {
-    var _borrow = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(amount) {
+  _proto.getTokenPrice = /*#__PURE__*/function () {
+    var _getTokenPrice = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(token) {
+      var price;
       return runtime_1.wrap(function _callee4$(_context4) {
         while (1) {
           switch (_context4.prev = _context4.next) {
             case 0:
-              return _context4.abrupt("return", this.dummyTransaction());
+              _context4.next = 2;
+              return fetchPrice(token.address, this._networkConnection.provider);
 
-            case 1:
+            case 2:
+              price = _context4.sent;
+              return _context4.abrupt("return", {
+                currency: "USD",
+                amount: price.toFixed(DECIMAL_PRECISION)
+              });
+
+            case 4:
             case "end":
               return _context4.stop();
           }
@@ -2862,22 +3048,28 @@ var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
       }, _callee4, this);
     }));
 
-    function borrow(_x2) {
-      return _borrow.apply(this, arguments);
+    function getTokenPrice(_x2) {
+      return _getTokenPrice.apply(this, arguments);
     }
 
-    return borrow;
+    return getTokenPrice;
   }();
 
-  _proto2.withdraw = /*#__PURE__*/function () {
-    var _withdraw = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(amount) {
+  _proto.stakeBalanceOf = /*#__PURE__*/function () {
+    var _stakeBalanceOf = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(user) {
+      var userInfo;
       return runtime_1.wrap(function _callee5$(_context5) {
         while (1) {
           switch (_context5.prev = _context5.next) {
             case 0:
-              return _context5.abrupt("return", this.dummyTransaction());
+              _context5.next = 2;
+              return this._auriFairLaunch.getUserInfo(AurPlyPid, user);
 
-            case 1:
+            case 2:
+              userInfo = _context5.sent;
+              return _context5.abrupt("return", new TokenAmount(AURPLYToken, userInfo.amount.toString()));
+
+            case 4:
             case "end":
               return _context5.stop();
           }
@@ -2885,22 +3077,42 @@ var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
       }, _callee5, this);
     }));
 
-    function withdraw(_x3) {
-      return _withdraw.apply(this, arguments);
+    function stakeBalanceOf(_x3) {
+      return _stakeBalanceOf.apply(this, arguments);
     }
 
-    return withdraw;
+    return stakeBalanceOf;
   }();
 
-  _proto2.repay = /*#__PURE__*/function () {
-    var _repay = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(amount) {
+  return SdkRead;
+}(BlockchainEntityRead);
+var SdkReadWrite = /*#__PURE__*/function (_SdkRead) {
+  _inheritsLoose(SdkReadWrite, _SdkRead);
+
+  function SdkReadWrite() {
+    return _SdkRead.apply(this, arguments) || this;
+  }
+
+  var _proto2 = SdkReadWrite.prototype;
+
+  _proto2.claim = /*#__PURE__*/function () {
+    var _claim = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6() {
       return runtime_1.wrap(function _callee6$(_context6) {
         while (1) {
           switch (_context6.prev = _context6.next) {
             case 0:
-              return _context6.abrupt("return", this.dummyTransaction());
-
-            case 1:
+              _context6.t0 = this._auriLens.connect(this._networkConnection.signer);
+              _context6.t1 = this._comptroller.address;
+              _context6.t2 = this._auriFairLaunch.address;
+              _context6.next = 5;
+              return this._networkConnection.signer.getAddress();
+
+            case 5:
+              _context6.t3 = _context6.sent;
+              _context6.t4 = [AurPlyPid];
+              return _context6.abrupt("return", _context6.t0.claimRewards.call(_context6.t0, _context6.t1, _context6.t2, _context6.t3, _context6.t4));
+
+            case 8:
             case "end":
               return _context6.stop();
           }
@@ -2908,20 +3120,20 @@ var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
       }, _callee6, this);
     }));
 
-    function repay(_x4) {
-      return _repay.apply(this, arguments);
+    function claim() {
+      return _claim.apply(this, arguments);
     }
 
-    return repay;
+    return claim;
   }();
 
-  _proto2.enableCollateral = /*#__PURE__*/function () {
-    var _enableCollateral = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7() {
+  _proto2.stake = /*#__PURE__*/function () {
+    var _stake = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(amount) {
       return runtime_1.wrap(function _callee7$(_context7) {
         while (1) {
           switch (_context7.prev = _context7.next) {
             case 0:
-              return _context7.abrupt("return", this.dummyTransaction());
+              return _context7.abrupt("return", this._auriFairLaunch.connect(this._networkConnection.signer).deposit(AurPlyPid, amount.rawAmount(), false));
 
             case 1:
             case "end":
@@ -2931,20 +3143,20 @@ var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
       }, _callee7, this);
     }));
 
-    function enableCollateral() {
-      return _enableCollateral.apply(this, arguments);
+    function stake(_x4) {
+      return _stake.apply(this, arguments);
     }
 
-    return enableCollateral;
+    return stake;
   }();
 
-  _proto2.disableCollateral = /*#__PURE__*/function () {
-    var _disableCollateral = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8() {
+  _proto2.unstake = /*#__PURE__*/function () {
+    var _unstake = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(amount) {
       return runtime_1.wrap(function _callee8$(_context8) {
         while (1) {
           switch (_context8.prev = _context8.next) {
             case 0:
-              return _context8.abrupt("return", this.dummyTransaction());
+              return _context8.abrupt("return", this._auriFairLaunch.connect(this._networkConnection.signer).withdraw(AurPlyPid, amount.rawAmount()));
 
             case 1:
             case "end":
@@ -2954,53 +3166,77 @@ var MoneyMarketReadWrite = /*#__PURE__*/function (_MoneyMarketRead) {
       }, _callee8, this);
     }));
 
-    function disableCollateral() {
-      return _disableCollateral.apply(this, arguments);
+    function unstake(_x5) {
+      return _unstake.apply(this, arguments);
     }
 
-    return disableCollateral;
+    return unstake;
   }();
 
-  return MoneyMarketReadWrite;
-}(MoneyMarketRead);
-var MoneyMarket = /*#__PURE__*/function (_BlockchainEntity) {
-  _inheritsLoose(MoneyMarket, _BlockchainEntity);
-
-  function MoneyMarket(address) {
-    var _this3;
+  return SdkReadWrite;
+}(SdkRead);
+var SDK = /*#__PURE__*/function (_BlockchainEntity) {
+  _inheritsLoose(SDK, _BlockchainEntity);
 
-    _this3 = _BlockchainEntity.call(this) || this;
-    _this3.address = validateAndParseAddress(address);
-    return _this3;
+  function SDK() {
+    return _BlockchainEntity.call(this) || this;
   }
 
-  var _proto3 = MoneyMarket.prototype;
+  var _proto3 = SDK.prototype;
 
-  _proto3.read = function read(provider) {
-    return new MoneyMarketRead(provider, this.address);
+  _proto3.read = function read(networkConnection) {
+    return new SdkRead(networkConnection);
   };
 
-  return MoneyMarket;
+  SDK.defaultProvider = function defaultProvider() {
+    return new ethers$1.ethers.providers.JsonRpcProvider(AVAX_DEFAULT_PROVIDER_URL);
+  };
+
+  return SDK;
 }(BlockchainEntity);
 
-function sum(a, b) {
-  return a + b;
-}
+var dummyToken = /*#__PURE__*/new Token('0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e', 6);
+var dummyPly = /*#__PURE__*/new Token('0x8729438eb15e2c8b576fcc6aecda6a148776c0f5', 18);
+var dummyPlyAurora = /*#__PURE__*/new Token('0xE530dC2095Ef5653205CF5ea79F8979a7028065c', 18);
+var dummyTokenAmount = /*#__PURE__*/new TokenAmount(dummyToken, '123.456', false);
+var dummyZeroTokenAmount = /*#__PURE__*/new TokenAmount(dummyToken, '0');
+var dummyTokenAmount2 = /*#__PURE__*/new TokenAmount(dummyToken, '456.123', false);
+var dummyTokenAmount3 = /*#__PURE__*/new TokenAmount(dummyToken, '1000.123', false);
+var dummyMarketAddress = '0xbeb5d47a3f720ec0a390d04b4d41ed7d9688bc7f';
+var dummyUserMarketDetails = {
+  market: dummyMarketAddress,
+  depositBalance: dummyTokenAmount2,
+  borrowBalance: dummyZeroTokenAmount,
+  isCollateral: true,
+  maxWithdrawableAmount: dummyTokenAmount
+};
 
+exports.AURORA_CHAINID = AURORA_CHAINID;
+exports.AURPLYToken = AURPLYToken;
 exports.AVAX_DEFAULT_PROVIDER = AVAX_DEFAULT_PROVIDER;
 exports.AVAX_DEFAULT_PROVIDER_URL = AVAX_DEFAULT_PROVIDER_URL;
 exports.AVAX_DEFAULT_SIGNER = AVAX_DEFAULT_SIGNER;
+exports.AurPlyPid = AurPlyPid;
+exports.BORROW_LIMIT_BUFFER = BORROW_LIMIT_BUFFER;
 exports.BlockchainEntity = BlockchainEntity;
 exports.BlockchainEntityRead = BlockchainEntityRead;
 exports.BlockchainEntityReadWrite = BlockchainEntityReadWrite;
-exports.DOLLAR = DOLLAR;
+exports.DECIMAL_PRECISION = DECIMAL_PRECISION;
+exports.ETHAddress = ETHAddress;
 exports.MoneyMarket = MoneyMarket;
 exports.MoneyMarketRead = MoneyMarketRead;
 exports.MoneyMarketReadWrite = MoneyMarketReadWrite;
+exports.ONE_DAY = ONE_DAY;
+exports.PLYToken = PLYToken;
+exports.REWARDCLAIMSTART = REWARDCLAIMSTART;
 exports.SDK = SDK;
 exports.SdkRead = SdkRead;
 exports.SdkReadWrite = SdkReadWrite;
+exports.Token = Token;
+exports.TokenAmount = TokenAmount;
+exports.calcLMRewardApr = calcLMRewardApr;
 exports.decimalFactor = decimalFactor;
+exports.dummyAddress = dummyAddress;
 exports.dummyMarketAddress = dummyMarketAddress;
 exports.dummyPly = dummyPly;
 exports.dummyPlyAurora = dummyPlyAurora;
@@ -3010,7 +3246,18 @@ exports.dummyTokenAmount2 = dummyTokenAmount2;
 exports.dummyTokenAmount3 = dummyTokenAmount3;
 exports.dummyUserMarketDetails = dummyUserMarketDetails;
 exports.dummyZeroTokenAmount = dummyZeroTokenAmount;
+exports.fetchBasicTokenPrice = fetchBasicTokenPrice;
+exports.fetchLPPositions = fetchLPPositions;
+exports.fetchLPPrice = fetchLPPrice;
+exports.fetchPrice = fetchPrice;
+exports.fetchPriceFromCoingecko = fetchPriceFromCoingecko;
+exports.fetchPriceFromOracle = fetchPriceFromOracle;
+exports.fetchUnderlyingTokensPrices = fetchUnderlyingTokensPrices;
+exports.fetchValuation = fetchValuation;
 exports.formatObject = formatObject;
-exports.sum = sum;
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.getDecimal = getDecimal;
+exports.isSameAddress = isSameAddress;
+exports.networkAddresses = networkAddresses;
 exports.validateAndParseAddress = validateAndParseAddress;
 //# sourceMappingURL=sdk.cjs.development.js.map