@aurigami/sdk 1.6.11 → 1.7.1

package/dist/contracts/Referral.d.ts

@@ -24,6 +24,13 @@ export declare class ReferralRead extends BlockchainEntityRead {
      * Get owner of a referral code, returns zero address if not found.
      */
     getReferralCodeOwner(code: string): Promise<Address>;
+    /**
+     * Get referrals of a user, sorted descending by timestamp.
+     */
+    getReferralsList(userAddr: Address): Promise<{
+        user: string;
+        timestamp: number;
+    }[]>;
 }
 export declare class ReferralReadWrite extends ReferralRead {
     /**

package/dist/helpers/aurigami-api.d.ts

@@ -0,0 +1,13 @@
+export declare function getApi(url: string, params?: Record<string, any>): Promise<any>;
+export declare type MetaApiResponse = {
+    totalItems: number;
+    itemCount: number;
+    itemsPerPage: number;
+    totalPages: number;
+    currentPage: number;
+};
+export declare type PaginagedApiResponse<T> = {
+    items: T[];
+    meta: MetaApiResponse;
+};
+export declare function getPaginatedApi(url: string, params?: Record<string, any>, page?: number, pageSize?: number): Promise<PaginagedApiResponse<any>>;

package/dist/helpers/graphql-helpers.d.ts

@@ -0,0 +1 @@
+export declare function queryGraphQL(query: string): Promise<any>;

package/dist/helpers/helpers.d.ts

@@ -11,6 +11,13 @@ export declare function getDecimal(address: Address): number;
 export declare function getSymbol(address: Address): string;
 export declare function calcLMRewardApr(rewardsValue: BigNumber, totalStakeValue: BigNumber, frequencyPerYear: number): BigNumber;
 export declare function getBlockTimestamp(provider: Provider, blockNumber: number): Promise<number>;
+export declare function getBlocksTimestampViaRPC(provider: Provider, blocksNumber: number[]): Promise<number[]>;
+/**
+ * Get timestamp of multiple blocks.
+ * @note the getBlockTimestamp function is too slow because of the RPC call, even with Promise.all.
+ * So I use the GraphQL endpoint of Aurora instead. You can check it here: https://explorer.mainnet.aurora.dev/graphiql
+ */
+export declare function getBlocksTimestamp(provider: Provider, blockNumbers: number[]): Promise<number[]>;
 /**
  * Get the block number of the last block that has a timestamp before the given timestamp
  * @param timestamp input timestamp

package/dist/helpers/index.d.ts

@@ -1,4 +1,6 @@
+export * from './aurigami-api';
 export * from './aurora-api-helpers';
+export * from './graphql-helpers';
 export * from './helpers';
 export * from './priceFetcher';
 export * from './transfer-event-query';

package/dist/sdk.cjs.development.js

@@ -26,6 +26,7 @@ var abis$9 = _interopDefault(require('@aurigami/contracts/artifacts/contracts/PU
 var abis$a = _interopDefault(require('@aurigami/contracts/artifacts/contracts/ReferralDirectory.sol/ReferralDirectory.json'));
 var abstractSigner = require('@ethersproject/abstract-signer');
 var axios = _interopDefault(require('axios'));
+var fetch = _interopDefault(require('node-fetch'));
 
 var dummyAddress = '0xDEADbeEfEEeEEEeEEEeEEeeeeeEeEEeeeeEEEEeE';
 var ETHAddress = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
@@ -1137,6 +1138,47 @@ function _getQuery() {
   return _getQuery.apply(this, arguments);
 }
 
+var GRAPHQL_URL = 'https://explorer.mainnet.aurora.dev/graphiql';
+function queryGraphQL(_x) {
+  return _queryGraphQL.apply(this, arguments);
+}
+
+function _queryGraphQL() {
+  _queryGraphQL = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(query) {
+    var resp;
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return fetch(GRAPHQL_URL, {
+              headers: {
+                'Content-Type': 'application/json'
+              },
+              method: 'POST',
+              body: JSON.stringify({
+                query: query
+              })
+            });
+
+          case 2:
+            resp = _context.sent;
+            _context.next = 5;
+            return resp.json();
+
+          case 5:
+            return _context.abrupt("return", _context.sent.data);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _queryGraphQL.apply(this, arguments);
+}
+
 function assert(condition, message) {
   if (message === void 0) {
     message = '';
@@ -1191,14 +1233,6 @@ function calcLMRewardApr(rewardsValue, totalStakeValue, frequencyPerYear) {
 function getBlockTimestamp(_x, _x2) {
   return _getBlockTimestamp.apply(this, arguments);
 }
-/**
- * Get the block number of the last block that has a timestamp before the given timestamp
- * @param timestamp input timestamp
- * @returns return the last block that its timestamp <= the give timestamp
- * @note Check this API for more information: https://aurorascan.dev/apis#blocks
- *
- * This function is much faster than using binary search.
- */
 
 function _getBlockTimestamp() {
   _getBlockTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(provider, blockNumber) {
@@ -1224,47 +1258,192 @@ function _getBlockTimestamp() {
   return _getBlockTimestamp.apply(this, arguments);
 }
 
-function getBlockBeforeTimestamp(_x3, _x4) {
+function getBlocksTimestampViaRPC(_x3, _x4) {
+  return _getBlocksTimestampViaRPC.apply(this, arguments);
+}
+/**
+ * Get timestamp of multiple blocks.
+ * @note the getBlockTimestamp function is too slow because of the RPC call, even with Promise.all.
+ * So I use the GraphQL endpoint of Aurora instead. You can check it here: https://explorer.mainnet.aurora.dev/graphiql
+ */
+
+function _getBlocksTimestampViaRPC() {
+  _getBlocksTimestampViaRPC = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(provider, blocksNumber) {
+    var CHUNK_SIZE, results, i, slice, promises;
+    return runtime_1.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            // Promise all 200 blocks at a time, using too many blocks at once will cause the RPC call timeout.
+            CHUNK_SIZE = 200;
+            results = [];
+            i = 0;
+
+          case 3:
+            if (!(i < blocksNumber.length)) {
+              _context3.next = 14;
+              break;
+            }
+
+            slice = blocksNumber.slice(i, i + CHUNK_SIZE);
+            promises = slice.map( /*#__PURE__*/function () {
+              var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(blockNumber) {
+                return runtime_1.wrap(function _callee2$(_context2) {
+                  while (1) {
+                    switch (_context2.prev = _context2.next) {
+                      case 0:
+                        return _context2.abrupt("return", getBlockTimestamp(provider, blockNumber));
+
+                      case 1:
+                      case "end":
+                        return _context2.stop();
+                    }
+                  }
+                }, _callee2);
+              }));
+
+              return function (_x9) {
+                return _ref.apply(this, arguments);
+              };
+            }());
+            _context3.t0 = results;
+            _context3.next = 9;
+            return Promise.all(promises);
+
+          case 9:
+            _context3.t1 = _context3.sent;
+            results = _context3.t0.concat.call(_context3.t0, _context3.t1);
+
+          case 11:
+            i += CHUNK_SIZE;
+            _context3.next = 3;
+            break;
+
+          case 14:
+            return _context3.abrupt("return", results);
+
+          case 15:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _getBlocksTimestampViaRPC.apply(this, arguments);
+}
+
+function getBlocksTimestamp(_x5, _x6) {
+  return _getBlocksTimestamp.apply(this, arguments);
+}
+/**
+ * Get the block number of the last block that has a timestamp before the given timestamp
+ * @param timestamp input timestamp
+ * @returns return the last block that its timestamp <= the give timestamp
+ * @note Check this API for more information: https://aurorascan.dev/apis#blocks
+ *
+ * This function is much faster than using binary search.
+ */
+
+function _getBlocksTimestamp() {
+  _getBlocksTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(provider, blockNumbers) {
+    var CHUNK_SIZE, promises, lines, i, query, results, missingBlocks, missingBlocksTimestamps;
+    return runtime_1.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            CHUNK_SIZE = 100; // graphql query limit
+
+            promises = [];
+            lines = blockNumbers.map(function (x) {
+              return "b" + x + ": block(number: " + x + ") { timestamp }";
+            });
+
+            for (i = 0; i < lines.length; i += CHUNK_SIZE) {
+              query = "{ " + lines.slice(i, i + CHUNK_SIZE).join('\n') + " }";
+              promises.push(queryGraphQL(query));
+            } // merge all the json objects
+
+
+            _context4.next = 6;
+            return Promise.all(promises);
+
+          case 6:
+            results = _context4.sent.reduce(function (acc, cur) {
+              return _extends({}, acc, cur);
+            });
+            missingBlocks = blockNumbers.filter(function (blockNumber) {
+              return !results["b" + blockNumber];
+            });
+
+            if (missingBlocks.length > 0) {
+              devLog("These blocks are missing from Aurora GraphQL endpoint: " + missingBlocks.join(', '));
+            }
+
+            _context4.next = 11;
+            return getBlocksTimestampViaRPC(provider, missingBlocks);
+
+          case 11:
+            missingBlocksTimestamps = _context4.sent;
+            missingBlocksTimestamps.forEach(function (timestamp, index) {
+              results["b" + missingBlocks[index]] = {
+                timestamp: new Date(timestamp * 1000).toISOString()
+              };
+            });
+            return _context4.abrupt("return", blockNumbers.map(function (blockNumber) {
+              return Math.trunc(new Date(results["b" + blockNumber].timestamp).getTime() / 1000);
+            }));
+
+          case 14:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _getBlocksTimestamp.apply(this, arguments);
+}
+
+function getBlockBeforeTimestamp(_x7, _x8) {
   return _getBlockBeforeTimestamp.apply(this, arguments);
 }
 
 function _getBlockBeforeTimestamp() {
-  _getBlockBeforeTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(provider, timestamp) {
+  _getBlockBeforeTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(provider, timestamp) {
     var result;
-    return runtime_1.wrap(function _callee2$(_context2) {
+    return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context2.prev = _context2.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
-            _context2.next = 2;
+            _context5.next = 2;
             return getQuery('block', 'getblocknobytime', {
               timestamp: timestamp,
               closest: 'before'
             });
 
           case 2:
-            result = _context2.sent;
-            _context2.t0 = parseInt(result);
+            result = _context5.sent;
+            _context5.t0 = parseInt(result);
 
-            if (_context2.t0) {
-              _context2.next = 8;
+            if (_context5.t0) {
+              _context5.next = 8;
               break;
             }
 
-            _context2.next = 7;
+            _context5.next = 7;
             return provider.getBlockNumber();
 
           case 7:
-            _context2.t0 = _context2.sent;
+            _context5.t0 = _context5.sent;
 
           case 8:
-            return _context2.abrupt("return", _context2.t0);
+            return _context5.abrupt("return", _context5.t0);
 
           case 9:
           case "end":
-            return _context2.stop();
+            return _context5.stop();
         }
       }
-    }, _callee2);
+    }, _callee5);
   }));
   return _getBlockBeforeTimestamp.apply(this, arguments);
 }
