@aurigami/sdk 1.7.0 → 1.7.2

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,5 +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

@@ -1137,6 +1137,37 @@ 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 axios.post(GRAPHQL_URL, {
+              query: query
+            });
+
+          case 2:
+            resp = _context.sent;
+            return _context.abrupt("return", resp.data.data);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _queryGraphQL.apply(this, arguments);
+}
+
 function assert(condition, message) {
   if (message === void 0) {
     message = '';
@@ -1191,14 +1222,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 +1247,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);
 }
@@ -2126,6 +2294,7 @@ var helpers = {
   getApi: getApi,
   getPaginatedApi: getPaginatedApi,
   getQuery: getQuery,
+  queryGraphQL: queryGraphQL,
   assert: assert,
   formatObject: formatObject,
   decimalFactor: decimalFactor,
@@ -2136,6 +2305,8 @@ var helpers = {
   getSymbol: getSymbol,
   calcLMRewardApr: calcLMRewardApr,
   getBlockTimestamp: getBlockTimestamp,
+  getBlocksTimestampViaRPC: getBlocksTimestampViaRPC,
+  getBlocksTimestamp: getBlocksTimestamp,
   getBlockBeforeTimestamp: getBlockBeforeTimestamp,
   devLog: devLog,
   fetchPriceFromCoingeckoAPI: fetchPriceFromCoingeckoAPI,
@@ -4306,7 +4477,7 @@ var ReferralRead = /*#__PURE__*/function (_BlockchainEntityRead) {
   /*#__PURE__*/
   function () {
     var _getReferralsList = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(userAddr) {
-      var result, items;
+      var result, blocks, blocksTimestamp, items;
       return runtime_1.wrap(function _callee4$(_context4) {
         while (1) {
           switch (_context4.prev = _context4.next) {
@@ -4318,20 +4489,28 @@ var ReferralRead = /*#__PURE__*/function (_BlockchainEntityRead) {
 
             case 2:
               result = _context4.sent;
-              items = result.items.map(function (item) {
+              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: item.blockNumber
+                  timestamp: blocksTimestamp[i]
                 };
               });
               return _context4.abrupt("return", items);
 
-            case 5:
+            case 9:
             case "end":
               return _context4.stop();
           }
         }
-      }, _callee4);
+      }, _callee4, this);
     }));
 
     function getReferralsList(_x4) {
@@ -4926,6 +5105,8 @@ 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;
@@ -4933,6 +5114,7 @@ exports.getQuery = getQuery;
 exports.getSymbol = getSymbol;
 exports.isSameAddress = isSameAddress;
 exports.networkAddresses = networkAddresses;
+exports.queryGraphQL = queryGraphQL;
 exports.symbolRecords = symbolRecords;
 exports.validateAndParseAddress = validateAndParseAddress;
 exports.valuateToken = valuateToken;