@domino-sdk/relay 1.0.0-next.8 → 1.0.0

package/dist/{chunk-6A6K5RUD.js → chunk-ZVIRG24J.js}

@@ -1,11 +1,12 @@
 import {
   createRelayClient
-} from "./chunk-V5R2DMGY.js";
+} from "./chunk-GZ6FJAXN.js";
 import {
   RelayErrorCode,
+  asRelayError,
   clientError,
   cosmosChain
-} from "./chunk-V7EZUZ3Z.js";
+} from "./chunk-36HTX2BM.js";
 
 // src/base58.ts
 var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -448,7 +449,10 @@ async function readSignInMethods(relay) {
       providers: [],
       email: true,
       wallets: [],
-      error: cause instanceof Error && cause.message ? cause.message : "Couldn't read the project's sign-in methods."
+      error: asRelayError(
+        cause,
+        "Couldn't read the project's sign-in methods."
+      )
     };
   }
 }
@@ -492,59 +496,158 @@ function createBrowserRelayClient(options) {
     submissionStore: options.submissionStore ?? browserSubmissionStore()
   });
 }
+var DATABASE = "domino-relay-submissions";
+var STORE = "submissions";
+var BLOCKED_GRACE_MS = 1e3;
+function errorName(error) {
+  return typeof error === "object" && error !== null && "name" in error ? String(error.name) : void 0;
+}
+function storageError(error, action) {
+  const name = errorName(error);
+  if (name === "QuotaExceededError") {
+    return clientError(
+      "Browser storage is full, so submission progress could not be saved. Free some space, then resume the saved submission.",
+      RelayErrorCode.SubmissionStorageQuota,
+      { cause: error }
+    );
+  }
+  if (name === "VersionError") {
+    return clientError(
+      "Another tab upgraded submission storage. Reload this page to continue.",
+      RelayErrorCode.SubmissionStorage,
+      { cause: error }
+    );
+  }
+  return clientError(
+    action === "open" ? "Could not open submission storage. Try again, and check that this browser allows site storage (private browsing can turn it off)." : action === "read" ? "Could not read the saved submission. Do not start another claim; try again when browser storage is available." : "Could not save submission progress. Resume the saved submission when browser storage is available.",
+    RelayErrorCode.SubmissionStorage,
+    { cause: error }
+  );
+}
 function browserSubmissionStore() {
-  let database;
-  function open() {
+  let opening;
+  function release(db) {
+    db.close();
+    if (opening?.db === db) {
+      opening = void 0;
+    }
+  }
+  function start() {
+    let unblock;
+    const current = {
+      blocked: new Promise((resolve) => unblock = resolve),
+      done: new Promise((resolve, reject) => {
+        let request;
+        try {
+          request = indexedDB.open(DATABASE, 1);
+        } catch (error) {
+          reject(storageError(error, "open"));
+          return;
+        }
+        request.onupgradeneeded = () => {
+          if (!request.result.objectStoreNames.contains(STORE)) {
+            request.result.createObjectStore(STORE);
+          }
+        };
+        request.onblocked = unblock;
+        request.onerror = () => reject(storageError(request.error, "open"));
+        request.onsuccess = () => {
+          const db = request.result;
+          db.onversionchange = () => release(db);
+          db.onclose = () => release(db);
+          current.db = db;
+          resolve(db);
+        };
+      })
+    };
+    current.done.catch(() => {
+      if (opening === current) {
+        opening = void 0;
+      }
+    });
+    return current;
+  }
+  async function connect() {
     if (!globalThis.indexedDB || !globalThis.navigator?.locks) {
       throw clientError(
         "This browser cannot safely save submissions. Use a browser with IndexedDB and Web Locks enabled.",
         RelayErrorCode.SubmissionStorage
       );
     }
-    return database ??= new Promise((resolve, reject) => {
-      const request = indexedDB.open("domino-relay-submissions", 1);
-      request.onupgradeneeded = () => request.result.createObjectStore("submissions");
-      request.onerror = () => reject(
-        clientError(
-          "Could not open submission storage",
-          RelayErrorCode.SubmissionStorage
-        )
-      );
-      request.onsuccess = () => resolve(request.result);
-      request.onblocked = () => reject(
-        clientError(
-          "Close other Relay tabs and try again",
-          RelayErrorCode.SubmissionStorage
+    if (opening?.db) {
+      return opening.db;
+    }
+    const attempt = opening ??= start();
+    let timer;
+    try {
+      return await Promise.race([
+        attempt.done,
+        attempt.blocked.then(
+          () => new Promise((_, reject) => {
+            timer = setTimeout(
+              () => reject(
+                clientError(
+                  "Submission storage is blocked by another Relay tab. Close or reload other Relay tabs, then try again.",
+                  RelayErrorCode.SubmissionStorage
+                )
+              ),
+              BLOCKED_GRACE_MS
+            );
+          })
         )
-      );
-    });
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
   }
-  async function transact(key, value) {
-    const db = await open();
-    return new Promise((resolve, reject) => {
-      const transaction = db.transaction(
-        "submissions",
-        value === void 0 ? "readonly" : "readwrite",
-        { durability: "strict" }
-      );
-      const store = transaction.objectStore("submissions");
-      const request = value === void 0 ? store.get(key) : store.put(value, key);
-      transaction.oncomplete = () => resolve(request.result);
-      transaction.onerror = transaction.onabort = () => reject(
-        clientError(
-          "Could not save submission progress. Resume the saved submission when browser storage is available.",
-          RelayErrorCode.SubmissionStorage
-        )
-      );
-    });
+  async function transact(key, action, value) {
+    for (let retry = true; ; retry = false) {
+      const db = await connect();
+      let transaction;
+      try {
+        transaction = db.transaction(
+          STORE,
+          action === "read" ? "readonly" : "readwrite",
+          { durability: "strict" }
+        );
+      } catch (error) {
+        release(db);
+        if (retry && errorName(error) === "InvalidStateError") {
+          continue;
+        }
+        throw storageError(error, action);
+      }
+      return new Promise((resolve, reject) => {
+        let request;
+        function fail(error) {
+          if (errorName(error) !== "QuotaExceededError") {
+            release(db);
+          }
+          reject(storageError(error, action));
+        }
+        try {
+          const objects = transaction.objectStore(STORE);
+          request = action === "read" ? objects.get(key) : objects.put(value, key);
+        } catch (error) {
+          try {
+            transaction.abort();
+          } catch {
+          }
+          fail(error);
+          return;
+        }
+        transaction.oncomplete = () => resolve(request.result);
+        transaction.onabort = () => fail(transaction.error ?? request.error);
+      });
+    }
   }
   return {
-    read: (key) => transact(key),
+    read: (key) => transact(key, "read"),
     write: async (key, value) => {
-      await transact(key, value);
+      await transact(key, "write", value);
     },
     exclusive: async (key, task) => {
-      await open();
+      await connect();
       return navigator.locks.request(key, task);
     }
   };