@@ -1343,6 +1522,91 @@ var dummyUserMarketDetails = {
   underlyingPrice: '1'
 };
 
+var AURIGAMI_API_END_POINT = 'https://api.aurigami.finance/app/';
+function getApi(_x, _x2) {
+  return _getApi.apply(this, arguments);
+}
+
+function _getApi() {
+  _getApi = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(url, params) {
+    var resp;
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (params === void 0) {
+              params = {};
+            }
+
+            _context.next = 3;
+            return axios.get(AURIGAMI_API_END_POINT + url + '?' + new URLSearchParams(params), {
+              headers: {
+                'Content-Type': 'application/json'
+              }
+            });
+
+          case 3:
+            resp = _context.sent;
+            return _context.abrupt("return", resp.data);
+
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _getApi.apply(this, arguments);
+}
+
+function getPaginatedApi(_x3, _x4, _x5, _x6) {
+  return _getPaginatedApi.apply(this, arguments);
+}
+
+function _getPaginatedApi() {
+  _getPaginatedApi = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(url, params, page, pageSize) {
+    var resp;
+    return runtime_1.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (params === void 0) {
+              params = {};
+            }
+
+            if (page === void 0) {
+              page = 1;
+            }
+
+            if (pageSize === void 0) {
+              pageSize = 50;
+            }
+
+            params = _extends({}, params, {
+              page: page,
+              limit: pageSize
+            });
+            _context2.next = 6;
+            return axios.get(AURIGAMI_API_END_POINT + url + '?' + new URLSearchParams(params), {
+              headers: {
+                'Content-Type': 'application/json'
+              }
+            });
+
+          case 6:
+            resp = _context2.sent;
+            return _context2.abrupt("return", resp.data);
+
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getPaginatedApi.apply(this, arguments);
+}
+
 function fetchPriceFromCoingeckoAPI(_x) {
   return _fetchPriceFromCoingeckoAPI.apply(this, arguments);
 }
@@ -2038,7 +2302,10 @@ var TransferEventQuery = /*#__PURE__*/function (_BlockchainEntityRead) {
 
 var helpers = {
   __proto__: null,
+  getApi: getApi,
+  getPaginatedApi: getPaginatedApi,
   getQuery: getQuery,
+  queryGraphQL: queryGraphQL,
   assert: assert,
   formatObject: formatObject,
   decimalFactor: decimalFactor,
@@ -2049,6 +2316,8 @@ var helpers = {
   getSymbol: getSymbol,
   calcLMRewardApr: calcLMRewardApr,
   getBlockTimestamp: getBlockTimestamp,
+  getBlocksTimestampViaRPC: getBlocksTimestampViaRPC,
+  getBlocksTimestamp: getBlocksTimestamp,
   getBlockBeforeTimestamp: getBlockBeforeTimestamp,
   devLog: devLog,
   fetchPriceFromCoingeckoAPI: fetchPriceFromCoingeckoAPI,
@@ -4209,6 +4478,57 @@ var ReferralRead = /*#__PURE__*/function (_BlockchainEntityRead) {
     }
 
     return getReferralCodeOwner;
+  }()
+  /**
+   * Get referrals of a user, sorted descending by timestamp.
+   */
+  ;
+
+  _proto.getReferralsList =
+  /*#__PURE__*/
+  function () {
+    var _getReferralsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(userAddr) {
+      var result, blocks, blocksTimestamp, items;
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return getPaginatedApi('/referral/list', {
+                address: userAddr
+              });
+
+            case 2:
+              result = _context4.sent;
+              blocks = result.items.map(function (item) {
+                return item.blockNumber;
+              });
+              _context4.next = 6;
+              return getBlocksTimestamp(this._networkConnection.provider, blocks);
+
+            case 6:
+              blocksTimestamp = _context4.sent;
+              items = result.items.map(function (item, i) {
+                return {
+                  user: item.user,
+                  timestamp: blocksTimestamp[i]
+                };
+              });
+              return _context4.abrupt("return", items);
+
+            case 9:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function getReferralsList(_x4) {
+      return _getReferralsList.apply(this, arguments);
+    }
+
+    return getReferralsList;
   }();
 
   return ReferralRead;
@@ -4230,21 +4550,21 @@ var ReferralReadWrite = /*#__PURE__*/function (_ReferralRead) {
   _proto2.registerNewReferralCode =
   /*#__PURE__*/
   function () {
-    var _registerNewReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
+    var _registerNewReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
       var referralCode;
-      return runtime_1.wrap(function _callee4$(_context4) {
+      return runtime_1.wrap(function _callee5$(_context5) {
         while (1) {
-          switch (_context4.prev = _context4.next) {
+          switch (_context5.prev = _context5.next) {
             case 0:
               referralCode = ethers.ethers.utils.formatBytes32String(this.generateReferralCode());
-              return _context4.abrupt("return", this.referral.connect(this._networkConnection.signer).registerNewUserReferralCode(referralCode));
+              return _context5.abrupt("return", this.referral.connect(this._networkConnection.signer).registerNewUserReferralCode(referralCode));
 
             case 2:
             case "end":
-              return _context4.stop();
+              return _context5.stop();
           }
         }
-      }, _callee4, this);
+      }, _callee5, this);
     }));
 
     function registerNewReferralCode() {
@@ -4261,24 +4581,24 @@ var ReferralReadWrite = /*#__PURE__*/function (_ReferralRead) {
   _proto2.useReferralCode =
   /*#__PURE__*/
   function () {
-    var _useReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(code) {
+    var _useReferralCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(code) {
       var referralCode;
-      return runtime_1.wrap(function _callee5$(_context5) {
+      return runtime_1.wrap(function _callee6$(_context6) {
         while (1) {
-          switch (_context5.prev = _context5.next) {
+          switch (_context6.prev = _context6.next) {
             case 0:
               referralCode = ethers.ethers.utils.formatBytes32String(code);
-              return _context5.abrupt("return", this.referral.connect(this._networkConnection.signer).registerReferralCodeUsed(referralCode));
+              return _context6.abrupt("return", this.referral.connect(this._networkConnection.signer).registerReferralCodeUsed(referralCode));
 
             case 2:
             case "end":
-              return _context5.stop();
+              return _context6.stop();
           }
         }
-      }, _callee5, this);
+      }, _callee6, this);
     }));
 
-    function useReferralCode(_x4) {
+    function useReferralCode(_x5) {
       return _useReferralCode.apply(this, arguments);
     }
 
@@ -4793,14 +5113,19 @@ exports.fetchToken0PriceByLP = fetchToken0PriceByLP;
 exports.fetchUnderlyingTokensPrices = fetchUnderlyingTokensPrices;
 exports.fetchValuation = fetchValuation;
 exports.formatObject = formatObject;
+exports.getApi = getApi;
 exports.getBlockBeforeTimestamp = getBlockBeforeTimestamp;
 exports.getBlockTimestamp = getBlockTimestamp;
+exports.getBlocksTimestamp = getBlocksTimestamp;
+exports.getBlocksTimestampViaRPC = getBlocksTimestampViaRPC;
 exports.getCurrentTimestamp = getCurrentTimestamp;
 exports.getDecimal = getDecimal;
+exports.getPaginatedApi = getPaginatedApi;
 exports.getQuery = getQuery;
 exports.getSymbol = getSymbol;
 exports.isSameAddress = isSameAddress;
 exports.networkAddresses = networkAddresses;
+exports.queryGraphQL = queryGraphQL;
 exports.symbolRecords = symbolRecords;
 exports.validateAndParseAddress = validateAndParseAddress;
 exports.valuateToken = valuateToken;