@the_library/public 1.0.0 → 2.0.1

package/dist/chunk-PUYDAUCI.js

@@ -1,2873 +0,0 @@
-import {
-  addressLoader
-} from "./chunk-3L6LH2XK.js";
-import {
-  getAllPatchesByUsername,
-  getNbPatches
-} from "./chunk-ZEZGI2TP.js";
-
-// src/web3/network/media/core-dao-core-logo.svg
-var core_dao_core_logo_default = "./core-dao-core-logo-VDT2I5IW.svg";
-
-// src/web3/network/chains.ts
-import { defineChain } from "viem";
-var EVM_CHAINS = {
-  1116: {
-    chainId: 1116,
-    name: "Core Blockchain MainNet",
-    symbol: "CORE",
-    shortName: "TREE",
-    decimals: 18,
-    explorer: "https://scan.coredao.org",
-    rpc: "https://rpc.coredao.org",
-    website: "https://coredao.org/",
-    main: true,
-    logo: core_dao_core_logo_default,
-    price: {
-      pythOracle: "0xA2aa501b19aff244D90cc15a4Cf739D2725B5729",
-      usdPriceId: "0x9b4503710cc8c53f75c30e6e4fda1a7064680ef2e0ee97acd2e3a7c37b3c830c"
-    },
-    deployed: true,
-    addresses: {
-      addressRegistry: "0x4c1759dF25AdddbdF5399D332Ac02B2E77ED90fF"
-    }
-  },
-  1114: {
-    chainId: 1114,
-    name: "Core Blockchain TestNet",
-    symbol: "tCORE2",
-    shortName: "SUN",
-    decimals: 18,
-    explorer: "https://scan.test2.btcs.network",
-    rpc: "https://rpc.test2.btcs.network",
-    website: "https://coredao.org/",
-    main: false,
-    logo: core_dao_core_logo_default,
-    price: {
-      pythOracle: "0x8D254a21b3C86D32F7179855531CE99164721933",
-      usdPriceId: "0x9b4503710cc8c53f75c30e6e4fda1a7064680ef2e0ee97acd2e3a7c37b3c830c"
-    },
-    stagingDeployed: true,
-    addresses: {
-      stagingAddressRegistry: "0x4AB2FF5fAd69eFe62e7Fce1f06FeE5cfFBC31469"
-    }
-  }
-};
-var DEFAULT_CHAIN_ID = 1116;
-function getChain(chainId) {
-  const id = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
-  const chain = EVM_CHAINS[id];
-  if (!chain) throw new Error(`Chain ${chainId} not configured`);
-  return chain;
-}
-function toViemChain(config) {
-  return defineChain({
-    id: config.chainId,
-    name: config.name,
-    nativeCurrency: { name: config.symbol, symbol: config.symbol, decimals: config.decimals || 18 },
-    rpcUrls: { default: { http: [config.rpc] }, public: { http: [config.rpc] } }
-  });
-}
-
-// src/web3/contracts/pythAbi.ts
-var pythAbi = [
-  {
-    "inputs": [
-      {
-        "internalType": "bytes32",
-        "name": "id",
-        "type": "bytes32"
-      }
-    ],
-    "name": "getPriceUnsafe",
-    "outputs": [
-      {
-        "components": [
-          {
-            "internalType": "int64",
-            "name": "price",
-            "type": "int64"
-          },
-          {
-            "internalType": "uint64",
-            "name": "conf",
-            "type": "uint64"
-          },
-          {
-            "internalType": "int32",
-            "name": "expo",
-            "type": "int32"
-          },
-          {
-            "internalType": "uint256",
-            "name": "publishTime",
-            "type": "uint256"
-          }
-        ],
-        "internalType": "struct PythStructs.Price",
-        "name": "price",
-        "type": "tuple"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "bytes[]",
-        "name": "updateData",
-        "type": "bytes[]"
-      }
-    ],
-    "name": "getUpdateFee",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "feeAmount",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "bytes[]",
-        "name": "updateData",
-        "type": "bytes[]"
-      }
-    ],
-    "name": "updatePriceFeeds",
-    "outputs": [],
-    "stateMutability": "payable",
-    "type": "function"
-  }
-];
-
-// src/web3/contracts/addressRegistryAbi.ts
-var addressRegistryAbi = [
-  {
-    "inputs": [],
-    "stateMutability": "nonpayable",
-    "type": "constructor"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "oldAdmin",
-        "type": "address"
-      },
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "newAdmin",
-        "type": "address"
-      }
-    ],
-    "name": "AdminChanged",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      },
-      {
-        "indexed": false,
-        "internalType": "string",
-        "name": "arweaveTxId",
-        "type": "string"
-      },
-      {
-        "indexed": false,
-        "internalType": "bytes32",
-        "name": "sha256Hash",
-        "type": "bytes32"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "version",
-        "type": "uint256"
-      }
-    ],
-    "name": "BlobRefAdded",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "internalType": "string",
-        "name": "name",
-        "type": "string"
-      },
-      {
-        "indexed": true,
-        "internalType": "address",
-        "name": "contractAddress",
-        "type": "address"
-      },
-      {
-        "indexed": false,
-        "internalType": "string",
-        "name": "abiUrl",
-        "type": "string"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "version",
-        "type": "uint256"
-      }
-    ],
-    "name": "ContractAdded",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": true,
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      },
-      {
-        "indexed": false,
-        "internalType": "string",
-        "name": "value",
-        "type": "string"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint256",
-        "name": "version",
-        "type": "uint256"
-      }
-    ],
-    "name": "DataAdded",
-    "type": "event"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      },
-      {
-        "internalType": "string",
-        "name": "arweaveTxId",
-        "type": "string"
-      },
-      {
-        "internalType": "bytes32",
-        "name": "sha256Hash",
-        "type": "bytes32"
-      }
-    ],
-    "name": "addBlobRef",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "name",
-        "type": "string"
-      },
-      {
-        "internalType": "address",
-        "name": "contractAddress",
-        "type": "address"
-      },
-      {
-        "internalType": "string",
-        "name": "abiUrl",
-        "type": "string"
-      }
-    ],
-    "name": "addContract",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      },
-      {
-        "internalType": "string",
-        "name": "value",
-        "type": "string"
-      }
-    ],
-    "name": "addData",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "admin",
-    "outputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "newAdmin",
-        "type": "address"
-      }
-    ],
-    "name": "changeAdmin",
-    "outputs": [],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "getAllBlobRefKeys",
-    "outputs": [
-      {
-        "internalType": "string[]",
-        "name": "",
-        "type": "string[]"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "getAllContractNames",
-    "outputs": [
-      {
-        "internalType": "string[]",
-        "name": "",
-        "type": "string[]"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [],
-    "name": "getAllDataKeys",
-    "outputs": [
-      {
-        "internalType": "string[]",
-        "name": "",
-        "type": "string[]"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      },
-      {
-        "internalType": "uint256",
-        "name": "offset",
-        "type": "uint256"
-      },
-      {
-        "internalType": "uint256",
-        "name": "limit",
-        "type": "uint256"
-      }
-    ],
-    "name": "getBlobRefHistory",
-    "outputs": [
-      {
-        "components": [
-          {
-            "internalType": "string",
-            "name": "arweaveTxId",
-            "type": "string"
-          },
-          {
-            "internalType": "bytes32",
-            "name": "sha256Hash",
-            "type": "bytes32"
-          }
-        ],
-        "internalType": "struct AddressRegistry.BlobRef[]",
-        "name": "",
-        "type": "tuple[]"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "name",
-        "type": "string"
-      }
-    ],
-    "name": "getContractHistory",
-    "outputs": [
-      {
-        "components": [
-          {
-            "internalType": "address",
-            "name": "contractAddress",
-            "type": "address"
-          },
-          {
-            "internalType": "string",
-            "name": "abiUrl",
-            "type": "string"
-          }
-        ],
-        "internalType": "struct AddressRegistry.ContractRecord[]",
-        "name": "",
-        "type": "tuple[]"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      }
-    ],
-    "name": "getDataHistory",
-    "outputs": [
-      {
-        "internalType": "string[]",
-        "name": "",
-        "type": "string[]"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      }
-    ],
-    "name": "getLatestBlobRef",
-    "outputs": [
-      {
-        "internalType": "string",
-        "name": "",
-        "type": "string"
-      },
-      {
-        "internalType": "bytes32",
-        "name": "",
-        "type": "bytes32"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "name",
-        "type": "string"
-      }
-    ],
-    "name": "getLatestContract",
-    "outputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      },
-      {
-        "internalType": "string",
-        "name": "",
-        "type": "string"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
-  {
-    "inputs": [
-      {
-        "internalType": "string",
-        "name": "key",
-        "type": "string"
-      }
-    ],
-    "name": "getLatestData",
-    "outputs": [
-      {
-        "internalType": "string",
-        "name": "",
-        "type": "string"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  }
-];
-
-// src/web3/client/EvmClient.ts
-import { createPublicClient, http } from "viem";
-
-// src/web3/utils/strings.ts
-import { hexToString, stringToHex } from "viem";
-function bytes4ToString(hex) {
-  const cleanHex = hex.startsWith("0x") ? hex : "0x" + hex;
-  return hexToString(cleanHex).replace(/\0/g, "");
-}
-function stringToBytes4(str) {
-  const hex = stringToHex(str);
-  return hex.padEnd(10, "0").slice(0, 10);
-}
-
-// src/web3/utils/errors.ts
-import {
-  BaseError as ViemBaseError,
-  ContractFunctionRevertedError,
-  InsufficientFundsError,
-  NonceTooLowError,
-  TimeoutError as ViemTimeoutError,
-  UserRejectedRequestError
-} from "viem";
-var cbs = [];
-var Web3Error = class _Web3Error extends Error {
-  constructor(code, message, opts) {
-    super(message);
-    this.name = "Web3Error";
-    this.code = code;
-    this.reason = opts?.reason;
-    this.data = opts?.data;
-    this.originalError = opts?.originalError;
-    Object.setPrototypeOf(this, _Web3Error.prototype);
-  }
-};
-function normalizeError(error) {
-  if (error instanceof Web3Error) {
-    return error;
-  }
-  const err = normalizeEVMError(error);
-  for (const cb of cbs) {
-    try {
-      cb(err);
-    } catch (cbError) {
-      console.error("[web3/errors] registerOnErrorCb listener threw", cbError);
-    }
-  }
-  return err;
-}
-var commonNormalization = (error) => {
-  const message = error?.message || error?.reason || String(error);
-  const messageLower = message.toLowerCase();
-  if (messageLower.includes("invalid compressedactions format")) {
-    return new Web3Error("INVALID_COMPRESSED_ACTIONS", "Invalid compressedActions format", {
-      originalError: error
-    });
-  }
-  if (messageLower.includes("switch chain error")) {
-    return new Web3Error("SWITCH_CHAIN_ERROR", "Error Switching Chains", {
-      data: error.code,
-      reason: error.message,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("switching accounts while on an unsupported chainid")) {
-    return new Web3Error("SWITCH_TO_UNSUPPORTED_CHAIN", messageLower, { originalError: error });
-  }
-  return null;
-};
-var isRecognizedViemError = (error) => error instanceof UserRejectedRequestError || error instanceof InsufficientFundsError || error instanceof NonceTooLowError || error instanceof ViemTimeoutError || error instanceof ContractFunctionRevertedError;
-function normalizeTypedViemError(error) {
-  if (error instanceof ViemBaseError && !isRecognizedViemError(error)) {
-    const nested = error.walk(isRecognizedViemError);
-    if (nested) {
-      return normalizeTypedViemError(nested);
-    }
-  }
-  if (error instanceof UserRejectedRequestError) {
-    return new Web3Error("USER_REJECTED", "User rejected the transaction", {
-      reason: error.shortMessage,
-      originalError: error
-    });
-  }
-  if (error instanceof InsufficientFundsError) {
-    return new Web3Error("INSUFFICIENT_FUNDS", "Insufficient funds for transaction", {
-      reason: error.shortMessage,
-      originalError: error
-    });
-  }
-  if (error instanceof NonceTooLowError) {
-    return new Web3Error("NONCE_TOO_LOW", "Transaction nonce is too low", {
-      reason: error.shortMessage,
-      originalError: error
-    });
-  }
-  if (error instanceof ViemTimeoutError) {
-    return new Web3Error("TIMEOUT", "Request timed out", {
-      reason: error.shortMessage,
-      originalError: error
-    });
-  }
-  if (error instanceof ContractFunctionRevertedError) {
-    return new Web3Error("REVERT", "Transaction reverted by contract", {
-      reason: error.reason ?? error.data?.errorName ?? error.shortMessage,
-      data: error.data,
-      originalError: error
-    });
-  }
-  return null;
-}
-function normalizeEVMError(error) {
-  const common = commonNormalization(error);
-  if (common) {
-    return common;
-  }
-  const typed = normalizeTypedViemError(error);
-  if (typed) {
-    return typed;
-  }
-  const message = error?.message || error?.reason || String(error);
-  const messageLower = message.toLowerCase();
-  if (messageLower.includes("no account connected to wallet")) {
-    return new Web3Error("NO_WALLET_CONNECTED", "No account connected to wallet", { originalError: error });
-  }
-  if (messageLower.includes("user rejected") || messageLower.includes("user denied") || messageLower.includes("user cancelled") || error?.code === 4001 || error?.code === "ACTION_REJECTED") {
-    return new Web3Error("USER_REJECTED", "User rejected the transaction", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("insufficient funds") || messageLower.includes("insufficient balance") || error?.code === "INSUFFICIENT_FUNDS") {
-    return new Web3Error("INSUFFICIENT_FUNDS", "Insufficient funds for transaction", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("nonce too low") || messageLower.includes("nonce has already been used") || error?.code === "NONCE_EXPIRED") {
-    return new Web3Error("NONCE_TOO_LOW", "Transaction nonce is too low", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("revert") || messageLower.includes("execution reverted") || error?.code === "CALL_EXCEPTION" || error?.code === 3) {
-    return new Web3Error("REVERT", "Transaction reverted by contract", {
-      reason: error?.reason || extractRevertReason(error),
-      data: error?.data,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("timeout") || error?.code === "TIMEOUT") {
-    return new Web3Error("TIMEOUT", "Request timed out", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("network") || messageLower.includes("connection") || error?.code === "NETWORK_ERROR" || error?.code === "ETIMEDOUT") {
-    return new Web3Error("NETWORK_ERROR", "Network error occurred", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("invalid argument") || error?.code === "INVALID_ARGUMENT") {
-    return new Web3Error("INVALID_ARGUMENT", "Invalid argument provided", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  if (messageLower.includes("unsupported") || error?.code === "UNSUPPORTED_OPERATION") {
-    return new Web3Error("UNSUPPORTED_OPERATION", "Unsupported operation", {
-      reason: error?.reason,
-      originalError: error
-    });
-  }
-  return new Web3Error("UNKNOWN", message || "Unknown error occurred", {
-    reason: error?.reason,
-    data: error?.data,
-    originalError: error
-  });
-}
-function extractRevertReason(error) {
-  if (error?.reason) return error.reason;
-  if (error?.data?.message) return error.data.message;
-  const message = error?.message || "";
-  const revertMatch = message.match(/revert\s+(.+?)(?:\s|$|")/i);
-  if (revertMatch) return revertMatch[1];
-  return void 0;
-}
-
-// src/web3/client/EvmClient.ts
-var toActionsTuple = (result) => [
-  (result?.[0] || []).map((x) => BigInt(x)),
-  (result?.[1] || []).map((x) => BigInt(x)),
-  (result?.[2] || []).map(String)
-];
-var toStripeDonation = (d) => ({
-  stripePaymentId: String(d.stripePaymentId ?? d[0]),
-  amountUSD: BigInt(d.amountUSD ?? d[1]),
-  username: String(d.username ?? d[2]),
-  donor: String(d.donor ?? d[3]),
-  country: String(d.country ?? d[4]),
-  language: String(d.language ?? d[5]),
-  timestamp: Number(d.timestamp ?? d[6]),
-  chainId: Number(d.chainId ?? d[7])
-});
-var EvmClient = class {
-  constructor(chainId, environment = "production") {
-    this._contractAddresses = {};
-    this.chainId = chainId;
-    this.environment = environment;
-    const chainConfig = getChain(chainId);
-    this.config = chainConfig;
-    const isDeployed = environment === "staging" ? chainConfig.stagingDeployed : chainConfig.deployed;
-    if (!isDeployed) {
-      throw new Error(`Chain EVM ${chainId} is not deployed for environment ${environment}`);
-    }
-    this.chain = toViemChain(chainConfig);
-    this.publicClient = createPublicClient({
-      chain: this.chain,
-      transport: http(chainConfig.rpc)
-    });
-    this.addressRegistry = this.createAddressRegistryReadAPI();
-    this.bouncerStorage = this.createBouncerStorageReadAPI();
-    this.scientistStorage = this.createScientistStorageReadAPI();
-    this.archivistStorage = this.createArchivistReadApi();
-    this.factory = this.createFactoryReadAPI();
-    this.projectManagerStorage = this.createProjectManagerStorageReadAPI();
-    this.subscriptionManager = this.createSubscriptionManagerReadAPI();
-    this.libraryRegistryStorage = this.createLibraryRegistryStorageReadAPI();
-    this.publicLibraryStorage = this.createPublicLibraryStorageReadAPI();
-    this._contractAddresses = { ...chainConfig.addresses || {} };
-    this.ready = new Promise(async (resolve, reject) => {
-      try {
-        console.log(`[EvmClient] Initializing registry for chain ${this.chainId} (env: ${this.environment})...`);
-        const staleAddresses = await addressLoader.Initialize(
-          this.chainId,
-          this.addressRegistry,
-          this.activeRegistryAddress,
-          true,
-          this.environment
-        );
-        Object.assign(this._contractAddresses, staleAddresses);
-        const freshAddresses = await addressLoader.loadAllKeys(this.chainId, this.environment);
-        Object.assign(this._contractAddresses, freshAddresses);
-        await addressLoader.waitForAbis(this.chainId, this.environment);
-        console.log(`[EvmClient] Registry ready for ${this.chainId}. Addresses:`, this._contractAddresses);
-        resolve();
-      } catch (e) {
-        console.error(`[EvmClient] Failed to initialize registry for ${this.chainId}`, e);
-        reject(e);
-      }
-    });
-  }
-  async getUsdPrice() {
-    const { price } = this.config;
-    if (price.stable) {
-      return 1;
-    }
-    const { pythOracle, usdPriceId } = price;
-    if (!pythOracle || !usdPriceId) {
-      throw new Error(`Pyth config missing for chain ${this.chainId}`);
-    }
-    const fetchFromHermes = async () => {
-      const res = await fetch(`https://hermes.pyth.network/v2/updates/price/latest?ids[]=${usdPriceId}`);
-      if (!res.ok) throw new Error(`Hermes price fetch failed: ${res.status}`);
-      const data = await res.json();
-      const parsedPrice = data.parsed?.[0]?.price;
-      if (!parsedPrice) throw new Error(`No price data from Hermes for ${usdPriceId}`);
-      return Number(parsedPrice.price) * Math.pow(10, Number(parsedPrice.expo));
-    };
-    if (!this.config.main) {
-      return fetchFromHermes();
-    }
-    try {
-      const result = await this.publicClient.readContract({
-        address: pythOracle,
-        abi: pythAbi,
-        functionName: "getPriceUnsafe",
-        args: [usdPriceId]
-      });
-      return Number(result.price) * Math.pow(10, Number(result.expo));
-    } catch (e) {
-      console.warn(`[EvmClient] On-chain Pyth unavailable for chain ${this.chainId}, falling back to Hermes`);
-      return fetchFromHermes();
-    }
-  }
-  get activeRegistryAddress() {
-    return (this.environment === "staging" && this.config.addresses?.stagingAddressRegistry ? this.config.addresses.stagingAddressRegistry : this.config.addresses?.addressRegistry) ?? "";
-  }
-  addresses() {
-    return this._contractAddresses;
-  }
-  // Shared read path for every registry-fetched contract (§4.2a): resolves the
-  // address, fetches the ABI via addressLoader (never a static import), reads,
-  // and normalizes errors. Collapses what used to be ~15 lines of repeated
-  // boilerplate per method (await ready / resolve address / try readContract /
-  // catch normalizeError) into one call. Not used by createAddressRegistryReadAPI
-  // (bootstrap exception, §4.2a — its own ABI is static and it must not await
-  // `ready`) or by methods with genuinely different failure semantics
-  // (`hasAccount` swallows errors and returns false instead of throwing).
-  // Mirrors EvmWriteClient.requireAbi (§4.2a) — throws an actionable error
-  // instead of letting a null ABI reach viem's readContract, which would
-  // otherwise fail deep inside viem with an opaque error (or silently
-  // misbehave) rather than pointing at the real cause: ABIs not yet synced.
-  requireAbi(contractName) {
-    const abi = addressLoader.getAbi(this.chainId, contractName, this.environment);
-    if (!abi) {
-      throw new Error(
-        `[EvmClient] ABI for '${contractName}' on chain ${this.chainId} is not loaded. The registry ABI sync may have failed or not completed. Reads are blocked until it is ready.`
-      );
-    }
-    return abi;
-  }
-  async read(opts) {
-    await this.ready;
-    const address = this.addresses()[opts.contractKey];
-    if (!address) {
-      if (opts.whenAddressMissing !== void 0) return opts.whenAddressMissing;
-      throw new Error(`[EvmClient] ${String(opts.contractKey)} address missing for chain ${this.chainId}`);
-    }
-    try {
-      const result = await this.publicClient.readContract({
-        address,
-        abi: this.requireAbi(opts.contractName),
-        functionName: opts.functionName,
-        args: opts.args ?? []
-      });
-      return opts.transform ? opts.transform(result) : result;
-    } catch (error) {
-      throw normalizeError(error);
-    }
-  }
-  // Bootstrap exception (§4.2a): uses the statically-imported addressRegistryAbi, not
-  // addressLoader.getAbi(). addressLoader.Initialize() below calls into this API to fetch
-  // every other contract's address/ABI — the registry's own ABI can't come from itself.
-  // Must not await `this.ready` either, for the same reason — this is why it doesn't
-  // go through the shared `read()` helper above.
-  createAddressRegistryReadAPI() {
-    return {
-      getLatestContract: async (name) => {
-        const address = this.activeRegistryAddress;
-        if (!address) throw new Error(`[EvmClient] addressRegistry address missing for chain ${this.chainId}`);
-        const result = await this.publicClient.readContract({
-          address,
-          abi: addressRegistryAbi,
-          functionName: "getLatestContract",
-          args: [name]
-        });
-        return [result[0], result[1]];
-      },
-      getContractHistory: async (name) => {
-        const address = this.activeRegistryAddress;
-        if (!address) throw new Error(`[EvmClient] addressRegistry address missing for chain ${this.chainId}`);
-        const result = await this.publicClient.readContract({
-          address,
-          abi: addressRegistryAbi,
-          functionName: "getContractHistory",
-          args: [name]
-        });
-        return result;
-      },
-      getAllContractNames: async () => {
-        const address = this.activeRegistryAddress;
-        if (!address) throw new Error(`[EvmClient] addressRegistry address missing for chain ${this.chainId}`);
-        const result = await this.publicClient.readContract({
-          address,
-          abi: addressRegistryAbi,
-          functionName: "getAllContractNames",
-          args: []
-        });
-        return result;
-      },
-      getLatestData: async (key) => {
-        const address = this.activeRegistryAddress;
-        if (!address) throw new Error(`[EvmClient] addressRegistry address missing for chain ${this.chainId}`);
-        const result = await this.publicClient.readContract({
-          address,
-          abi: addressRegistryAbi,
-          functionName: "getLatestData",
-          args: [key]
-        });
-        return String(result);
-      },
-      getAllDataKeys: async () => {
-        const address = this.activeRegistryAddress;
-        if (!address) throw new Error(`[EvmClient] addressRegistry address missing for chain ${this.chainId}`);
-        const result = await this.publicClient.readContract({
-          address,
-          abi: addressRegistryAbi,
-          functionName: "getAllDataKeys",
-          args: []
-        });
-        return result;
-      },
-      admin: async () => {
-        const address = this.activeRegistryAddress;
-        if (!address) throw new Error(`[EvmClient] addressRegistry address missing for chain ${this.chainId}`);
-        const result = await this.publicClient.readContract({
-          address,
-          abi: addressRegistryAbi,
-          functionName: "admin",
-          args: []
-        });
-        return String(result);
-      },
-      getLastUpdateInfo: async (name) => {
-        const address = this.activeRegistryAddress;
-        if (!address) return null;
-        try {
-          const logs = await this.publicClient.getLogs({
-            address,
-            event: {
-              type: "event",
-              name: "ContractAdded",
-              inputs: [
-                { type: "string", name: "name", indexed: true },
-                { type: "address", name: "contractAddress", indexed: true },
-                { type: "string", name: "abiUrl" },
-                { type: "uint256", name: "version" }
-              ]
-            },
-            args: { name },
-            fromBlock: 0n
-          });
-          if (logs.length === 0) return null;
-          const lastLog = logs[logs.length - 1];
-          const block = await this.publicClient.getBlock({ blockNumber: lastLog.blockNumber });
-          return {
-            timestamp: Number(block.timestamp),
-            blockNumber: lastLog.blockNumber,
-            transactionHash: lastLog.transactionHash
-          };
-        } catch (e) {
-          console.error(`[EvmClient] Failed to get last update info for ${name}:`, e);
-          return null;
-        }
-      }
-    };
-  }
-  createArchivistReadApi() {
-    const contractKey = "backupStorage";
-    const contractName = "BackupStorage";
-    return {
-      userLevel: (userId) => this.read({ contractKey, contractName, functionName: "userLevel", args: [userId], transform: Number }),
-      isAuthorized: (userAddress) => this.read({ contractKey, contractName, functionName: "isAuthorized", args: [userAddress], transform: Boolean }),
-      nbWrites: (userId) => this.read({ contractKey, contractName, functionName: "nbWrites", args: [userId], transform: Number }),
-      loadActions: (userId) => this.read({ contractKey, contractName, functionName: "loadActions", args: [userId], transform: toActionsTuple }),
-      loadActionsSince: (userId, index) => this.read({ contractKey, contractName, functionName: "loadActionsSince", args: [userId, index], transform: toActionsTuple })
-    };
-  }
-  createProjectManagerStorageReadAPI() {
-    return {
-      nbProjects: async () => {
-        await this.ready;
-        const factoryAddress = this.addresses().factory;
-        if (!factoryAddress) {
-          console.error("[EvmClient] Factory address missing in config!");
-          return 0;
-        }
-        try {
-          return await this.read({ contractKey: "factory", contractName: "Factory", functionName: "nbProjects", transform: Number });
-        } catch (error) {
-          console.error("[EvmClient] nbProjects failed:", error);
-          throw error;
-        }
-      },
-      balanceOfAddress: (account) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getUserBalances",
-        args: [account],
-        transform: (result) => ({
-          total: Number(result[0]),
-          donations: Number(result[1]),
-          unspent: Number(result[2])
-        })
-      }),
-      loadProject: (projectId) => this.read({
-        contractKey: "factory",
-        contractName: "Factory",
-        functionName: "getProject",
-        args: [projectId],
-        transform: (result) => ({
-          id: projectId,
-          balance: Number(result[1]),
-          versions: result[2].map((version) => {
-            version.publicationDate = new Date(Number(version.publicationDate) * 1e3);
-            version.maximumFunding = Number(version.maximumFunding);
-            version.minimumFundingBeforeStartWork = Number(version.minimumFundingBeforeStartWork);
-            version.tags = version.tags.map(Number);
-            version.status = Number(version.status);
-            return version;
-          }),
-          availableLanguages: result[3].map((lang) => bytes4ToString(lang))
-        })
-      }),
-      addressDonationsPerProject: (account) => this.read({
-        contractKey: "factory",
-        contractName: "Factory",
-        functionName: "addressDonationsPerProject",
-        args: [account],
-        transform: (result) => result.map(Number)
-      }),
-      getProjectSupportedLanguages: (projectId) => this.read({
-        contractKey: "factory",
-        contractName: "Factory",
-        functionName: "getProjectSupportedLanguages",
-        args: [projectId],
-        transform: (result) => result.map(String)
-      }),
-      // NOTE: interface declares Promise<number> but this actually returns number[]
-      // (pre-existing mismatch, previously masked by an `any`-typed intermediate —
-      // preserved as-is here rather than silently changed).
-      projectVotingBalances: (projectId) => this.read({
-        contractKey: "factory",
-        contractName: "Factory",
-        functionName: "getProjectAllocatedBudget",
-        args: [projectId],
-        transform: (result) => result.map(Number)
-      }),
-      getWeeklyDonations: (weekNum) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getWeeklyDonations",
-        args: [BigInt(weekNum)],
-        transform: (result) => result.map(toStripeDonation)
-      }),
-      getDonationsRange: (fromWeek, toWeek) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getDonationsRange",
-        args: [BigInt(fromWeek), BigInt(toWeek)],
-        transform: (result) => result.map(toStripeDonation)
-      }),
-      isAuthorized: (userAddress) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "isAuthorized",
-        args: [userAddress],
-        transform: Boolean
-      }),
-      admin: () => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "admin",
-        transform: String
-      }),
-      getNbLanguages: (projectId) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getNbLanguages",
-        args: [projectId],
-        transform: Number
-      }),
-      getLanguageAtIndex: (projectId, index) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getLanguageAtIndex",
-        args: [projectId, index],
-        transform: (result) => bytes4ToString(result)
-      }),
-      getNbVersions: (projectId, lang) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getNbVersions",
-        args: [projectId, stringToBytes4(lang)],
-        transform: Number
-      }),
-      getVersion: (projectId, lang, versionNumber) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getVersion",
-        args: [projectId, stringToBytes4(lang), versionNumber],
-        transform: (result) => ({
-          uri: result.uri,
-          publicationDate: new Date(Number(result.publicationDate) * 1e3),
-          name: result.name,
-          headline: result.headline,
-          descriptionMarkdown: result.descriptionMarkdown,
-          arweaveAddressLogo: result.arweaveAddressLogo,
-          arweaveAddressBanner: result.arweaveAddressBanner,
-          minimumFundingBeforeStartWork: Number(result.minimumFundingBeforeStartWork),
-          maximumFunding: Number(result.maximumFunding),
-          tags: result.tags.map(Number),
-          status: Number(result.status),
-          complexity: Number(result.complexity)
-        })
-      }),
-      getVotingBalance: (projectId, lang) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getVotingBalance",
-        args: [projectId, stringToBytes4(lang)]
-      }),
-      getUserBalances: (address) => this.read({
-        contractKey: "projectManagerStorage",
-        contractName: "ProjectManagerStorage",
-        functionName: "getUserBalances",
-        args: [address],
-        transform: (result) => [BigInt(result[0]), BigInt(result[1]), BigInt(result[2])]
-      })
-    };
-  }
-  createBouncerStorageReadAPI() {
-    const contractKey = "bouncerStorage";
-    const contractName = "BouncerStorage";
-    return {
-      hasAccount: async (userAddress) => {
-        await this.ready;
-        const address = this.addresses().bouncerStorage;
-        if (!address) return false;
-        try {
-          const abi = addressLoader.getAbi(this.chainId, contractName, this.environment);
-          if (!abi) return false;
-          const result = await this.publicClient.readContract({ address, abi, functionName: "hasAccount", args: [userAddress] });
-          return Boolean(result);
-        } catch (error) {
-          console.error(`[EvmClient] hasAccount FAILED for ${userAddress} (returning false):`, error);
-          return false;
-        }
-      },
-      userInfos: (userAddress) => this.read({
-        contractKey,
-        contractName,
-        functionName: "userInfos",
-        args: [userAddress],
-        transform: (result) => [
-          String((result.username ?? result[0]) || ""),
-          String((result.country ?? result[1]) || ""),
-          String((result.language ?? result[2]) || ""),
-          Number((result.newUserId ?? result[3]) || 0)
-        ]
-      }),
-      userData: (userId) => this.read({
-        contractKey,
-        contractName,
-        functionName: "userData",
-        args: [userId],
-        transform: (result) => [
-          Number(result.id ?? result[0]),
-          String(result.addr ?? result[1]),
-          String(result.username ?? result[2]),
-          String(result.language ?? result[3]),
-          String(result.country ?? result[4])
-        ]
-      }),
-      userIdOf: (userAddress) => this.read({ contractKey, contractName, functionName: "userIdOf", args: [userAddress], transform: Number }),
-      userIdToUsername: (userId) => this.read({ contractKey, contractName, functionName: "userIdToUsername", args: [BigInt(userId)], transform: String }),
-      userAddr: (userId) => this.read({ contractKey, contractName, functionName: "userAddr", args: [BigInt(userId)], transform: String }),
-      getUsernameByAddress: (userAddress) => this.read({ contractKey, contractName, functionName: "getUsernameByAddress", args: [userAddress], transform: String }),
-      getAccountCountByCountryLanguage: (country, language) => this.read({
-        contractKey,
-        contractName,
-        functionName: "getAccountCountByCountryLanguage",
-        args: [country, language],
-        transform: Number
-      }),
-      nbAccounts: () => this.read({ contractKey, contractName, functionName: "nbAccounts", transform: Number }),
-      getAllLocationCounts: () => this.read({
-        contractKey,
-        contractName,
-        functionName: "getAllLocationCounts",
-        transform: (result) => result.map((data) => ({
-          country: String(data.country ?? data[0]),
-          language: String(data.language ?? data[1]),
-          count: Number(data.count ?? data[2])
-        }))
-      }),
-      getActiveLocationCount: () => this.read({ contractKey, contractName, functionName: "getActiveLocationCount", transform: Number }),
-      identityStats: () => this.read({
-        contractKey,
-        contractName,
-        functionName: "identityStats",
-        transform: (result) => [Number(result[0]), Number(result[1])]
-      }),
-      isAuthorized: (userAddress) => this.read({ contractKey, contractName, functionName: "isAuthorized", args: [userAddress], transform: Boolean }),
-      getLatestRegisteredUser: async () => {
-        try {
-          const count = await this.bouncerStorage.nbAccounts();
-          if (count === 0) return null;
-          return await this.bouncerStorage.userAddr(count);
-        } catch (error) {
-          console.error("[EvmClient] getLatestRegisteredUser FAILED:", error);
-          return null;
-        }
-      },
-      getTokenName: () => this.read({ contractKey, contractName, functionName: "getTokenName", transform: String }),
-      usernameToUserId: (username) => this.read({ contractKey, contractName, functionName: "usernameToUserId", args: [username], transform: Number })
-    };
-  }
-  createScientistStorageReadAPI() {
-    const contractKey = "scientistStorage";
-    const contractName = "ScientistStorage";
-    return {
-      getDeploymentDate: () => this.read({
-        contractKey,
-        contractName,
-        functionName: "getDeploymentDate",
-        transform: (result) => [Number(result[0]), Number(result[1])]
-      }),
-      getLastMonthId: () => this.read({ contractKey, contractName, functionName: "getLastMonthId", transform: Number }),
-      getStatsRaw: (action, objectType, monthId) => this.read({
-        contractKey,
-        contractName,
-        functionName: "getStatsRaw",
-        args: [BigInt(action), BigInt(objectType), BigInt(monthId)],
-        transform: (result) => [
-          result[0].map((v) => BigInt(v)),
-          result[1].map((v) => Number(v))
-        ]
-      }),
-      isAuthorized: (userAddress) => this.read({ contractKey, contractName, functionName: "isAuthorized", args: [userAddress], transform: Boolean })
-    };
-  }
-  createFactoryReadAPI() {
-    const contractKey = "factory";
-    const contractName = "Factory";
-    return {
-      nbWritesByUsername: (username) => this.read({ contractKey, contractName, functionName: "nbWritesByUsername", args: [username], transform: Number }),
-      loadUsername: (username) => this.read({ contractKey, contractName, functionName: "loadUsername", args: [username], transform: toActionsTuple }),
-      loadUsernameSince: (username, index) => this.read({ contractKey, contractName, functionName: "loadUsernameSince", args: [username, index], transform: toActionsTuple }),
-      load: () => this.read({ contractKey, contractName, functionName: "load", transform: toActionsTuple }),
-      isAuthorized: (userAddress) => this.read({ contractKey, contractName, functionName: "isAuthorized", args: [userAddress], transform: Boolean }),
-      owner: () => this.read({ contractKey, contractName, functionName: "owner", transform: String }),
-      oracleSigner: () => this.read({ contractKey, contractName, functionName: "oracleSigner", transform: String }),
-      bouncerStorage: () => this.read({ contractKey, contractName, functionName: "bouncerStorage", transform: String }),
-      scientistStorage: () => this.read({ contractKey, contractName, functionName: "scientistStorage", transform: String }),
-      backupStorage: () => this.read({ contractKey, contractName, functionName: "backupStorage", transform: String }),
-      projectManagerStorage: () => this.read({ contractKey, contractName, functionName: "projectManagerStorage", transform: String }),
-      usedPaymentIntents: (paymentIntentId) => this.read({ contractKey, contractName, functionName: "usedPaymentIntents", args: [paymentIntentId], transform: Boolean })
-    };
-  }
-  createSubscriptionManagerReadAPI() {
-    const contractKey = "subscriptionManager";
-    const contractName = "SubscriptionManager";
-    return {
-      getSubscriptions: (userId) => this.read({
-        contractKey,
-        contractName,
-        functionName: "getSubscriptions",
-        args: [userId],
-        transform: (result) => [...result],
-        whenAddressMissing: []
-      }),
-      getSubscriptionCount: (userId) => this.read({ contractKey, contractName, functionName: "getSubscriptionCount", args: [userId], transform: BigInt, whenAddressMissing: 0n }),
-      isSubscribed: (subscriber, target) => this.read({
-        contractKey,
-        contractName,
-        functionName: "isSubscribed",
-        args: [subscriber, target],
-        transform: Boolean,
-        whenAddressMissing: false
-      }),
-      scoreOf: (userId) => this.read({ contractKey, contractName, functionName: "scoreOf", args: [userId], transform: BigInt, whenAddressMissing: 0n })
-    };
-  }
-  createLibraryRegistryStorageReadAPI() {
-    const contractKey = "libraryRegistryStorage";
-    const contractName = "LibraryRegistryStorage";
-    return {
-      getUnverifiedCollectionIds: () => this.read({
-        contractKey,
-        contractName,
-        functionName: "getUnverifiedCollectionIds",
-        transform: (result) => [...result]
-      }),
-      getVerifiedCollectionIds: () => this.read({
-        contractKey,
-        contractName,
-        functionName: "getVerifiedCollectionIds",
-        transform: (result) => [...result]
-      }),
-      getCollection: (id) => this.read({
-        contractKey,
-        contractName,
-        functionName: "getCollection",
-        args: [id],
-        transform: (result) => ({
-          id: String(result.id),
-          slug: String(result.slug),
-          manifestUrl: String(result.manifestUrl),
-          importerUsername: String(result.importerUsername),
-          owner: String(result.owner),
-          verified: Boolean(result.verified),
-          fileCount: Number(result.fileCount),
-          libraryType: Number(result.libraryType),
-          publicLibraryId: Number(result.publicLibraryId),
-          country: String(result.country),
-          language: String(result.language),
-          isPublic: Boolean(result.isPublic),
-          createdAt: Number(result.createdAt),
-          updatedAt: Number(result.updatedAt),
-          initialBookCount: Number(result.initialBookCount),
-          dSafeBookCount: Number(result.dSafeBookCount),
-          importStatus: Number(result.importStatus),
-          published: Boolean(result.published)
-        })
-      })
-    };
-  }
-  createPublicLibraryStorageReadAPI() {
-    const contractKey = "publicLibraryStorage";
-    const contractName = "PublicLibraryStorage";
-    return {
-      libraryExists: (id) => this.read({
-        contractKey,
-        contractName,
-        functionName: "libraryExists",
-        args: [id],
-        transform: Boolean
-      }),
-      getPublicLibrary: (id) => this.read({
-        contractKey,
-        contractName,
-        functionName: "getPublicLibrary",
-        args: [id],
-        transform: (result) => ({
-          id: Number(result.id),
-          name: String(result.name),
-          physicalAddress: String(result.physicalAddress),
-          country: String(result.country),
-          language: String(result.language),
-          ownership: Number(result.ownership),
-          website: String(result.website),
-          preferredFormat: Number(result.preferredFormat),
-          createdAt: Number(result.createdAt),
-          updatedAt: Number(result.updatedAt)
-        })
-      }),
-      nbLibraries: () => this.read({
-        contractKey,
-        contractName,
-        functionName: "nbLibraries",
-        transform: Number
-      })
-    };
-  }
-  async getRegistryStatus() {
-    await this.ready;
-    return addressLoader.getLoadingStatus(this.chainId);
-  }
-};
-function createEvmClient(chainId = DEFAULT_CHAIN_ID, environment = "production") {
-  return new EvmClient(chainId, environment);
-}
-
-// src/web3/client/registry.ts
-var readOnlyClients = {};
-var readOnlyStagingClients = {};
-var evmClients = {};
-var evmStagingClients = {};
-for (const [id, config] of Object.entries(EVM_CHAINS)) {
-  const chainId = Number(id);
-  if (config.deployed) {
-    const client = new EvmClient(chainId, "production");
-    evmClients[chainId] = client;
-    readOnlyClients[chainId] = client;
-  }
-  if (config.stagingDeployed) {
-    const client = new EvmClient(chainId, "staging");
-    evmStagingClients[chainId] = client;
-    readOnlyStagingClients[chainId] = client;
-  }
-}
-function getReadClient(chainId, environment = "production") {
-  const map = environment === "staging" ? readOnlyStagingClients : readOnlyClients;
-  const client = map[chainId];
-  if (!client) throw new Error(`No read client for chain ${chainId} (${environment})`);
-  return client;
-}
-function getEvmClient(chainId, environment = "production") {
-  const map = environment === "staging" ? evmStagingClients : evmClients;
-  const client = map[chainId];
-  if (!client) throw new Error(`No EVM client for chain ${chainId} (${environment})`);
-  return client;
-}
-async function getReadyEvmClient(chainId, environment = "production") {
-  const client = getEvmClient(chainId, environment);
-  await client.ready;
-  await addressLoader.waitForAbis(chainId, environment);
-  return client;
-}
-
-// src/web3/session/store.ts
-function createSessionStore() {
-  const PREFIX = "@the_library/web3-session:";
-  const NEW_SEG = "infos_web3_";
-  const ACTIVE_KEY = "active_session";
-  const state = {
-    active: null,
-    known: []
-  };
-  const changeListeners = /* @__PURE__ */ new Set();
-  const notify = () => changeListeners.forEach((l) => l());
-  const getLocalStorageKey = (address, chainId) => {
-    return `${NEW_SEG}${chainId}_${address.toLowerCase()}`;
-  };
-  const persistAccount = (account) => {
-    if (typeof localStorage === "undefined") return;
-    const key = getLocalStorageKey(account.account, account.chainId);
-    localStorage.setItem(PREFIX + key, JSON.stringify(account));
-  };
-  const removePersistedAccount = (address, chainId) => {
-    if (typeof localStorage === "undefined") return;
-    const key = getLocalStorageKey(address, chainId);
-    localStorage.removeItem(PREFIX + key);
-  };
-  const persistActive = () => {
-    if (typeof localStorage === "undefined") return;
-    if (state.active) {
-      localStorage.setItem(
-        PREFIX + ACTIVE_KEY,
-        JSON.stringify({ address: state.active.account, chainId: state.active.chainId })
-      );
-    } else {
-      localStorage.removeItem(PREFIX + ACTIVE_KEY);
-    }
-  };
-  const loadActive = () => {
-    if (typeof localStorage === "undefined") return null;
-    const raw = localStorage.getItem(PREFIX + ACTIVE_KEY);
-    if (!raw) return null;
-    try {
-      const parsed = JSON.parse(raw);
-      return state.known.find(
-        (a) => a.account.toLowerCase() === parsed.address.toLowerCase() && a.chainId === parsed.chainId
-      ) || null;
-    } catch {
-      return null;
-    }
-  };
-  function migrateStorageKeys() {
-    if (typeof localStorage === "undefined") return;
-    const OLD_SEG = "infos_evm_";
-    for (let i = 0; i < localStorage.length; i++) {
-      const raw = localStorage.key(i);
-      if (!raw) continue;
-      const bare = raw.startsWith(PREFIX) ? raw.slice(PREFIX.length) : null;
-      if (bare && bare.startsWith(OLD_SEG)) {
-        const newRaw = PREFIX + NEW_SEG + bare.slice(OLD_SEG.length);
-        localStorage.setItem(newRaw, localStorage.getItem(raw));
-        localStorage.removeItem(raw);
-        i--;
-      }
-    }
-  }
-  const store = {
-    getState() {
-      return state;
-    },
-    setActive(account) {
-      state.active = account;
-      if (account) {
-        const exists = state.known.some(
-          (a) => a.account.toLowerCase() === account.account.toLowerCase() && a.chainId === account.chainId
-        );
-        if (!exists) {
-          state.known.push(account);
-          persistAccount(account);
-        }
-      }
-      persistActive();
-      notify();
-    },
-    addKnown(account) {
-      const index = state.known.findIndex(
-        (a) => a.account.toLowerCase() === account.account.toLowerCase() && a.chainId === account.chainId
-      );
-      if (index >= 0) {
-        state.known[index] = account;
-      } else {
-        state.known.push(account);
-      }
-      persistAccount(account);
-      notify();
-    },
-    updateAccount(address, chainId, patch) {
-      const account = state.known.find(
-        (a) => a.account.toLowerCase() === address.toLowerCase() && a.chainId === chainId
-      );
-      if (account) {
-        Object.assign(account, patch);
-        persistAccount(account);
-        if (state.active && state.active.account.toLowerCase() === address.toLowerCase() && state.active.chainId === chainId) {
-          Object.assign(state.active, patch);
-          persistActive();
-        }
-        notify();
-      }
-    },
-    removeAccount(address, chainId) {
-      state.known = state.known.filter(
-        (a) => !(a.account.toLowerCase() === address.toLowerCase() && a.chainId === chainId)
-      );
-      removePersistedAccount(address, chainId);
-      if (state.active && state.active.account.toLowerCase() === address.toLowerCase() && state.active.chainId === chainId) {
-        state.active = null;
-        persistActive();
-      }
-      notify();
-    },
-    clearAll() {
-      if (typeof localStorage !== "undefined") {
-        const keysToRemove = [];
-        for (let i = 0; i < localStorage.length; i++) {
-          const key = localStorage.key(i);
-          if (key && key.startsWith(PREFIX)) {
-            keysToRemove.push(key);
-          }
-        }
-        for (const k of keysToRemove) {
-          localStorage.removeItem(k);
-        }
-      }
-      state.active = null;
-      state.known = [];
-      notify();
-    },
-    setLastSavedPatchIndex(address, chainId, index) {
-      this.updateAccount(address, chainId, { lastPatchIndex: index });
-    },
-    setLastRestorationIndex(address, chainId, index) {
-      this.updateAccount(address, chainId, { lastRestorationIndex: index });
-    },
-    lastSyncCounters(address, chainId) {
-      const account = state.known.find(
-        (a) => a.account.toLowerCase() === address.toLowerCase() && a.chainId === chainId
-      );
-      return {
-        lastPatchIndex: account?.lastPatchIndex ?? 0,
-        lastRestorationIndex: account?.lastRestorationIndex ?? 0
-      };
-    },
-    updateProjectVotes(address, chainId, projectId, amount) {
-      const account = state.known.find(
-        (a) => a.account.toLowerCase() === address.toLowerCase() && a.chainId === chainId
-      );
-      if (account) {
-        const index = projectId - 1;
-        if (index < 0) return;
-        const votes = [...account.donationsPerProject || []];
-        while (votes.length <= index) {
-          votes.push(0);
-        }
-        votes[index] = (votes[index] || 0) + amount;
-        this.updateAccount(address, chainId, { donationsPerProject: votes });
-      }
-    },
-    persist() {
-      for (const a of state.known) {
-        persistAccount(a);
-      }
-      persistActive();
-    },
-    load() {
-      if (typeof localStorage === "undefined") return;
-      migrateStorageKeys();
-      const loadedKnown = [];
-      for (let i = 0; i < localStorage.length; i++) {
-        const rawKey = localStorage.key(i);
-        if (rawKey && rawKey.startsWith(PREFIX + NEW_SEG)) {
-          try {
-            const rawVal = localStorage.getItem(rawKey);
-            if (rawVal) {
-              const account = JSON.parse(rawVal);
-              loadedKnown.push(account);
-            }
-          } catch (e) {
-            console.warn("Failed to parse loaded session account:", e);
-          }
-        }
-      }
-      state.known = loadedKnown;
-      state.active = loadActive();
-      notify();
-    },
-    subscribe(listener) {
-      changeListeners.add(listener);
-      return () => changeListeners.delete(listener);
-    }
-  };
-  return store;
-}
-var sessionStore = createSessionStore();
-var allRegisteredAccounts = () => sessionStore.getState().known.filter((a) => a.hasAccount);
-
-// src/web3/events/EventBus.ts
-var EventBus = class {
-  constructor() {
-    this.listeners = /* @__PURE__ */ new Map();
-  }
-  on(eventType, listener) {
-    if (!this.listeners.has(eventType)) {
-      this.listeners.set(eventType, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(eventType).add(listener);
-    return () => this.off(eventType, listener);
-  }
-  off(eventType, listener) {
-    const listenersSet = this.listeners.get(eventType);
-    if (listenersSet) {
-      listenersSet.delete(listener);
-      if (listenersSet.size === 0) {
-        this.listeners.delete(eventType);
-      }
-    }
-  }
-  emit(eventType, data) {
-    const listenersSet = this.listeners.get(eventType);
-    if (listenersSet) {
-      listenersSet.forEach((listener) => {
-        try {
-          listener(data);
-        } catch (error) {
-          console.error(`Error in event listener for ${eventType}:`, error);
-        }
-      });
-    }
-  }
-  once(eventType, listener) {
-    const wrappedListener = (data) => {
-      listener(data);
-      this.off(eventType, wrappedListener);
-    };
-    return this.on(eventType, wrappedListener);
-  }
-  clear(eventType) {
-    if (eventType) {
-      this.listeners.delete(eventType);
-    } else {
-      this.listeners.clear();
-    }
-  }
-  listenerCount(eventType) {
-    return this.listeners.get(eventType)?.size || 0;
-  }
-};
-var globalEventBus = null;
-function getEventBus() {
-  if (!globalEventBus) {
-    globalEventBus = new EventBus();
-  }
-  return globalEventBus;
-}
-
-// src/web3/events/enums.ts
-var EventName = /* @__PURE__ */ ((EventName2) => {
-  EventName2["WALLET_STATE_CHANGED"] = "wallet:state:changed";
-  EventName2["WALLET_CHAIN_CHANGED"] = "wallet:chain:changed";
-  EventName2["WALLET_ERROR"] = "wallet:error";
-  EventName2["SESSION_UPDATED"] = "session:updated";
-  EventName2["WALLET_DISCONNECTED"] = "wallet:disconnected";
-  EventName2["SESSION_DELETED"] = "session:deleted";
-  EventName2["SAVE_RESTORED"] = "save:restored";
-  EventName2["SUBSCRIPTION_PATCHES_SYNCED"] = "subscription:patches:synced";
-  return EventName2;
-})(EventName || {});
-var WalletState = /* @__PURE__ */ ((WalletState2) => {
-  WalletState2["INITIALIZING"] = "INITIALIZING";
-  WalletState2["UPDATING_STATE_STARTED"] = "UPDATING_STATE_STARTED";
-  WalletState2["UPDATING_STATE_DONE"] = "UPDATING_STATE_DONE";
-  WalletState2["UPDATING_STATE_FAILED"] = "UPDATING_STATE_FAILED";
-  WalletState2["READY"] = "READY";
-  WalletState2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
-  WalletState2["NOT_CONNECTED"] = "NOT_CONNECTED";
-  WalletState2["NOT_INSTALLED"] = "NOT_INSTALLED";
-  WalletState2["NOT_ALLOWED"] = "NOT_ALLOWED";
-  WalletState2["NOT_SUPPORTED"] = "NOT_SUPPORTED";
-  WalletState2["NOT_READY"] = "NOT_READY";
-  WalletState2["CONNECT_STARTED"] = "CONNECT_STARTED";
-  WalletState2["CONNECT_DONE"] = "CONNECT_DONE";
-  WalletState2["CONNECT_FAILED"] = "CONNECT_FAILED";
-  WalletState2["TRANSACTION_STARTED"] = "TRANSACTION_STARTED";
-  WalletState2["TRANSACTION_DONE"] = "TRANSACTION_DONE";
-  WalletState2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
-  WalletState2["TIMEOUT"] = "TIMEOUT";
-  WalletState2["CHAIN_CHANGED_STARTED"] = "CHAIN_CHANGED_STARTED";
-  WalletState2["CHAIN_CHANGED_DONE"] = "CHAIN_CHANGED_DONE";
-  WalletState2["CHAIN_CHANGED_FAILED"] = "CHAIN_CHANGED_FAILED";
-  WalletState2["WALLET_INSTALLED"] = "WALLET_INSTALLED";
-  return WalletState2;
-})(WalletState || {});
-var WalletError = /* @__PURE__ */ ((WalletError2) => {
-  WalletError2["NO_ACCOUNTS"] = "NO_ACCOUNTS";
-  WalletError2["USER_REJECTED"] = "USER_REJECTED";
-  WalletError2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
-  WalletError2["LOGIN_INTO_WALLET"] = "LOGIN_INTO_WALLET";
-  WalletError2["REQUEST_ALREADY_PENDING"] = "REQUEST_ALREADY_PENDING";
-  WalletError2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
-  WalletError2["CONFIG_MISSING"] = "CONFIG_MISSING";
-  WalletError2["NOT_SUPPORTED"] = "NOT_SUPPORTED";
-  WalletError2["NOT_CONNECTED"] = "NOT_CONNECTED";
-  WalletError2["NOT_INSTALLED"] = "NOT_INSTALLED";
-  WalletError2["NOT_ALLOWED"] = "NOT_ALLOWED";
-  WalletError2["NETWORK_NOT_SUPPORTED"] = "NETWORK_NOT_SUPPORTED";
-  return WalletError2;
-})(WalletError || {});
-var WalletUxError = /* @__PURE__ */ ((WalletUxError2) => {
-  WalletUxError2["NO_ACCOUNT_SWITCH"] = "NO_ACCOUNT_SWITCH";
-  WalletUxError2["NO_NETWORK_SWITCH"] = "NO_NETWORK_SWITCH";
-  WalletUxError2["NETWORK_NOT_SUPPORTED"] = "NETWORK_NOT_SUPPORTED";
-  WalletUxError2["NO_INTERNET"] = "NO_INTERNET";
-  WalletUxError2["NO_DISCONNECT"] = "NO_DISCONNECT";
-  WalletUxError2["NO_ACCOUNT_DISCONNECT"] = "NO_ACCOUNT_DISCONNECT";
-  return WalletUxError2;
-})(WalletUxError || {});
-
-// src/web3/events/wallet_events.ts
-var createEmitter = (eventName) => {
-  return (data) => {
-    getEventBus().emit(eventName, data);
-  };
-};
-var createListener = (eventName) => {
-  return (listener) => {
-    return getEventBus().on(eventName, listener);
-  };
-};
-var WalletEvents = {
-  emitWalletStateEvent: createEmitter("wallet:state:changed" /* WALLET_STATE_CHANGED */),
-  onWalletStateEvent: createListener("wallet:state:changed" /* WALLET_STATE_CHANGED */),
-  emitSessionUpdated: createEmitter("session:updated" /* SESSION_UPDATED */),
-  onSessionUpdated: createListener("session:updated" /* SESSION_UPDATED */),
-  emitChainChanged: createEmitter("wallet:chain:changed" /* WALLET_CHAIN_CHANGED */),
-  onChainChanged: createListener("wallet:chain:changed" /* WALLET_CHAIN_CHANGED */),
-  emitDisconnected: createEmitter("wallet:disconnected" /* WALLET_DISCONNECTED */),
-  onDisconnected: createListener("wallet:disconnected" /* WALLET_DISCONNECTED */),
-  emitWalletSessionDeleted: createEmitter("session:deleted" /* SESSION_DELETED */),
-  onWalletSessionDeleted: createListener("session:deleted" /* SESSION_DELETED */),
-  emitWalletError: createEmitter("wallet:error" /* WALLET_ERROR */),
-  onWalletError: createListener("wallet:error" /* WALLET_ERROR */),
-  emitSaveRestored: createEmitter("save:restored" /* SAVE_RESTORED */),
-  onSaveRestored: createListener("save:restored" /* SAVE_RESTORED */),
-  emitSubscriptionPatchesSynced: createEmitter("subscription:patches:synced" /* SUBSCRIPTION_PATCHES_SYNCED */),
-  onSubscriptionPatchesSynced: createListener("subscription:patches:synced" /* SUBSCRIPTION_PATCHES_SYNCED */)
-};
-
-// src/web3/subscription/contract.ts
-var MULTICALL3_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
-function subscriptionManagerBinding(client) {
-  const address = addressLoader.getAddress(client.chainId, "subscriptionManager", client.environment);
-  const abi = addressLoader.getAbi(client.chainId, "SubscriptionManager", client.environment);
-  if (!address || !abi) return null;
-  return { address, abi };
-}
-async function multicallGetSubscriptions(client, userIds) {
-  const result = /* @__PURE__ */ new Map();
-  if (userIds.length === 0) return result;
-  const binding = subscriptionManagerBinding(client);
-  if (binding) {
-    try {
-      const raw = await client.publicClient.multicall({
-        multicallAddress: MULTICALL3_ADDRESS,
-        allowFailure: true,
-        contracts: userIds.map((userId) => ({ ...binding, functionName: "getSubscriptions", args: [userId] }))
-      });
-      userIds.forEach((userId, i) => {
-        const r = raw[i];
-        result.set(userId, r.status === "success" ? (r.result ?? []).map(Number) : []);
-      });
-      return result;
-    } catch (e) {
-      console.warn("[subscription/contract] multicall getSubscriptions failed, falling back to sequential reads", e);
-    }
-  }
-  await Promise.all(
-    userIds.map(async (userId) => {
-      try {
-        result.set(userId, await client.subscriptionManager.getSubscriptions(userId));
-      } catch {
-        result.set(userId, []);
-      }
-    })
-  );
-  return result;
-}
-async function multicallGetSubscriptionCounts(client, userIds) {
-  const result = /* @__PURE__ */ new Map();
-  if (userIds.length === 0) return result;
-  const binding = subscriptionManagerBinding(client);
-  if (binding) {
-    try {
-      const raw = await client.publicClient.multicall({
-        multicallAddress: MULTICALL3_ADDRESS,
-        allowFailure: true,
-        contracts: userIds.map((userId) => ({ ...binding, functionName: "getSubscriptionCount", args: [userId] }))
-      });
-      userIds.forEach((userId, i) => {
-        const r = raw[i];
-        result.set(userId, r.status === "success" ? Number(r.result) : 0);
-      });
-      return result;
-    } catch (e) {
-      console.warn("[subscription/contract] multicall getSubscriptionCount failed, falling back to sequential reads", e);
-    }
-  }
-  await Promise.all(
-    userIds.map(async (userId) => {
-      try {
-        result.set(userId, Number(await client.subscriptionManager.getSubscriptionCount(userId)));
-      } catch {
-        result.set(userId, 0);
-      }
-    })
-  );
-  return result;
-}
-
-// src/web3/subscription/graph-walk.ts
-var BATCH_SIZE = 50;
-var DEFAULT_MAX_WALK_NODES = 1e3;
-async function walkGraph(client, rootUserId, opts) {
-  const maxWalkNodes = opts?.maxNodes ?? DEFAULT_MAX_WALK_NODES;
-  const maxDepth = opts?.maxDepth;
-  const visited = /* @__PURE__ */ new Set([rootUserId]);
-  const depth = /* @__PURE__ */ new Map([[rootUserId, 0]]);
-  const nodes = /* @__PURE__ */ new Map();
-  const queue = [rootUserId];
-  let depthLimited = false;
-  while (queue.length > 0 && visited.size < maxWalkNodes) {
-    const batch = queue.splice(0, BATCH_SIZE);
-    const results = await multicallGetSubscriptions(client, batch);
-    for (const userId of batch) {
-      const subs = results.get(userId) ?? [];
-      nodes.set(userId, { userId, subscriptions: subs });
-      for (const sub of subs) {
-        if (visited.has(sub) || visited.size >= maxWalkNodes) continue;
-        const nextDepth = (depth.get(userId) ?? 0) + 1;
-        if (maxDepth !== void 0 && nextDepth > maxDepth) {
-          depthLimited = true;
-          continue;
-        }
-        visited.add(sub);
-        depth.set(sub, nextDepth);
-        queue.push(sub);
-      }
-    }
-  }
-  return { rootUserId, nodes, truncated: queue.length > 0 || depthLimited };
-}
-
-// src/web3/subscription/patch-resolver.ts
-async function fetchNodePatches(client, userId, fromIndex) {
-  const [compressedActions, indexes, stringIndexes] = await client.archivistStorage.loadActionsSince(userId, fromIndex);
-  if (!compressedActions || compressedActions.length === 0) return null;
-  return {
-    userId,
-    fromIndex,
-    toIndex: fromIndex + compressedActions.length,
-    raw: { compressedActions, indexes, stringIndexes }
-  };
-}
-async function fetchPatches(client, graph, cursor, opts) {
-  const concurrency = opts?.concurrency ?? 4;
-  const userIds = Array.from(graph.nodes.keys());
-  const patches = [];
-  for (let i = 0; i < userIds.length; i += concurrency) {
-    const slice = userIds.slice(i, i + concurrency);
-    const results = await Promise.all(
-      slice.map(
-        (userId) => fetchNodePatches(client, userId, cursor?.get(userId) ?? 0).catch((e) => {
-          console.warn(`[subscription/patch-resolver] failed to fetch patches for userId ${userId}`, e);
-          return null;
-        })
-      )
-    );
-    for (const patch of results) {
-      if (patch) patches.push(patch);
-    }
-  }
-  return patches;
-}
-
-// src/web3/subscription/patch-codec.ts
-function patchToEvmPayload(patch, version) {
-  const raw = patch.raw;
-  return {
-    version,
-    patches: raw.compressedActions,
-    textIndex: raw.indexes.map(Number),
-    textData: raw.stringIndexes
-  };
-}
-
-// src/web3/subscription/SubscriptionClient.ts
-import { deserializePatches, applyRestoredPatches, CURRENT_VERSION } from "@the_library/public/models";
-var SubscriptionClient = class {
-  constructor(config) {
-    this.client = getEvmClient(config.chainId, config.environment ?? "production");
-    this.defaultMaxWalkNodes = config.maxWalkNodes;
-    this.defaultMaxDepth = config.maxDepth;
-  }
-  async walkGraph(rootUserId, opts) {
-    await this.client.ready;
-    return walkGraph(this.client, rootUserId, {
-      maxNodes: opts?.maxNodes ?? this.defaultMaxWalkNodes,
-      maxDepth: opts?.maxDepth ?? this.defaultMaxDepth
-    });
-  }
-  async fetchPatches(graph, cursor, opts) {
-    await this.client.ready;
-    return fetchPatches(this.client, graph, cursor, opts);
-  }
-  /** Full walk + fetch from scratch. */
-  async sync(rootUserId, opts) {
-    const graph = await this.walkGraph(rootUserId, opts);
-    const patches = await this.fetchPatches(graph, void 0, opts);
-    const countSnapshot = /* @__PURE__ */ new Map();
-    for (const [userId, node] of graph.nodes) {
-      countSnapshot.set(userId, node.subscriptions.length);
-    }
-    const patchIndex = /* @__PURE__ */ new Map();
-    for (const patch of patches) {
-      patchIndex.set(patch.userId, Math.max(patchIndex.get(patch.userId) ?? 0, patch.toIndex));
-    }
-    for (const userId of graph.nodes.keys()) {
-      if (!patchIndex.has(userId)) patchIndex.set(userId, 0);
-    }
-    return {
-      patches,
-      cursor: { rootUserId, knownNodes: graph.nodes, countSnapshot, patchIndex },
-      truncated: graph.truncated
-    };
-  }
-  /**
-   * Incremental sync (spec §8, unchanged algorithm): multicall
-   * getSubscriptionCount for every known node, deep re-walk only the nodes
-   * whose count changed (O4: completeness over cost), then fetch only new
-   * patches per node since the cursor.
-   */
-  async syncSince(cursor, opts) {
-    await this.client.ready;
-    const knownUserIds = Array.from(cursor.knownNodes.keys());
-    const counts = await multicallGetSubscriptionCounts(this.client, knownUserIds);
-    const changed = knownUserIds.filter((userId) => counts.get(userId) !== cursor.countSnapshot.get(userId));
-    const knownNodes = new Map(cursor.knownNodes);
-    const countSnapshot = new Map(counts.size ? counts : cursor.countSnapshot);
-    let truncated = false;
-    for (const userId of changed) {
-      const subs = await this.client.subscriptionManager.getSubscriptions(userId);
-      knownNodes.set(userId, { userId, subscriptions: subs });
-      countSnapshot.set(userId, subs.length);
-      for (const sub of subs) {
-        if (knownNodes.has(sub)) continue;
-        const subGraph = await this.walkGraph(sub, opts);
-        for (const [id, node] of subGraph.nodes) {
-          if (!knownNodes.has(id)) {
-            knownNodes.set(id, node);
-            countSnapshot.set(id, node.subscriptions.length);
-          }
-        }
-        truncated = truncated || subGraph.truncated;
-      }
-    }
-    if (!knownNodes.has(cursor.rootUserId)) {
-      const subs = await this.client.subscriptionManager.getSubscriptions(cursor.rootUserId);
-      knownNodes.set(cursor.rootUserId, { userId: cursor.rootUserId, subscriptions: subs });
-      countSnapshot.set(cursor.rootUserId, subs.length);
-    }
-    const graph = { rootUserId: cursor.rootUserId, nodes: knownNodes, truncated };
-    const patches = await this.fetchPatches(graph, cursor.patchIndex, opts);
-    const patchIndex = new Map(cursor.patchIndex);
-    for (const patch of patches) {
-      patchIndex.set(patch.userId, Math.max(patchIndex.get(patch.userId) ?? 0, patch.toIndex));
-    }
-    for (const userId of knownNodes.keys()) {
-      if (!patchIndex.has(userId)) patchIndex.set(userId, 0);
-    }
-    return {
-      patches,
-      cursor: { rootUserId: cursor.rootUserId, knownNodes, countSnapshot, patchIndex },
-      truncated
-    };
-  }
-  async getSubscriptions(userId) {
-    await this.client.ready;
-    return this.client.subscriptionManager.getSubscriptions(userId);
-  }
-  async getScore(userId) {
-    await this.client.ready;
-    return this.client.subscriptionManager.scoreOf(userId);
-  }
-  /**
-   * High-level API: load and apply library patches for a user by username.
-   * Orchestrates: username→userId lookup, sync, deserialize, and IndexedDB application.
-   * Errors are caught and logged to console but not thrown (graceful degradation).
-   */
-  async loadLibraryByUsername(username) {
-    try {
-      await this.client.ready;
-      console.log(`[SubscriptionClient] Starting library load for @${username}...`);
-      console.log(`[SubscriptionClient] Looking up userId for @${username}...`);
-      const userId = await this.client.bouncerStorage.usernameToUserId(username);
-      if (!userId) {
-        console.error(`[SubscriptionClient] Username @${username} not found on-chain`);
-        return;
-      }
-      console.log(`[SubscriptionClient] Resolved @${username} \u2192 userId ${userId}`);
-      console.log(`[SubscriptionClient] Syncing patches for userId ${userId}...`);
-      const result = await this.sync(userId);
-      console.log(`[SubscriptionClient] Fetched ${result.patches.length} patch(es), truncated: ${result.truncated}`);
-      if (result.patches.length > 0) {
-        console.log(`[SubscriptionClient] Applying patches for ${result.patches.length} subscription graph patch(es)...`);
-        for (const patch of result.patches) {
-          try {
-            const patchUsername = await this.client.bouncerStorage.userIdToUsername(patch.userId);
-            if (!patchUsername) {
-              console.warn(`[SubscriptionClient] No username found for userId ${patch.userId}, skipping patch`);
-              continue;
-            }
-            console.log(`[SubscriptionClient] Applying patch for @${patchUsername} (userId ${patch.userId}, index ${patch.fromIndex}\u2013${patch.toIndex})...`);
-            await deserializePatches(patchUsername, patchToEvmPayload(patch, CURRENT_VERSION));
-            const patches = await getAllPatchesByUsername(patchUsername);
-            await applyRestoredPatches(patches, patchUsername);
-          } catch (patchErr) {
-            console.error(`[SubscriptionClient] Failed to apply patch for userId ${patch.userId}:`, patchErr?.message || patchErr);
-          }
-        }
-      }
-      console.log(`[SubscriptionClient] Successfully loaded library for @${username}`);
-    } catch (err) {
-      console.error(`[SubscriptionClient] Failed to load library for @${username}:`, err?.message || err);
-    }
-  }
-};
-
-// src/web3/subscription/registry.ts
-var clients = {};
-function getSubscriptionClient(chainId, environment = "production") {
-  const key = `${chainId}:${environment}`;
-  if (!clients[key]) {
-    clients[key] = new SubscriptionClient({ chainId, environment });
-  }
-  return clients[key];
-}
-
-// src/web3/subscription/sync-cursor.ts
-import { del, get, set } from "idb-keyval";
-function serializeCursor(cursor) {
-  return {
-    rootUserId: cursor.rootUserId,
-    knownNodes: Array.from(cursor.knownNodes.entries()),
-    countSnapshot: Array.from(cursor.countSnapshot.entries()),
-    patchIndex: Array.from(cursor.patchIndex.entries())
-  };
-}
-function deserializeCursor(serialized) {
-  return {
-    rootUserId: serialized.rootUserId,
-    knownNodes: new Map(serialized.knownNodes),
-    countSnapshot: new Map(serialized.countSnapshot),
-    patchIndex: new Map(serialized.patchIndex)
-  };
-}
-function emptyCursor(rootUserId) {
-  return {
-    rootUserId,
-    knownNodes: /* @__PURE__ */ new Map(),
-    countSnapshot: /* @__PURE__ */ new Map(),
-    patchIndex: /* @__PURE__ */ new Map()
-  };
-}
-var IDB_KEY_PREFIX = "web3-sdk:subscription-cursor:";
-var cursorStore = {
-  async get(userId) {
-    try {
-      const serialized = await get(`${IDB_KEY_PREFIX}${userId}`);
-      return serialized ? deserializeCursor(serialized) : void 0;
-    } catch (e) {
-      console.warn(`[cursorStore] Failed to read cursor for userId ${userId}:`, e);
-      return void 0;
-    }
-  },
-  async set(userId, cursor) {
-    try {
-      await set(`${IDB_KEY_PREFIX}${userId}`, serializeCursor(cursor));
-    } catch (e) {
-      console.warn(`[cursorStore] Failed to persist cursor for userId ${userId}:`, e);
-    }
-  },
-  async clear(userId) {
-    try {
-      await del(`${IDB_KEY_PREFIX}${userId}`);
-    } catch {
-    }
-  }
-};
-
-// src/web3/session/storage.ts
-var STORAGE_KEY_PREFIX = "@the_library/web3-cache:";
-function isLocalStorageAvailable() {
-  if (typeof window === "undefined" || typeof localStorage === "undefined") {
-    return false;
-  }
-  try {
-    const testKey = "__storage_test__";
-    localStorage.setItem(testKey, "test");
-    localStorage.removeItem(testKey);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getItem(key) {
-  if (!isLocalStorageAvailable()) return null;
-  try {
-    const item = localStorage.getItem(STORAGE_KEY_PREFIX + key);
-    return item ? JSON.parse(item) : null;
-  } catch {
-    return null;
-  }
-}
-function setItem(key, value) {
-  if (!isLocalStorageAvailable()) return;
-  try {
-    localStorage.setItem(STORAGE_KEY_PREFIX + key, JSON.stringify(value));
-  } catch (error) {
-    console.warn("[session/storage] Failed to save to localStorage:", error);
-  }
-}
-
-// src/web3/session/sync.ts
-import { deserializePatches as deserializePatches2, applyRestoredPatches as applyRestoredPatches2, CURRENT_VERSION as CURRENT_VERSION2 } from "@the_library/public/models";
-var _syncedThisSession = /* @__PURE__ */ new Map();
-async function triggerSubscriptionSync(userId, chainId, environment) {
-  const key = `${chainId}:${userId}`;
-  const inFlight = _syncedThisSession.get(key);
-  if (inFlight) return inFlight;
-  const run = (async () => {
-    const subscriptionClient = getSubscriptionClient(chainId, environment);
-    const existingCursor = await cursorStore.get(userId);
-    const result = existingCursor ? await subscriptionClient.syncSince(existingCursor) : await subscriptionClient.sync(userId);
-    let appliedCount = 0;
-    if (result.patches.length > 0) {
-      const client = getReadClient(chainId, environment);
-      await client.ready;
-      for (const patch of result.patches) {
-        try {
-          const username = await client.bouncerStorage.userIdToUsername(patch.userId);
-          if (!username) continue;
-          await deserializePatches2(username, patchToEvmPayload(patch, CURRENT_VERSION2));
-          const patches = await getAllPatchesByUsername(username);
-          await applyRestoredPatches2(patches, username);
-          appliedCount += patch.toIndex - patch.fromIndex;
-        } catch (e) {
-          console.warn(`[session/sync] failed to apply subscription patch for userId ${patch.userId}`, e);
-        }
-      }
-    }
-    await cursorStore.set(userId, result.cursor);
-    WalletEvents.emitSubscriptionPatchesSynced({ rootUserId: userId, chainId, appliedCount, timestamp: Date.now() });
-  })();
-  _syncedThisSession.set(key, run);
-  try {
-    await run;
-  } catch (e) {
-    _syncedThisSession.delete(key);
-    console.warn(`[session/sync] subscription sync failed for userId ${userId}`, e);
-  }
-}
-async function syncAccount(address, chainId, wallet, environment = "production", forceRefresh = false) {
-  const existing = sessionStore.getState().known.find((a) => a.account.toLowerCase() === address.toLowerCase() && a.chainId === chainId);
-  if (!forceRefresh && existing?.lastUpdated) {
-    if (existing.hasAccount && existing.userId) {
-      void triggerSubscriptionSync(existing.userId, chainId, environment);
-    }
-    return existing;
-  }
-  const client = getReadClient(chainId, environment);
-  await client.ready;
-  const account = existing ? { ...existing } : {
-    account: address,
-    username: "",
-    hasAccount: false,
-    userId: 0,
-    lastPatchIndex: 0,
-    lastRestorationIndex: 0,
-    chainId,
-    wallet
-  };
-  const hasAccount = await client.bouncerStorage.hasAccount(address);
-  account.hasAccount = hasAccount;
-  if (hasAccount) {
-    const [username, country, language, userId] = await client.bouncerStorage.userInfos(address);
-    account.username = username;
-    account.country = country;
-    account.language = language;
-    account.userId = userId;
-    const { total, donations, unspent } = await client.projectManagerStorage.balanceOfAddress(address);
-    account.projectBalance = { contributions: total, allocated: donations, remaining: unspent };
-    try {
-      account.level = await client.archivistStorage.userLevel(userId);
-    } catch {
-      account.level = 1;
-    }
-    try {
-      account.donationsPerProject = await client.projectManagerStorage.addressDonationsPerProject(address);
-    } catch {
-      account.donationsPerProject = [];
-    }
-    await triggerSubscriptionSync(userId, chainId, environment);
-  }
-  account.lastUpdated = Date.now();
-  sessionStore.addKnown(account);
-  return account;
-}
-async function restoreAccountSave(address, chainId, environment = "production") {
-  const known = sessionStore.getState().known.find((a) => a.account.toLowerCase() === address.toLowerCase() && a.chainId === chainId);
-  if (!known || !known.hasAccount) return false;
-  const client = getReadClient(chainId, environment);
-  await client.ready;
-  try {
-    const nbSavedIndex = await client.factory.nbWritesByUsername(known.username);
-    if (nbSavedIndex > known.lastRestorationIndex) {
-      const [compressedActions, indexes, stringIndexes] = await client.factory.loadUsernameSince(
-        known.username,
-        known.lastRestorationIndex
-      );
-      let appliedCount = 0;
-      if (compressedActions && compressedActions.length > 0) {
-        await deserializePatches2("mine", {
-          version: CURRENT_VERSION2,
-          patches: compressedActions,
-          textIndex: indexes.map(Number),
-          textData: stringIndexes
-        });
-        const patches = await getAllPatchesByUsername("mine");
-        await applyRestoredPatches2(patches, "mine");
-        appliedCount = compressedActions.length;
-      }
-      sessionStore.setLastRestorationIndex(address, chainId, nbSavedIndex);
-      WalletEvents.emitSaveRestored({
-        wallet: known.wallet,
-        chainId,
-        account: address,
-        username: known.username,
-        newRestorationIndex: nbSavedIndex,
-        appliedCount,
-        timestamp: Date.now()
-      });
-    }
-    return true;
-  } catch (e) {
-    console.error(`[session/sync] restoreAccountSave failed for ${address} on ${chainId}`, e);
-    return false;
-  }
-}
-async function hasUnsavedPatches(address, chainId) {
-  const { lastPatchIndex } = sessionStore.lastSyncCounters(address, chainId);
-  const nbPatches = await getNbPatches("mine");
-  return nbPatches > lastPatchIndex;
-}
-async function loadNetworkInfos(chainId, environment = "production", forceRefresh = false) {
-  const key = `networkInfos_${chainId}${environment === "staging" ? "_staging" : ""}`;
-  if (!forceRefresh) {
-    const cached = getItem(key);
-    if (cached) return cached;
-  }
-  const client = getReadClient(chainId, environment);
-  await client.ready;
-  const [locationStats, nbProjects, nbUsers] = await Promise.all([
-    client.bouncerStorage.getAllLocationCounts(),
-    client.projectManagerStorage.nbProjects(),
-    client.bouncerStorage.nbAccounts()
-  ]);
-  const result = { nbUsers, nbLocations: locationStats.length, nbProjects, locationStats };
-  setItem(key, result);
-  return result;
-}
-
-// src/web3/wallet/registry.ts
-var connectors = /* @__PURE__ */ new Map();
-function registerConnector(connector) {
-  connectors.set(connector.type, connector);
-}
-function getConnector(type) {
-  return connectors.get(type);
-}
-function getRegisteredConnectors() {
-  return Array.from(connectors.values());
-}
-
-// src/web3/wallet/credentials.ts
-var PK_STORAGE_KEY_PREFIX = "wallet_pk_";
-var STORAGE_KEY_PREFIX2 = "@the_library/web3-session:";
-var cachedEmail = null;
-function getCachedEmail() {
-  return cachedEmail;
-}
-function setCachedEmail(email) {
-  cachedEmail = email;
-}
-function isLocalStorageAvailable2() {
-  if (typeof window === "undefined" || typeof localStorage === "undefined") {
-    return false;
-  }
-  try {
-    const testKey = "__storage_test__";
-    localStorage.setItem(testKey, "test");
-    localStorage.removeItem(testKey);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getItem2(key) {
-  if (!isLocalStorageAvailable2()) {
-    return null;
-  }
-  try {
-    const item = localStorage.getItem(STORAGE_KEY_PREFIX2 + key);
-    return item ? JSON.parse(item) : null;
-  } catch {
-    return null;
-  }
-}
-function setItem2(key, value) {
-  if (!isLocalStorageAvailable2()) {
-    return;
-  }
-  try {
-    localStorage.setItem(STORAGE_KEY_PREFIX2 + key, JSON.stringify(value));
-  } catch (error) {
-    console.warn("Failed to save to localStorage:", error);
-  }
-}
-function storePrivateKey(chainId, privateKey) {
-  if (!privateKey) {
-    throw new Error("Private key is required");
-  }
-  const key = `${PK_STORAGE_KEY_PREFIX}${chainId}`;
-  setItem2(key, privateKey);
-}
-function getPrivateKey(chainId) {
-  const key = `${PK_STORAGE_KEY_PREFIX}${chainId}`;
-  return getItem2(key);
-}
-function hasPrivateKey(chainId) {
-  const key = `${PK_STORAGE_KEY_PREFIX}${chainId}`;
-  return !!getItem2(key);
-}
-function hasAnyPrivateKey() {
-  if (!isLocalStorageAvailable2()) return false;
-  const prefix = `${STORAGE_KEY_PREFIX2}${PK_STORAGE_KEY_PREFIX}`;
-  for (let i = 0; i < localStorage.length; i++) {
-    if (localStorage.key(i)?.startsWith(prefix)) return true;
-  }
-  return false;
-}
-var storeEncryptedPrivateKey = (chainId, privateKey, _email) => storePrivateKey(chainId, privateKey);
-var getDecryptedPrivateKey = (chainId, _email) => getPrivateKey(chainId);
-var hasEncryptedPrivateKey = (chainId) => hasPrivateKey(chainId);
-
-// src/web3/wallet/PrivateKeyConnector.ts
-import { privateKeyToAccount } from "viem/accounts";
-import { createWalletClient, http as http2 } from "viem";
-function normalizePrivateKeyHex(privateKey) {
-  return privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
-}
-function addressFromPrivateKey(privateKey) {
-  return privateKeyToAccount(normalizePrivateKeyHex(privateKey)).address;
-}
-function createPrivateKeyWalletClient(chainId, privateKey) {
-  const account = privateKeyToAccount(normalizePrivateKeyHex(privateKey));
-  const chainConfig = getChain(chainId);
-  return createWalletClient({
-    account,
-    chain: toViemChain(chainConfig),
-    transport: http2(chainConfig.rpc)
-  });
-}
-var PrivateKeyConnector = class {
-  constructor() {
-    this.type = "private_key";
-    this.activeChainId = 0;
-    this.chainChangedCallbacks = /* @__PURE__ */ new Set();
-  }
-  isAvailable() {
-    return true;
-  }
-  // chainId is optional on the WalletConnector interface (defaults to DEFAULT_CHAIN_ID) —
-  // callers that know the target chain (e.g. bootstrapWebSDK, UI chain selector) pass it
-  // explicitly rather than relying on whichever key happens to be stored first.
-  async connect(chainId = DEFAULT_CHAIN_ID) {
-    if (!hasPrivateKey(chainId)) {
-      throw new Error(`No private key configured for chain ${chainId}`);
-    }
-    this.activeChainId = chainId;
-    const privateKey = getPrivateKey(chainId);
-    if (!privateKey) {
-      throw new Error(`No private key configured for chain ${chainId}`);
-    }
-    return {
-      address: addressFromPrivateKey(privateKey),
-      chainId
-    };
-  }
-  async getAccounts() {
-    if (!this.activeChainId) return [];
-    const privateKey = getPrivateKey(this.activeChainId);
-    if (!privateKey) return [];
-    return [addressFromPrivateKey(privateKey)];
-  }
-  async getChainId() {
-    return this.activeChainId;
-  }
-  async requestSwitchChain(chainId) {
-    const privateKey = getPrivateKey(chainId);
-    if (!privateKey) {
-      throw new Error(`No private key configured for chain ${chainId}`);
-    }
-    this.activeChainId = chainId;
-    for (const cb of this.chainChangedCallbacks) {
-      cb(chainId);
-    }
-  }
-  async sendTransaction(tx, chainId) {
-    const privateKey = getPrivateKey(chainId);
-    if (!privateKey) {
-      throw new Error(`No private key found for chain ${chainId}`);
-    }
-    const walletClient = createPrivateKeyWalletClient(chainId, privateKey);
-    return await walletClient.sendTransaction(tx);
-  }
-  async signMessage(message) {
-    if (!this.activeChainId) {
-      throw new Error("Wallet not connected");
-    }
-    const privateKey = getPrivateKey(this.activeChainId);
-    if (!privateKey) {
-      throw new Error("No private key found");
-    }
-    const account = privateKeyToAccount(normalizePrivateKeyHex(privateKey));
-    return await account.signMessage({ message });
-  }
-  async getWalletClient(chainId) {
-    const privateKey = getPrivateKey(chainId);
-    if (!privateKey) {
-      throw new Error(`No private key configured for chain ${chainId}`);
-    }
-    return createPrivateKeyWalletClient(chainId, privateKey);
-  }
-  onAccountChanged(cb) {
-    return () => {
-    };
-  }
-  onChainChanged(cb) {
-    this.chainChangedCallbacks.add(cb);
-    return () => {
-      this.chainChangedCallbacks.delete(cb);
-    };
-  }
-  disconnect() {
-    this.activeChainId = 0;
-  }
-};
-function createPrivateKeyConnector() {
-  return new PrivateKeyConnector();
-}
-
-// src/web3/session/projects.ts
-var projectLocale = (project, userLanguage, chainId) => {
-  const { decimals } = getChain(chainId);
-  const balance = project.balance / 10 ** decimals;
-  const projectLangIndex = project.availableLanguages.findIndex((lang) => lang === userLanguage);
-  if (projectLangIndex !== -1) {
-    return {
-      lang: project.availableLanguages[projectLangIndex],
-      version: { ...project.versions[projectLangIndex] },
-      id: project.id,
-      balance
-    };
-  }
-  const englishIndex = project.availableLanguages.findIndex((lang) => lang === " eng");
-  if (englishIndex !== -1) {
-    return {
-      lang: " eng",
-      version: { ...project.versions[englishIndex] },
-      id: project.id,
-      balance
-    };
-  }
-  if (project.availableLanguages.length === 0) {
-    throw new Error(`No language available for project ${project.id}`);
-  }
-  return {
-    lang: project.availableLanguages[0],
-    version: { ...project.versions[0] },
-    id: project.id,
-    balance
-  };
-};
-var ProjectRegistry = class {
-  projectKey(chainId, language, projectId) {
-    return `${chainId}_${language}_${projectId}_v2`;
-  }
-  nbProjectsKey(chainId, language) {
-    return `${chainId}_${language}_nbProjects_v2`;
-  }
-  nbProjects(chainId, language) {
-    const nb = getItem(this.nbProjectsKey(chainId, language));
-    return nb ? parseInt(nb, 10) : 0;
-  }
-  setNbProjects(chainId, language, nb) {
-    setItem(this.nbProjectsKey(chainId, language), nb.toString());
-  }
-  getProject(chainId, language, projectId) {
-    return getItem(this.projectKey(chainId, language, projectId));
-  }
-  cacheProject(chainId, language, project) {
-    setItem(this.projectKey(chainId, language, project.id), project);
-  }
-  // Preserves position (null for a missing entry) so callers can index this
-  // the same way as loadProjects()'s online path: result[i] is always project
-  // (i+1), whether the data came from a live fetch or this offline fallback.
-  getCachedProjects(chainId, language) {
-    const nbProjects = this.nbProjects(chainId, language);
-    if (nbProjects <= 0) return [];
-    const projects = [];
-    for (let i = 1; i <= nbProjects; i++) {
-      projects.push(this.getProject(chainId, language, i));
-    }
-    return projects;
-  }
-  async loadProject(chainId, language, projectId, refresh = false) {
-    const cached = this.getProject(chainId, language, projectId);
-    if (cached !== null && !refresh) {
-      return cached;
-    }
-    const client = getReadClient(chainId);
-    await client.ready;
-    const loaded = projectLocale(await client.projectManagerStorage.loadProject(projectId), language, chainId);
-    this.cacheProject(chainId, language, loaded);
-    return loaded;
-  }
-  async loadProjects(chainId, language) {
-    let client;
-    try {
-      client = getReadClient(chainId);
-    } catch (e) {
-      console.warn(`[ProjectRegistry] No read client for chain ${chainId} \u2014 returning cached projects only.`, e);
-      return this.getCachedProjects(chainId, language);
-    }
-    await client.ready;
-    const cachedNbProjects = this.nbProjects(chainId, language);
-    const liveNbProjects = await client.projectManagerStorage.nbProjects();
-    if (liveNbProjects !== cachedNbProjects) {
-      this.setNbProjects(chainId, language, liveNbProjects);
-    }
-    const range = Array.from({ length: liveNbProjects }, (_, i) => i + 1);
-    return Promise.all(
-      range.map(
-        (id) => this.loadProject(chainId, language, id).catch((e) => {
-          console.error(`[ProjectRegistry] Error loading project ${id}:`, e);
-          return null;
-        })
-      )
-    );
-  }
-};
-var projectRegistry = new ProjectRegistry();
-var loadProjects = (chainId, language) => projectRegistry.loadProjects(chainId, language);
-var loadProject = (chainId, language, projectId, refresh = false) => projectRegistry.loadProject(chainId, language, projectId, refresh);
-
-// src/web3/wallet/MetaMaskConnector.ts
-import { createWalletClient as createWalletClient2, custom } from "viem";
-var announcedMetaMaskProvider = null;
-if (typeof window !== "undefined") {
-  window.addEventListener("eip6963:announceProvider", (event) => {
-    const detail = event.detail;
-    if (detail.info.rdns === "io.metamask" || detail.info.rdns === "io.metamask.flask") {
-      announcedMetaMaskProvider = detail.provider;
-    }
-  });
-  window.dispatchEvent(new Event("eip6963:requestProvider"));
-}
-var MetaMaskConnector = class {
-  constructor() {
-    this.type = "metamask";
-    this.accountChangedCallbacks = /* @__PURE__ */ new Set();
-    this.chainChangedCallbacks = /* @__PURE__ */ new Set();
-    this.isListening = false;
-  }
-  getProvider() {
-    if (announcedMetaMaskProvider) return announcedMetaMaskProvider;
-    if (typeof window !== "undefined") {
-      return window.ethereum;
-    }
-    return null;
-  }
-  isAvailable() {
-    const provider = this.getProvider();
-    return !!provider;
-  }
-  setupListeners() {
-    if (this.isListening) return;
-    const provider = this.getProvider();
-    if (!provider) return;
-    if (typeof provider.on === "function") {
-      provider.on("accountsChanged", (accounts) => {
-        const address = accounts[0] || "";
-        for (const cb of this.accountChangedCallbacks) {
-          cb(address);
-        }
-      });
-      provider.on("chainChanged", (chainIdHex) => {
-        const chainId = parseInt(chainIdHex, 16);
-        for (const cb of this.chainChangedCallbacks) {
-          cb(chainId);
-        }
-      });
-      this.isListening = true;
-    }
-  }
-  async connect() {
-    const provider = this.getProvider();
-    if (!provider) {
-      throw new Error("MetaMask provider not found");
-    }
-    this.setupListeners();
-    const accounts = await provider.request({
-      method: "eth_requestAccounts"
-    });
-    const chainIdHex = await provider.request({
-      method: "eth_chainId"
-    });
-    return {
-      address: accounts[0],
-      chainId: parseInt(chainIdHex, 16)
-    };
-  }
-  async getAccounts() {
-    const provider = this.getProvider();
-    if (!provider) return [];
-    try {
-      const accounts = await provider.request({
-        method: "eth_accounts"
-      });
-      return accounts || [];
-    } catch {
-      return [];
-    }
-  }
-  async getChainId() {
-    const provider = this.getProvider();
-    if (!provider) return 0;
-    try {
-      const chainIdHex = await provider.request({
-        method: "eth_chainId"
-      });
-      return parseInt(chainIdHex, 16);
-    } catch {
-      return 0;
-    }
-  }
-  async requestSwitchChain(chainId) {
-    const provider = this.getProvider();
-    if (!provider) {
-      throw new Error("MetaMask provider not found");
-    }
-    const targetChainIdHex = "0x" + chainId.toString(16);
-    try {
-      await provider.request({
-        method: "wallet_switchEthereumChain",
-        params: [{ chainId: targetChainIdHex }]
-      });
-    } catch (switchError) {
-      if (switchError.code === 4902) {
-        const chainConfig = getChain(chainId);
-        if (!chainConfig) {
-          throw new Error(`No configuration found for chain ID: ${chainId}`);
-        }
-        await provider.request({
-          method: "wallet_addEthereumChain",
-          params: [
-            {
-              chainId: targetChainIdHex,
-              chainName: chainConfig.name,
-              rpcUrls: [chainConfig.rpc],
-              blockExplorerUrls: [chainConfig.explorer],
-              nativeCurrency: {
-                decimals: chainConfig.decimals || 18,
-                name: chainConfig.name,
-                symbol: chainConfig.symbol
-              }
-            }
-          ]
-        });
-      } else {
-        throw switchError;
-      }
-    }
-  }
-  async sendTransaction(tx, chainId) {
-    const provider = this.getProvider();
-    if (!provider) {
-      throw new Error("MetaMask provider not found");
-    }
-    const accounts = await this.getAccounts();
-    if (accounts.length === 0) {
-      throw new Error("No accounts connected");
-    }
-    const chain = toViemChain(getChain(chainId));
-    const walletClient = createWalletClient2({
-      account: accounts[0],
-      chain,
-      transport: custom(provider)
-    });
-    return await walletClient.sendTransaction(tx);
-  }
-  async signMessage(message) {
-    const provider = this.getProvider();
-    if (!provider) {
-      throw new Error("MetaMask provider not found");
-    }
-    const accounts = await this.getAccounts();
-    if (accounts.length === 0) {
-      throw new Error("No accounts connected");
-    }
-    const walletClient = createWalletClient2({
-      account: accounts[0],
-      transport: custom(provider)
-    });
-    return await walletClient.signMessage({
-      account: accounts[0],
-      message
-    });
-  }
-  async getWalletClient(chainId) {
-    const provider = this.getProvider();
-    if (!provider) {
-      throw new Error("MetaMask provider not found");
-    }
-    const accounts = await this.getAccounts();
-    if (accounts.length === 0) {
-      throw new Error("No accounts connected");
-    }
-    const chain = toViemChain(getChain(chainId));
-    return createWalletClient2({
-      account: accounts[0],
-      chain,
-      transport: custom(provider)
-    });
-  }
-  onAccountChanged(cb) {
-    this.setupListeners();
-    this.accountChangedCallbacks.add(cb);
-    return () => {
-      this.accountChangedCallbacks.delete(cb);
-    };
-  }
-  onChainChanged(cb) {
-    this.setupListeners();
-    this.chainChangedCallbacks.add(cb);
-    return () => {
-      this.chainChangedCallbacks.delete(cb);
-    };
-  }
-  disconnect() {
-  }
-};
-function createMetaMaskConnector() {
-  return new MetaMaskConnector();
-}
-
-export {
-  EVM_CHAINS,
-  DEFAULT_CHAIN_ID,
-  getChain,
-  toViemChain,
-  pythAbi,
-  addressRegistryAbi,
-  stringToBytes4,
-  normalizeError,
-  EvmClient,
-  createEvmClient,
-  readOnlyClients,
-  readOnlyStagingClients,
-  getReadClient,
-  getEvmClient,
-  getReadyEvmClient,
-  createSessionStore,
-  sessionStore,
-  allRegisteredAccounts,
-  EventBus,
-  getEventBus,
-  EventName,
-  WalletState,
-  WalletError,
-  WalletUxError,
-  WalletEvents,
-  SubscriptionClient,
-  getSubscriptionClient,
-  serializeCursor,
-  deserializeCursor,
-  emptyCursor,
-  cursorStore,
-  syncAccount,
-  restoreAccountSave,
-  hasUnsavedPatches,
-  loadNetworkInfos,
-  registerConnector,
-  getConnector,
-  getRegisteredConnectors,
-  getCachedEmail,
-  setCachedEmail,
-  storePrivateKey,
-  getPrivateKey,
-  hasPrivateKey,
-  hasAnyPrivateKey,
-  storeEncryptedPrivateKey,
-  getDecryptedPrivateKey,
-  hasEncryptedPrivateKey,
-  addressFromPrivateKey,
-  createPrivateKeyWalletClient,
-  PrivateKeyConnector,
-  createPrivateKeyConnector,
-  projectLocale,
-  loadProjects,
-  loadProject,
-  MetaMaskConnector,
-  createMetaMaskConnector
-};
-//# sourceMappingURL=chunk-PUYDAUCI.js.map