@the_library/public 1.0.0

package/dist/web3/index.js

@@ -0,0 +1,1020 @@
+import {
+  DEFAULT_CHAIN_ID,
+  EVM_CHAINS,
+  EventBus,
+  EventName,
+  EvmClient,
+  MetaMaskConnector,
+  PrivateKeyConnector,
+  SubscriptionClient,
+  WalletError,
+  WalletEvents,
+  WalletState,
+  WalletUxError,
+  addressFromPrivateKey,
+  addressRegistryAbi,
+  allRegisteredAccounts,
+  createEvmClient,
+  createMetaMaskConnector,
+  createPrivateKeyConnector,
+  createPrivateKeyWalletClient,
+  createSessionStore,
+  cursorStore,
+  deserializeCursor,
+  emptyCursor,
+  getCachedEmail,
+  getChain,
+  getConnector,
+  getDecryptedPrivateKey,
+  getEventBus,
+  getEvmClient,
+  getPrivateKey,
+  getReadClient,
+  getReadyEvmClient,
+  getRegisteredConnectors,
+  getSubscriptionClient,
+  hasAnyPrivateKey,
+  hasEncryptedPrivateKey,
+  hasPrivateKey,
+  hasUnsavedPatches,
+  loadNetworkInfos,
+  loadProject,
+  loadProjects,
+  normalizeError,
+  projectLocale,
+  pythAbi,
+  readOnlyClients,
+  readOnlyStagingClients,
+  registerConnector,
+  restoreAccountSave,
+  serializeCursor,
+  sessionStore,
+  setCachedEmail,
+  storeEncryptedPrivateKey,
+  storePrivateKey,
+  stringToBytes4,
+  syncAccount,
+  toViemChain
+} from "../chunk-PUYDAUCI.js";
+import {
+  CACHE_DURATION_MS,
+  NodeFileCacheStorage,
+  RegistryAddressLoader,
+  addressLoader,
+  createNodeFileCacheStorage,
+  getContractAbi,
+  getRegistryBaseUrl,
+  setRegistryBaseUrl,
+  sidecarUrlsFromManifest
+} from "../chunk-3L6LH2XK.js";
+import {
+  getNbPatches
+} from "../chunk-ZEZGI2TP.js";
+
+// src/web3/client/types.ts
+var LibraryOwnership = /* @__PURE__ */ ((LibraryOwnership2) => {
+  LibraryOwnership2[LibraryOwnership2["Public"] = 0] = "Public";
+  LibraryOwnership2[LibraryOwnership2["Private"] = 1] = "Private";
+  return LibraryOwnership2;
+})(LibraryOwnership || {});
+var PreferredFormat = /* @__PURE__ */ ((PreferredFormat2) => {
+  PreferredFormat2[PreferredFormat2["MARC21"] = 0] = "MARC21";
+  PreferredFormat2[PreferredFormat2["UNIMARC"] = 1] = "UNIMARC";
+  PreferredFormat2[PreferredFormat2["MARCXML"] = 2] = "MARCXML";
+  PreferredFormat2[PreferredFormat2["DublinCore"] = 3] = "DublinCore";
+  PreferredFormat2[PreferredFormat2["MODS"] = 4] = "MODS";
+  PreferredFormat2[PreferredFormat2["BIBFRAME"] = 5] = "BIBFRAME";
+  PreferredFormat2[PreferredFormat2["ONIX"] = 6] = "ONIX";
+  PreferredFormat2[PreferredFormat2["OPDS"] = 7] = "OPDS";
+  PreferredFormat2[PreferredFormat2["InternetArchive"] = 8] = "InternetArchive";
+  PreferredFormat2[PreferredFormat2["HathiTrust"] = 9] = "HathiTrust";
+  PreferredFormat2[PreferredFormat2["EAD"] = 10] = "EAD";
+  PreferredFormat2[PreferredFormat2["Other"] = 11] = "Other";
+  return PreferredFormat2;
+})(PreferredFormat || {});
+
+// src/web3/client/EvmWriteClient.ts
+import {
+  parseEther
+} from "viem";
+var EvmWriteClient = class {
+  constructor(wallet, readonlyApi, walletClient, account) {
+    this.wallet = wallet;
+    this.readonly = readonlyApi;
+    this.config = readonlyApi.config;
+    this.environment = readonlyApi.environment;
+    this.chain = readonlyApi.chain;
+    this.publicClient = readonlyApi.publicClient;
+    this._account = account;
+    this.writeOnly = {
+      factory: this.createFactoryWriteAPI(walletClient),
+      subscriptionManager: this.createSubscriptionManagerWriteAPI(walletClient),
+      addressRegistry: this.createAddressRegistryWriteAPI(walletClient),
+      libraryRegistryStorage: this.createLibraryRegistryStorageWriteAPI(walletClient),
+      publicLibraryStorage: this.createPublicLibraryStorageWriteAPI(walletClient)
+    };
+  }
+  get factory() {
+    return this.writeOnly.factory;
+  }
+  get subscriptionManager() {
+    return this.writeOnly.subscriptionManager;
+  }
+  get addressRegistry() {
+    return this.writeOnly.addressRegistry;
+  }
+  get libraryRegistryStorage() {
+    return this.writeOnly.libraryRegistryStorage;
+  }
+  get publicLibraryStorage() {
+    return this.writeOnly.publicLibraryStorage;
+  }
+  getChainId() {
+    return this.readonly.chainId;
+  }
+  account() {
+    return this._account;
+  }
+  getNormalizedAddress(address) {
+    return address.toLowerCase();
+  }
+  requireAbi(contractName) {
+    const abi = addressLoader.getAbi(this.readonly.chainId, contractName, this.environment);
+    if (!abi) {
+      throw new Error(
+        `[EvmWriteClient] Registry ABI for '${contractName}' on chain ${this.readonly.chainId} is not loaded. The AddressRegistry may be offline, incomplete, or the chain has not finished syncing. Write operations are blocked until the registry is ready.`
+      );
+    }
+    return abi;
+  }
+  // Was duplicated identically inside createFactoryWriteAPI and
+  // createSubscriptionManagerWriteAPI as a local closure each — hoisted here
+  // once consolidation made the duplication visible in one file.
+  getFactoryAddress() {
+    const dynamic = addressLoader.getAddress(this.readonly.chainId, "factory", this.environment);
+    if (!dynamic) {
+      throw new Error(
+        `Factory address not resolved for chain ${this.readonly.chainId} (${this.environment}) \u2014 await client.ready before writing.`
+      );
+    }
+    return dynamic;
+  }
+  // AddressRegistry's own ABI is static (see requireAbi's comment on EvmClient's
+  // bootstrap exception) and so is its address per environment — mirrors
+  // EvmClient's private activeRegistryAddress getter.
+  getRegistryAddress() {
+    const address = this.environment === "staging" && this.config.addresses?.stagingAddressRegistry ? this.config.addresses.stagingAddressRegistry : this.config.addresses?.addressRegistry;
+    if (!address) {
+      throw new Error(`AddressRegistry address not configured for chain ${this.readonly.chainId} (${this.environment})`);
+    }
+    return address;
+  }
+  createFactoryWriteAPI(walletClient) {
+    const pushPythPrice = async () => {
+      if (!this.config.main) return;
+      const { price } = this.config;
+      if (price.stable) return;
+      const { pythOracle, usdPriceId } = price;
+      if (!pythOracle || !usdPriceId) return;
+      const res = await fetch(
+        `https://hermes.pyth.network/v2/updates/price/latest?ids[]=${usdPriceId}&encoding=hex`
+      );
+      if (!res.ok) throw new Error(`Hermes price fetch failed: ${res.status}`);
+      const data = await res.json();
+      const hexItems = data.binary?.data ?? [];
+      if (hexItems.length === 0) throw new Error("No price update data from Hermes");
+      const updateData = hexItems.map((h) => `0x${h}`);
+      const fee = await this.publicClient.readContract({
+        address: pythOracle,
+        abi: pythAbi,
+        functionName: "getUpdateFee",
+        args: [updateData]
+      });
+      const account = walletClient.account;
+      const hash = await walletClient.writeContract({
+        address: pythOracle,
+        abi: pythAbi,
+        functionName: "updatePriceFeeds",
+        args: [updateData],
+        account,
+        chain: this.chain,
+        value: fee
+      });
+      await this.publicClient.waitForTransactionReceipt({ hash });
+    };
+    return {
+      donateToProject: async (projectId, lang, amount, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getFactoryAddress();
+          const votes = BigInt(Math.round(amount));
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "voteForProject",
+            args: [projectId, stringToBytes4(lang), votes],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      register: async (country, language, paymentValue, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          await walletClient.getAddresses();
+          const address = this.getFactoryAddress();
+          const valueInWei = parseEther(String(paymentValue));
+          await pushPythPrice();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "register",
+            args: [country, language, 0n],
+            account,
+            chain: this.chain,
+            value: valueInWei,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      unregister: async (options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "unregister",
+            args: [],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      save: async (patches, level, indexes, text, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "save",
+            args: [patches, level, indexes, text],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      createProject: async (lang, uri, publicationDate, name, headline, arweaveAddressLogo, arweaveAddressBanner, descriptionMarkdown, minimumFundingBeforeStartWork, maximumFunding, tags, complexity, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "createProject",
+            args: [
+              stringToBytes4(lang),
+              uri,
+              publicationDate,
+              name,
+              headline,
+              arweaveAddressLogo,
+              arweaveAddressBanner,
+              descriptionMarkdown,
+              minimumFundingBeforeStartWork,
+              maximumFunding,
+              tags,
+              complexity
+            ],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      registerStripe: async (country, language, paymentIntentId, votes, signature, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) throw new Error("No account connected to wallet");
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "registerStripe",
+            args: [country, language, paymentIntentId, votes, 0, signature],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      fundStripe: async (paymentIntentId, votes, signature, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) throw new Error("No account connected to wallet");
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "fundStripe",
+            args: [paymentIntentId, votes, signature],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      addProjectVersion: async (projectId, lang, publicationDate, uri, name, headline, arweaveAddressLogo, arweaveAddressBanner, descriptionMarkdown, minimumFundingBeforeStartWork, maximumFunding, tags, status, complexity, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "addProjectVersion",
+            args: [
+              BigInt(projectId),
+              stringToBytes4(lang),
+              publicationDate,
+              uri,
+              name,
+              headline,
+              arweaveAddressLogo,
+              arweaveAddressBanner,
+              descriptionMarkdown,
+              minimumFundingBeforeStartWork,
+              maximumFunding,
+              tags,
+              status,
+              complexity
+            ],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      deleteProject: async (projectId, lang, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "deleteProject",
+            args: [projectId, stringToBytes4(lang)],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      }
+    };
+  }
+  createSubscriptionManagerWriteAPI(walletClient) {
+    return {
+      subscribeTo: async (subscriber, target, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const targetUsername = await this.readonly.bouncerStorage.userIdToUsername(target);
+          if (!targetUsername) {
+            throw new Error(`Target user ID ${target} not registered (no username found)`);
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "subscribeTo",
+            args: [targetUsername],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      },
+      unsubscribeFrom: async (subscriber, target, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const targetUsername = await this.readonly.bouncerStorage.userIdToUsername(target);
+          if (!targetUsername) {
+            throw new Error(`Target user ID ${target} not registered (no username found)`);
+          }
+          const address = this.getFactoryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: this.requireAbi("Factory"),
+            functionName: "unsubscribeFrom",
+            args: [targetUsername],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      }
+    };
+  }
+  createAddressRegistryWriteAPI(walletClient) {
+    return {
+      addData: async (key, value, options) => {
+        try {
+          const account = walletClient.account;
+          if (!account) {
+            throw new Error("No account connected to wallet");
+          }
+          const address = this.getRegistryAddress();
+          const hash = await walletClient.writeContract({
+            address,
+            abi: addressRegistryAbi,
+            functionName: "addData",
+            args: [key, value],
+            account,
+            chain: this.chain,
+            gas: options?.gasLimit
+          });
+          options?.onAccepted?.(hash);
+          const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+          if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("wallet_transaction_accepted"));
+          }
+          return receipt;
+        } catch (error) {
+          throw normalizeError(error);
+        }
+      }
+    };
+  }
+  getLibraryRegistryStorageAddress() {
+    const dynamic = addressLoader.getAddress(this.readonly.chainId, "libraryRegistryStorage", this.environment);
+    if (!dynamic) {
+      throw new Error(
+        `LibraryRegistryStorage address not resolved for chain ${this.readonly.chainId} (${this.environment}) \u2014 await client.ready before writing.`
+      );
+    }
+    return dynamic;
+  }
+  createLibraryRegistryStorageWriteAPI(walletClient) {
+    const executeWrite = async (functionName, args, options) => {
+      try {
+        const account = walletClient.account;
+        if (!account) throw new Error("No account connected to wallet");
+        const address = this.getLibraryRegistryStorageAddress();
+        const hash = await walletClient.writeContract({
+          address,
+          abi: this.requireAbi("LibraryRegistryStorage"),
+          functionName,
+          args,
+          account,
+          chain: this.chain,
+          gas: options?.gasLimit
+        });
+        options?.onAccepted?.(hash);
+        const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+        if (typeof window !== "undefined") {
+          window.dispatchEvent(new Event("wallet_transaction_accepted"));
+        }
+        return receipt;
+      } catch (error) {
+        throw normalizeError(error);
+      }
+    };
+    return {
+      addUnverifiedCollection: (input, options) => executeWrite("addUnverifiedCollection", [input], options),
+      verifyCollection: (id, options) => executeWrite("verifyCollection", [id], options),
+      rejectCollection: (id, options) => executeWrite("rejectCollection", [id], options),
+      updateCollectionStats: (id, initialBookCount, dSafeBookCount, options) => executeWrite("updateCollectionStats", [id, BigInt(initialBookCount), BigInt(dSafeBookCount)], options),
+      setImportStatus: (id, status, options) => executeWrite("setImportStatus", [id, status], options),
+      setPublished: (id, isPublished, options) => executeWrite("setPublished", [id, isPublished], options),
+      setCollectionPublicLibrary: (id, publicLibraryId, options) => executeWrite("setCollectionPublicLibrary", [id, BigInt(publicLibraryId)], options),
+      setPublicLibraryStorage: (storageAddr, options) => executeWrite("setPublicLibraryStorage", [storageAddr], options)
+    };
+  }
+  getPublicLibraryStorageAddress() {
+    const dynamic = addressLoader.getAddress(this.readonly.chainId, "publicLibraryStorage", this.environment);
+    if (!dynamic) {
+      throw new Error(
+        `PublicLibraryStorage address not resolved for chain ${this.readonly.chainId} (${this.environment}) \u2014 await client.ready before writing.`
+      );
+    }
+    return dynamic;
+  }
+  createPublicLibraryStorageWriteAPI(walletClient) {
+    const executeWrite = async (functionName, args, options) => {
+      try {
+        const account = walletClient.account;
+        if (!account) throw new Error("No account connected to wallet");
+        const address = this.getPublicLibraryStorageAddress();
+        const hash = await walletClient.writeContract({
+          address,
+          abi: this.requireAbi("PublicLibraryStorage"),
+          functionName,
+          args,
+          account,
+          chain: this.chain,
+          gas: options?.gasLimit
+        });
+        options?.onAccepted?.(hash);
+        const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+        if (typeof window !== "undefined") {
+          window.dispatchEvent(new Event("wallet_transaction_accepted"));
+        }
+        return receipt;
+      } catch (error) {
+        throw normalizeError(error);
+      }
+    };
+    return {
+      addPublicLibrary: (input, options) => executeWrite("addPublicLibrary", [input], options),
+      updatePublicLibrary: (id, input, options) => executeWrite("updatePublicLibrary", [BigInt(id), input], options)
+    };
+  }
+};
+
+// src/web3/session/writeClient.ts
+async function createWriteClient(connector, chainId, environment = "production") {
+  const evmConnector = connector;
+  if (typeof evmConnector.getWalletClient !== "function") {
+    throw new Error(`Connector '${connector.type}' does not support EVM write operations`);
+  }
+  const accounts = await connector.getAccounts();
+  const account = accounts[0];
+  if (!account) {
+    throw new Error(`No account available for wallet '${connector.type}' \u2014 connect() first`);
+  }
+  const evmClient = await getReadyEvmClient(chainId, environment);
+  const walletClient = await evmConnector.getWalletClient(chainId);
+  return new EvmWriteClient(connector.type, evmClient, walletClient, account);
+}
+async function createPrivateKeyWriteClient(chainId, privateKey, environment = "production") {
+  const evmClient = await getReadyEvmClient(chainId, environment);
+  const walletClient = createPrivateKeyWalletClient(chainId, privateKey);
+  const account = addressFromPrivateKey(privateKey);
+  return new EvmWriteClient("private_key", evmClient, walletClient, account);
+}
+
+// src/web3/session/mutations.ts
+import { serializePatches, getLevel } from "@the_library/public/models";
+var running = { lastRun: 0, running: false };
+var resetTransactionState = () => {
+  running.running = false;
+  running.lastRun = 0;
+};
+var checkRunning = () => {
+  if (running.running && Date.now() - running.lastRun < 1e3 * 60) {
+    return false;
+  }
+  running.lastRun = Date.now();
+  running.running = true;
+  return true;
+};
+var handleWriteOperationErrors = (wallet, chainId, e) => {
+  console.error(`[session/mutations] error while transaction wallet=${wallet} chainId=${chainId}`, e);
+  resetTransactionState();
+  const isUserRejection = normalizeError(e).code === "USER_REJECTED";
+  WalletEvents.emitWalletError({
+    wallet,
+    chainId,
+    timestamp: Date.now(),
+    reason: isUserRejection ? "USER_REJECTED" /* USER_REJECTED */ : e?.code ?? "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
+    args: e
+  });
+};
+var transactionStarted = (wallet, chainId) => {
+  WalletEvents.emitWalletStateEvent({ wallet, chainId, event: "TRANSACTION_STARTED" /* TRANSACTION_STARTED */, timestamp: Date.now() });
+};
+var transactionDone = (wallet, chainId) => {
+  WalletEvents.emitWalletStateEvent({ wallet, chainId, event: "TRANSACTION_DONE" /* TRANSACTION_DONE */, timestamp: Date.now() });
+};
+var preTransaction = async (wallet, chainId) => {
+  if (!checkRunning()) {
+    console.log("[session/mutations] preTransaction skipped \u2014 another transaction is running, wait 1min");
+    return false;
+  }
+  return true;
+};
+var postTransaction = async (wallet, chainId, account) => {
+  running.running = false;
+  running.lastRun = 0;
+  WalletEvents.emitWalletStateEvent({
+    wallet,
+    chainId,
+    event: "UPDATING_STATE_STARTED" /* UPDATING_STATE_STARTED */,
+    functionName: "syncAccount",
+    timestamp: Date.now()
+  });
+  try {
+    await syncAccount(account, chainId, wallet, "production", true);
+  } catch (e) {
+    WalletEvents.emitWalletStateEvent({
+      wallet,
+      chainId,
+      event: "UPDATING_STATE_FAILED" /* UPDATING_STATE_FAILED */,
+      functionName: "syncAccount",
+      timestamp: Date.now()
+    });
+    console.error(e);
+    return false;
+  }
+  WalletEvents.emitWalletStateEvent({
+    wallet,
+    chainId,
+    event: "UPDATING_STATE_DONE" /* UPDATING_STATE_DONE */,
+    functionName: "syncAccount",
+    timestamp: Date.now()
+  });
+  return true;
+};
+async function getWriteClient(wallet, chainId) {
+  const connector = getConnector(wallet);
+  if (!connector) {
+    throw new Error(`No connector registered for wallet '${wallet}' \u2014 bootstrapWebSDK() must run first`);
+  }
+  return createWriteClient(connector, chainId);
+}
+async function runWriteOperation(wallet, chainId, account, fn, afterWrite) {
+  if (!await preTransaction(wallet, chainId)) return false;
+  transactionStarted(wallet, chainId);
+  try {
+    const client = await getWriteClient(wallet, chainId);
+    await fn(client);
+  } catch (e) {
+    handleWriteOperationErrors(wallet, chainId, e);
+    throw e;
+  }
+  transactionDone(wallet, chainId);
+  afterWrite?.();
+  return postTransaction(wallet, chainId, account);
+}
+var writeOperations = {
+  register: (wallet, chainId, account, amount) => {
+    const userGeo = typeof window !== "undefined" ? window.__userGeo : void 0;
+    let countryCode;
+    let languageCode;
+    if (userGeo?.location && userGeo?.locale) {
+      countryCode = userGeo.location.toUpperCase();
+      languageCode = userGeo.locale.split("-")[0];
+    } else {
+      const defaultLanguage = "en";
+      const defaultCountry = "";
+      const hasNavigator = typeof navigator !== "undefined";
+      const parts = hasNavigator ? navigator.language.split("-") : [defaultLanguage];
+      languageCode = parts[0];
+      countryCode = parts.length > 1 ? parts[1].toUpperCase() : defaultCountry;
+    }
+    return runWriteOperation(
+      wallet,
+      chainId,
+      account,
+      (client) => client.factory.register(countryCode, languageCode, amount, { value: amount })
+    );
+  },
+  retire: (wallet, chainId, account, options) => runWriteOperation(wallet, chainId, account, (client) => client.factory.unregister(options)),
+  vote: (wallet, chainId, account, projectId, lang, amount, options) => runWriteOperation(wallet, chainId, account, (client) => client.factory.donateToProject(projectId, lang, amount, options)),
+  save: (wallet, chainId, account, compressedActions, textIndexes, textData, level, options) => runWriteOperation(
+    wallet,
+    chainId,
+    account,
+    (client) => client.factory.save(compressedActions, level, textIndexes, textData, options),
+    () => {
+      if (!options?.skipCounterUpdate) {
+        const { lastPatchIndex } = sessionStore.lastSyncCounters(account, chainId);
+        sessionStore.setLastSavedPatchIndex(account, chainId, lastPatchIndex + compressedActions.length);
+      }
+    }
+  ),
+  // postTransaction's syncAccount() refresh also runs SubscriptionClient.syncSince()
+  // (session/sync.ts) — the graph change from these two writes is picked up
+  // automatically, no bespoke "refresh subscriptions" step needed (spec §4.7/§15.8).
+  subscribe: (wallet, chainId, account, subscriber, target) => runWriteOperation(wallet, chainId, account, (client) => client.subscriptionManager.subscribeTo(subscriber, target)),
+  unsubscribe: (wallet, chainId, account, subscriber, target) => runWriteOperation(wallet, chainId, account, (client) => client.subscriptionManager.unsubscribeFrom(subscriber, target))
+};
+async function saveMyLevel(wallet, chainId, account, options) {
+  const { lastPatchIndex } = sessionStore.lastSyncCounters(account, chainId);
+  const nbPatches = await getNbPatches("mine");
+  if (nbPatches <= lastPatchIndex) return false;
+  const payload = await serializePatches(lastPatchIndex, nbPatches);
+  const level = getLevel("mine").level;
+  return writeOperations.save(wallet, chainId, account, payload.patches, payload.textIndex, payload.textData, level, options);
+}
+
+// src/web3/wallet/browsers.ts
+var Browser = /* @__PURE__ */ ((Browser2) => {
+  Browser2["chromium"] = "chromium";
+  Browser2["firefox"] = "firefox";
+  Browser2["safari"] = "safari";
+  Browser2["edge"] = "edge";
+  Browser2["opera"] = "opera";
+  Browser2["brave"] = "brave";
+  Browser2["vivaldi"] = "vivaldi";
+  Browser2["yandex"] = "yandex";
+  Browser2["palemoon"] = "palemoon";
+  return Browser2;
+})(Browser || {});
+var Platform = /* @__PURE__ */ ((Platform2) => {
+  Platform2["android"] = "android";
+  Platform2["ios"] = "ios";
+  Platform2["browsers"] = "browsers";
+  return Platform2;
+})(Platform || {});
+var parseUserAgent = (userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "") => {
+  const ua = userAgent.toLowerCase();
+  let browser;
+  if (ua.includes("yabrowser") || ua.includes("yandex")) {
+    browser = "yandex" /* yandex */;
+  } else if (ua.includes("brave")) {
+    browser = "brave" /* brave */;
+  } else if (ua.includes("vivaldi")) {
+    browser = "vivaldi" /* vivaldi */;
+  } else if (ua.includes("palemoon")) {
+    browser = "palemoon" /* palemoon */;
+  } else if (ua.includes("edg/") || ua.includes("edge/")) {
+    browser = "edge" /* edge */;
+  } else if (ua.includes("opr/") || ua.includes("opera/")) {
+    browser = "opera" /* opera */;
+  } else if (ua.includes("firefox/")) {
+    browser = "firefox" /* firefox */;
+  } else if (ua.includes("safari/") && !ua.includes("chrome/")) {
+    browser = "safari" /* safari */;
+  } else if (ua.includes("chrome/") || ua.includes("chromium/")) {
+    browser = "chromium" /* chromium */;
+  } else {
+    browser = "chromium" /* chromium */;
+  }
+  let platform;
+  if (ua.includes("android")) {
+    platform = "android" /* android */;
+  } else if (ua.includes("iphone") || ua.includes("ipad") || ua.includes("ipod")) {
+    platform = "ios" /* ios */;
+  } else {
+    platform = "browsers" /* browsers */;
+  }
+  return {
+    browser,
+    platform
+  };
+};
+
+// src/web3/wallet/walletMeta.ts
+var METAMASK_LOGO_BASE64 = "data:image/svg+xml;base64,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";
+var walletMeta = {
+  metamask: {
+    displayName: "MetaMask",
+    logoUrl: METAMASK_LOGO_BASE64,
+    description: "The most popular Ethereum wallet extension",
+    website: "https://metamask.io/",
+    isInstalled() {
+      return typeof window !== "undefined" && typeof window.ethereum !== "undefined" && window.ethereum.isMetaMask;
+    },
+    isInstallable() {
+      try {
+        this.getInstallUrl();
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    getInstallUrl(customBrowser) {
+      const { browser, platform } = parseUserAgent();
+      const targetBrowser = customBrowser || browser;
+      switch (platform) {
+        case "android" /* android */:
+          return "https://play.google.com/store/apps/details?id=io.metamask";
+        case "ios" /* ios */:
+          return "https://apps.apple.com/us/app/metamask-crypto-wallet/id1438144202";
+        case "browsers" /* browsers */:
+          switch (targetBrowser) {
+            case "chromium" /* chromium */:
+            case "brave" /* brave */:
+              return "https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn";
+            case "firefox" /* firefox */:
+              return "https://addons.mozilla.org/en-US/firefox/addon/ether-metamask/";
+            case "opera" /* opera */:
+              return "https://addons.opera.com/en/extensions/details/metamask/";
+            case "edge" /* edge */:
+              return "https://microsoftedge.microsoft.com/addons/detail/metamask/ejbalbakoplchlghecdalmeeeajnimhm";
+            default:
+              throw new Error(`Browser ${targetBrowser} is not supported for installation of MetaMask extension.`);
+          }
+        default:
+          throw new Error(`Platform ${platform} is not supported for MetaMask.`);
+      }
+    }
+  },
+  private_key: {
+    displayName: "Private Key",
+    logoUrl: "",
+    description: "Direct embedded wallet using a raw private key",
+    website: "",
+    isInstalled() {
+      return true;
+    },
+    isInstallable() {
+      return false;
+    },
+    getInstallUrl() {
+      return "";
+    }
+  }
+};
+
+// src/web3/index.ts
+import { formatEther, parseEther as parseEther2 } from "viem";
+export {
+  Browser,
+  CACHE_DURATION_MS,
+  DEFAULT_CHAIN_ID,
+  EVM_CHAINS,
+  EventBus,
+  EventName,
+  EvmClient,
+  EvmWriteClient,
+  LibraryOwnership,
+  MetaMaskConnector,
+  NodeFileCacheStorage,
+  Platform,
+  PreferredFormat,
+  PrivateKeyConnector,
+  RegistryAddressLoader,
+  SubscriptionClient,
+  WalletError,
+  WalletEvents,
+  WalletState,
+  WalletUxError,
+  addressFromPrivateKey,
+  addressLoader,
+  addressRegistryAbi,
+  allRegisteredAccounts,
+  createEvmClient,
+  createMetaMaskConnector,
+  createNodeFileCacheStorage,
+  createPrivateKeyConnector,
+  createPrivateKeyWalletClient,
+  createPrivateKeyWriteClient,
+  createSessionStore,
+  createWriteClient,
+  cursorStore,
+  deserializeCursor,
+  emptyCursor,
+  formatEther,
+  getCachedEmail,
+  getChain,
+  getConnector,
+  getContractAbi,
+  getDecryptedPrivateKey,
+  getEventBus,
+  getEvmClient,
+  getPrivateKey,
+  getReadClient,
+  getReadyEvmClient,
+  getRegisteredConnectors,
+  getRegistryBaseUrl,
+  getSubscriptionClient,
+  handleWriteOperationErrors,
+  hasAnyPrivateKey,
+  hasEncryptedPrivateKey,
+  hasPrivateKey,
+  hasUnsavedPatches,
+  loadNetworkInfos,
+  loadProject,
+  loadProjects,
+  parseEther2 as parseEther,
+  parseUserAgent,
+  projectLocale,
+  pythAbi,
+  readOnlyClients,
+  readOnlyStagingClients,
+  registerConnector,
+  resetTransactionState,
+  restoreAccountSave,
+  saveMyLevel,
+  serializeCursor,
+  sessionStore,
+  setCachedEmail,
+  setRegistryBaseUrl,
+  sidecarUrlsFromManifest,
+  storeEncryptedPrivateKey,
+  storePrivateKey,
+  syncAccount,
+  toViemChain,
+  walletMeta,
+  writeOperations
+};
+//# sourceMappingURL=index.js.map