@domino-sdk/relay 0.24.0 → 0.25.0

package/dist/chunk-MZFUQQDP.js

@@ -0,0 +1,355 @@
+import {
+  createRelayClient
+} from "./chunk-S44XSDW2.js";
+import {
+  cosmosNetworks
+} from "./chunk-7QICEKC2.js";
+
+// src/base58.ts
+var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58(bytes) {
+  let zeros = 0;
+  while (zeros < bytes.length && bytes[zeros] === 0) {
+    zeros++;
+  }
+  const digits = [];
+  for (let index = zeros; index < bytes.length; index++) {
+    let carry = bytes[index];
+    for (let digit = 0; digit < digits.length; digit++) {
+      carry += digits[digit] * 256;
+      digits[digit] = carry % 58;
+      carry = Math.floor(carry / 58);
+    }
+    while (carry > 0) {
+      digits.push(carry % 58);
+      carry = Math.floor(carry / 58);
+    }
+  }
+  let result = "1".repeat(zeros);
+  for (let digit = digits.length - 1; digit >= 0; digit--) {
+    result += alphabet[digits[digit]];
+  }
+  return result;
+}
+
+// src/wallet-browser.ts
+function injected() {
+  return typeof window === "undefined" ? void 0 : window;
+}
+function slug(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+}
+function utf8Hex(message) {
+  let hex = "0x";
+  for (const byte of new TextEncoder().encode(message)) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+var noAccount = "The wallet didn't share an account. Unlock it and try again.";
+function evmSigner(provider, info = {}) {
+  return {
+    chain: "eip155",
+    name: info.name,
+    async address() {
+      const accounts = await provider.request({
+        method: "eth_requestAccounts"
+      });
+      const account = Array.isArray(accounts) ? accounts[0] : void 0;
+      if (typeof account !== "string") {
+        throw new Error(noAccount);
+      }
+      return account;
+    },
+    async chainId() {
+      const id = await provider.request({ method: "eth_chainId" });
+      const parsed = typeof id === "string" ? Number.parseInt(id, 16) : NaN;
+      return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : 1;
+    },
+    async sign(message, address) {
+      const signature = await provider.request({
+        method: "personal_sign",
+        params: [utf8Hex(message), address]
+      });
+      if (typeof signature !== "string") {
+        throw new Error("The wallet returned no signature.");
+      }
+      return { signature };
+    }
+  };
+}
+function solanaSigner(provider, info = {}) {
+  return {
+    chain: "solana",
+    name: info.name,
+    async address() {
+      const connected = await provider.connect();
+      const key = connected?.publicKey ?? provider.publicKey;
+      if (!key) {
+        throw new Error(noAccount);
+      }
+      return key.toBase58();
+    },
+    async sign(message) {
+      const signed = await provider.signMessage(
+        new TextEncoder().encode(message),
+        "utf8"
+      );
+      return {
+        signature: base58(
+          signed instanceof Uint8Array ? signed : signed.signature
+        )
+      };
+    }
+  };
+}
+function walletStandardSolanaSigner(wallet) {
+  let connected;
+  function feature(name) {
+    const value = wallet.features[name];
+    if (!value) {
+      throw new Error(`${wallet.name} doesn't support ${name}.`);
+    }
+    return value;
+  }
+  return {
+    chain: "solana",
+    name: wallet.name,
+    async address() {
+      const { accounts } = await feature("standard:connect").connect();
+      const available = accounts.length ? accounts : wallet.accounts;
+      connected = available.find(
+        (account) => account.chains.some((chain) => chain.startsWith("solana:"))
+      ) ?? available[0];
+      if (!connected) {
+        throw new Error(noAccount);
+      }
+      return connected.address;
+    },
+    async sign(message, address) {
+      const account = connected?.address === address ? connected : wallet.accounts.find((candidate) => candidate.address === address);
+      if (!account) {
+        throw new Error("Connect this wallet before signing.");
+      }
+      const [signed] = await feature(
+        "solana:signMessage"
+      ).signMessage({ account, message: new TextEncoder().encode(message) });
+      if (!signed) {
+        throw new Error("The wallet returned no signature.");
+      }
+      return { signature: base58(signed.signature) };
+    }
+  };
+}
+function cosmosSigner(provider, network, info = {}) {
+  const { chainId } = cosmosNetworks[network];
+  return {
+    chain: "cosmos",
+    network,
+    name: info.name,
+    async address() {
+      await provider.enable(chainId);
+      return (await provider.getKey(chainId)).bech32Address;
+    },
+    async sign(message, address) {
+      const { signature, pub_key } = await provider.signArbitrary(
+        chainId,
+        address,
+        message
+      );
+      if (pub_key.type !== "tendermint/PubKeySecp256k1") {
+        throw new Error(
+          "This wallet uses Ethermint keys, which Relay does not support"
+        );
+      }
+      return { signature, publicKey: pub_key.value };
+    }
+  };
+}
+async function discoverEvmWallets(timeoutMs = 300) {
+  const target = injected();
+  if (!target) {
+    return [];
+  }
+  const found = /* @__PURE__ */ new Map();
+  const announce = (event) => {
+    const detail = event.detail;
+    const info = detail?.info;
+    if (!info?.uuid || !detail?.provider || found.has(info.uuid)) {
+      return;
+    }
+    const name = info.name || "Browser wallet";
+    found.set(info.uuid, {
+      id: info.rdns || info.uuid,
+      name,
+      ...info.icon ? { icon: info.icon } : {},
+      signer: evmSigner(detail.provider, { name })
+    });
+  };
+  target.addEventListener("eip6963:announceProvider", announce);
+  try {
+    target.dispatchEvent(new Event("eip6963:requestProvider"));
+    await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+  } finally {
+    target.removeEventListener("eip6963:announceProvider", announce);
+  }
+  if (!found.size && target.ethereum) {
+    return [
+      {
+        id: "injected",
+        name: "Browser wallet",
+        signer: evmSigner(target.ethereum, { name: "Browser wallet" })
+      }
+    ];
+  }
+  return [...found.values()];
+}
+function isSolanaInjected(value) {
+  const provider = value;
+  return typeof provider?.connect === "function" && typeof provider.signMessage === "function";
+}
+function discoverSolanaWallets() {
+  const target = injected();
+  if (!target) {
+    return [];
+  }
+  const standard = [];
+  const api = {
+    register(...wallets2) {
+      for (const wallet of wallets2) {
+        if (!standard.includes(wallet)) {
+          standard.push(wallet);
+        }
+      }
+      return () => {
+      };
+    }
+  };
+  const registered = (event) => {
+    const callback = event.detail;
+    if (typeof callback === "function") {
+      try {
+        callback(api);
+      } catch {
+      }
+    }
+  };
+  target.addEventListener("wallet-standard:register-wallet", registered);
+  try {
+    target.dispatchEvent(
+      new CustomEvent("wallet-standard:app-ready", { detail: api })
+    );
+  } finally {
+    target.removeEventListener("wallet-standard:register-wallet", registered);
+  }
+  const wallets = [];
+  const seen = /* @__PURE__ */ new Set();
+  function add(name, signer, icon) {
+    if (!wallets.some((wallet) => wallet.name === name)) {
+      wallets.push({ id: slug(name), name, ...icon ? { icon } : {}, signer });
+    }
+  }
+  for (const wallet of standard) {
+    if (wallet.features["standard:connect"] && wallet.features["solana:signMessage"]) {
+      add(wallet.name, walletStandardSolanaSigner(wallet), wallet.icon);
+    }
+  }
+  for (const [name, provider] of [
+    ["Phantom", target.phantom?.solana],
+    ["Solflare", target.solflare],
+    ["Backpack", target.backpack?.solana],
+    ["Solana wallet", target.solana]
+  ]) {
+    if (isSolanaInjected(provider) && !seen.has(provider)) {
+      seen.add(provider);
+      add(name, solanaSigner(provider, { name }));
+    }
+  }
+  return wallets;
+}
+function discoverCosmosWallets(network) {
+  const target = injected();
+  if (!target) {
+    return [];
+  }
+  const wallets = [];
+  for (const [name, provider] of [
+    ["Keplr", target.keplr],
+    ["Leap", target.leap],
+    ["Cosmostation", target.cosmostation?.providers?.keplr]
+  ]) {
+    if (typeof provider?.signArbitrary === "function") {
+      wallets.push({
+        id: `${slug(name)}:${cosmosNetworks[network].chainId}`,
+        name,
+        signer: cosmosSigner(provider, network, { name })
+      });
+    }
+  }
+  return wallets;
+}
+
+// src/browser.ts
+function createBrowserRelayClient(options) {
+  return createRelayClient({
+    ...options,
+    submissionStore: options.submissionStore ?? browserSubmissionStore()
+  });
+}
+function browserSubmissionStore() {
+  let database;
+  function open() {
+    if (!globalThis.indexedDB || !globalThis.navigator?.locks) {
+      throw new Error(
+        "This browser cannot safely save submissions. Use a browser with IndexedDB and Web Locks enabled."
+      );
+    }
+    return database ??= new Promise((resolve, reject) => {
+      const request = indexedDB.open("domino-relay-submissions", 1);
+      request.onupgradeneeded = () => request.result.createObjectStore("submissions");
+      request.onerror = () => reject(new Error("Could not open submission storage"));
+      request.onsuccess = () => resolve(request.result);
+      request.onblocked = () => reject(new Error("Close other Relay tabs and try again"));
+    });
+  }
+  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(
+        new Error(
+          "Could not save submission progress. Resume the saved submission when browser storage is available."
+        )
+      );
+    });
+  }
+  return {
+    read: (key) => transact(key),
+    write: async (key, value) => {
+      await transact(key, value);
+    },
+    exclusive: async (key, task) => {
+      await open();
+      return navigator.locks.request(key, task);
+    }
+  };
+}
+
+export {
+  evmSigner,
+  solanaSigner,
+  walletStandardSolanaSigner,
+  cosmosSigner,
+  discoverEvmWallets,
+  discoverSolanaWallets,
+  discoverCosmosWallets,
+  createBrowserRelayClient,
+  browserSubmissionStore
+};