@aurigami/sdk 1.11.0 → 1.11.1

package/dist/helpers/helpers.d.ts

@@ -8,6 +8,7 @@ export declare function formatObject(object: Object): string;
 export declare function decimalFactor(decimal: number): string;
 export declare const isSameAddress: (address1: Address, address2: Address) => boolean;
 export declare const getCurrentTimestamp: () => number;
+export declare function sleep(duration: number): Promise<void>;
 export declare function validateAndParseAddress(address: Address): Address;
 export declare function getDecimal(address: Address): number;
 export declare function getSymbol(address: Address): string;

package/dist/sdk.cjs.development.js

@@ -1212,6 +1212,30 @@ var isSameAddress = function isSameAddress(address1, address2) {
 var getCurrentTimestamp = function getCurrentTimestamp() {
   return Math.trunc(Date.now() / 1000);
 };
+function sleep(_x) {
+  return _sleep.apply(this, arguments);
+}
+
+function _sleep() {
+  _sleep = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(duration) {
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", new Promise(function (resolve) {
+              setTimeout(resolve, duration);
+            }));
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _sleep.apply(this, arguments);
+}
+
 function validateAndParseAddress(address) {
   try {
     return ethers.utils.getAddress(address);
@@ -1253,35 +1277,35 @@ function calcLMRewardApr(rewardsValue, totalStakeValue, frequencyPerYear) {
 
   return rewardsValue.multipliedBy(frequencyPerYear).dividedBy(totalStakeValue);
 }
-function getBlockTimestamp(_x, _x2) {
+function getBlockTimestamp(_x2, _x3) {
   return _getBlockTimestamp.apply(this, arguments);
 }
 
 function _getBlockTimestamp() {
-  _getBlockTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(provider, blockNumber) {
+  _getBlockTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(provider, blockNumber) {
     var block;
-    return runtime_1.wrap(function _callee$(_context) {
+    return runtime_1.wrap(function _callee2$(_context2) {
       while (1) {
-        switch (_context.prev = _context.next) {
+        switch (_context2.prev = _context2.next) {
           case 0:
-            _context.next = 2;
+            _context2.next = 2;
             return provider.getBlock(blockNumber);
 
           case 2:
-            block = _context.sent;
-            return _context.abrupt("return", block.timestamp);
+            block = _context2.sent;
+            return _context2.abrupt("return", block.timestamp);
 
           case 4:
           case "end":
-            return _context.stop();
+            return _context2.stop();
         }
       }
-    }, _callee);
+    }, _callee2);
   }));
   return _getBlockTimestamp.apply(this, arguments);
 }
 
-function getBlocksTimestampViaRPC(_x3, _x4) {
+function getBlocksTimestampViaRPC(_x4, _x5) {
   return _getBlocksTimestampViaRPC.apply(this, arguments);
 }
 /**
@@ -1291,11 +1315,11 @@ function getBlocksTimestampViaRPC(_x3, _x4) {
  */
 
 function _getBlocksTimestampViaRPC() {
-  _getBlocksTimestampViaRPC = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(provider, blocksNumber) {
+  _getBlocksTimestampViaRPC = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(provider, blocksNumber) {
     var CHUNK_SIZE, results, i, slice, promises;
-    return runtime_1.wrap(function _callee3$(_context3) {
+    return runtime_1.wrap(function _callee4$(_context4) {
       while (1) {
-        switch (_context3.prev = _context3.next) {
+        switch (_context4.prev = _context4.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;
@@ -1304,58 +1328,58 @@ function _getBlocksTimestampViaRPC() {
 
           case 3:
             if (!(i < blocksNumber.length)) {
-              _context3.next = 14;
+              _context4.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) {
+              var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(blockNumber) {
+                return runtime_1.wrap(function _callee3$(_context3) {
                   while (1) {
-                    switch (_context2.prev = _context2.next) {
+                    switch (_context3.prev = _context3.next) {
                       case 0:
-                        return _context2.abrupt("return", getBlockTimestamp(provider, blockNumber));
+                        return _context3.abrupt("return", getBlockTimestamp(provider, blockNumber));
 
                       case 1:
                       case "end":
-                        return _context2.stop();
+                        return _context3.stop();
                     }
                   }
-                }, _callee2);
+                }, _callee3);
               }));
 
-              return function (_x9) {
+              return function (_x10) {
                 return _ref.apply(this, arguments);
               };
             }());
-            _context3.t0 = results;
-            _context3.next = 9;
+            _context4.t0 = results;
+            _context4.next = 9;
             return Promise.all(promises);
 
           case 9:
-            _context3.t1 = _context3.sent;
-            results = _context3.t0.concat.call(_context3.t0, _context3.t1);
+            _context4.t1 = _context4.sent;
+            results = _context4.t0.concat.call(_context4.t0, _context4.t1);
 
           case 11:
             i += CHUNK_SIZE;
-            _context3.next = 3;
+            _context4.next = 3;
             break;
 
           case 14:
-            return _context3.abrupt("return", results);
+            return _context4.abrupt("return", results);
 
           case 15:
           case "end":
-            return _context3.stop();
+            return _context4.stop();
         }
       }
-    }, _callee3);
+    }, _callee4);
   }));
   return _getBlocksTimestampViaRPC.apply(this, arguments);
 }
 
-function getBlocksTimestamp(_x5, _x6) {
+function getBlocksTimestamp(_x6, _x7) {
   return _getBlocksTimestamp.apply(this, arguments);
 }
 /**
@@ -1368,18 +1392,18 @@ function getBlocksTimestamp(_x5, _x6) {
  */
 
 function _getBlocksTimestamp() {
-  _getBlocksTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(provider, blockNumbers) {
+  _getBlocksTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(provider, blockNumbers) {
     var CHUNK_SIZE, promises, lines, i, query, results, missingBlocks, missingBlocksTimestamps;
-    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:
             if (!(blockNumbers.length == 0)) {
-              _context4.next = 2;
+              _context5.next = 2;
               break;
             }
 
-            return _context4.abrupt("return", []);
+            return _context5.abrupt("return", []);
 
           case 2:
             CHUNK_SIZE = 100; // graphql query limit
@@ -1395,11 +1419,11 @@ function _getBlocksTimestamp() {
             } // merge all the json objects
 
 
-            _context4.next = 8;
+            _context5.next = 8;
             return Promise.all(promises);
 
           case 8:
-            results = _context4.sent.reduce(function (acc, cur) {
+            results = _context5.sent.reduce(function (acc, cur) {
               return _extends({}, acc, cur);
             });
             missingBlocks = blockNumbers.filter(function (blockNumber) {
@@ -1410,71 +1434,71 @@ function _getBlocksTimestamp() {
               devLog("These blocks are missing from Aurora GraphQL endpoint: " + missingBlocks.join(', '));
             }
 
-            _context4.next = 13;
+            _context5.next = 13;
             return getBlocksTimestampViaRPC(provider, missingBlocks);
 
           case 13:
-            missingBlocksTimestamps = _context4.sent;
+            missingBlocksTimestamps = _context5.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 _context5.abrupt("return", blockNumbers.map(function (blockNumber) {
               return Math.trunc(new Date(results["b" + blockNumber].timestamp).getTime() / 1000);
             }));
 
           case 16:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
       }
-    }, _callee4);
+    }, _callee5);
   }));
   return _getBlocksTimestamp.apply(this, arguments);
 }
 
-function getBlockBeforeTimestamp(_x7, _x8) {
+function getBlockBeforeTimestamp(_x8, _x9) {
   return _getBlockBeforeTimestamp.apply(this, arguments);
 }
 
 function _getBlockBeforeTimestamp() {
-  _getBlockBeforeTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(provider, timestamp) {
+  _getBlockBeforeTimestamp = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(provider, timestamp) {
     var result;
-    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:
-            _context5.next = 2;
+            _context6.next = 2;
             return getQuery('block', 'getblocknobytime', {
               timestamp: timestamp,
               closest: 'before'
             });
 
           case 2:
-            result = _context5.sent;
-            _context5.t0 = parseInt(result);
+            result = _context6.sent;
+            _context6.t0 = parseInt(result);
 
-            if (_context5.t0) {
-              _context5.next = 8;
+            if (_context6.t0) {
+              _context6.next = 8;
               break;
             }
 
-            _context5.next = 7;
+            _context6.next = 7;
             return provider.getBlockNumber();
 
           case 7:
-            _context5.t0 = _context5.sent;
+            _context6.t0 = _context6.sent;
 
           case 8:
-            return _context5.abrupt("return", _context5.t0);
+            return _context6.abrupt("return", _context6.t0);
 
           case 9:
           case "end":
-            return _context5.stop();
+            return _context6.stop();
         }
       }
-    }, _callee5);
+    }, _callee6);
   }));
   return _getBlockBeforeTimestamp.apply(this, arguments);
 }
