[quick node token] add jwt

src/modules/gql-module/abortRequest.ts

@@ -29,14 +29,16 @@ class AbortRequest<Data, ModifiedData> {
   promise: AbortPromise<ModifiedData>
   body: string
   isAborted: boolean
+  requestId: string
 
   constructor(url: RequestInfo | URL, abortRequestInit: AbortRequestInit<Data, ModifiedData>) {
     const { onSuccess, onError, ...init } = abortRequestInit
 
     this.body = init.body as string
     this.isAborted = false
+    this.requestId = `${url}_${this.body}`
 
-    const pendingRequest = requestsQueue[this.body]
+    const pendingRequest = requestsQueue[this.requestId]
 
     if (pendingRequest) {
       pendingRequest.count += 1
@@ -55,7 +57,7 @@ class AbortRequest<Data, ModifiedData> {
           return response.json().then((json) => Promise.reject(json))
         })
         .then((json) => {
-          requestsQueue[this.body] = undefined
+          requestsQueue[this.requestId] = undefined
 
           if (json?.errors) {
             throw new Error(json.errors[0].message)
@@ -69,7 +71,7 @@ class AbortRequest<Data, ModifiedData> {
           return json?.data as Data
         })
         .catch((error) => {
-          requestsQueue[this.body] = undefined
+          requestsQueue[this.requestId] = undefined
 
           if (typeof onError === 'function') {
             onError(error)
@@ -78,7 +80,7 @@ class AbortRequest<Data, ModifiedData> {
           return Promise.reject(error)
         })
 
-      requestsQueue[this.body] = {
+      requestsQueue[this.requestId] = {
         promise: this.request,
         count: 1,
       }
@@ -120,13 +122,13 @@ class AbortRequest<Data, ModifiedData> {
   abort() {
     this.isAborted = true
 
-    const count = requestsQueue[this.body]?.count || 0
+    const count = requestsQueue[this.requestId]?.count || 0
 
     if (count > 1) {
-      (requestsQueue[this.body] as PendingRequest).count -= 1
+      (requestsQueue[this.requestId] as PendingRequest).count -= 1
     }
     else {
-      requestsQueue[this.body] = undefined
+      requestsQueue[this.requestId] = undefined
       this.controller.abort()
     }
   }

src/modules/gql-module/utils/getRequestUrl.ts

@@ -1,4 +1,5 @@
 import { constants } from '../../../utils'
+import localStorage from './local-storage'
 
 
 const sessionErrorUrl = constants.sessionStorageNames.moduleErrorUrl
@@ -19,7 +20,7 @@ const getRequestUrl = (url: string | ReadonlyArray<string>): string => {
 
     const [ primaryUrl, backupUrl ] = url
 
-    const hasError = sessionStorage.getItem(sessionErrorUrl) === primaryUrl
+    const hasError = localStorage.getSessionItem<string>(sessionErrorUrl) === primaryUrl
 
     return hasError ? backupUrl : primaryUrl
   }

src/modules/gql-module/utils/local-storage/LocalStorage.ts

@@ -0,0 +1,170 @@
+/* eslint-disable no-restricted-globals */
+import MemoryStorage from './MemoryStorage'
+
+
+const ffErrors = [
+  'NS_ERROR_FAILURE', // has max size
+  'NS_ERROR_FILE_CORRUPTED', // is crashed
+  'NS_ERROR_FILE_NO_DEVICE_SPACE',
+]
+
+class LocalStorage {
+  readonly memoryLocalStorage?: MemoryStorage
+  readonly memorySessionStorage?: MemoryStorage
+
+  constructor() {
+    if (!LocalStorage.isSupported(() => localStorage)) {
+      this.memoryLocalStorage = new MemoryStorage()
+    }
+
+    if (!LocalStorage.isSupported(() => sessionStorage)) {
+      this.memorySessionStorage = new MemoryStorage()
+    }
+  }
+
+  // we should check it like this, to avoid "Operation Insecure" errors
+  // add replace it with MemoryStorage
+  private static isSupported(getStorage: () => Storage) {
+    try {
+      const testKey = '__some_random_key_you_are_not_going_to_use__'
+      getStorage().setItem(testKey, testKey)
+      getStorage().removeItem(testKey)
+      return true
+    }
+    catch (error) {
+      return false
+    }
+  }
+
+  private getLocalStorage(): Storage {
+    return this.memoryLocalStorage || localStorage
+  }
+
+  private getSessionStorage(): Storage {
+    return this.memorySessionStorage || sessionStorage
+  }
+
+  private get<T>(name: string, storage: Storage): T | null {
+    try {
+      const value = storage.getItem(name)
+
+      return value && JSON.parse(value)
+    }
+    catch (err) {
+      // @ts-ignore
+      if (ffErrors.includes(err.name)) {
+        this.clear(storage)
+
+        return null
+      }
+
+      this.remove(name, storage) // remove invalid data
+
+      return null
+    }
+  }
+
+  private set<T>(name: string, value: T, storage: Storage) {
+    try {
+      storage.setItem(name, JSON.stringify(value))
+    }
+    catch (err) {
+      // @ts-ignore
+      if (ffErrors.includes(err.name)) {
+        this.clear(storage)
+      }
+    }
+  }
+
+  private remove(name: string, storage: Storage) {
+    try {
+      storage.removeItem(name)
+    }
+    catch (error) {
+      console.error(error, name)
+    }
+  }
+
+  // to show error alert only once
+  private corruptedAlertWasShowed = false
+
+  private clear(storage: Storage) {
+    // Firefox corrupted file error, try to clean up the storage, and ignore error
+    // https://stackoverflow.com/questions/18877643/error-in-local-storage-ns-error-file-corrupted-firefox
+    try {
+      storage.clear()
+    }
+    catch (error) {
+      // @ts-ignore
+      if (ffErrors.includes(error.name) && !this.corruptedAlertWasShowed) {
+        // eslint-disable-next-line max-len
+        alert('Oops, looks like your browser storage got corrupted. Follow the steps at https://support.mozilla.org/en-US/kb/storage to fix it.')
+
+        this.corruptedAlertWasShowed = true
+      }
+    }
+  }
+
+  private keys(storage: Storage): string[] {
+    const result: string[] = []
+
+    for (let i = 0; i < storage.length; i++) {
+      const key = storage.key(i)
+
+      if (key) {
+        result.push()
+      }
+    }
+
+    return result
+  }
+
+  // localStorage
+  public getItem<T>(name: string): T | null {
+    return this.get<T>(name, this.getLocalStorage())
+  }
+
+  public setItem<T>(name: string, value: T) {
+    this.set<T>(name, value, this.getLocalStorage())
+  }
+
+  public removeItem(name: string) {
+    this.remove(name, this.getLocalStorage())
+  }
+
+  public getKeys(): string[] {
+    return this.keys(this.getLocalStorage())
+  }
+
+  public clearAll() {
+    const storage = this.getLocalStorage()
+
+    this.clear(storage)
+  }
+
+  // session storage
+  public getSessionItem<T>(name: string): T | null {
+    return this.get(name, this.getSessionStorage())
+  }
+
+  public setSessionItem<T>(name: string, value: T) {
+    this.set(name, value, this.getSessionStorage())
+  }
+
+  public removeSessionItem(name: string) {
+    this.remove(name, this.getSessionStorage())
+  }
+
+  public getSessionKeys(): string[] {
+    return this.keys(this.getSessionStorage())
+  }
+
+  public clearAllSession() {
+    const storage = this.getSessionStorage()
+
+    this.clear(storage)
+  }
+}
+
+
+export default LocalStorage

src/modules/gql-module/utils/local-storage/MemoryStorage.ts

@@ -0,0 +1,36 @@
+// This class is fallback storage when localStorage is blocked
+
+class MemoryStorage implements Storage {
+  private storage = new Map<string, string | null>()
+
+  get length(): number {
+    return this.storage.size
+  }
+
+  key(index: number): string | null {
+    return Array.from(this.storage.keys())[index] || null
+  }
+
+  getItem(key: string): string | null {
+    if (this.storage.has(key)) {
+      return this.storage.get(key) as string | null
+    }
+
+    return null
+  }
+
+  setItem(key: string, value: string) {
+    this.storage.set(key, value)
+  }
+
+  removeItem(key: string) {
+    this.storage.delete(key)
+  }
+
+  clear(): void {
+    this.storage.clear()
+  }
+}
+
+
+export default MemoryStorage

src/modules/gql-module/utils/local-storage/index.ts

@@ -0,0 +1,4 @@
+import LocalStorage from './LocalStorage'
+
+
+export default new LocalStorage()

src/modules/gql-module/utils/saveErrorUrlToSessionStorage.ts

@@ -1,16 +1,17 @@
 import { constants } from '../../../utils'
+import localStorage from './local-storage'
 
 
 const sessionErrorUrl = constants.sessionStorageNames.moduleErrorUrl
 
 const saveErrorUrlToSessionStorage = (url: string) => {
-  const currentErrorUrl = sessionStorage.getItem(sessionErrorUrl)
+  const currentErrorUrl = localStorage.getSessionItem<string>(sessionErrorUrl)
 
   if (currentErrorUrl !== url) {
-    sessionStorage.setItem(sessionErrorUrl, url)
+    localStorage.setSessionItem(sessionErrorUrl, url)
 
     setTimeout(() => {
-      sessionStorage.removeItem(sessionErrorUrl)
+      localStorage.removeSessionItem(sessionErrorUrl)
     },  60 * 60 * 1000) // 1 hour
   }
 }

src/types/global.ts

@@ -44,13 +44,20 @@ declare global {
       send: () => any
     }
 
+    type UrlWithHeaders = {
+      url: string
+      headers: Record<string, string>
+    }
+
+    type Web3Endpoints = string | string[] | UrlWithHeaders[]
+
     type Options = {
       network: Network
       provider?: Provider
       endpoints?: {
         api?: string
         subgraph?: string | ReadonlyArray<string>
-        web3?: string | string[]
+        web3?: Web3Endpoints
       }
     }