@aurigami/sdk 1.6.1 → 1.6.3

package/dist/consts/constants.d.ts

@@ -33,3 +33,6 @@ export declare const DEPOSIT_NEAR_REWARDS_PER_WEEK: {
 export declare const BORROW_NEAR_REWARDS_PER_WEEK: {
     [k: string]: string;
 };
+export declare const HARDCODE_PRICE_TOKENS: {
+    [k: string]: string;
+};

package/dist/contracts/Referral.d.ts

@@ -0,0 +1,44 @@
+import { ReferralDirectory } from '@aurigami/contracts/typechain';
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { BlockchainEntity, BlockchainEntityRead } from '../entities';
+import { Address, NetworkConnection } from '../types';
+export declare class ReferralRead extends BlockchainEntityRead {
+    protected _referral: ReferralDirectory;
+    constructor(networkConnection: NetworkConnection);
+    /**
+     * Generate a 10-character referral code
+     * containing alphanumeric characters.
+     */
+    protected generateReferralCode(): string;
+    /**
+     * Get the referral code for a given address, returns empty string if not found.
+     *
+     * Called to check if a user has a referral code.
+     */
+    getUserReferralCode(userAddr: Address): Promise<string>;
+    /**
+     * Get referral code that a user was referred by, returns empty string if not found.
+     */
+    getReferralCodeUsed(userAddr: Address): Promise<string>;
+    /**
+     * Get owner of a referral code, returns zero address if not found.
+     */
+    getReferralCodeOwner(code: string): Promise<Address>;
+}
+export declare class ReferralReadWrite extends ReferralRead {
+    /**
+     * Generate a referral code for a given address.
+     *
+     * Called when an user want to creates his own referral code
+     */
+    registerNewReferralCode(): Promise<TransactionResponse>;
+    /**
+     * Called when an user confirms he is referred by a specified code
+     */
+    useReferralCode(code: string): Promise<TransactionResponse>;
+}
+export declare class Referral extends BlockchainEntity {
+    constructor();
+    read(networkConnection: NetworkConnection): ReferralRead;
+    readWrite(networkConnection: NetworkConnection): ReferralReadWrite;
+}

package/dist/contracts/index.d.ts

@@ -1,4 +1,5 @@
 export * from './airdrop-lottery';
 export * from './MoneyMarket';
 export * from './Papermill';
+export * from './Referral';
 export * from './Staking';

package/dist/sdk.cjs.development.js

@@ -21,6 +21,7 @@ var EthRepayHelperABI = _interopDefault(require('@aurigami/contracts/artifacts/c
 var AuriFairLaunchABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/AuriFairLaunch.sol/AuriFairLaunch.json'));
 var EIP20InterfaceABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/interfaces/EIP20Interface.sol/EIP20Interface.json'));
 var PulpABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/PULP.sol/PULP.json'));
+var ReferralDirectoryABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json'));
 var FaucetABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/mock/Faucet.sol/Faucet.json'));
 var Multicall2ABI = _interopDefault(require('@aurigami/contracts/artifacts/contracts/mock/Multicall2.sol/Multicall2.json'));
 
@@ -69,6 +70,10 @@ var networkAddresses = {
     name: 'auPLY',
     address: /*#__PURE__*/MAINNET_ADDRESSES.auTokens.PLY.toLowerCase(),
     underlying: /*#__PURE__*/'0x09c9d464b58d96837f8d8b6f4d9fe4ad408d3a4f'.toLowerCase()
+  }, {
+    name: 'auUSN',
+    address: /*#__PURE__*/MAINNET_ADDRESSES.auTokens.USN.toLowerCase(),
+    underlying: /*#__PURE__*/'0x5183e1b1091804bc2602586919e6880ac1cf2896'.toLowerCase()
   }],
   misc: {
     COMPTROLLER: /*#__PURE__*/MAINNET_ADDRESSES.comptroller.toLowerCase(),
@@ -79,7 +84,8 @@ var networkAddresses = {
     AURI_AIRDROP: /*#__PURE__*/MAINNET_ADDRESSES.auriAirdrop.toLowerCase(),
     MULTICALL: /*#__PURE__*/MAINNET_ADDRESSES.multicall.toLowerCase(),
     TEAM_MULTISIG: /*#__PURE__*/'0x2D05FfFE70CE64c5954710D4C308dB31C8dBd8dE'.toLowerCase(),
-    PLY_TOKEN_LOCK: /*#__PURE__*/MAINNET_ADDRESSES.plyTokenLock.toLowerCase()
+    PLY_TOKEN_LOCK: /*#__PURE__*/MAINNET_ADDRESSES.plyTokenLock.toLowerCase(),
+    REFERRAL: /*#__PURE__*/MAINNET_ADDRESSES.referralDirectory.toLocaleLowerCase()
   },
   tokens: {
     AURORA: /*#__PURE__*/'0x8bec47865ade3b172a928df8f990bc7f2a3b9f79'.toLowerCase(),
@@ -88,9 +94,10 @@ var networkAddresses = {
     USDC: /*#__PURE__*/'0xb12bfca5a55806aaf64e99521918a4bf0fc40802'.toLowerCase(),
     WNEAR: /*#__PURE__*/'0xC42C30aC6Cc15faC9bD938618BcaA1a1FaE8501d'.toLowerCase(),
     TRI: /*#__PURE__*/'0xFa94348467f64D5A457F75F8bc40495D33c65aBB'.toLowerCase(),
-    META: /*#__PURE__*/'0xc21ff01229e982d7c8b8691163b0a3cb8f357453'.toLocaleLowerCase(),
+    META: /*#__PURE__*/'0xc21ff01229e982d7c8b8691163b0a3cb8f357453'.toLowerCase(),
     PULP: /*#__PURE__*/MAINNET_ADDRESSES.PULP.toLowerCase(),
-    PLYWNEAR: /*#__PURE__*/MAINNET_ADDRESSES.ply_wnear_lp.toLowerCase()
+    PLYWNEAR: /*#__PURE__*/MAINNET_ADDRESSES.ply_wnear_lp.toLowerCase(),
+    USN: /*#__PURE__*/'0x5183e1b1091804bc2602586919e6880ac1cf2896'.toLowerCase()
   }
 }; // All token that we can calculate the price via oracle + coingecko
 
@@ -127,6 +134,7 @@ Object.entries({
 }));
 var BORROW_NEAR_REWARDS_PER_WEEK = {// currently 0 for all markets
 };
+var HARDCODE_PRICE_TOKENS = /*#__PURE__*/Object.fromEntries([[/*#__PURE__*/networkAddresses.tokens.USN.toLowerCase(), '1']]);
 
 var decimalRecords = {
   '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee': 18,
@@ -150,7 +158,8 @@ var decimalRecords = {
   '0xf4eb217ba2454613b15dbdea6e5f22276410e89e': 8,
   '0xc21ff01229e982d7c8b8691163b0a3cb8f357453': 24,
   '0x04ac48711bcdc45b4d223fb021e09da73c71095e': 18,
-  '0x044b6b0cd3bb13d2b9057781df4459c66781dce7': 18
+  '0x044b6b0cd3bb13d2b9057781df4459c66781dce7': 18,
+  '0x5183e1b1091804bc2602586919e6880ac1cf2896': 18
 };
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
@@ -2624,33 +2633,41 @@ function _fetchPrice3() {
       while (1) {
         switch (_context10.prev = _context10.next) {
           case 0:
-            if (!isSameAddress(address, networkAddresses.tokens.PLYWNEAR)) {
+            if (!(address.toLowerCase() in HARDCODE_PRICE_TOKENS)) {
               _context10.next = 4;
               break;
             }
 
-            return _context10.abrupt("return", fetchLPPrice(address, provider));
+            return _context10.abrupt("return", new BigNumber(HARDCODE_PRICE_TOKENS[address.toLowerCase()]));
 
           case 4:
-            if (!isSameAddress(address, networkAddresses.tokens.PLY)) {
+            if (!isSameAddress(address, networkAddresses.tokens.PLYWNEAR)) {
               _context10.next = 8;
               break;
             }
 
-            return _context10.abrupt("return", fetchPLYPrice(provider));
+            return _context10.abrupt("return", fetchLPPrice(address, provider));
 
           case 8:
+            if (!isSameAddress(address, networkAddresses.tokens.PLY)) {
+              _context10.next = 12;
+              break;
+            }
+
+            return _context10.abrupt("return", fetchPLYPrice(provider));
+
+          case 12:
             if (!isSameAddress(address, networkAddresses.tokens.PULP)) {
-              _context10.next = 10;
+              _context10.next = 14;
               break;
             }
 
             return _context10.abrupt("return", fetchPULPPrice(provider));
 
-          case 10:
+          case 14:
             return _context10.abrupt("return", _fetchPrice(address, provider));
 
-          case 11:
+          case 15:
           case "end":
             return _context10.stop();
         }
@@ -107171,6 +107188,236 @@ var Papermill = /*#__PURE__*/function (_BlockchainEntity) {
   return Papermill;
 }(BlockchainEntity);
 
+var ReferralRead = /*#__PURE__*/function (_BlockchainEntityRead) {
+  _inheritsLoose(ReferralRead, _BlockchainEntityRead);
+
+  function ReferralRead(networkConnection) {
+    var _this;
+
+    _this = _BlockchainEntityRead.call(this, networkConnection) || this;
+    _this._referral = new ethers.Contract(networkAddresses.misc.REFERRAL, ReferralDirectoryABI.abi, networkConnection.provider);
+    return _this;
+  }
+  /**
+   * Generate a 10-character referral code
+   * containing alphanumeric characters.
+   */
+
+
+  var _proto = ReferralRead.prototype;
+
+  _proto.generateReferralCode = function generateReferralCode() {
+    var letters = 'abcdefghijklmnopqrstuvwxyz';
+    var numbers = '1234567890';
+    var charset = letters + letters.toUpperCase() + numbers;
+    var R = '';
+
+    for (var i = 0; i < 10; i++) {
+      R += charset[Math.floor(Math.random() * charset.length)];
+    }
+
+    return R;
+  }
+  /**
+   * Get the referral code for a given address, returns empty string if not found.
+   *
+   * Called to check if a user has a referral code.
+   */
+  ;
+
+  _proto.getUserReferralCode =
+  /*#__PURE__*/
+  function () {
+    var _getUserReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(userAddr) {
+      var result;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this._referral.userReferralCode(userAddr);
+
+            case 2:
+              result = _context.sent;
+              return _context.abrupt("return", ethers.ethers.utils.parseBytes32String(result));
+
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function getUserReferralCode(_x) {
+      return _getUserReferralCode.apply(this, arguments);
+    }
+
+    return getUserReferralCode;
+  }()
+  /**
+   * Get referral code that a user was referred by, returns empty string if not found.
+   */
+  ;
+
+  _proto.getReferralCodeUsed =
+  /*#__PURE__*/
+  function () {
+    var _getReferralCodeUsed = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(userAddr) {
+      var result;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this._referral.referralCodeUsed(userAddr);
+
+            case 2:
+              result = _context2.sent;
+              return _context2.abrupt("return", ethers.ethers.utils.parseBytes32String(result));
+
+            case 4:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function getReferralCodeUsed(_x2) {
+      return _getReferralCodeUsed.apply(this, arguments);
+    }
+
+    return getReferralCodeUsed;
+  }()
+  /**
+   * Get owner of a referral code, returns zero address if not found.
+   */
+  ;
+
+  _proto.getReferralCodeOwner =
+  /*#__PURE__*/
+  function () {
+    var _getReferralCodeOwner = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(code) {
+      var referralCode;
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              referralCode = ethers.ethers.utils.formatBytes32String(code);
+              return _context3.abrupt("return", this._referral.referralCodeOwner(referralCode));
+
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function getReferralCodeOwner(_x3) {
+      return _getReferralCodeOwner.apply(this, arguments);
+    }
+
+    return getReferralCodeOwner;
+  }();
+
+  return ReferralRead;
+}(BlockchainEntityRead);
+var ReferralReadWrite = /*#__PURE__*/function (_ReferralRead) {
+  _inheritsLoose(ReferralReadWrite, _ReferralRead);
+
+  function ReferralReadWrite() {
+    return _ReferralRead.apply(this, arguments) || this;
+  }
+
+  var _proto2 = ReferralReadWrite.prototype;
+
+  /**
+   * Generate a referral code for a given address.
+   *
+   * Called when an user want to creates his own referral code
+   */
+  _proto2.registerNewReferralCode =
+  /*#__PURE__*/
+  function () {
+    var _registerNewReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
+      var referralCode;
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              referralCode = ethers.ethers.utils.formatBytes32String(this.generateReferralCode());
+              return _context4.abrupt("return", this._referral.connect(this._networkConnection.signer).registerNewUserReferralCode(referralCode));
+
+            case 2:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function registerNewReferralCode() {
+      return _registerNewReferralCode.apply(this, arguments);
+    }
+
+    return registerNewReferralCode;
+  }()
+  /**
+   * Called when an user confirms he is referred by a specified code
+   */
+  ;
+
+  _proto2.useReferralCode =
+  /*#__PURE__*/
+  function () {
+    var _useReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(code) {
+      var referralCode;
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              referralCode = ethers.ethers.utils.formatBytes32String(code);
+              return _context5.abrupt("return", this._referral.connect(this._networkConnection.signer).registerReferralCodeUsed(referralCode));
+
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function useReferralCode(_x4) {
+      return _useReferralCode.apply(this, arguments);
+    }
+
+    return useReferralCode;
+  }();
+
+  return ReferralReadWrite;
+}(ReferralRead);
+var Referral = /*#__PURE__*/function (_BlockchainEntity) {
+  _inheritsLoose(Referral, _BlockchainEntity);
+
+  function Referral() {
+    return _BlockchainEntity.call(this) || this;
+  }
+
+  var _proto3 = Referral.prototype;
+
+  _proto3.read = function read(networkConnection) {
+    return new ReferralRead(networkConnection);
+  };
+
+  _proto3.readWrite = function readWrite(networkConnection) {
+    return new ReferralReadWrite(networkConnection);
+  };
+
+  return Referral;
+}(BlockchainEntity);
+
 var StakingRead = /*#__PURE__*/function (_BlockchainEntityRead) {
   _inheritsLoose(StakingRead, _BlockchainEntityRead);
 
@@ -108129,6 +108376,7 @@ exports.BlockchainEntityReadWrite = BlockchainEntityReadWrite;
 exports.DECIMAL_PRECISION = DECIMAL_PRECISION;
 exports.DEPOSIT_NEAR_REWARDS_PER_WEEK = DEPOSIT_NEAR_REWARDS_PER_WEEK;
 exports.ETHAddress = ETHAddress;
+exports.HARDCODE_PRICE_TOKENS = HARDCODE_PRICE_TOKENS;
 exports.INF = INF;
 exports.MoneyMarket = MoneyMarket;
 exports.MoneyMarketRead = MoneyMarketRead;
@@ -108145,6 +108393,9 @@ exports.Papermill = Papermill;
 exports.PapermillRead = PapermillRead;
 exports.PapermillReadWrite = PapermillReadWrite;
 exports.REWARD_CLAIM_START = REWARD_CLAIM_START;
+exports.Referral = Referral;
+exports.ReferralRead = ReferralRead;
+exports.ReferralReadWrite = ReferralReadWrite;
 exports.SDK = SDK;
 exports.SdkRead = SdkRead;
 exports.SdkReadWrite = SdkReadWrite;