@@ -2602,6 +2626,7 @@ var helpers = {
   decimalFactor: decimalFactor,
   isSameAddress: isSameAddress,
   getCurrentTimestamp: getCurrentTimestamp,
+  sleep: sleep,
   validateAndParseAddress: validateAndParseAddress,
   getDecimal: getDecimal,
   getSymbol: getSymbol,
@@ -4839,16 +4864,48 @@ var PlyGameRead = /*#__PURE__*/function (_BlockchainEntityRead) {
     var _getPlyGameResultsInTransaction = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(txHash) {
       var _this3 = this;
 
-      var tx, filter, betMadeEvents;
+      var tx, i, filter, betMadeEvents;
       return runtime_1.wrap(function _callee5$(_context5) {
         while (1) {
           switch (_context5.prev = _context5.next) {
             case 0:
               _context5.next = 2;
-              return this._networkConnection.provider.waitForTransaction(txHash, 1);
+              return this._networkConnection.provider.getTransactionReceipt(txHash);
 
             case 2:
               tx = _context5.sent;
+              i = 0;
+
+            case 4:
+              if (!(i < 100 && !tx)) {
+                _context5.next = 13;
+                break;
+              }
+
+              _context5.next = 7;
+              return sleep(1000);
+
+            case 7:
+              _context5.next = 9;
+              return this._networkConnection.provider.getTransactionReceipt(txHash);
+
+            case 9:
+              tx = _context5.sent;
+
+            case 10:
+              i++;
+              _context5.next = 4;
+              break;
+
+            case 13:
+              if (tx) {
+                _context5.next = 15;
+                break;
+              }
+
+              throw new Error("Transaction " + txHash + " takes too long to be mined");
+
+            case 15:
               filter = this.env.plygame.filters.BetMade();
               betMadeEvents = tx.logs.filter(function (log) {
                 return isSameAddress(log.topics[0], filter.topics[0]);
@@ -4862,7 +4919,7 @@ var PlyGameRead = /*#__PURE__*/function (_BlockchainEntityRead) {
                 return _this3.parseBetMakeEvent(e);
               })));
 
-            case 6:
+            case 18:
             case "end":
               return _context5.stop();
           }
@@ -5911,6 +5968,7 @@ exports.networkAddresses = networkAddresses;
 exports.queryGraphQL = queryGraphQL;
 exports.referralRewardDummy1 = referralRewardDummy1;
 exports.referralRewardDummy2 = referralRewardDummy2;
+exports.sleep = sleep;
 exports.sortEvents = sortEvents;
 exports.symbolRecords = symbolRecords;
 exports.validateAndParseAddress = validateAndParseAddress;