@ethereansos/interfaces-core 0.4.145 → 0.4.148

package/dist/index.cjs.js

@@ -64049,6 +64049,174 @@ const gBase64 = {
     extendBuiltins: extendBuiltins,
 };
 
+(typeof window === "undefined" ? "undefined" : _typeof(window)).toLowerCase() === 'undefined' && (global.window = global);
+var dbEngine = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+window.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction || {
+  READ_WRITE: 'readwrite'
+};
+window.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
+var dbName = 'ethereansos';
+var dbTable = 'ethereansos';
+var dbVersion = 1;
+var internalDB;
+
+function openDB(name, version) {
+  return new Promise(function (ok, ko) {
+    if (internalDB) {
+      return ok(internalDB);
+    }
+
+    var request = dbEngine.open(name, version);
+
+    request.onerror = function (event) {
+      return ko(event.target.errorCode);
+    };
+
+    request.onsuccess = function (event) {
+      return ok(internalDB = event.target.result);
+    };
+
+    request.onupgradeneeded = function (event) {
+      var store = event.target.result.createObjectStore(dbTable, {
+        autoIncrement: true
+      });
+      store.createIndex('key', 'key', {
+        unique: true
+      });
+    };
+  });
+}
+
+function setItem(key, value) {
+  return new Promise( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(ok, ko) {
+      var db, txn, store, query;
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return openDB(dbName, dbVersion);
+
+            case 2:
+              db = _context2.sent;
+              txn = db.transaction(dbTable, 'readwrite');
+              store = txn.objectStore(dbTable);
+              query = store.put(value && _typeof(value).toLowerCase() === 'string' ? value : JSON.stringify(value || null), key);
+
+              query.onsuccess = function (event) {
+                return ok(event.target.result);
+              };
+
+              query.onerror = function (event) {
+                return ko(event.target.error || event.target.errorCode);
+              };
+
+              txn.oncomplete = /*#__PURE__*/_asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+                return regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) {
+                    switch (_context.prev = _context.next) {
+                      case 0:
+                      case "end":
+                        return _context.stop();
+                    }
+                  }
+                }, _callee);
+              }));
+
+            case 9:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+}
+
+function getItem(key) {
+  return new Promise( /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(ok, ko) {
+      var db, txn, store, index, query;
+      return regeneratorRuntime.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              _context4.next = 2;
+              return openDB(dbName, dbVersion);
+
+            case 2:
+              db = _context4.sent;
+              txn = db.transaction(dbTable, 'readonly');
+              store = txn.objectStore(dbTable);
+              index = store.index('key');
+              query = index.get(key);
+
+              query.onsuccess = function (event) {
+                var _event$target, _event$target$result;
+
+                return ok(((_event$target = event.target) === null || _event$target === void 0 ? void 0 : (_event$target$result = _event$target.result) === null || _event$target$result === void 0 ? void 0 : _event$target$result.value) || 'null');
+              };
+
+              query.onerror = function (event) {
+                return ko(event.target.error || event.target.errorCode);
+              };
+
+              txn.oncomplete = /*#__PURE__*/_asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
+                return regeneratorRuntime.wrap(function _callee3$(_context3) {
+                  while (1) {
+                    switch (_context3.prev = _context3.next) {
+                      case 0:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }
+                }, _callee3);
+              }));
+
+            case 10:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4);
+    }));
+
+    return function (_x3, _x4) {
+      return _ref3.apply(this, arguments);
+    };
+  }());
+}
+
+function clear(_x5) {
+  return _clear.apply(this, arguments);
+}
+
+function _clear() {
+  _clear = _asyncToGenerator$1( /*#__PURE__*/regeneratorRuntime.mark(function _callee5(key) {
+    return regeneratorRuntime.wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  }));
+  return _clear.apply(this, arguments);
+}
+
+var cache = window.ethereansOSCache = {
+  getItem: getItem,
+  setItem: setItem,
+  clear: clear
+};
+
 function memoryFetch(_x, _x2) {
   return _memoryFetch.apply(this, arguments);
 }
@@ -64079,42 +64247,61 @@ function _memoryFetch() {
 
           case 8:
             key = web3Utils__default["default"].sha3(url);
+            _context.prev = 9;
+            _context.t0 = JSON;
+            _context.next = 13;
+            return cache.getItem(key);
 
-            try {
-              element = JSON.parse(window.localStorage.getItem(key));
-            } catch (e) {}
+          case 13:
+            _context.t1 = _context.sent;
+            element = _context.t0.parse.call(_context.t0, _context.t1);
+            _context.next = 19;
+            break;
 
+          case 17:
+            _context.prev = 17;
+            _context.t2 = _context["catch"](9);
+
+          case 19:
             if (!element) {
-              _context.next = 12;
+              _context.next = 21;
               break;
             }
 
             return _context.abrupt("return", element);
 
-          case 12:
-            _context.next = 14;
+          case 21:
+            _context.next = 23;
             return fetch(url);
 
-          case 14:
+          case 23:
             element = _context.sent;
-            _context.next = 17;
+            _context.next = 26;
             return element[type || 'json']();
 
-          case 17:
+          case 26:
             element = _context.sent;
+            _context.prev = 27;
+            _context.next = 30;
+            return cache.setItem(key, JSON.stringify(element));
 
-            try {
-              window.localStorage.setItem(key, JSON.stringify(element));
-            } catch (e) {}
+          case 30:
+            _context.next = 34;
+            break;
+
+          case 32:
+            _context.prev = 32;
+            _context.t3 = _context["catch"](27);
 
+          case 34:
             return _context.abrupt("return", element);
 
-          case 20:
+          case 35:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee);
+    }, _callee, null, [[9, 17], [27, 32]]);
   }));
   return _memoryFetch.apply(this, arguments);
 }
@@ -65434,6 +65621,7 @@ exports.Wordlist = Wordlist;
 exports.abi = abi;
 exports.add = add;
 exports.blockchainCall = blockchainCall;
+exports.cache = cache;
 exports.checkCoverSize = checkCoverSize;
 exports.computePoolAddress = computePoolAddress;
 exports.computePriceImpact = computePriceImpact;