@sudobility/components-rn 1.0.19 → 1.0.21

package/dist/index.esm.js

@@ -1,7 +1,7 @@
 import { clsx } from "clsx";
 import * as React from "react";
-import React__default, { useState, useCallback, useRef, useEffect, createContext, useContext } from "react";
-import { Pressable, ActivityIndicator, Text as Text$1, View, TextInput, Dimensions, Animated, Modal as Modal$1, SafeAreaView, FlatList, Image, KeyboardAvoidingView, ScrollView, Platform, PanResponder, Linking, TouchableWithoutFeedback, useWindowDimensions, StyleSheet, RefreshControl, UIManager, LayoutAnimation, Alert as Alert$1 } from "react-native";
+import React__default, { useState, useRef, useCallback, useEffect, createContext, useContext } from "react";
+import { Animated, View, Text as Text$1, Pressable, ActivityIndicator, TextInput, Dimensions, Modal as Modal$1, SafeAreaView, FlatList, Image, KeyboardAvoidingView, ScrollView, Platform, PanResponder, Linking, TouchableWithoutFeedback, useWindowDimensions, StyleSheet, RefreshControl, UIManager, LayoutAnimation, Alert as Alert$1 } from "react-native";
 import { cva } from "class-variance-authority";
 import { variants, getCardVariantColors, textVariants } from "@sudobility/design";
 import { colors, designTokens, textVariants as textVariants2, variants as variants2 } from "@sudobility/design";
@@ -936,6 +936,2825 @@ function requireJsxRuntime() {
   return jsxRuntime.exports;
 }
 var jsxRuntimeExports = requireJsxRuntime();
+var dist = {};
+var enums = {};
+var hasRequiredEnums;
+function requireEnums() {
+  if (hasRequiredEnums) return enums;
+  hasRequiredEnums = 1;
+  Object.defineProperty(enums, "__esModule", { value: true });
+  enums.Currency = enums.ErrorType = enums.FeatureFlag = enums.EmailValidationState = enums.PlatformType = enums.ConnectionState = enums.ConnectionType = enums.EmailSortCriteria = enums.SortOrder = enums.EmailAddressType = enums.InfoType = enums.NotificationType = enums.RequestStatus = enums.SubscriptionAction = enums.EmailAction = enums.MediumView = enums.MobileView = enums.EmailComposeType = enums.FontSize = enums.Theme = enums.Chain = enums.ChainType = enums.AuthStatus = void 0;
+  var AuthStatus;
+  (function(AuthStatus2) {
+    AuthStatus2["CONNECTED"] = "connected";
+    AuthStatus2["DISCONNECTED"] = "disconnected";
+    AuthStatus2["VERIFIED"] = "verified";
+  })(AuthStatus || (enums.AuthStatus = AuthStatus = {}));
+  var ChainType;
+  (function(ChainType2) {
+    ChainType2["EVM"] = "evm";
+    ChainType2["SOLANA"] = "solana";
+  })(ChainType || (enums.ChainType = ChainType = {}));
+  var Chain;
+  (function(Chain2) {
+    Chain2["ETH_MAINNET"] = "eth-mainnet";
+    Chain2["ETH_SEPOLIA"] = "eth-sepolia";
+    Chain2["ETH_GOERLI"] = "eth-goerli";
+    Chain2["POLYGON_MAINNET"] = "polygon-mainnet";
+    Chain2["POLYGON_MUMBAI"] = "polygon-mumbai";
+    Chain2["POLYGON_AMOY"] = "polygon-amoy";
+    Chain2["OPTIMISM_MAINNET"] = "optimism-mainnet";
+    Chain2["OPTIMISM_SEPOLIA"] = "optimism-sepolia";
+    Chain2["OPTIMISM_GOERLI"] = "optimism-goerli";
+    Chain2["ARBITRUM_MAINNET"] = "arbitrum-mainnet";
+    Chain2["ARBITRUM_SEPOLIA"] = "arbitrum-sepolia";
+    Chain2["ARBITRUM_GOERLI"] = "arbitrum-goerli";
+    Chain2["BASE_MAINNET"] = "base-mainnet";
+    Chain2["BASE_SEPOLIA"] = "base-sepolia";
+    Chain2["BASE_GOERLI"] = "base-goerli";
+    Chain2["AVALANCHE_MAINNET"] = "avalanche-mainnet";
+    Chain2["AVALANCHE_FUJI"] = "avalanche-fuji";
+    Chain2["BNB_MAINNET"] = "bnb-mainnet";
+    Chain2["BNB_TESTNET"] = "bnb-testnet";
+    Chain2["GNOSIS_MAINNET"] = "gnosis-mainnet";
+    Chain2["GNOSIS_CHIADO"] = "gnosis-chiado";
+    Chain2["CELO_MAINNET"] = "celo-mainnet";
+    Chain2["CELO_ALFAJORES"] = "celo-alfajores";
+    Chain2["ZKSYNC_MAINNET"] = "zksync-mainnet";
+    Chain2["ZKSYNC_SEPOLIA"] = "zksync-sepolia";
+    Chain2["LINEA_MAINNET"] = "linea-mainnet";
+    Chain2["LINEA_SEPOLIA"] = "linea-sepolia";
+    Chain2["SCROLL_MAINNET"] = "scroll-mainnet";
+    Chain2["SCROLL_SEPOLIA"] = "scroll-sepolia";
+    Chain2["MONAD_MAINNET"] = "monad-mainnet";
+    Chain2["MONAD_TESTNET"] = "monad-testnet";
+    Chain2["STORY_MAINNET"] = "story-mainnet";
+    Chain2["STORY_TESTNET"] = "story-testnet";
+    Chain2["PLUME_MAINNET"] = "plume-mainnet";
+    Chain2["PLUME_TESTNET"] = "plume-testnet";
+    Chain2["NEXUS_MAINNET"] = "nexus-mainnet";
+    Chain2["NEXUS_TESTNET"] = "nexus-testnet";
+    Chain2["HYPEREVM_MAINNET"] = "hyperevm-mainnet";
+    Chain2["HYPEREVM_TESTNET"] = "hyperevm-testnet";
+    Chain2["SONIC_MAINNET"] = "sonic-mainnet";
+    Chain2["SONIC_TESTNET"] = "sonic-testnet";
+    Chain2["SONIC_BLAZE"] = "sonic-blaze";
+    Chain2["UNICHAIN_MAINNET"] = "unichain-mainnet";
+    Chain2["UNICHAIN_SEPOLIA"] = "unichain-sepolia";
+    Chain2["WORLD_MAINNET"] = "world-mainnet";
+    Chain2["XDC_MAINNET"] = "xdc-mainnet";
+    Chain2["INK_TESTNET"] = "ink-testnet";
+    Chain2["FETCH_MAINNET"] = "fetch-mainnet";
+    Chain2["FETCH_TESTNET"] = "fetch-testnet";
+    Chain2["GENSYN_MAINNET"] = "gensyn-mainnet";
+    Chain2["GENSYN_TESTNET"] = "gensyn-testnet";
+    Chain2["RITUAL_MAINNET"] = "ritual-mainnet";
+    Chain2["RITUAL_TESTNET"] = "ritual-testnet";
+    Chain2["SOLANA_MAINNET"] = "solana-mainnet";
+    Chain2["SOLANA_DEVNET"] = "solana-devnet";
+    Chain2["SOLANA_TESTNET"] = "solana-testnet";
+    Chain2["EVM_LOCAL"] = "evm-local";
+    Chain2["SOLANA_LOCAL"] = "solana-local";
+  })(Chain || (enums.Chain = Chain = {}));
+  var Theme;
+  (function(Theme2) {
+    Theme2["LIGHT"] = "light";
+    Theme2["DARK"] = "dark";
+    Theme2["SYSTEM"] = "system";
+  })(Theme || (enums.Theme = Theme = {}));
+  var FontSize;
+  (function(FontSize2) {
+    FontSize2["SMALL"] = "small";
+    FontSize2["MEDIUM"] = "medium";
+    FontSize2["LARGE"] = "large";
+  })(FontSize || (enums.FontSize = FontSize = {}));
+  var EmailComposeType;
+  (function(EmailComposeType2) {
+    EmailComposeType2["NEW"] = "new";
+    EmailComposeType2["REPLY"] = "reply";
+    EmailComposeType2["REPLY_ALL"] = "replyAll";
+    EmailComposeType2["FORWARD"] = "forward";
+  })(EmailComposeType || (enums.EmailComposeType = EmailComposeType = {}));
+  var MobileView;
+  (function(MobileView2) {
+    MobileView2["EMAIL_ADDRESSES"] = "emailAddresses";
+    MobileView2["FOLDERS"] = "folders";
+    MobileView2["EMAILS"] = "emails";
+    MobileView2["EMAIL_BODY"] = "emailBody";
+  })(MobileView || (enums.MobileView = MobileView = {}));
+  var MediumView;
+  (function(MediumView2) {
+    MediumView2["LEFT"] = "left";
+    MediumView2["RIGHT"] = "right";
+  })(MediumView || (enums.MediumView = MediumView = {}));
+  var EmailAction;
+  (function(EmailAction2) {
+    EmailAction2["OPEN"] = "open";
+    EmailAction2["REPLY"] = "reply";
+    EmailAction2["FORWARD"] = "forward";
+    EmailAction2["DELETE"] = "delete";
+    EmailAction2["STAR"] = "star";
+    EmailAction2["UNSTAR"] = "unstar";
+    EmailAction2["MARK_READ"] = "mark_read";
+    EmailAction2["MARK_UNREAD"] = "mark_unread";
+  })(EmailAction || (enums.EmailAction = EmailAction = {}));
+  var SubscriptionAction;
+  (function(SubscriptionAction2) {
+    SubscriptionAction2["VIEW"] = "view";
+    SubscriptionAction2["PURCHASE"] = "purchase";
+    SubscriptionAction2["CANCEL"] = "cancel";
+    SubscriptionAction2["RESTORE"] = "restore";
+  })(SubscriptionAction || (enums.SubscriptionAction = SubscriptionAction = {}));
+  var RequestStatus;
+  (function(RequestStatus2) {
+    RequestStatus2["IDLE"] = "idle";
+    RequestStatus2["LOADING"] = "loading";
+    RequestStatus2["SUCCESS"] = "success";
+    RequestStatus2["ERROR"] = "error";
+  })(RequestStatus || (enums.RequestStatus = RequestStatus = {}));
+  var NotificationType;
+  (function(NotificationType2) {
+    NotificationType2["INFO"] = "info";
+    NotificationType2["SUCCESS"] = "success";
+    NotificationType2["WARNING"] = "warning";
+    NotificationType2["ERROR"] = "error";
+  })(NotificationType || (enums.NotificationType = NotificationType = {}));
+  var InfoType;
+  (function(InfoType2) {
+    InfoType2["INFO"] = "info";
+    InfoType2["SUCCESS"] = "success";
+    InfoType2["WARNING"] = "warning";
+    InfoType2["ERROR"] = "error";
+  })(InfoType || (enums.InfoType = InfoType = {}));
+  var EmailAddressType;
+  (function(EmailAddressType2) {
+    EmailAddressType2["DIRECT"] = "direct";
+    EmailAddressType2["ENS"] = "ens";
+    EmailAddressType2["SNS"] = "sns";
+    EmailAddressType2["CUSTOM"] = "custom";
+  })(EmailAddressType || (enums.EmailAddressType = EmailAddressType = {}));
+  var SortOrder;
+  (function(SortOrder2) {
+    SortOrder2["ASC"] = "asc";
+    SortOrder2["DESC"] = "desc";
+  })(SortOrder || (enums.SortOrder = SortOrder = {}));
+  var EmailSortCriteria;
+  (function(EmailSortCriteria2) {
+    EmailSortCriteria2["DATE"] = "date";
+    EmailSortCriteria2["SUBJECT"] = "subject";
+    EmailSortCriteria2["FROM"] = "from";
+    EmailSortCriteria2["SIZE"] = "size";
+  })(EmailSortCriteria || (enums.EmailSortCriteria = EmailSortCriteria = {}));
+  var ConnectionType;
+  (function(ConnectionType2) {
+    ConnectionType2["UNKNOWN"] = "unknown";
+    ConnectionType2["NONE"] = "none";
+    ConnectionType2["WIFI"] = "wifi";
+    ConnectionType2["CELLULAR_2G"] = "2g";
+    ConnectionType2["CELLULAR_3G"] = "3g";
+    ConnectionType2["CELLULAR_4G"] = "4g";
+    ConnectionType2["CELLULAR_5G"] = "5g";
+    ConnectionType2["ETHERNET"] = "ethernet";
+  })(ConnectionType || (enums.ConnectionType = ConnectionType = {}));
+  var ConnectionState;
+  (function(ConnectionState2) {
+    ConnectionState2["UNKNOWN"] = "unknown";
+    ConnectionState2["DISCONNECTED"] = "disconnected";
+    ConnectionState2["CONNECTING"] = "connecting";
+    ConnectionState2["CONNECTED"] = "connected";
+    ConnectionState2["RECONNECTING"] = "reconnecting";
+    ConnectionState2["VERIFIED"] = "verified";
+    ConnectionState2["LIMITED"] = "limited";
+    ConnectionState2["ERROR"] = "error";
+  })(ConnectionState || (enums.ConnectionState = ConnectionState = {}));
+  var PlatformType;
+  (function(PlatformType2) {
+    PlatformType2["WEB"] = "web";
+    PlatformType2["REACT_NATIVE"] = "react_native";
+    PlatformType2["DESKTOP"] = "desktop";
+  })(PlatformType || (enums.PlatformType = PlatformType = {}));
+  var EmailValidationState;
+  (function(EmailValidationState2) {
+    EmailValidationState2["VALID"] = "valid";
+    EmailValidationState2["INVALID"] = "invalid";
+    EmailValidationState2["PENDING"] = "pending";
+    EmailValidationState2["UNKNOWN"] = "unknown";
+  })(EmailValidationState || (enums.EmailValidationState = EmailValidationState = {}));
+  var FeatureFlag;
+  (function(FeatureFlag2) {
+    FeatureFlag2["AI_SEARCH"] = "ai_search";
+    FeatureFlag2["SMART_COMPOSE"] = "smart_compose";
+    FeatureFlag2["ADVANCED_FILTERS"] = "advanced_filters";
+    FeatureFlag2["DARK_MODE"] = "dark_mode";
+    FeatureFlag2["NOTIFICATIONS"] = "notifications";
+    FeatureFlag2["ANALYTICS"] = "analytics";
+  })(FeatureFlag || (enums.FeatureFlag = FeatureFlag = {}));
+  var ErrorType;
+  (function(ErrorType2) {
+    ErrorType2["NETWORK"] = "network";
+    ErrorType2["AUTH"] = "auth";
+    ErrorType2["VALIDATION"] = "validation";
+    ErrorType2["PERMISSION"] = "permission";
+    ErrorType2["UNKNOWN"] = "unknown";
+  })(ErrorType || (enums.ErrorType = ErrorType = {}));
+  var Currency;
+  (function(Currency2) {
+    Currency2["USD"] = "USD";
+    Currency2["EUR"] = "EUR";
+    Currency2["GBP"] = "GBP";
+    Currency2["CAD"] = "CAD";
+    Currency2["AUD"] = "AUD";
+  })(Currency || (enums.Currency = Currency = {}));
+  return enums;
+}
+var walletStatus = {};
+var hasRequiredWalletStatus;
+function requireWalletStatus() {
+  if (hasRequiredWalletStatus) return walletStatus;
+  hasRequiredWalletStatus = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.getWalletConnectionState = exports$1.isWalletVerified = exports$1.isWalletConnected = void 0;
+    const enums_1 = requireEnums();
+    const isWalletConnected = (status) => {
+      return status !== void 0 && status !== null && Boolean(status.walletAddress);
+    };
+    exports$1.isWalletConnected = isWalletConnected;
+    const isWalletVerified = (status) => {
+      return (0, exports$1.isWalletConnected)(status) && Boolean(status.message) && Boolean(status.signature);
+    };
+    exports$1.isWalletVerified = isWalletVerified;
+    const getWalletConnectionState = (status) => {
+      if (!(0, exports$1.isWalletConnected)(status)) {
+        return enums_1.ConnectionState.DISCONNECTED;
+      }
+      if ((0, exports$1.isWalletVerified)(status)) {
+        return enums_1.ConnectionState.VERIFIED;
+      }
+      return enums_1.ConnectionState.CONNECTED;
+    };
+    exports$1.getWalletConnectionState = getWalletConnectionState;
+  })(walletStatus);
+  return walletStatus;
+}
+var common = {};
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  Object.defineProperty(common, "__esModule", { value: true });
+  common.PROTOCOL_CONSTANTS = common.TransactionStatus = common.MessageType = void 0;
+  common.isSolanaAddress = isSolanaAddress;
+  common.isEvmAddress = isEvmAddress;
+  common.isSolanaRecipient = isSolanaRecipient;
+  common.isEvmRecipient = isEvmRecipient;
+  var MessageType;
+  (function(MessageType2) {
+    MessageType2["STANDARD"] = "standard";
+    MessageType2["PRIORITY"] = "priority";
+    MessageType2["PREPARED_STANDARD"] = "prepared_standard";
+    MessageType2["PREPARED_PRIORITY"] = "prepared_priority";
+  })(MessageType || (common.MessageType = MessageType = {}));
+  var TransactionStatus;
+  (function(TransactionStatus2) {
+    TransactionStatus2["SUCCESS"] = "success";
+    TransactionStatus2["FAILED"] = "failed";
+    TransactionStatus2["PENDING"] = "pending";
+  })(TransactionStatus || (common.TransactionStatus = TransactionStatus = {}));
+  function isSolanaAddress(address2) {
+    try {
+      if (address2.length < 32 || address2.length > 44) {
+        return false;
+      }
+      const base58Regex = /^[1-9A-HJ-NP-Za-km-z]+$/;
+      if (!base58Regex.test(address2)) {
+        return false;
+      }
+      try {
+        const bs58 = require("bs58");
+        const decoded = bs58.decode(address2);
+        return decoded.length === 32;
+      } catch {
+        return true;
+      }
+    } catch {
+      return false;
+    }
+  }
+  function isEvmAddress(address2) {
+    return /^0x[a-fA-F0-9]{40}$/.test(address2);
+  }
+  function isSolanaRecipient(recipient) {
+    return isSolanaAddress(recipient);
+  }
+  function isEvmRecipient(recipient) {
+    return isEvmAddress(recipient);
+  }
+  common.PROTOCOL_CONSTANTS = {
+    /** Base send fee: 0.1 USDC (100,000 with 6 decimals) */
+    SEND_FEE: 100000n,
+    /** Claim period: 60 days in seconds */
+    CLAIM_PERIOD: 60 * 24 * 60 * 60,
+    /** Revenue share percentages */
+    REVENUE_SHARES: {
+      SENDER: 90,
+      OWNER: 10
+    },
+    /** USDC token decimals */
+    USDC_DECIMALS: 6,
+    /** Maximum message lengths */
+    MAX_LENGTHS: {
+      SUBJECT: 200,
+      BODY: 2e3,
+      MAIL_ID: 100
+    }
+  };
+  return common;
+}
+var validation = {};
+var address = {};
+var hasRequiredAddress;
+function requireAddress() {
+  if (hasRequiredAddress) return address;
+  hasRequiredAddress = 1;
+  Object.defineProperty(address, "__esModule", { value: true });
+  address.AddressType = void 0;
+  address.isENSName = isENSName;
+  address.isSNSName = isSNSName;
+  address.getAddressType = getAddressType;
+  address.isValidWalletAddress = isValidWalletAddress;
+  address.isValidSignature = isValidSignature;
+  address.parseEmailAddress = parseEmailAddress;
+  address.formatWalletAddress = formatWalletAddress;
+  address.getChainDisplayName = getChainDisplayName;
+  const enums_1 = requireEnums();
+  const common_1 = requireCommon();
+  var AddressType;
+  (function(AddressType2) {
+    AddressType2["EVMAddress"] = "EVMAddress";
+    AddressType2["SolanaAddress"] = "SolanaAddress";
+    AddressType2["ENSName"] = "ENSName";
+    AddressType2["SNSName"] = "SNSName";
+  })(AddressType || (address.AddressType = AddressType = {}));
+  function isENSName(address2) {
+    const lowerAddress = address2.toLowerCase();
+    if (!lowerAddress.endsWith(".eth") && !lowerAddress.endsWith(".box")) {
+      return false;
+    }
+    const nameWithoutTLD = lowerAddress.endsWith(".eth") ? lowerAddress.slice(0, -4) : lowerAddress.slice(0, -4);
+    if (nameWithoutTLD.length === 0) {
+      return false;
+    }
+    const labels = nameWithoutTLD.split(".");
+    const validLabelRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+    for (const label of labels) {
+      if (label.length === 0 || !validLabelRegex.test(label)) {
+        return false;
+      }
+      if (label.includes("--")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function isSNSName(address2) {
+    const lowerAddress = address2.toLowerCase();
+    const snsExtensions = [
+      ".sol",
+      ".abc",
+      ".bonk",
+      ".poor",
+      ".gm",
+      ".dao",
+      ".defi",
+      ".web3"
+    ];
+    const matchingExtension = snsExtensions.find((ext) => lowerAddress.endsWith(ext));
+    if (!matchingExtension) {
+      return false;
+    }
+    const nameWithoutTLD = lowerAddress.slice(0, -matchingExtension.length);
+    if (nameWithoutTLD.length === 0) {
+      return false;
+    }
+    const labels = nameWithoutTLD.split(".");
+    const validLabelRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+    for (const label of labels) {
+      if (label.length === 0 || !validLabelRegex.test(label)) {
+        return false;
+      }
+      if (label.includes("--")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getAddressType(address2, parentAddressType = void 0) {
+    if ((0, common_1.isEvmAddress)(address2)) {
+      return AddressType.EVMAddress;
+    }
+    if ((0, common_1.isSolanaAddress)(address2)) {
+      return AddressType.SolanaAddress;
+    }
+    if (parentAddressType && address2.includes(".")) {
+      if (parentAddressType === AddressType.EVMAddress) {
+        return AddressType.ENSName;
+      }
+      if (parentAddressType === AddressType.SolanaAddress) {
+        return AddressType.SNSName;
+      }
+    }
+    return void 0;
+  }
+  function isValidWalletAddress(address2, chainType) {
+    if (!address2 || typeof address2 !== "string") {
+      return false;
+    }
+    const addressType = getAddressType(address2);
+    switch (chainType) {
+      case enums_1.ChainType.EVM:
+        return addressType === AddressType.EVMAddress || addressType === AddressType.ENSName;
+      case enums_1.ChainType.SOLANA:
+        return addressType === AddressType.SolanaAddress || addressType === AddressType.SNSName;
+      default:
+        return !!addressType;
+    }
+  }
+  function isValidSignature(signature, chainType) {
+    if (!signature || typeof signature !== "string") {
+      return false;
+    }
+    switch (chainType) {
+      case enums_1.ChainType.EVM:
+        return /^0x[a-fA-F0-9]{130}$/.test(signature);
+      case enums_1.ChainType.SOLANA:
+        return /^[1-9A-HJ-NP-Za-km-z]{87,88}$/.test(signature);
+      default:
+        return signature.length > 50;
+    }
+  }
+  function parseEmailAddress(email) {
+    if (!email || typeof email !== "string") {
+      return void 0;
+    }
+    const parts = email.split("@");
+    if (parts.length !== 2) {
+      return void 0;
+    }
+    const [address2, domain] = parts;
+    if (!address2 || !domain) {
+      return void 0;
+    }
+    const type = getAddressType(address2);
+    return {
+      address: address2,
+      domain,
+      type
+    };
+  }
+  function formatWalletAddress(address2) {
+    if (!address2 || address2.length < 10) {
+      return address2;
+    }
+    const addressType = getAddressType(address2);
+    if ((addressType === AddressType.ENSName || addressType === AddressType.SNSName) && address2.length <= 20) {
+      return address2;
+    }
+    return `${address2.slice(0, 6)}...${address2.slice(-4)}`;
+  }
+  function getChainDisplayName(chainType) {
+    if (!chainType) {
+      return "Unknown Chain";
+    }
+    switch (chainType) {
+      case enums_1.ChainType.EVM:
+        return "EVM Chain";
+      case enums_1.ChainType.SOLANA:
+        return "Solana";
+      default:
+        return "Blockchain";
+    }
+  }
+  return address;
+}
+var hasRequiredValidation;
+function requireValidation() {
+  if (hasRequiredValidation) return validation;
+  hasRequiredValidation = 1;
+  Object.defineProperty(validation, "__esModule", { value: true });
+  validation.validateDomain = validateDomain;
+  validation.validateMessage = validateMessage;
+  validation.validateAddress = validateAddress;
+  validation.validateAmount = validateAmount;
+  const address_1 = requireAddress();
+  function validateDomain(domain) {
+    if (!domain || domain.length === 0) {
+      throw new Error("Domain cannot be empty");
+    }
+    if (domain.length > 100) {
+      throw new Error("Domain cannot exceed 100 characters");
+    }
+    const domainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    if (!domainRegex.test(domain)) {
+      throw new Error("Invalid domain format");
+    }
+    return true;
+  }
+  function validateMessage(subject, body) {
+    if (!subject || subject.length === 0) {
+      throw new Error("Message subject cannot be empty");
+    }
+    if (subject.length > 200) {
+      throw new Error("Message subject cannot exceed 200 characters");
+    }
+    if (!body || body.length === 0) {
+      throw new Error("Message body cannot be empty");
+    }
+    if (body.length > 1e4) {
+      throw new Error("Message body cannot exceed 10000 characters");
+    }
+    return true;
+  }
+  function validateAddress(address2, chainType) {
+    if (!address2 || address2.length === 0) {
+      throw new Error("Address cannot be empty");
+    }
+    if (!(0, address_1.isValidWalletAddress)(address2, chainType)) {
+      throw new Error(`Invalid ${chainType} address format`);
+    }
+    return true;
+  }
+  function validateAmount(amount) {
+    if (amount === null || amount === void 0 || amount === "" || typeof amount === "string" && amount.trim() === "") {
+      throw new Error("Invalid amount format");
+    }
+    let amountBigInt;
+    try {
+      if (typeof amount === "string") {
+        if (!/^-?\d+$/.test(amount.trim())) {
+          throw new Error("Invalid amount format");
+        }
+        amountBigInt = BigInt(amount);
+      } else if (typeof amount === "number") {
+        if (!Number.isFinite(amount)) {
+          throw new Error("Invalid amount format");
+        }
+        amountBigInt = BigInt(Math.floor(amount));
+      } else if (typeof amount === "bigint") {
+        amountBigInt = amount;
+      } else {
+        throw new Error("Invalid amount format");
+      }
+    } catch {
+      throw new Error("Invalid amount format");
+    }
+    if (amountBigInt < 0n) {
+      throw new Error("Amount cannot be negative");
+    }
+    return amountBigInt;
+  }
+  return validation;
+}
+var environment = {};
+var hasRequiredEnvironment;
+function requireEnvironment() {
+  if (hasRequiredEnvironment) return environment;
+  hasRequiredEnvironment = 1;
+  Object.defineProperty(environment, "__esModule", { value: true });
+  environment.StorageType = void 0;
+  var StorageType;
+  (function(StorageType2) {
+    StorageType2["LOCAL_STORAGE"] = "localStorage";
+    StorageType2["SESSION_STORAGE"] = "sessionStorage";
+    StorageType2["ASYNC_STORAGE"] = "asyncStorage";
+    StorageType2["MEMORY"] = "memory";
+  })(StorageType || (environment.StorageType = StorageType = {}));
+  return environment;
+}
+var analytics = {};
+var hasRequiredAnalytics;
+function requireAnalytics() {
+  if (hasRequiredAnalytics) return analytics;
+  hasRequiredAnalytics = 1;
+  Object.defineProperty(analytics, "__esModule", { value: true });
+  analytics.AnalyticsEventBuilder = analytics.AnalyticsEvent = void 0;
+  var AnalyticsEvent;
+  (function(AnalyticsEvent2) {
+    AnalyticsEvent2["USER_LOGIN"] = "user_login";
+    AnalyticsEvent2["USER_LOGOUT"] = "user_logout";
+    AnalyticsEvent2["USER_SIGNUP"] = "user_signup";
+    AnalyticsEvent2["EMAIL_SENT"] = "email_sent";
+    AnalyticsEvent2["EMAIL_RECEIVED"] = "email_received";
+    AnalyticsEvent2["EMAIL_OPENED"] = "email_opened";
+    AnalyticsEvent2["EMAIL_REPLY"] = "email_reply";
+    AnalyticsEvent2["EMAIL_FORWARD"] = "email_forward";
+    AnalyticsEvent2["EMAIL_DELETE"] = "email_delete";
+    AnalyticsEvent2["EMAIL_STAR"] = "email_star";
+    AnalyticsEvent2["EMAIL_COMPOSE"] = "email_compose";
+    AnalyticsEvent2["EMAIL_CLICKED"] = "email_clicked";
+    AnalyticsEvent2["PAGE_VIEW"] = "page_view";
+    AnalyticsEvent2["SCREEN_VIEW"] = "screen_view";
+    AnalyticsEvent2["FOLDER_SWITCH"] = "folder_switch";
+    AnalyticsEvent2["SUBSCRIPTION_VIEW"] = "subscription_view";
+    AnalyticsEvent2["SUBSCRIPTION_PURCHASE"] = "subscription_purchase";
+    AnalyticsEvent2["SUBSCRIPTION_CANCEL"] = "subscription_cancel";
+    AnalyticsEvent2["SEARCH_PERFORMED"] = "search_performed";
+    AnalyticsEvent2["SETTINGS_CHANGED"] = "settings_changed";
+    AnalyticsEvent2["ERROR_OCCURRED"] = "error_occurred";
+    AnalyticsEvent2["AB_TEST_VIEWED"] = "ab_test_viewed";
+    AnalyticsEvent2["AB_TEST_CONVERTED"] = "ab_test_converted";
+    AnalyticsEvent2["CUSTOM_EVENT"] = "custom_event";
+  })(AnalyticsEvent || (analytics.AnalyticsEvent = AnalyticsEvent = {}));
+  class AnalyticsEventBuilder {
+    /**
+     * Build properties for email action events.
+     *
+     * @param action Email action performed (read, sent, archived, etc.)
+     * @param emailId Unique identifier for the email
+     * @param folder Email folder context (inbox, sent, trash, etc.)
+     * @returns Standardized event properties object
+     *
+     * @ai-builder Email action properties
+     * @ai-standardization Consistent email event tracking
+     */
+    static emailAction(action, emailId, folder) {
+      return {
+        action,
+        email_id: emailId,
+        folder,
+        timestamp: Date.now()
+      };
+    }
+    /**
+     * Build properties for page/screen view events.
+     *
+     * @param pageName Human-readable page name
+     * @param pagePath URL path or screen identifier
+     * @returns Standardized page view properties
+     *
+     * @ai-builder Navigation tracking properties
+     * @ai-cross-platform Works for web pages and mobile screens
+     */
+    static pageView(pageName, pagePath) {
+      return {
+        page_name: pageName,
+        page_path: pagePath,
+        timestamp: Date.now()
+      };
+    }
+    /**
+     * Build properties for error tracking events.
+     *
+     * @param errorType Category of error (network, validation, runtime, etc.)
+     * @param errorMessage Error message or description
+     * @param pageName Page/screen where error occurred
+     * @returns Standardized error event properties
+     *
+     * @ai-builder Error tracking properties
+     * @ai-debugging Consistent error event structure
+     */
+    static error(errorType, errorMessage, pageName) {
+      return {
+        error_type: errorType,
+        error_message: errorMessage,
+        page_name: pageName,
+        timestamp: Date.now()
+      };
+    }
+    /**
+     * Build properties for subscription/revenue events.
+     *
+     * @param action Subscription action (subscribe, upgrade, cancel, etc.)
+     * @param planType Subscription plan type (free, premium, pro, etc.)
+     * @param amount Monetary amount (for revenue tracking)
+     * @param currency Currency code (USD, EUR, etc.)
+     * @returns Standardized subscription event properties
+     *
+     * @ai-builder Revenue tracking properties
+     * @ai-business-metrics Subscription and revenue analytics
+     */
+    static subscription(action, planType, amount, currency2) {
+      return {
+        action,
+        plan_type: planType,
+        amount,
+        currency: currency2,
+        timestamp: Date.now()
+      };
+    }
+    /**
+     * Build properties for user engagement events.
+     *
+     * @param feature Feature name or component identifier
+     * @param interaction Type of interaction (click, scroll, hover, etc.)
+     * @param duration Time spent on interaction (milliseconds)
+     * @returns Standardized engagement event properties
+     *
+     * @ai-builder User engagement properties
+     * @ai-ux-analytics User experience and interaction tracking
+     */
+    static engagement(feature, interaction, duration) {
+      return {
+        feature,
+        interaction,
+        duration,
+        timestamp: Date.now()
+      };
+    }
+    /**
+     * Build properties for performance monitoring events.
+     *
+     * @param metric Performance metric name (load_time, api_response, etc.)
+     * @param value Metric value (usually in milliseconds)
+     * @param context Additional context about the performance event
+     * @returns Standardized performance event properties
+     *
+     * @ai-builder Performance monitoring properties
+     * @ai-performance Application performance tracking
+     */
+    static performance(metric, value, context) {
+      return {
+        metric,
+        value,
+        context,
+        timestamp: Date.now()
+      };
+    }
+  }
+  analytics.AnalyticsEventBuilder = AnalyticsEventBuilder;
+  return analytics;
+}
+var api = {};
+var hasRequiredApi;
+function requireApi() {
+  if (hasRequiredApi) return api;
+  hasRequiredApi = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.ProcessedEventName = exports$1.ContractType = exports$1.ChainType = void 0;
+    var enums_1 = requireEnums();
+    Object.defineProperty(exports$1, "ChainType", { enumerable: true, get: function() {
+      return enums_1.ChainType;
+    } });
+    var ContractType;
+    (function(ContractType2) {
+      ContractType2["Mailer"] = "Mailer";
+      ContractType2["MailService"] = "MailService";
+    })(ContractType || (exports$1.ContractType = ContractType = {}));
+    var ProcessedEventName;
+    (function(ProcessedEventName2) {
+      ProcessedEventName2["MailSent"] = "MailSent";
+      ProcessedEventName2["PreparedMailSent"] = "PreparedMailSent";
+      ProcessedEventName2["DelegationSet"] = "DelegationSet";
+      ProcessedEventName2["DelegationCleared"] = "DelegationCleared";
+      ProcessedEventName2["DomainRegistered"] = "DomainRegistered";
+      ProcessedEventName2["DomainExtended"] = "DomainExtended";
+      ProcessedEventName2["DomainReleased"] = "DomainReleased";
+      ProcessedEventName2["FeeUpdated"] = "FeeUpdated";
+      ProcessedEventName2["SharesRecorded"] = "SharesRecorded";
+      ProcessedEventName2["RecipientClaimed"] = "RecipientClaimed";
+      ProcessedEventName2["OwnerClaimed"] = "OwnerClaimed";
+      ProcessedEventName2["ExpiredSharesClaimed"] = "ExpiredSharesClaimed";
+    })(ProcessedEventName || (exports$1.ProcessedEventName = ProcessedEventName = {}));
+  })(api);
+  return api;
+}
+var network = {};
+var hasRequiredNetwork;
+function requireNetwork() {
+  if (hasRequiredNetwork) return network;
+  hasRequiredNetwork = 1;
+  Object.defineProperty(network, "__esModule", { value: true });
+  network.NetworkError = void 0;
+  class NetworkError extends Error {
+    constructor(message, status, statusText, response) {
+      super(message);
+      this.name = "NetworkError";
+      this.status = status;
+      this.statusText = statusText;
+      this.response = response;
+    }
+  }
+  network.NetworkError = NetworkError;
+  return network;
+}
+var wallet = {};
+var hasRequiredWallet;
+function requireWallet() {
+  if (hasRequiredWallet) return wallet;
+  hasRequiredWallet = 1;
+  Object.defineProperty(wallet, "__esModule", { value: true });
+  wallet.WalletType = void 0;
+  var WalletType;
+  (function(WalletType2) {
+    WalletType2["METAMASK"] = "metamask";
+    WalletType2["PHANTOM"] = "phantom";
+    WalletType2["COINBASE"] = "coinbase";
+    WalletType2["WALLETCONNECT"] = "walletconnect";
+    WalletType2["INJECTED"] = "injected";
+  })(WalletType || (wallet.WalletType = WalletType = {}));
+  return wallet;
+}
+var rateLimits = {};
+var hasRequiredRateLimits;
+function requireRateLimits() {
+  if (hasRequiredRateLimits) return rateLimits;
+  hasRequiredRateLimits = 1;
+  Object.defineProperty(rateLimits, "__esModule", { value: true });
+  rateLimits.RateLimitPeriodType = void 0;
+  var RateLimitPeriodType;
+  (function(RateLimitPeriodType2) {
+    RateLimitPeriodType2["HOUR"] = "hour";
+    RateLimitPeriodType2["DAY"] = "day";
+    RateLimitPeriodType2["MONTH"] = "month";
+  })(RateLimitPeriodType || (rateLimits.RateLimitPeriodType = RateLimitPeriodType = {}));
+  return rateLimits;
+}
+var period = {};
+var hasRequiredPeriod;
+function requirePeriod() {
+  if (hasRequiredPeriod) return period;
+  hasRequiredPeriod = 1;
+  Object.defineProperty(period, "__esModule", { value: true });
+  period.ALL_PERIODS = period.PERIOD_RANKS = void 0;
+  period.PERIOD_RANKS = {
+    weekly: 1,
+    monthly: 2,
+    quarterly: 3,
+    yearly: 4,
+    lifetime: 5
+  };
+  period.ALL_PERIODS = [
+    "weekly",
+    "monthly",
+    "quarterly",
+    "yearly",
+    "lifetime"
+  ];
+  return period;
+}
+var entitlements = {};
+var hasRequiredEntitlements;
+function requireEntitlements() {
+  if (hasRequiredEntitlements) return entitlements;
+  hasRequiredEntitlements = 1;
+  Object.defineProperty(entitlements, "__esModule", { value: true });
+  entitlements.NONE_ENTITLEMENT = void 0;
+  entitlements.NONE_ENTITLEMENT = "none";
+  return entitlements;
+}
+var entity = {};
+var hasRequiredEntity;
+function requireEntity() {
+  if (hasRequiredEntity) return entity;
+  hasRequiredEntity = 1;
+  Object.defineProperty(entity, "__esModule", { value: true });
+  entity.InvitationStatus = entity.EntityRole = entity.EntityType = void 0;
+  var EntityType;
+  (function(EntityType2) {
+    EntityType2["PERSONAL"] = "personal";
+    EntityType2["ORGANIZATION"] = "organization";
+  })(EntityType || (entity.EntityType = EntityType = {}));
+  var EntityRole;
+  (function(EntityRole2) {
+    EntityRole2["OWNER"] = "owner";
+    EntityRole2["MANAGER"] = "manager";
+    EntityRole2["MEMBER"] = "member";
+  })(EntityRole || (entity.EntityRole = EntityRole = {}));
+  var InvitationStatus;
+  (function(InvitationStatus2) {
+    InvitationStatus2["PENDING"] = "pending";
+    InvitationStatus2["ACCEPTED"] = "accepted";
+    InvitationStatus2["DECLINED"] = "declined";
+    InvitationStatus2["EXPIRED"] = "expired";
+  })(InvitationStatus || (entity.InvitationStatus = InvitationStatus = {}));
+  return entity;
+}
+var permissions = {};
+var hasRequiredPermissions;
+function requirePermissions() {
+  if (hasRequiredPermissions) return permissions;
+  hasRequiredPermissions = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.ROLE_PERMISSIONS = exports$1.MEMBER_PERMISSIONS = exports$1.MANAGER_PERMISSIONS = exports$1.OWNER_PERMISSIONS = void 0;
+    exports$1.getPermissionsForRole = getPermissionsForRole;
+    exports$1.hasPermission = hasPermission;
+    const entity_1 = requireEntity();
+    exports$1.OWNER_PERMISSIONS = {
+      canViewEntity: true,
+      canEditEntity: true,
+      canDeleteEntity: true,
+      canManageMembers: true,
+      canInviteMembers: true,
+      canManageProjects: true,
+      canCreateProjects: true,
+      canViewProjects: true,
+      canManageApiKeys: true,
+      canViewApiKeys: true
+    };
+    exports$1.MANAGER_PERMISSIONS = {
+      canViewEntity: true,
+      canEditEntity: true,
+      canDeleteEntity: false,
+      canManageMembers: false,
+      canInviteMembers: false,
+      canManageProjects: true,
+      canCreateProjects: true,
+      canViewProjects: true,
+      canManageApiKeys: true,
+      canViewApiKeys: true
+    };
+    exports$1.MEMBER_PERMISSIONS = {
+      canViewEntity: true,
+      canEditEntity: false,
+      canDeleteEntity: false,
+      canManageMembers: false,
+      canInviteMembers: false,
+      canManageProjects: false,
+      canCreateProjects: false,
+      canViewProjects: true,
+      canManageApiKeys: false,
+      canViewApiKeys: true
+    };
+    exports$1.ROLE_PERMISSIONS = {
+      [entity_1.EntityRole.OWNER]: exports$1.OWNER_PERMISSIONS,
+      [entity_1.EntityRole.MANAGER]: exports$1.MANAGER_PERMISSIONS,
+      [entity_1.EntityRole.MEMBER]: exports$1.MEMBER_PERMISSIONS
+    };
+    function getPermissionsForRole(role) {
+      return exports$1.ROLE_PERMISSIONS[role];
+    }
+    function hasPermission(role, permission) {
+      return exports$1.ROLE_PERMISSIONS[role][permission];
+    }
+  })(permissions);
+  return permissions;
+}
+var web3UsernameValidator = {};
+var hasRequiredWeb3UsernameValidator;
+function requireWeb3UsernameValidator() {
+  if (hasRequiredWeb3UsernameValidator) return web3UsernameValidator;
+  hasRequiredWeb3UsernameValidator = 1;
+  Object.defineProperty(web3UsernameValidator, "__esModule", { value: true });
+  web3UsernameValidator.Web3UsernameValidator = void 0;
+  const enums_1 = requireEnums();
+  class Web3UsernameValidator {
+    /**
+     * Comprehensive address validation for API endpoint
+     * Returns AddressValidationResult for valid addresses, undefined for invalid ones
+     */
+    static validate(address2) {
+      if (!address2) {
+        return void 0;
+      }
+      if (this.EVM_REGEX.test(address2)) {
+        return {
+          name: null,
+          address: address2.toLowerCase(),
+          chainType: enums_1.ChainType.EVM
+        };
+      }
+      if (!address2.startsWith("0x") && address2.length >= 32 && address2.length <= 44 && this.BASE58_REGEX.test(address2)) {
+        return {
+          name: null,
+          address: address2,
+          // Keep case for Solana
+          chainType: enums_1.ChainType.SOLANA
+        };
+      }
+      if ((address2.toLowerCase().endsWith(".eth") || address2.toLowerCase().endsWith(".box")) && address2.length >= 5 && // minimum: "a.eth" = 5 chars
+      this.ENS_REGEX.test(address2)) {
+        return {
+          name: address2.toLowerCase(),
+          address: null,
+          chainType: enums_1.ChainType.EVM
+          // ENS resolves to EVM addresses
+        };
+      }
+      if (address2.toLowerCase().includes(".")) {
+        const parts = address2.toLowerCase().split(".");
+        if (parts.length === 2) {
+          const [name, tld] = parts;
+          if (this.VALID_SNS_TLDS.includes(tld) && this.SNS_NAME_REGEX.test(name) && name.length >= 1) {
+            return {
+              name: address2.toLowerCase(),
+              address: null,
+              chainType: enums_1.ChainType.SOLANA
+              // SNS resolves to Solana addresses
+            };
+          }
+        }
+      }
+      return void 0;
+    }
+    /**
+     * Quick EVM address validation
+     */
+    static isValidEVMAddress(address2) {
+      return this.EVM_REGEX.test(address2);
+    }
+    /**
+     * Quick Solana address validation
+     */
+    static isValidSolanaAddress(address2) {
+      return !address2.startsWith("0x") && address2.length >= 32 && address2.length <= 44 && this.BASE58_REGEX.test(address2);
+    }
+    /**
+     * Quick ENS name validation
+     */
+    static isValidENSName(address2) {
+      return (address2.toLowerCase().endsWith(".eth") || address2.toLowerCase().endsWith(".box")) && address2.length >= 5 && this.ENS_REGEX.test(address2);
+    }
+    /**
+     * Quick SNS name validation
+     */
+    static isValidSNSName(address2) {
+      if (!address2.toLowerCase().includes("."))
+        return false;
+      const parts = address2.toLowerCase().split(".");
+      if (parts.length !== 2)
+        return false;
+      const [name, tld] = parts;
+      return this.VALID_SNS_TLDS.includes(tld) && this.SNS_NAME_REGEX.test(name) && name.length >= 1;
+    }
+  }
+  web3UsernameValidator.Web3UsernameValidator = Web3UsernameValidator;
+  Web3UsernameValidator.EVM_REGEX = /^0x[a-fA-F0-9]{40}$/;
+  Web3UsernameValidator.BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
+  Web3UsernameValidator.ENS_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9]|(-[a-zA-Z0-9]))*\.(eth|box)$/i;
+  Web3UsernameValidator.SNS_NAME_REGEX = /^[a-zA-Z0-9]([a-zA-Z0-9]|(-[a-zA-Z0-9]))*$/;
+  Web3UsernameValidator.VALID_SNS_TLDS = [
+    "sol",
+    "abc",
+    "backpack",
+    "bonk",
+    "coin",
+    "dao",
+    "defi",
+    "gm",
+    "poor",
+    "pump",
+    "shdw",
+    "stepn",
+    "web3"
+  ];
+  return web3UsernameValidator;
+}
+var typeValidation = {};
+var hasRequiredTypeValidation;
+function requireTypeValidation() {
+  if (hasRequiredTypeValidation) return typeValidation;
+  hasRequiredTypeValidation = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.parseJson = exports$1.createAssertion = exports$1.isUrl = exports$1.isEmail = exports$1.isValidDate = exports$1.isErrorResponse = exports$1.isSuccessResponse = exports$1.isApiResponse = exports$1.optional = exports$1.validateArray = exports$1.hasRequiredProperties = exports$1.isNullish = exports$1.isArray = exports$1.isObject = exports$1.isBoolean = exports$1.isNumber = exports$1.isString = exports$1.createValidator = void 0;
+    const createValidator = (validationFn, typeName) => {
+      return (data) => {
+        try {
+          if (validationFn(data)) {
+            return { isValid: true, data };
+          }
+          return { isValid: false, error: `Invalid ${typeName}`, data: null };
+        } catch (error) {
+          return {
+            isValid: false,
+            error: `Validation error for ${typeName}: ${error instanceof Error ? error.message : "Unknown error"}`,
+            data: null
+          };
+        }
+      };
+    };
+    exports$1.createValidator = createValidator;
+    const isString = (value) => typeof value === "string";
+    exports$1.isString = isString;
+    const isNumber = (value) => typeof value === "number" && !isNaN(value);
+    exports$1.isNumber = isNumber;
+    const isBoolean = (value) => typeof value === "boolean";
+    exports$1.isBoolean = isBoolean;
+    const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+    exports$1.isObject = isObject;
+    const isArray = (value) => Array.isArray(value);
+    exports$1.isArray = isArray;
+    const isNullish = (value) => value === null || value === void 0;
+    exports$1.isNullish = isNullish;
+    const hasRequiredProperties = (obj, requiredProps) => {
+      if (!(0, exports$1.isObject)(obj))
+        return false;
+      return requiredProps.every((prop) => prop in obj);
+    };
+    exports$1.hasRequiredProperties = hasRequiredProperties;
+    const validateArray = (data, itemValidator) => {
+      if (!(0, exports$1.isArray)(data))
+        return false;
+      return data.every(itemValidator);
+    };
+    exports$1.validateArray = validateArray;
+    const optional = (validator) => (value) => {
+      return value === void 0 || validator(value);
+    };
+    exports$1.optional = optional;
+    const isApiResponse = (data) => {
+      return (0, exports$1.isObject)(data) && (0, exports$1.isBoolean)(data.success);
+    };
+    exports$1.isApiResponse = isApiResponse;
+    const isSuccessResponse = (data, dataValidator) => {
+      if (!(0, exports$1.isApiResponse)(data) || !data.success)
+        return false;
+      if (dataValidator && "data" in data) {
+        return dataValidator(data.data);
+      }
+      return true;
+    };
+    exports$1.isSuccessResponse = isSuccessResponse;
+    const isErrorResponse = (data) => {
+      return (0, exports$1.isApiResponse)(data) && !data.success && "error" in data && (0, exports$1.isString)(data.error);
+    };
+    exports$1.isErrorResponse = isErrorResponse;
+    const isValidDate = (value) => {
+      if (!(0, exports$1.isString)(value))
+        return false;
+      const date2 = new Date(value);
+      return !isNaN(date2.getTime());
+    };
+    exports$1.isValidDate = isValidDate;
+    const isEmail = (value) => {
+      if (!(0, exports$1.isString)(value))
+        return false;
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      return emailRegex.test(value);
+    };
+    exports$1.isEmail = isEmail;
+    const isUrl = (value) => {
+      if (!(0, exports$1.isString)(value))
+        return false;
+      try {
+        new URL(value);
+        return true;
+      } catch {
+        return false;
+      }
+    };
+    exports$1.isUrl = isUrl;
+    const createAssertion = (validator, typeName) => {
+      return (data, context = typeName) => {
+        if (!validator(data)) {
+          throw new TypeError(`Invalid ${context}: expected ${typeName}`);
+        }
+      };
+    };
+    exports$1.createAssertion = createAssertion;
+    const parseJson = (jsonString, validator) => {
+      try {
+        const parsed = JSON.parse(jsonString);
+        if (validator) {
+          if (validator(parsed)) {
+            return { isValid: true, data: parsed };
+          }
+          return {
+            isValid: false,
+            error: "Parsed JSON does not match expected type",
+            data: null
+          };
+        }
+        return { isValid: true, data: parsed };
+      } catch (error) {
+        return {
+          isValid: false,
+          error: `JSON parse error: ${error instanceof Error ? error.message : "Unknown error"}`,
+          data: null
+        };
+      }
+    };
+    exports$1.parseJson = parseJson;
+  })(typeValidation);
+  return typeValidation;
+}
+var eventHelpers = {};
+var hasRequiredEventHelpers;
+function requireEventHelpers() {
+  if (hasRequiredEventHelpers) return eventHelpers;
+  hasRequiredEventHelpers = 1;
+  Object.defineProperty(eventHelpers, "__esModule", { value: true });
+  eventHelpers.createMultiChainId = createMultiChainId;
+  eventHelpers.createUserMultiChainId = createUserMultiChainId;
+  eventHelpers.createChainStatsId = createChainStatsId;
+  eventHelpers.createDelegationId = createDelegationId;
+  eventHelpers.normalizeAddress = normalizeAddress;
+  eventHelpers.formatBigInt = formatBigInt;
+  eventHelpers.isZeroAddress = isZeroAddress;
+  eventHelpers.isTestNet = isTestNet;
+  eventHelpers.validateEventArgs = validateEventArgs;
+  function createMultiChainId(chainId, txHash, logIndex) {
+    return `${chainId}-${txHash}-${logIndex}`;
+  }
+  function createUserMultiChainId(chainId, address2) {
+    return `${chainId}-${address2.toLowerCase()}`;
+  }
+  function createChainStatsId(chainId) {
+    return `${chainId}-global`;
+  }
+  function createDelegationId(delegatorAddress, isTestNet2) {
+    return `${delegatorAddress.toLowerCase()}-${isTestNet2}`;
+  }
+  function normalizeAddress(address2) {
+    return address2.toLowerCase();
+  }
+  function formatBigInt(value, decimals = 18) {
+    const divisor = BigInt(10 ** decimals);
+    const whole = value / divisor;
+    const fraction = value % divisor;
+    if (fraction === 0n) {
+      return whole.toString();
+    }
+    return `${whole}.${fraction.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+  }
+  function isZeroAddress(address2) {
+    return address2.toLowerCase() === "0x0000000000000000000000000000000000000000";
+  }
+  function isTestNet(chainId) {
+    const evmTestnets = /* @__PURE__ */ new Set([
+      31337,
+      // Hardhat (local development)
+      11155111,
+      // Ethereum Sepolia
+      80001,
+      // Polygon Mumbai (if configured)
+      80002,
+      // Polygon Amoy (if configured)
+      421614,
+      // Arbitrum Sepolia (if configured)
+      11155420,
+      // OP Sepolia (if configured)
+      84532,
+      // Base Sepolia (if configured)
+      43113
+      // Avalanche Fuji (if configured)
+    ]);
+    const solanaTestnets = /* @__PURE__ */ new Set([
+      -102,
+      // Solana Devnet
+      -103,
+      // Solana Testnet
+      -104
+      // Solana Localnet
+    ]);
+    return evmTestnets.has(chainId) || solanaTestnets.has(chainId);
+  }
+  function validateEventArgs(args, requiredFields) {
+    for (const field of requiredFields) {
+      if (args[field] === void 0 || args[field] === null) {
+        console.error(`❌ Missing required field: ${String(field)}`);
+        return false;
+      }
+    }
+    return true;
+  }
+  return eventHelpers;
+}
+var auth = {};
+var hasRequiredAuth;
+function requireAuth() {
+  if (hasRequiredAuth) return auth;
+  hasRequiredAuth = 1;
+  Object.defineProperty(auth, "__esModule", { value: true });
+  auth.generateAuthMessage = generateAuthMessage;
+  auth.isAuthExpired = isAuthExpired;
+  auth.getAuthStatusText = getAuthStatusText;
+  auth.canAccessProtectedFeatures = canAccessProtectedFeatures;
+  auth.isAuthStatusConnected = isAuthStatusConnected;
+  auth.generateNonce = generateNonce;
+  auth.extractNonceFromMessage = extractNonceFromMessage;
+  auth.isValidNonce = isValidNonce;
+  const enums_1 = requireEnums();
+  function generateAuthMessage(emailDomain, nonce) {
+    const actualNonce = nonce || `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    return `Authenticate with ${emailDomain}
+Nonce: ${actualNonce}`;
+  }
+  function isAuthExpired(createdAt, expirationHours = 24) {
+    const expirationTime = new Date(createdAt.getTime() + expirationHours * 60 * 60 * 1e3);
+    return /* @__PURE__ */ new Date() > expirationTime;
+  }
+  function getAuthStatusText(status) {
+    switch (status) {
+      case enums_1.AuthStatus.DISCONNECTED:
+        return "Not connected";
+      case enums_1.AuthStatus.CONNECTED:
+        return "Connected - Please verify";
+      case enums_1.AuthStatus.VERIFIED:
+        return "Authenticated";
+      default:
+        return "Unknown status";
+    }
+  }
+  function canAccessProtectedFeatures(status) {
+    return status === enums_1.AuthStatus.VERIFIED;
+  }
+  function isAuthStatusConnected(status) {
+    return status === enums_1.AuthStatus.CONNECTED || status === enums_1.AuthStatus.VERIFIED;
+  }
+  function generateNonce() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  function extractNonceFromMessage(message) {
+    const match = message.match(/Nonce:\s*(.+)$/m);
+    return match ? match[1].trim() : void 0;
+  }
+  function isValidNonce(nonce) {
+    if (!nonce || typeof nonce !== "string") {
+      return false;
+    }
+    if (nonce.length < 10) {
+      return false;
+    }
+    const parts = nonce.split("-");
+    if (parts.length >= 2) {
+      const timestamp = parseInt(parts[0], 10);
+      if (!isNaN(timestamp)) {
+        const oneDayAgo = Date.now() - 24 * 60 * 60 * 1e3;
+        if (timestamp < oneDayAgo) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  return auth;
+}
+var adminEmails = {};
+var hasRequiredAdminEmails;
+function requireAdminEmails() {
+  if (hasRequiredAdminEmails) return adminEmails;
+  hasRequiredAdminEmails = 1;
+  Object.defineProperty(adminEmails, "__esModule", { value: true });
+  adminEmails.parseAdminEmails = parseAdminEmails;
+  adminEmails.isAdminEmail = isAdminEmail;
+  adminEmails.createAdminChecker = createAdminChecker;
+  function parseAdminEmails(input) {
+    if (!input) {
+      return [];
+    }
+    return input.split(",").map((email) => email.trim().toLowerCase()).filter((email) => email.length > 0 && email.includes("@"));
+  }
+  function isAdminEmail(email, adminEmails2) {
+    if (!email) {
+      return false;
+    }
+    return adminEmails2.includes(email.toLowerCase());
+  }
+  function createAdminChecker(input) {
+    const adminEmails2 = parseAdminEmails(input);
+    return (email) => {
+      return isAdminEmail(email, adminEmails2);
+    };
+  }
+  return adminEmails;
+}
+var currency = {};
+var hasRequiredCurrency;
+function requireCurrency() {
+  if (hasRequiredCurrency) return currency;
+  hasRequiredCurrency = 1;
+  (function(exports$1) {
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.CLAIM_PERIOD_DAYS = exports$1.USDC_DECIMALS = void 0;
+    exports$1.formatUSDC = formatUSDC;
+    exports$1.parseUSDC = parseUSDC;
+    exports$1.USDC_DECIMALS = 6;
+    exports$1.CLAIM_PERIOD_DAYS = 60;
+    function formatUSDC(amount) {
+      return (amount / Math.pow(10, exports$1.USDC_DECIMALS)).toFixed(2);
+    }
+    function parseUSDC(amount) {
+      return Math.floor(parseFloat(amount) * Math.pow(10, exports$1.USDC_DECIMALS));
+    }
+  })(currency);
+  return currency;
+}
+var date = {};
+var hasRequiredDate;
+function requireDate() {
+  if (hasRequiredDate) return date;
+  hasRequiredDate = 1;
+  Object.defineProperty(date, "__esModule", { value: true });
+  date.formatEmailDate = formatEmailDate;
+  date.formatTimestamp = formatTimestamp;
+  date.formatRelativeTime = formatRelativeTime;
+  date.parseDate = parseDate;
+  date.isDateInRange = isDateInRange;
+  date.addDays = addDays;
+  date.addHours = addHours;
+  function formatEmailDate(date2) {
+    const dateObj = typeof date2 === "string" ? new Date(date2) : date2;
+    if (isNaN(dateObj.getTime())) {
+      return "Invalid date";
+    }
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - dateObj.getTime();
+    const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+    if (diffDays === 0) {
+      return dateObj.toLocaleTimeString("en-US", {
+        hour: "numeric",
+        minute: "2-digit",
+        hour12: true
+      });
+    }
+    if (diffDays === 1) {
+      return "Yesterday";
+    }
+    if (diffDays < 7) {
+      return dateObj.toLocaleDateString("en-US", {
+        weekday: "long"
+      });
+    }
+    if (dateObj.getFullYear() === now.getFullYear()) {
+      return dateObj.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric"
+      });
+    }
+    return dateObj.toLocaleDateString("en-US", {
+      year: "numeric",
+      month: "short",
+      day: "numeric"
+    });
+  }
+  function formatTimestamp(timestamp) {
+    return new Date(timestamp).toISOString();
+  }
+  function formatRelativeTime(date2) {
+    const dateObj = typeof date2 === "string" || typeof date2 === "number" ? new Date(date2) : date2;
+    if (isNaN(dateObj.getTime())) {
+      return "Invalid date";
+    }
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - dateObj.getTime();
+    const diffSeconds = Math.floor(diffMs / 1e3);
+    const diffMinutes = Math.floor(diffSeconds / 60);
+    const diffHours = Math.floor(diffMinutes / 60);
+    const diffDays = Math.floor(diffHours / 24);
+    const diffWeeks = Math.floor(diffDays / 7);
+    const diffMonths = Math.floor(diffDays / 30);
+    const diffYears = Math.floor(diffDays / 365);
+    if (diffSeconds < 60) {
+      return "just now";
+    }
+    if (diffMinutes < 60) {
+      return diffMinutes === 1 ? "1 minute ago" : `${diffMinutes} minutes ago`;
+    }
+    if (diffHours < 24) {
+      return diffHours === 1 ? "1 hour ago" : `${diffHours} hours ago`;
+    }
+    if (diffDays < 7) {
+      return diffDays === 1 ? "1 day ago" : `${diffDays} days ago`;
+    }
+    if (diffWeeks < 4) {
+      return diffWeeks === 1 ? "1 week ago" : `${diffWeeks} weeks ago`;
+    }
+    if (diffMonths < 12) {
+      return diffMonths === 1 ? "1 month ago" : `${diffMonths} months ago`;
+    }
+    return diffYears === 1 ? "1 year ago" : `${diffYears} years ago`;
+  }
+  function parseDate(dateString) {
+    try {
+      const date2 = new Date(dateString);
+      if (isNaN(date2.getTime())) {
+        return null;
+      }
+      return date2;
+    } catch {
+      return null;
+    }
+  }
+  function isDateInRange(date2, startDate, endDate) {
+    return date2 >= startDate && date2 <= endDate;
+  }
+  function addDays(date2, days) {
+    const result = new Date(date2);
+    result.setDate(result.getDate() + days);
+    return result;
+  }
+  function addHours(date2, hours) {
+    const result = new Date(date2);
+    result.setHours(result.getHours() + hours);
+    return result;
+  }
+  return date;
+}
+var string = {};
+var hasRequiredString;
+function requireString() {
+  if (hasRequiredString) return string;
+  hasRequiredString = 1;
+  Object.defineProperty(string, "__esModule", { value: true });
+  string.truncate = truncate;
+  string.capitalize = capitalize;
+  string.toTitleCase = toTitleCase;
+  string.toKebabCase = toKebabCase;
+  string.toCamelCase = toCamelCase;
+  string.toSnakeCase = toSnakeCase;
+  string.normalizeWhitespace = normalizeWhitespace;
+  string.isBlank = isBlank;
+  string.isNotBlank = isNotBlank;
+  string.escapeHtml = escapeHtml;
+  string.stripHtml = stripHtml;
+  string.getInitials = getInitials;
+  string.formatBytes = formatBytes;
+  string.randomString = randomString;
+  string.pluralize = pluralize;
+  string.formatNumber = formatNumber;
+  function truncate(str, maxLength, suffix = "...") {
+    if (!str || str.length <= maxLength) {
+      return str;
+    }
+    return str.slice(0, maxLength - suffix.length) + suffix;
+  }
+  function capitalize(str) {
+    if (!str)
+      return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  function toTitleCase(str) {
+    if (!str)
+      return str;
+    return str.toLowerCase().split(" ").map((word) => capitalize(word)).join(" ");
+  }
+  function toKebabCase(str) {
+    if (!str)
+      return str;
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+  }
+  function toCamelCase(str) {
+    if (!str)
+      return str;
+    return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^./, (char) => char.toLowerCase());
+  }
+  function toSnakeCase(str) {
+    if (!str)
+      return str;
+    return str.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+  }
+  function normalizeWhitespace(str) {
+    if (!str)
+      return str;
+    return str.replace(/\s+/g, " ").trim();
+  }
+  function isBlank(str) {
+    return !str || str.trim().length === 0;
+  }
+  function isNotBlank(str) {
+    return !isBlank(str);
+  }
+  function escapeHtml(str) {
+    if (!str)
+      return str;
+    const htmlEscapes = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    };
+    return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+  }
+  function stripHtml(str) {
+    if (!str)
+      return str;
+    return str.replace(/<[^>]*>/g, "");
+  }
+  function getInitials(name, maxInitials = 2) {
+    if (!name)
+      return "";
+    const words = name.trim().split(/\s+/);
+    const initials = words.slice(0, maxInitials).map((word) => word.charAt(0).toUpperCase()).join("");
+    return initials;
+  }
+  function formatBytes(bytes, decimals = 2) {
+    if (bytes === 0)
+      return "0 Bytes";
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+  }
+  function randomString(length, charset = "alphanumeric") {
+    let chars;
+    switch (charset) {
+      case "alpha":
+        chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        break;
+      case "numeric":
+        chars = "0123456789";
+        break;
+      case "alphanumeric":
+        chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        break;
+      case "hex":
+        chars = "0123456789abcdef";
+        break;
+      default:
+        chars = charset;
+    }
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+  function pluralize(count, singular, plural) {
+    if (count === 1) {
+      return singular;
+    }
+    return plural || `${singular}s`;
+  }
+  function formatNumber(num) {
+    return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  }
+  return string;
+}
+var application = {};
+var hasRequiredApplication;
+function requireApplication() {
+  if (hasRequiredApplication) return application;
+  hasRequiredApplication = 1;
+  Object.defineProperty(application, "__esModule", { value: true });
+  application.Z_INDEX = application.ANIMATION = application.NETWORK_IDS = application.WALLET_NAMES = application.CONTACT_INFO = application.ROUTES = application.SUCCESS_MESSAGES = application.ERROR_MESSAGES = application.TIME_FORMAT = application.SUBSCRIPTION_TIERS = application.EMAIL_CONFIG = application.STORAGE_KEYS = application.CHAIN_TYPE = application.AUTH_STATUS = application.API_RETRY_DELAY = application.API_RETRY_ATTEMPTS = application.API_TIMEOUT = void 0;
+  const API_TIMEOUT = 3e4;
+  application.API_TIMEOUT = API_TIMEOUT;
+  const API_RETRY_ATTEMPTS = 3;
+  application.API_RETRY_ATTEMPTS = API_RETRY_ATTEMPTS;
+  const API_RETRY_DELAY = 1e3;
+  application.API_RETRY_DELAY = API_RETRY_DELAY;
+  const AUTH_STATUS = {
+    DISCONNECTED: "disconnected",
+    CONNECTED: "connected",
+    VERIFIED: "verified"
+  };
+  application.AUTH_STATUS = AUTH_STATUS;
+  const CHAIN_TYPE = {
+    EVM: "evm",
+    SOLANA: "solana",
+    UNKNOWN: "unknown"
+  };
+  application.CHAIN_TYPE = CHAIN_TYPE;
+  const STORAGE_KEYS = {
+    AUTH_TOKEN: "authToken",
+    USER_DATA: "userData",
+    THEME: "theme",
+    EMAIL_CACHE: "emailCache",
+    WALLET_ADDRESS: "walletAddress",
+    CHAIN_TYPE: "chainType"
+  };
+  application.STORAGE_KEYS = STORAGE_KEYS;
+  const EMAIL_CONFIG = {
+    MAX_ATTACHMENT_SIZE: 25 * 1024 * 1024,
+    // 25MB
+    MAX_RECIPIENTS: 100,
+    ITEMS_PER_PAGE: 50,
+    REFRESH_INTERVAL: 6e4,
+    // 1 minute
+    NOTIFICATION_COOLDOWN: 3e5
+    // 5 minutes
+  };
+  application.EMAIL_CONFIG = EMAIL_CONFIG;
+  const SUBSCRIPTION_TIERS = {
+    FREE: "free",
+    BASIC: "basic",
+    PRO: "pro",
+    ENTERPRISE: "enterprise"
+  };
+  application.SUBSCRIPTION_TIERS = SUBSCRIPTION_TIERS;
+  const TIME_FORMAT = {
+    SHORT_DATE: "MMM d",
+    FULL_DATE: "MMM d, yyyy",
+    DATE_TIME: "MMM d, yyyy h:mm a",
+    RELATIVE: "relative"
+  };
+  application.TIME_FORMAT = TIME_FORMAT;
+  const ERROR_MESSAGES = {
+    WALLET_NOT_CONNECTED: "Please connect your wallet first",
+    INVALID_ADDRESS: "Please enter a valid address",
+    NETWORK_ERROR: "Network error. Please try again.",
+    AUTHENTICATION_FAILED: "Authentication failed. Please sign in again.",
+    TRANSACTION_FAILED: "Transaction failed. Please try again.",
+    INSUFFICIENT_FUNDS: "Insufficient funds for this operation",
+    RATE_LIMITED: "Too many requests. Please wait a moment.",
+    SESSION_EXPIRED: "Your session has expired. Please sign in again.",
+    PERMISSION_DENIED: "You do not have permission to perform this action"
+  };
+  application.ERROR_MESSAGES = ERROR_MESSAGES;
+  const SUCCESS_MESSAGES = {
+    EMAIL_SENT: "Email sent successfully",
+    EMAIL_DELETED: "Email deleted successfully",
+    PREFERENCES_SAVED: "Preferences saved successfully",
+    WALLET_CONNECTED: "Wallet connected successfully",
+    AUTHENTICATION_SUCCESS: "Authentication successful",
+    DELEGATION_SUCCESS: "Delegation successful",
+    SUBSCRIPTION_ACTIVATED: "Subscription activated successfully"
+  };
+  application.SUCCESS_MESSAGES = SUCCESS_MESSAGES;
+  const ROUTES = {
+    HOME: "/",
+    ABOUT: "/about",
+    CONNECT: "/connect",
+    MAIL: "/mail",
+    COMPOSE: "/mail/compose",
+    PREFERENCES: "/preferences",
+    TERMS: "/terms",
+    PRIVACY: "/privacy",
+    DOCUMENTATION: "/document",
+    WEB3_USERS: "/web3-users",
+    WEB3_PROJECTS: "/web3-projects"
+  };
+  application.ROUTES = ROUTES;
+  const CONTACT_INFO = {
+    SUPPORT_EMAIL: "support@sudobility.com",
+    CONTACT_EMAIL: "info@sudobility.com"
+  };
+  application.CONTACT_INFO = CONTACT_INFO;
+  const WALLET_NAMES = {
+    METAMASK: "MetaMask",
+    WALLETCONNECT: "WalletConnect",
+    COINBASE: "Coinbase Wallet",
+    PHANTOM: "Phantom",
+    SAFE: "Safe",
+    ARGENT: "Argent",
+    RAINBOW: "Rainbow",
+    TRUST: "Trust Wallet",
+    LEDGER: "Ledger",
+    TREZOR: "Trezor"
+  };
+  application.WALLET_NAMES = WALLET_NAMES;
+  const NETWORK_IDS = {
+    ETHEREUM_MAINNET: 1,
+    POLYGON: 137,
+    ARBITRUM: 42161,
+    OPTIMISM: 10,
+    BASE: 8453,
+    SOLANA_MAINNET: "mainnet-beta",
+    SOLANA_DEVNET: "devnet"
+  };
+  application.NETWORK_IDS = NETWORK_IDS;
+  const ANIMATION = {
+    FAST: 150,
+    NORMAL: 300,
+    SLOW: 500,
+    VERY_SLOW: 1e3
+  };
+  application.ANIMATION = ANIMATION;
+  const Z_INDEX = {
+    DROPDOWN: 10,
+    OVERLAY: 20,
+    MODAL: 30,
+    POPOVER: 40,
+    TOOLTIP: 50,
+    TOAST: 60
+  };
+  application.Z_INDEX = Z_INDEX;
+  return application;
+}
+var statusValues = {};
+var hasRequiredStatusValues;
+function requireStatusValues() {
+  if (hasRequiredStatusValues) return statusValues;
+  hasRequiredStatusValues = 1;
+  Object.defineProperty(statusValues, "__esModule", { value: true });
+  statusValues.STATUS_VALUES = void 0;
+  statusValues.STATUS_VALUES = {
+    SUCCESS: "success",
+    PENDING: "pending",
+    FAILED: "failed",
+    ERROR: "error"
+  };
+  return statusValues;
+}
+var logger = {};
+var hasRequiredLogger;
+function requireLogger() {
+  if (hasRequiredLogger) return logger;
+  hasRequiredLogger = 1;
+  Object.defineProperty(logger, "__esModule", { value: true });
+  logger.storageLogger = logger.ensLogger = logger.contractLogger = logger.apiLogger = logger.authLogger = logger.logger = logger.LogLevel = void 0;
+  var LogLevel;
+  (function(LogLevel2) {
+    LogLevel2["ERROR"] = "error";
+    LogLevel2["WARN"] = "warn";
+    LogLevel2["INFO"] = "info";
+    LogLevel2["DEBUG"] = "debug";
+  })(LogLevel || (logger.LogLevel = LogLevel = {}));
+  class Logger {
+    constructor() {
+      this.isDevelopment = process.env.NODE_ENV === "development";
+    }
+    formatTimestamp() {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+    formatMessage(_level, message, context) {
+      const timestamp = this.formatTimestamp();
+      const contextStr = context ? ` [${context}]` : "";
+      return `[${timestamp}]${contextStr} ${message}`;
+    }
+    shouldLog(level) {
+      if (!this.isDevelopment) {
+        return level === LogLevel.ERROR || level === LogLevel.WARN;
+      }
+      return true;
+    }
+    error(message, context, data) {
+      if (this.shouldLog(LogLevel.ERROR)) {
+        console.error(this.formatMessage(LogLevel.ERROR, message, context));
+        if (data) {
+          console.error(data);
+        }
+      }
+    }
+    warn(message, context, data) {
+      if (this.shouldLog(LogLevel.WARN)) {
+        console.warn(this.formatMessage(LogLevel.WARN, message, context));
+        if (data) {
+          console.warn(data);
+        }
+      }
+    }
+    info(message, context, data) {
+      if (this.shouldLog(LogLevel.INFO)) {
+        console.log(this.formatMessage(LogLevel.INFO, message, context));
+        if (data) {
+          console.log(data);
+        }
+      }
+    }
+    debug(message, context, data) {
+      if (this.shouldLog(LogLevel.DEBUG)) {
+        console.log(this.formatMessage(LogLevel.DEBUG, message, context));
+        if (data) {
+          console.log(data);
+        }
+      }
+    }
+    /**
+     * Create a contextual logger that automatically includes context in all calls
+     */
+    withContext(context) {
+      return {
+        error: (message, data) => this.error(message, context, data),
+        warn: (message, data) => this.warn(message, context, data),
+        info: (message, data) => this.info(message, context, data),
+        debug: (message, data) => this.debug(message, context, data)
+      };
+    }
+  }
+  const logger$1 = new Logger();
+  logger.logger = logger$1;
+  const authLogger = logger$1.withContext("AUTH");
+  logger.authLogger = authLogger;
+  const apiLogger = logger$1.withContext("API");
+  logger.apiLogger = apiLogger;
+  const contractLogger = logger$1.withContext("CONTRACT");
+  logger.contractLogger = contractLogger;
+  const ensLogger = logger$1.withContext("ENS");
+  logger.ensLogger = ensLogger;
+  const storageLogger = logger$1.withContext("STORAGE");
+  logger.storageLogger = storageLogger;
+  return logger;
+}
+var urlParams = {};
+var hasRequiredUrlParams;
+function requireUrlParams() {
+  if (hasRequiredUrlParams) return urlParams;
+  hasRequiredUrlParams = 1;
+  Object.defineProperty(urlParams, "__esModule", { value: true });
+  urlParams.createURLSearchParams = createURLSearchParams;
+  urlParams.createSearchParams = createSearchParams;
+  urlParams.searchParamsToString = searchParamsToString;
+  urlParams.parseSearchParams = parseSearchParams;
+  class SimpleURLSearchParams {
+    constructor(init) {
+      this.params = /* @__PURE__ */ new Map();
+      if (init) {
+        if (typeof init === "string") {
+          this.parseString(init);
+        } else if (Array.isArray(init)) {
+          for (const [key, value] of init) {
+            this.append(key, value);
+          }
+        } else {
+          for (const [key, value] of Object.entries(init)) {
+            if (value !== void 0) {
+              this.append(key, value);
+            }
+          }
+        }
+      }
+    }
+    parseString(str) {
+      const params = str.startsWith("?") ? str.slice(1) : str;
+      if (!params)
+        return;
+      for (const pair of params.split("&")) {
+        const [key, value = ""] = pair.split("=");
+        if (key) {
+          this.append(decodeURIComponent(key), decodeURIComponent(value));
+        }
+      }
+    }
+    append(name, value) {
+      if (!this.params.has(name)) {
+        this.params.set(name, []);
+      }
+      const existingValues = this.params.get(name);
+      if (existingValues) {
+        existingValues.push(value);
+      }
+    }
+    delete(name) {
+      this.params.delete(name);
+    }
+    get(name) {
+      const values = this.params.get(name);
+      return values && values.length > 0 ? values[0] : null;
+    }
+    getAll(name) {
+      return this.params.get(name) || [];
+    }
+    has(name) {
+      return this.params.has(name);
+    }
+    set(name, value) {
+      this.params.set(name, [value]);
+    }
+    toString() {
+      const pairs = [];
+      this.params.forEach((values, key) => {
+        for (const value of values) {
+          pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+        }
+      });
+      return pairs.join("&");
+    }
+    forEach(callback) {
+      this.params.forEach((values, key) => {
+        for (const value of values) {
+          callback(value, key);
+        }
+      });
+    }
+  }
+  function createURLSearchParams(init) {
+    if (typeof URLSearchParams !== "undefined") {
+      return new URLSearchParams(init);
+    }
+    return new SimpleURLSearchParams(init);
+  }
+  function createSearchParams(params) {
+    const searchParams = createURLSearchParams(void 0);
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        searchParams.append(key, String(value));
+      }
+    }
+    return searchParams;
+  }
+  function searchParamsToString(params) {
+    return params.toString();
+  }
+  function parseSearchParams(queryString) {
+    const params = createURLSearchParams(queryString);
+    const result = {};
+    params.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  return urlParams;
+}
+var asyncHelpers = {};
+var hasRequiredAsyncHelpers;
+function requireAsyncHelpers() {
+  if (hasRequiredAsyncHelpers) return asyncHelpers;
+  hasRequiredAsyncHelpers = 1;
+  Object.defineProperty(asyncHelpers, "__esModule", { value: true });
+  asyncHelpers.debounceAsync = asyncHelpers.clearExpiredCache = asyncHelpers.withCache = asyncHelpers.withTimeout = asyncHelpers.safeParallel = asyncHelpers.withLoadingState = asyncHelpers.safeAsync = void 0;
+  const logger_1 = requireLogger();
+  const safeAsync = async (operation, context) => {
+    try {
+      const data = await operation();
+      return { data, success: true };
+    } catch (error) {
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      logger_1.logger.error(`Async operation failed: ${errorObj.message}`, context, error);
+      return { error: errorObj, success: false };
+    }
+  };
+  asyncHelpers.safeAsync = safeAsync;
+  const withLoadingState = async (operation, setLoading, setError, context) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await operation();
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      setError(errorMessage);
+      logger_1.logger.error(`Operation failed: ${errorMessage}`, context, error);
+      return void 0;
+    } finally {
+      setLoading(false);
+    }
+  };
+  asyncHelpers.withLoadingState = withLoadingState;
+  const safeParallel = async (operations, context) => {
+    try {
+      const results = await Promise.all(operations.map((op) => op()));
+      return { data: results, success: true };
+    } catch (error) {
+      const errorObj = error instanceof Error ? error : new Error(String(error));
+      logger_1.logger.error(`Parallel operations failed: ${errorObj.message}`, context, error);
+      return { error: errorObj, success: false };
+    }
+  };
+  asyncHelpers.safeParallel = safeParallel;
+  const withTimeout = async (operation, timeoutMs, context) => {
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timed out after ${timeoutMs}ms`)), timeoutMs));
+    try {
+      return await Promise.race([operation(), timeoutPromise]);
+    } catch (error) {
+      logger_1.logger.error(`Timeout operation failed`, context, error);
+      throw error;
+    }
+  };
+  asyncHelpers.withTimeout = withTimeout;
+  const cache = /* @__PURE__ */ new Map();
+  const withCache = async (key, operation, ttlMs = 5 * 60 * 1e3) => {
+    const cached = cache.get(key);
+    const now = Date.now();
+    if (cached && now - cached.timestamp < cached.ttl) {
+      return cached.data;
+    }
+    const result = await operation();
+    cache.set(key, { data: result, timestamp: now, ttl: ttlMs });
+    return result;
+  };
+  asyncHelpers.withCache = withCache;
+  const clearExpiredCache = () => {
+    const now = Date.now();
+    for (const [key, entry] of cache.entries()) {
+      if (now - entry.timestamp >= entry.ttl) {
+        cache.delete(key);
+      }
+    }
+  };
+  asyncHelpers.clearExpiredCache = clearExpiredCache;
+  const debounceMap = /* @__PURE__ */ new Map();
+  const debounceAsync = (fn, delay, key) => {
+    return (...args) => {
+      return new Promise((resolve) => {
+        const existingTimeout = debounceMap.get(key);
+        if (existingTimeout) {
+          clearTimeout(existingTimeout);
+        }
+        const timeout = setTimeout(async () => {
+          debounceMap.delete(key);
+          try {
+            const result = await fn(...args);
+            resolve(result);
+          } catch (error) {
+            logger_1.logger.error(`Debounced operation failed`, key, error);
+            resolve(void 0);
+          }
+        }, delay);
+        debounceMap.set(key, timeout);
+      });
+    };
+  };
+  asyncHelpers.debounceAsync = debounceAsync;
+  return asyncHelpers;
+}
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  (function(exports$1) {
+    /**
+     * @johnqh/types - Common TypeScript types for Web3 email projects
+     *
+     * This package contains all shared TypeScript definitions used across
+     * Web3 email applications including business logic types, blockchain
+     * types, configuration interfaces, infrastructure types, and utility functions.
+     *
+     * @version 1.0.0
+     * @license MIT
+     */
+    Object.defineProperty(exports$1, "__esModule", { value: true });
+    exports$1.EntityRole = exports$1.EntityType = exports$1.NONE_ENTITLEMENT = exports$1.ALL_PERIODS = exports$1.PERIOD_RANKS = exports$1.RateLimitPeriodType = exports$1.WalletType = exports$1.NetworkError = exports$1.ProcessedEventName = exports$1.ContractType = exports$1.AnalyticsEventBuilder = exports$1.AnalyticsEvent = exports$1.StorageType = exports$1.validateMessage = exports$1.validateDomain = exports$1.validateAmount = exports$1.validateAddress = exports$1.isSolanaRecipient = exports$1.isSolanaAddress = exports$1.isEvmRecipient = exports$1.isEvmAddress = exports$1.TransactionStatus = exports$1.PROTOCOL_CONSTANTS = exports$1.MessageType = exports$1.isWalletVerified = exports$1.isWalletConnected = exports$1.getWalletConnectionState = exports$1.Theme = exports$1.SubscriptionAction = exports$1.SortOrder = exports$1.RequestStatus = exports$1.PlatformType = exports$1.NotificationType = exports$1.MobileView = exports$1.MediumView = exports$1.InfoType = exports$1.FontSize = exports$1.FeatureFlag = exports$1.ErrorType = exports$1.EmailValidationState = exports$1.EmailSortCriteria = exports$1.EmailComposeType = exports$1.EmailAddressType = exports$1.EmailAction = exports$1.Currency = exports$1.ConnectionType = exports$1.ConnectionState = exports$1.ChainType = exports$1.Chain = exports$1.AuthStatus = void 0;
+    exports$1.isAuthStatusConnected = exports$1.isAuthExpired = exports$1.getAuthStatusText = exports$1.generateNonce = exports$1.generateAuthMessage = exports$1.extractNonceFromMessage = exports$1.canAccessProtectedFeatures = exports$1.validateEventArgs = exports$1.normalizeAddress = exports$1.isZeroAddress = exports$1.isTestNet = exports$1.formatBigInt = exports$1.createUserMultiChainId = exports$1.createMultiChainId = exports$1.createDelegationId = exports$1.createChainStatsId = exports$1.parseEmailAddress = exports$1.isValidWalletAddress = exports$1.isValidSignature = exports$1.isSNSName = exports$1.isENSName = exports$1.getChainDisplayName = exports$1.getAddressType = exports$1.formatWalletAddress = exports$1.AddressType = exports$1.validateArray = exports$1.parseJson = exports$1.optional = exports$1.isValidDate = exports$1.isUrl = exports$1.isSuccessResponse = exports$1.isString = exports$1.isObject = exports$1.isNumber = exports$1.isNullish = exports$1.isErrorResponse = exports$1.isEmail = exports$1.isBoolean = exports$1.isArray = exports$1.isApiResponse = exports$1.hasRequiredProperties = exports$1.createValidator = exports$1.createAssertion = exports$1.Web3UsernameValidator = exports$1.hasPermission = exports$1.getPermissionsForRole = exports$1.MEMBER_PERMISSIONS = exports$1.MANAGER_PERMISSIONS = exports$1.OWNER_PERMISSIONS = exports$1.InvitationStatus = void 0;
+    exports$1.LogLevel = exports$1.STATUS_VALUES = exports$1.Z_INDEX = exports$1.ANIMATION = exports$1.NETWORK_IDS = exports$1.WALLET_NAMES = exports$1.CONTACT_INFO = exports$1.ROUTES = exports$1.SUCCESS_MESSAGES = exports$1.ERROR_MESSAGES = exports$1.TIME_FORMAT = exports$1.SUBSCRIPTION_TIERS = exports$1.EMAIL_CONFIG = exports$1.STORAGE_KEYS = exports$1.CHAIN_TYPE = exports$1.AUTH_STATUS = exports$1.API_RETRY_DELAY = exports$1.API_RETRY_ATTEMPTS = exports$1.API_TIMEOUT = exports$1.truncate = exports$1.toTitleCase = exports$1.toSnakeCase = exports$1.toKebabCase = exports$1.toCamelCase = exports$1.stripHtml = exports$1.randomString = exports$1.pluralize = exports$1.normalizeWhitespace = exports$1.isNotBlank = exports$1.isBlank = exports$1.getInitials = exports$1.formatNumber = exports$1.formatBytes = exports$1.escapeHtml = exports$1.capitalize = exports$1.parseDate = exports$1.isDateInRange = exports$1.formatTimestamp = exports$1.formatRelativeTime = exports$1.formatEmailDate = exports$1.addHours = exports$1.addDays = exports$1.parseUSDC = exports$1.formatUSDC = exports$1.USDC_DECIMALS = exports$1.CLAIM_PERIOD_DAYS = exports$1.createAdminChecker = exports$1.isAdminEmail = exports$1.parseAdminEmails = exports$1.isValidNonce = void 0;
+    exports$1.debounceAsync = exports$1.clearExpiredCache = exports$1.withCache = exports$1.withTimeout = exports$1.safeParallel = exports$1.withLoadingState = exports$1.safeAsync = exports$1.parseSearchParams = exports$1.searchParamsToString = exports$1.createSearchParams = exports$1.createURLSearchParams = exports$1.storageLogger = exports$1.ensLogger = exports$1.contractLogger = exports$1.apiLogger = exports$1.authLogger = exports$1.logger = void 0;
+    var enums_1 = requireEnums();
+    Object.defineProperty(exports$1, "AuthStatus", { enumerable: true, get: function() {
+      return enums_1.AuthStatus;
+    } });
+    Object.defineProperty(exports$1, "Chain", { enumerable: true, get: function() {
+      return enums_1.Chain;
+    } });
+    Object.defineProperty(exports$1, "ChainType", { enumerable: true, get: function() {
+      return enums_1.ChainType;
+    } });
+    Object.defineProperty(exports$1, "ConnectionState", { enumerable: true, get: function() {
+      return enums_1.ConnectionState;
+    } });
+    Object.defineProperty(exports$1, "ConnectionType", { enumerable: true, get: function() {
+      return enums_1.ConnectionType;
+    } });
+    Object.defineProperty(exports$1, "Currency", { enumerable: true, get: function() {
+      return enums_1.Currency;
+    } });
+    Object.defineProperty(exports$1, "EmailAction", { enumerable: true, get: function() {
+      return enums_1.EmailAction;
+    } });
+    Object.defineProperty(exports$1, "EmailAddressType", { enumerable: true, get: function() {
+      return enums_1.EmailAddressType;
+    } });
+    Object.defineProperty(exports$1, "EmailComposeType", { enumerable: true, get: function() {
+      return enums_1.EmailComposeType;
+    } });
+    Object.defineProperty(exports$1, "EmailSortCriteria", { enumerable: true, get: function() {
+      return enums_1.EmailSortCriteria;
+    } });
+    Object.defineProperty(exports$1, "EmailValidationState", { enumerable: true, get: function() {
+      return enums_1.EmailValidationState;
+    } });
+    Object.defineProperty(exports$1, "ErrorType", { enumerable: true, get: function() {
+      return enums_1.ErrorType;
+    } });
+    Object.defineProperty(exports$1, "FeatureFlag", { enumerable: true, get: function() {
+      return enums_1.FeatureFlag;
+    } });
+    Object.defineProperty(exports$1, "FontSize", { enumerable: true, get: function() {
+      return enums_1.FontSize;
+    } });
+    Object.defineProperty(exports$1, "InfoType", { enumerable: true, get: function() {
+      return enums_1.InfoType;
+    } });
+    Object.defineProperty(exports$1, "MediumView", { enumerable: true, get: function() {
+      return enums_1.MediumView;
+    } });
+    Object.defineProperty(exports$1, "MobileView", { enumerable: true, get: function() {
+      return enums_1.MobileView;
+    } });
+    Object.defineProperty(exports$1, "NotificationType", { enumerable: true, get: function() {
+      return enums_1.NotificationType;
+    } });
+    Object.defineProperty(exports$1, "PlatformType", { enumerable: true, get: function() {
+      return enums_1.PlatformType;
+    } });
+    Object.defineProperty(exports$1, "RequestStatus", { enumerable: true, get: function() {
+      return enums_1.RequestStatus;
+    } });
+    Object.defineProperty(exports$1, "SortOrder", { enumerable: true, get: function() {
+      return enums_1.SortOrder;
+    } });
+    Object.defineProperty(exports$1, "SubscriptionAction", { enumerable: true, get: function() {
+      return enums_1.SubscriptionAction;
+    } });
+    Object.defineProperty(exports$1, "Theme", { enumerable: true, get: function() {
+      return enums_1.Theme;
+    } });
+    var wallet_status_1 = requireWalletStatus();
+    Object.defineProperty(exports$1, "getWalletConnectionState", { enumerable: true, get: function() {
+      return wallet_status_1.getWalletConnectionState;
+    } });
+    Object.defineProperty(exports$1, "isWalletConnected", { enumerable: true, get: function() {
+      return wallet_status_1.isWalletConnected;
+    } });
+    Object.defineProperty(exports$1, "isWalletVerified", { enumerable: true, get: function() {
+      return wallet_status_1.isWalletVerified;
+    } });
+    var common_1 = requireCommon();
+    Object.defineProperty(exports$1, "MessageType", { enumerable: true, get: function() {
+      return common_1.MessageType;
+    } });
+    Object.defineProperty(exports$1, "PROTOCOL_CONSTANTS", { enumerable: true, get: function() {
+      return common_1.PROTOCOL_CONSTANTS;
+    } });
+    Object.defineProperty(exports$1, "TransactionStatus", { enumerable: true, get: function() {
+      return common_1.TransactionStatus;
+    } });
+    Object.defineProperty(exports$1, "isEvmAddress", { enumerable: true, get: function() {
+      return common_1.isEvmAddress;
+    } });
+    Object.defineProperty(exports$1, "isEvmRecipient", { enumerable: true, get: function() {
+      return common_1.isEvmRecipient;
+    } });
+    Object.defineProperty(exports$1, "isSolanaAddress", { enumerable: true, get: function() {
+      return common_1.isSolanaAddress;
+    } });
+    Object.defineProperty(exports$1, "isSolanaRecipient", { enumerable: true, get: function() {
+      return common_1.isSolanaRecipient;
+    } });
+    var validation_1 = requireValidation();
+    Object.defineProperty(exports$1, "validateAddress", { enumerable: true, get: function() {
+      return validation_1.validateAddress;
+    } });
+    Object.defineProperty(exports$1, "validateAmount", { enumerable: true, get: function() {
+      return validation_1.validateAmount;
+    } });
+    Object.defineProperty(exports$1, "validateDomain", { enumerable: true, get: function() {
+      return validation_1.validateDomain;
+    } });
+    Object.defineProperty(exports$1, "validateMessage", { enumerable: true, get: function() {
+      return validation_1.validateMessage;
+    } });
+    var environment_1 = requireEnvironment();
+    Object.defineProperty(exports$1, "StorageType", { enumerable: true, get: function() {
+      return environment_1.StorageType;
+    } });
+    var analytics_1 = requireAnalytics();
+    Object.defineProperty(exports$1, "AnalyticsEvent", { enumerable: true, get: function() {
+      return analytics_1.AnalyticsEvent;
+    } });
+    Object.defineProperty(exports$1, "AnalyticsEventBuilder", { enumerable: true, get: function() {
+      return analytics_1.AnalyticsEventBuilder;
+    } });
+    var api_1 = requireApi();
+    Object.defineProperty(exports$1, "ContractType", { enumerable: true, get: function() {
+      return api_1.ContractType;
+    } });
+    Object.defineProperty(exports$1, "ProcessedEventName", { enumerable: true, get: function() {
+      return api_1.ProcessedEventName;
+    } });
+    var network_1 = requireNetwork();
+    Object.defineProperty(exports$1, "NetworkError", { enumerable: true, get: function() {
+      return network_1.NetworkError;
+    } });
+    var wallet_1 = requireWallet();
+    Object.defineProperty(exports$1, "WalletType", { enumerable: true, get: function() {
+      return wallet_1.WalletType;
+    } });
+    var rate_limits_1 = requireRateLimits();
+    Object.defineProperty(exports$1, "RateLimitPeriodType", { enumerable: true, get: function() {
+      return rate_limits_1.RateLimitPeriodType;
+    } });
+    var period_1 = requirePeriod();
+    Object.defineProperty(exports$1, "PERIOD_RANKS", { enumerable: true, get: function() {
+      return period_1.PERIOD_RANKS;
+    } });
+    Object.defineProperty(exports$1, "ALL_PERIODS", { enumerable: true, get: function() {
+      return period_1.ALL_PERIODS;
+    } });
+    var entitlements_1 = requireEntitlements();
+    Object.defineProperty(exports$1, "NONE_ENTITLEMENT", { enumerable: true, get: function() {
+      return entitlements_1.NONE_ENTITLEMENT;
+    } });
+    var entity_1 = requireEntity();
+    Object.defineProperty(exports$1, "EntityType", { enumerable: true, get: function() {
+      return entity_1.EntityType;
+    } });
+    Object.defineProperty(exports$1, "EntityRole", { enumerable: true, get: function() {
+      return entity_1.EntityRole;
+    } });
+    Object.defineProperty(exports$1, "InvitationStatus", { enumerable: true, get: function() {
+      return entity_1.InvitationStatus;
+    } });
+    var permissions_1 = requirePermissions();
+    Object.defineProperty(exports$1, "OWNER_PERMISSIONS", { enumerable: true, get: function() {
+      return permissions_1.OWNER_PERMISSIONS;
+    } });
+    Object.defineProperty(exports$1, "MANAGER_PERMISSIONS", { enumerable: true, get: function() {
+      return permissions_1.MANAGER_PERMISSIONS;
+    } });
+    Object.defineProperty(exports$1, "MEMBER_PERMISSIONS", { enumerable: true, get: function() {
+      return permissions_1.MEMBER_PERMISSIONS;
+    } });
+    Object.defineProperty(exports$1, "getPermissionsForRole", { enumerable: true, get: function() {
+      return permissions_1.getPermissionsForRole;
+    } });
+    Object.defineProperty(exports$1, "hasPermission", { enumerable: true, get: function() {
+      return permissions_1.hasPermission;
+    } });
+    var web3_username_validator_1 = requireWeb3UsernameValidator();
+    Object.defineProperty(exports$1, "Web3UsernameValidator", { enumerable: true, get: function() {
+      return web3_username_validator_1.Web3UsernameValidator;
+    } });
+    var type_validation_1 = requireTypeValidation();
+    Object.defineProperty(exports$1, "createAssertion", { enumerable: true, get: function() {
+      return type_validation_1.createAssertion;
+    } });
+    Object.defineProperty(exports$1, "createValidator", { enumerable: true, get: function() {
+      return type_validation_1.createValidator;
+    } });
+    Object.defineProperty(exports$1, "hasRequiredProperties", { enumerable: true, get: function() {
+      return type_validation_1.hasRequiredProperties;
+    } });
+    Object.defineProperty(exports$1, "isApiResponse", { enumerable: true, get: function() {
+      return type_validation_1.isApiResponse;
+    } });
+    Object.defineProperty(exports$1, "isArray", { enumerable: true, get: function() {
+      return type_validation_1.isArray;
+    } });
+    Object.defineProperty(exports$1, "isBoolean", { enumerable: true, get: function() {
+      return type_validation_1.isBoolean;
+    } });
+    Object.defineProperty(exports$1, "isEmail", { enumerable: true, get: function() {
+      return type_validation_1.isEmail;
+    } });
+    Object.defineProperty(exports$1, "isErrorResponse", { enumerable: true, get: function() {
+      return type_validation_1.isErrorResponse;
+    } });
+    Object.defineProperty(exports$1, "isNullish", { enumerable: true, get: function() {
+      return type_validation_1.isNullish;
+    } });
+    Object.defineProperty(exports$1, "isNumber", { enumerable: true, get: function() {
+      return type_validation_1.isNumber;
+    } });
+    Object.defineProperty(exports$1, "isObject", { enumerable: true, get: function() {
+      return type_validation_1.isObject;
+    } });
+    Object.defineProperty(exports$1, "isString", { enumerable: true, get: function() {
+      return type_validation_1.isString;
+    } });
+    Object.defineProperty(exports$1, "isSuccessResponse", { enumerable: true, get: function() {
+      return type_validation_1.isSuccessResponse;
+    } });
+    Object.defineProperty(exports$1, "isUrl", { enumerable: true, get: function() {
+      return type_validation_1.isUrl;
+    } });
+    Object.defineProperty(exports$1, "isValidDate", { enumerable: true, get: function() {
+      return type_validation_1.isValidDate;
+    } });
+    Object.defineProperty(exports$1, "optional", { enumerable: true, get: function() {
+      return type_validation_1.optional;
+    } });
+    Object.defineProperty(exports$1, "parseJson", { enumerable: true, get: function() {
+      return type_validation_1.parseJson;
+    } });
+    Object.defineProperty(exports$1, "validateArray", { enumerable: true, get: function() {
+      return type_validation_1.validateArray;
+    } });
+    var address_1 = requireAddress();
+    Object.defineProperty(exports$1, "AddressType", { enumerable: true, get: function() {
+      return address_1.AddressType;
+    } });
+    Object.defineProperty(exports$1, "formatWalletAddress", { enumerable: true, get: function() {
+      return address_1.formatWalletAddress;
+    } });
+    Object.defineProperty(exports$1, "getAddressType", { enumerable: true, get: function() {
+      return address_1.getAddressType;
+    } });
+    Object.defineProperty(exports$1, "getChainDisplayName", { enumerable: true, get: function() {
+      return address_1.getChainDisplayName;
+    } });
+    Object.defineProperty(exports$1, "isENSName", { enumerable: true, get: function() {
+      return address_1.isENSName;
+    } });
+    Object.defineProperty(exports$1, "isSNSName", { enumerable: true, get: function() {
+      return address_1.isSNSName;
+    } });
+    Object.defineProperty(exports$1, "isValidSignature", { enumerable: true, get: function() {
+      return address_1.isValidSignature;
+    } });
+    Object.defineProperty(exports$1, "isValidWalletAddress", { enumerable: true, get: function() {
+      return address_1.isValidWalletAddress;
+    } });
+    Object.defineProperty(exports$1, "parseEmailAddress", { enumerable: true, get: function() {
+      return address_1.parseEmailAddress;
+    } });
+    var event_helpers_1 = requireEventHelpers();
+    Object.defineProperty(exports$1, "createChainStatsId", { enumerable: true, get: function() {
+      return event_helpers_1.createChainStatsId;
+    } });
+    Object.defineProperty(exports$1, "createDelegationId", { enumerable: true, get: function() {
+      return event_helpers_1.createDelegationId;
+    } });
+    Object.defineProperty(exports$1, "createMultiChainId", { enumerable: true, get: function() {
+      return event_helpers_1.createMultiChainId;
+    } });
+    Object.defineProperty(exports$1, "createUserMultiChainId", { enumerable: true, get: function() {
+      return event_helpers_1.createUserMultiChainId;
+    } });
+    Object.defineProperty(exports$1, "formatBigInt", { enumerable: true, get: function() {
+      return event_helpers_1.formatBigInt;
+    } });
+    Object.defineProperty(exports$1, "isTestNet", { enumerable: true, get: function() {
+      return event_helpers_1.isTestNet;
+    } });
+    Object.defineProperty(exports$1, "isZeroAddress", { enumerable: true, get: function() {
+      return event_helpers_1.isZeroAddress;
+    } });
+    Object.defineProperty(exports$1, "normalizeAddress", { enumerable: true, get: function() {
+      return event_helpers_1.normalizeAddress;
+    } });
+    Object.defineProperty(exports$1, "validateEventArgs", { enumerable: true, get: function() {
+      return event_helpers_1.validateEventArgs;
+    } });
+    var auth_1 = requireAuth();
+    Object.defineProperty(exports$1, "canAccessProtectedFeatures", { enumerable: true, get: function() {
+      return auth_1.canAccessProtectedFeatures;
+    } });
+    Object.defineProperty(exports$1, "extractNonceFromMessage", { enumerable: true, get: function() {
+      return auth_1.extractNonceFromMessage;
+    } });
+    Object.defineProperty(exports$1, "generateAuthMessage", { enumerable: true, get: function() {
+      return auth_1.generateAuthMessage;
+    } });
+    Object.defineProperty(exports$1, "generateNonce", { enumerable: true, get: function() {
+      return auth_1.generateNonce;
+    } });
+    Object.defineProperty(exports$1, "getAuthStatusText", { enumerable: true, get: function() {
+      return auth_1.getAuthStatusText;
+    } });
+    Object.defineProperty(exports$1, "isAuthExpired", { enumerable: true, get: function() {
+      return auth_1.isAuthExpired;
+    } });
+    Object.defineProperty(exports$1, "isAuthStatusConnected", { enumerable: true, get: function() {
+      return auth_1.isAuthStatusConnected;
+    } });
+    Object.defineProperty(exports$1, "isValidNonce", { enumerable: true, get: function() {
+      return auth_1.isValidNonce;
+    } });
+    var admin_emails_1 = requireAdminEmails();
+    Object.defineProperty(exports$1, "parseAdminEmails", { enumerable: true, get: function() {
+      return admin_emails_1.parseAdminEmails;
+    } });
+    Object.defineProperty(exports$1, "isAdminEmail", { enumerable: true, get: function() {
+      return admin_emails_1.isAdminEmail;
+    } });
+    Object.defineProperty(exports$1, "createAdminChecker", { enumerable: true, get: function() {
+      return admin_emails_1.createAdminChecker;
+    } });
+    var currency_1 = requireCurrency();
+    Object.defineProperty(exports$1, "CLAIM_PERIOD_DAYS", { enumerable: true, get: function() {
+      return currency_1.CLAIM_PERIOD_DAYS;
+    } });
+    Object.defineProperty(exports$1, "USDC_DECIMALS", { enumerable: true, get: function() {
+      return currency_1.USDC_DECIMALS;
+    } });
+    Object.defineProperty(exports$1, "formatUSDC", { enumerable: true, get: function() {
+      return currency_1.formatUSDC;
+    } });
+    Object.defineProperty(exports$1, "parseUSDC", { enumerable: true, get: function() {
+      return currency_1.parseUSDC;
+    } });
+    var date_1 = requireDate();
+    Object.defineProperty(exports$1, "addDays", { enumerable: true, get: function() {
+      return date_1.addDays;
+    } });
+    Object.defineProperty(exports$1, "addHours", { enumerable: true, get: function() {
+      return date_1.addHours;
+    } });
+    Object.defineProperty(exports$1, "formatEmailDate", { enumerable: true, get: function() {
+      return date_1.formatEmailDate;
+    } });
+    Object.defineProperty(exports$1, "formatRelativeTime", { enumerable: true, get: function() {
+      return date_1.formatRelativeTime;
+    } });
+    Object.defineProperty(exports$1, "formatTimestamp", { enumerable: true, get: function() {
+      return date_1.formatTimestamp;
+    } });
+    Object.defineProperty(exports$1, "isDateInRange", { enumerable: true, get: function() {
+      return date_1.isDateInRange;
+    } });
+    Object.defineProperty(exports$1, "parseDate", { enumerable: true, get: function() {
+      return date_1.parseDate;
+    } });
+    var string_1 = requireString();
+    Object.defineProperty(exports$1, "capitalize", { enumerable: true, get: function() {
+      return string_1.capitalize;
+    } });
+    Object.defineProperty(exports$1, "escapeHtml", { enumerable: true, get: function() {
+      return string_1.escapeHtml;
+    } });
+    Object.defineProperty(exports$1, "formatBytes", { enumerable: true, get: function() {
+      return string_1.formatBytes;
+    } });
+    Object.defineProperty(exports$1, "formatNumber", { enumerable: true, get: function() {
+      return string_1.formatNumber;
+    } });
+    Object.defineProperty(exports$1, "getInitials", { enumerable: true, get: function() {
+      return string_1.getInitials;
+    } });
+    Object.defineProperty(exports$1, "isBlank", { enumerable: true, get: function() {
+      return string_1.isBlank;
+    } });
+    Object.defineProperty(exports$1, "isNotBlank", { enumerable: true, get: function() {
+      return string_1.isNotBlank;
+    } });
+    Object.defineProperty(exports$1, "normalizeWhitespace", { enumerable: true, get: function() {
+      return string_1.normalizeWhitespace;
+    } });
+    Object.defineProperty(exports$1, "pluralize", { enumerable: true, get: function() {
+      return string_1.pluralize;
+    } });
+    Object.defineProperty(exports$1, "randomString", { enumerable: true, get: function() {
+      return string_1.randomString;
+    } });
+    Object.defineProperty(exports$1, "stripHtml", { enumerable: true, get: function() {
+      return string_1.stripHtml;
+    } });
+    Object.defineProperty(exports$1, "toCamelCase", { enumerable: true, get: function() {
+      return string_1.toCamelCase;
+    } });
+    Object.defineProperty(exports$1, "toKebabCase", { enumerable: true, get: function() {
+      return string_1.toKebabCase;
+    } });
+    Object.defineProperty(exports$1, "toSnakeCase", { enumerable: true, get: function() {
+      return string_1.toSnakeCase;
+    } });
+    Object.defineProperty(exports$1, "toTitleCase", { enumerable: true, get: function() {
+      return string_1.toTitleCase;
+    } });
+    Object.defineProperty(exports$1, "truncate", { enumerable: true, get: function() {
+      return string_1.truncate;
+    } });
+    var application_1 = requireApplication();
+    Object.defineProperty(exports$1, "API_TIMEOUT", { enumerable: true, get: function() {
+      return application_1.API_TIMEOUT;
+    } });
+    Object.defineProperty(exports$1, "API_RETRY_ATTEMPTS", { enumerable: true, get: function() {
+      return application_1.API_RETRY_ATTEMPTS;
+    } });
+    Object.defineProperty(exports$1, "API_RETRY_DELAY", { enumerable: true, get: function() {
+      return application_1.API_RETRY_DELAY;
+    } });
+    Object.defineProperty(exports$1, "AUTH_STATUS", { enumerable: true, get: function() {
+      return application_1.AUTH_STATUS;
+    } });
+    Object.defineProperty(exports$1, "CHAIN_TYPE", { enumerable: true, get: function() {
+      return application_1.CHAIN_TYPE;
+    } });
+    Object.defineProperty(exports$1, "STORAGE_KEYS", { enumerable: true, get: function() {
+      return application_1.STORAGE_KEYS;
+    } });
+    Object.defineProperty(exports$1, "EMAIL_CONFIG", { enumerable: true, get: function() {
+      return application_1.EMAIL_CONFIG;
+    } });
+    Object.defineProperty(exports$1, "SUBSCRIPTION_TIERS", { enumerable: true, get: function() {
+      return application_1.SUBSCRIPTION_TIERS;
+    } });
+    Object.defineProperty(exports$1, "TIME_FORMAT", { enumerable: true, get: function() {
+      return application_1.TIME_FORMAT;
+    } });
+    Object.defineProperty(exports$1, "ERROR_MESSAGES", { enumerable: true, get: function() {
+      return application_1.ERROR_MESSAGES;
+    } });
+    Object.defineProperty(exports$1, "SUCCESS_MESSAGES", { enumerable: true, get: function() {
+      return application_1.SUCCESS_MESSAGES;
+    } });
+    Object.defineProperty(exports$1, "ROUTES", { enumerable: true, get: function() {
+      return application_1.ROUTES;
+    } });
+    Object.defineProperty(exports$1, "CONTACT_INFO", { enumerable: true, get: function() {
+      return application_1.CONTACT_INFO;
+    } });
+    Object.defineProperty(exports$1, "WALLET_NAMES", { enumerable: true, get: function() {
+      return application_1.WALLET_NAMES;
+    } });
+    Object.defineProperty(exports$1, "NETWORK_IDS", { enumerable: true, get: function() {
+      return application_1.NETWORK_IDS;
+    } });
+    Object.defineProperty(exports$1, "ANIMATION", { enumerable: true, get: function() {
+      return application_1.ANIMATION;
+    } });
+    Object.defineProperty(exports$1, "Z_INDEX", { enumerable: true, get: function() {
+      return application_1.Z_INDEX;
+    } });
+    var status_values_1 = requireStatusValues();
+    Object.defineProperty(exports$1, "STATUS_VALUES", { enumerable: true, get: function() {
+      return status_values_1.STATUS_VALUES;
+    } });
+    var logger_1 = requireLogger();
+    Object.defineProperty(exports$1, "LogLevel", { enumerable: true, get: function() {
+      return logger_1.LogLevel;
+    } });
+    Object.defineProperty(exports$1, "logger", { enumerable: true, get: function() {
+      return logger_1.logger;
+    } });
+    Object.defineProperty(exports$1, "authLogger", { enumerable: true, get: function() {
+      return logger_1.authLogger;
+    } });
+    Object.defineProperty(exports$1, "apiLogger", { enumerable: true, get: function() {
+      return logger_1.apiLogger;
+    } });
+    Object.defineProperty(exports$1, "contractLogger", { enumerable: true, get: function() {
+      return logger_1.contractLogger;
+    } });
+    Object.defineProperty(exports$1, "ensLogger", { enumerable: true, get: function() {
+      return logger_1.ensLogger;
+    } });
+    Object.defineProperty(exports$1, "storageLogger", { enumerable: true, get: function() {
+      return logger_1.storageLogger;
+    } });
+    var url_params_1 = requireUrlParams();
+    Object.defineProperty(exports$1, "createURLSearchParams", { enumerable: true, get: function() {
+      return url_params_1.createURLSearchParams;
+    } });
+    Object.defineProperty(exports$1, "createSearchParams", { enumerable: true, get: function() {
+      return url_params_1.createSearchParams;
+    } });
+    Object.defineProperty(exports$1, "searchParamsToString", { enumerable: true, get: function() {
+      return url_params_1.searchParamsToString;
+    } });
+    Object.defineProperty(exports$1, "parseSearchParams", { enumerable: true, get: function() {
+      return url_params_1.parseSearchParams;
+    } });
+    var async_helpers_1 = requireAsyncHelpers();
+    Object.defineProperty(exports$1, "safeAsync", { enumerable: true, get: function() {
+      return async_helpers_1.safeAsync;
+    } });
+    Object.defineProperty(exports$1, "withLoadingState", { enumerable: true, get: function() {
+      return async_helpers_1.withLoadingState;
+    } });
+    Object.defineProperty(exports$1, "safeParallel", { enumerable: true, get: function() {
+      return async_helpers_1.safeParallel;
+    } });
+    Object.defineProperty(exports$1, "withTimeout", { enumerable: true, get: function() {
+      return async_helpers_1.withTimeout;
+    } });
+    Object.defineProperty(exports$1, "withCache", { enumerable: true, get: function() {
+      return async_helpers_1.withCache;
+    } });
+    Object.defineProperty(exports$1, "clearExpiredCache", { enumerable: true, get: function() {
+      return async_helpers_1.clearExpiredCache;
+    } });
+    Object.defineProperty(exports$1, "debounceAsync", { enumerable: true, get: function() {
+      return async_helpers_1.debounceAsync;
+    } });
+  })(dist);
+  return dist;
+}
+var distExports = requireDist();
+const variantConfig = {
+  [distExports.InfoType.INFO]: {
+    icon: "ℹ",
+    container: "bg-blue-50 dark:bg-blue-950 border-blue-200 dark:border-blue-800",
+    iconColor: "text-blue-600 dark:text-blue-400",
+    titleColor: "text-blue-900 dark:text-blue-100",
+    descriptionColor: "text-blue-700 dark:text-blue-300"
+  },
+  [distExports.InfoType.SUCCESS]: {
+    icon: "✓",
+    container: "bg-green-50 dark:bg-green-950 border-green-200 dark:border-green-800",
+    iconColor: "text-green-600 dark:text-green-400",
+    titleColor: "text-green-900 dark:text-green-100",
+    descriptionColor: "text-green-700 dark:text-green-300"
+  },
+  [distExports.InfoType.WARNING]: {
+    icon: "⚠",
+    container: "bg-yellow-50 dark:bg-amber-950 border-yellow-200 dark:border-amber-800",
+    iconColor: "text-yellow-600 dark:text-amber-400",
+    titleColor: "text-yellow-900 dark:text-amber-100",
+    descriptionColor: "text-yellow-700 dark:text-amber-300"
+  },
+  [distExports.InfoType.ERROR]: {
+    icon: "✗",
+    container: "bg-red-50 dark:bg-red-950 border-red-200 dark:border-red-800",
+    iconColor: "text-red-600 dark:text-red-400",
+    titleColor: "text-red-900 dark:text-red-100",
+    descriptionColor: "text-red-700 dark:text-red-300"
+  }
+};
+const Banner = ({
+  isVisible,
+  onDismiss,
+  title,
+  description,
+  variant = distExports.InfoType.INFO,
+  duration = 5e3,
+  icon,
+  className,
+  closeAccessibilityLabel = "Dismiss banner"
+}) => {
+  const [mounted, setMounted] = useState(false);
+  const slideAnim = useRef(new Animated.Value(-100)).current;
+  const opacityAnim = useRef(new Animated.Value(0)).current;
+  const dismissTimeoutRef = useRef(null);
+  const config = variantConfig[variant];
+  const clearDismissTimeout = useCallback(() => {
+    if (dismissTimeoutRef.current) {
+      clearTimeout(dismissTimeoutRef.current);
+      dismissTimeoutRef.current = null;
+    }
+  }, []);
+  const handleDismiss = useCallback(() => {
+    clearDismissTimeout();
+    Animated.parallel([
+      Animated.timing(slideAnim, {
+        toValue: -100,
+        duration: 300,
+        useNativeDriver: true
+      }),
+      Animated.timing(opacityAnim, {
+        toValue: 0,
+        duration: 300,
+        useNativeDriver: true
+      })
+    ]).start(() => {
+      setMounted(false);
+      onDismiss();
+    });
+  }, [clearDismissTimeout, slideAnim, opacityAnim, onDismiss]);
+  useEffect(() => {
+    if (isVisible) {
+      setMounted(true);
+      slideAnim.setValue(-100);
+      opacityAnim.setValue(0);
+      Animated.parallel([
+        Animated.spring(slideAnim, {
+          toValue: 0,
+          useNativeDriver: true,
+          friction: 8
+        }),
+        Animated.timing(opacityAnim, {
+          toValue: 1,
+          duration: 300,
+          useNativeDriver: true
+        })
+      ]).start(() => {
+        if (duration > 0) {
+          dismissTimeoutRef.current = setTimeout(() => {
+            handleDismiss();
+          }, duration);
+        }
+      });
+    } else if (mounted) {
+      handleDismiss();
+    }
+    return () => clearDismissTimeout();
+  }, [isVisible]);
+  useEffect(() => {
+    return () => clearDismissTimeout();
+  }, [clearDismissTimeout]);
+  if (!mounted) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    Animated.View,
+    {
+      style: {
+        transform: [{ translateY: slideAnim }],
+        opacity: opacityAnim
+      },
+      className: cn("absolute top-0 left-0 right-0 z-50", className),
+      accessibilityRole: "alert",
+      accessibilityLiveRegion: "polite",
+      children: /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        View,
+        {
+          className: cn(
+            "flex-row items-start gap-3 p-4 border-b",
+            config.container
+          ),
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: "flex-shrink-0 mt-0.5", children: icon || /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("text-lg", config.iconColor), children: config.icon }) }),
+            /* @__PURE__ */ jsxRuntimeExports.jsxs(View, { className: "flex-1 min-w-0", children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("font-semibold", config.titleColor), children: title }),
+              description ? /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("text-sm mt-1", config.descriptionColor), children: description }) : null
+            ] }),
+            /* @__PURE__ */ jsxRuntimeExports.jsx(
+              Pressable,
+              {
+                onPress: handleDismiss,
+                className: "flex-shrink-0 p-1 rounded-md",
+                accessibilityRole: "button",
+                accessibilityLabel: closeAccessibilityLabel,
+                children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("text-lg", config.iconColor), children: "✗" })
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+};
+const useBanner = (options = {}) => {
+  const { defaultDuration = 5e3 } = options;
+  const [isVisible, setIsVisible] = useState(false);
+  const [bannerProps, setBannerProps] = useState(null);
+  const showBanner = useCallback(
+    ({
+      title,
+      description,
+      variant = distExports.InfoType.INFO,
+      duration = defaultDuration
+    }) => {
+      setBannerProps({ title, description, variant, duration });
+      setIsVisible(true);
+    },
+    [defaultDuration]
+  );
+  const hideBanner = useCallback(() => {
+    setIsVisible(false);
+  }, []);
+  return {
+    isVisible,
+    bannerProps,
+    showBanner,
+    hideBanner
+  };
+};
 const mapSizeToVariantKey = (size) => {
   if (!size) return "default";
   const sizeMap2 = {
@@ -2116,7 +4935,7 @@ const HelperText = ({
     sm: "w-4 h-4",
     base: "w-5 h-5"
   };
-  const variantConfig = {
+  const variantConfig2 = {
     default: {
       text: "text-gray-600 dark:text-gray-400",
       icon: "ℹ"
@@ -2134,7 +4953,7 @@ const HelperText = ({
       icon: "⚠"
     }
   };
-  const config = variantConfig[variant];
+  const config = variantConfig2[variant];
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(View, { className: cn("flex flex-row items-start gap-1.5", className), children: [
     showIcon && /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn(iconSize[size], config.text, "mt-0.5"), children: config.icon }),
     /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn(sizeClasses[size], config.text), ...textProps, children })
@@ -3276,7 +6095,7 @@ const IconText = ({
 const FormattedNumber = ({
   value,
   style = "decimal",
-  currency = "USD",
+  currency: currency2 = "USD",
   minimumFractionDigits,
   maximumFractionDigits,
   locale = "en-US",
@@ -3292,7 +6111,7 @@ const FormattedNumber = ({
         maximumFractionDigits
       };
       if (style === "currency") {
-        options.currency = currency;
+        options.currency = currency2;
       }
       return new Intl.NumberFormat(locale, options).format(value);
     } catch (error) {
@@ -3348,23 +6167,23 @@ const InfoBox = ({
     md: "p-4",
     lg: "p-6"
   };
-  const variantConfig = variantClasses[variant];
+  const variantConfig2 = variantClasses[variant];
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(
     View,
     {
       className: cn(
         "rounded-lg",
-        variantConfig.bg,
-        bordered && `border ${variantConfig.border}`,
+        variantConfig2.bg,
+        bordered && `border ${variantConfig2.border}`,
         sizeClasses[size],
         className
       ),
       children: [
         (title || icon) && /* @__PURE__ */ jsxRuntimeExports.jsxs(View, { className: "flex flex-row items-start gap-3 mb-2", children: [
           icon,
-          title && /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("font-semibold", variantConfig.title), children: title })
+          title && /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("font-semibold", variantConfig2.title), children: title })
         ] }),
-        /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: cn(!title && !icon && variantConfig.text), children })
+        /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: cn(!title && !icon && variantConfig2.text), children })
       ]
     }
   );
@@ -5276,23 +8095,23 @@ const Calendar = ({
   className
 }) => {
   const [currentMonth, setCurrentMonth] = useState(value || /* @__PURE__ */ new Date());
-  const getDaysInMonth = (date) => {
-    const year = date.getFullYear();
-    const month = date.getMonth();
+  const getDaysInMonth = (date2) => {
+    const year = date2.getFullYear();
+    const month = date2.getMonth();
     return new Date(year, month + 1, 0).getDate();
   };
-  const getFirstDayOfMonth = (date) => {
-    const year = date.getFullYear();
-    const month = date.getMonth();
+  const getFirstDayOfMonth = (date2) => {
+    const year = date2.getFullYear();
+    const month = date2.getMonth();
     return new Date(year, month, 1).getDay();
   };
   const isSameDay = (date1, date2) => {
     return date1.getFullYear() === date2.getFullYear() && date1.getMonth() === date2.getMonth() && date1.getDate() === date2.getDate();
   };
-  const isDateDisabled = (date) => {
-    if (minDate && date < minDate) return true;
-    if (maxDate && date > maxDate) return true;
-    return disabledDates.some((disabledDate) => isSameDay(date, disabledDate));
+  const isDateDisabled = (date2) => {
+    if (minDate && date2 < minDate) return true;
+    if (maxDate && date2 > maxDate) return true;
+    return disabledDates.some((disabledDate) => isSameDay(date2, disabledDate));
   };
   const goToPreviousMonth = () => {
     setCurrentMonth(
@@ -5333,9 +8152,9 @@ const Calendar = ({
   };
   const calendarDays = generateCalendarDays();
   const weekDays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
-  const handleDayPress = (date) => {
-    if (!date || isDateDisabled(date)) return;
-    onChange(date);
+  const handleDayPress = (date2) => {
+    if (!date2 || isDateDisabled(date2)) return;
+    onChange(date2);
   };
   const monthYear = currentMonth.toLocaleDateString("en-US", {
     month: "long",
@@ -5370,8 +8189,8 @@ const Calendar = ({
       )
     ] }),
     /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: "flex-row mb-2", children: weekDays.map((day) => /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: "flex-1 items-center py-2", children: /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: "text-xs font-medium text-gray-600 dark:text-gray-400", children: day }) }, day)) }),
-    weeks.map((week, weekIndex) => /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: "flex-row", children: week.map((date, dayIndex) => {
-      if (!date) {
+    weeks.map((week, weekIndex) => /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: "flex-row", children: week.map((date2, dayIndex) => {
+      if (!date2) {
         return /* @__PURE__ */ jsxRuntimeExports.jsx(
           View,
           {
@@ -5380,14 +8199,14 @@ const Calendar = ({
           `empty-${dayIndex}`
         );
       }
-      const isCurrentMonth = date.getMonth() === currentMonth.getMonth();
-      const isSelected = value && isSameDay(date, value);
-      const isToday = isSameDay(date, /* @__PURE__ */ new Date());
-      const isDisabled = isDateDisabled(date);
+      const isCurrentMonth = date2.getMonth() === currentMonth.getMonth();
+      const isSelected = value && isSameDay(date2, value);
+      const isToday = isSameDay(date2, /* @__PURE__ */ new Date());
+      const isDisabled = isDateDisabled(date2);
       return /* @__PURE__ */ jsxRuntimeExports.jsx(
         Pressable,
         {
-          onPress: () => handleDayPress(date),
+          onPress: () => handleDayPress(date2),
           disabled: isDisabled,
           className: cn(
             "flex-1 aspect-square items-center justify-center rounded-md m-0.5",
@@ -5397,7 +8216,7 @@ const Calendar = ({
             isToday && !isSelected && "border-2 border-blue-600 dark:border-blue-400"
           ),
           accessibilityRole: "button",
-          accessibilityLabel: date.toLocaleDateString(),
+          accessibilityLabel: date2.toLocaleDateString(),
           accessibilityState: {
             selected: isSelected,
             disabled: isDisabled
@@ -5410,11 +8229,11 @@ const Calendar = ({
                 isCurrentMonth ? "text-gray-900 dark:text-white" : "text-gray-400 dark:text-gray-600",
                 isSelected && "text-white font-semibold"
               ),
-              children: date.getDate()
+              children: date2.getDate()
             }
           )
         },
-        `${date.getTime()}-${dayIndex}`
+        `${date2.getTime()}-${dayIndex}`
       );
     }) }, weekIndex))
   ] });
@@ -6110,7 +8929,7 @@ const TimePicker = ({
   const [isOpen, setIsOpen] = useState(false);
   const [internalHour, setInternalHour] = useState("12");
   const [internalMinute, setInternalMinute] = useState("00");
-  const [period, setPeriod] = useState("AM");
+  const [period2, setPeriod] = useState("AM");
   useEffect(() => {
     if (value) {
       const [hours, minutes] = value.split(":");
@@ -6204,7 +9023,7 @@ const TimePicker = ({
                     handleTimeChange(
                       hour,
                       internalMinute,
-                      use12Hour ? period : void 0
+                      use12Hour ? period2 : void 0
                     );
                   },
                   className: cn(
@@ -6236,7 +9055,7 @@ const TimePicker = ({
                     handleTimeChange(
                       internalHour,
                       minute,
-                      use12Hour ? period : void 0
+                      use12Hour ? period2 : void 0
                     );
                   },
                   className: cn(
@@ -6275,14 +9094,14 @@ const TimePicker = ({
                     className: cn(
                       "px-3 py-2 rounded",
                       "active:bg-gray-100 dark:active:bg-gray-800",
-                      period === "AM" && "bg-blue-100 dark:bg-blue-900/30"
+                      period2 === "AM" && "bg-blue-100 dark:bg-blue-900/30"
                     ),
                     children: /* @__PURE__ */ jsxRuntimeExports.jsx(
                       Text$1,
                       {
                         className: cn(
                           "text-sm text-center",
-                          period === "AM" ? "text-blue-700 dark:text-blue-300 font-medium" : "text-gray-900 dark:text-white"
+                          period2 === "AM" ? "text-blue-700 dark:text-blue-300 font-medium" : "text-gray-900 dark:text-white"
                         ),
                         children: "AM"
                       }
@@ -6303,14 +9122,14 @@ const TimePicker = ({
                     className: cn(
                       "px-3 py-2 rounded",
                       "active:bg-gray-100 dark:active:bg-gray-800",
-                      period === "PM" && "bg-blue-100 dark:bg-blue-900/30"
+                      period2 === "PM" && "bg-blue-100 dark:bg-blue-900/30"
                     ),
                     children: /* @__PURE__ */ jsxRuntimeExports.jsx(
                       Text$1,
                       {
                         className: cn(
                           "text-sm text-center",
-                          period === "PM" ? "text-blue-700 dark:text-blue-300 font-medium" : "text-gray-900 dark:text-white"
+                          period2 === "PM" ? "text-blue-700 dark:text-blue-300 font-medium" : "text-gray-900 dark:text-white"
                         ),
                         children: "PM"
                       }
@@ -6564,16 +9383,16 @@ const TreeView = ({
   };
   return /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: cn("w-full", className), children: data.map((node) => renderNode(node, 0)) });
 };
-const getExplorerUrl = (address, chainId, explorerUrl) => {
+const getExplorerUrl = (address2, chainId, explorerUrl) => {
   if (explorerUrl) {
-    return `${explorerUrl}/address/${address}`;
+    return `${explorerUrl}/address/${address2}`;
   }
   if (!chainId) {
     return null;
   }
   if (chainId < 0) {
     const cluster = chainId === -101 ? "" : chainId === -102 ? "?cluster=devnet" : "?cluster=testnet";
-    return `https://explorer.solana.com/address/${address}${cluster}`;
+    return `https://explorer.solana.com/address/${address2}${cluster}`;
   }
   const explorerMap = {
     1: "https://etherscan.io",
@@ -6592,19 +9411,19 @@ const getExplorerUrl = (address, chainId, explorerUrl) => {
   if (!baseUrl) {
     return null;
   }
-  return `${baseUrl}/address/${address}`;
+  return `${baseUrl}/address/${address2}`;
 };
-const formatAddress = (address, format) => {
+const formatAddress = (address2, format) => {
   if (format === "full") {
-    return address;
+    return address2;
   }
   if (format === "medium") {
-    return `${address.substring(0, 10)}...${address.substring(address.length - 8)}`;
+    return `${address2.substring(0, 10)}...${address2.substring(address2.length - 8)}`;
   }
-  return `${address.substring(0, 6)}...${address.substring(address.length - 4)}`;
+  return `${address2.substring(0, 6)}...${address2.substring(address2.length - 4)}`;
 };
 const AddressLink = ({
-  address,
+  address: address2,
   chainId,
   explorerUrl,
   label,
@@ -6615,17 +9434,17 @@ const AddressLink = ({
   className
 }) => {
   const [copied, setCopied] = useState(false);
-  const formattedAddress = formatAddress(address, format);
-  const explorerLink = getExplorerUrl(address, chainId, explorerUrl);
+  const formattedAddress = formatAddress(address2, format);
+  const explorerLink = getExplorerUrl(address2, chainId, explorerUrl);
   const handleCopy = useCallback(async () => {
     if (!onCopy) return;
     try {
-      await onCopy(address);
+      await onCopy(address2);
       setCopied(true);
       setTimeout(() => setCopied(false), 2e3);
     } catch {
     }
-  }, [address, onCopy]);
+  }, [address2, onCopy]);
   const handleOpenExplorer = useCallback(() => {
     if (explorerLink) {
       Linking.openURL(explorerLink);
@@ -6779,19 +9598,19 @@ const DateInput = ({
     lg: "py-3 px-4 text-lg"
   };
   const dateValue = value instanceof Date ? value : value ? new Date(value) : null;
-  const formatDisplay = (date) => {
-    if (!date) return "";
-    return date.toLocaleDateString("en-US", {
+  const formatDisplay = (date2) => {
+    if (!date2) return "";
+    return date2.toLocaleDateString("en-US", {
       month: "short",
       day: "numeric",
       year: "numeric"
     });
   };
   const handleDateChange = useCallback(
-    (date) => {
-      const year = date.getFullYear();
-      const month = String(date.getMonth() + 1).padStart(2, "0");
-      const day = String(date.getDate()).padStart(2, "0");
+    (date2) => {
+      const year = date2.getFullYear();
+      const month = String(date2.getMonth() + 1).padStart(2, "0");
+      const day = String(date2.getDate()).padStart(2, "0");
       onChange(`${year}-${month}-${day}`);
       setIsOpen(false);
     },
@@ -6877,24 +9696,24 @@ const DateTimePicker = ({
 }) => {
   const [isOpen, setIsOpen] = useState(false);
   const [selectedDate, setSelectedDate] = useState(value);
-  const formatDisplay = (date) => {
-    const dateStr = date.toLocaleDateString("en-US", {
+  const formatDisplay = (date2) => {
+    const dateStr = date2.toLocaleDateString("en-US", {
       month: "short",
       day: "numeric",
       year: "numeric"
     });
-    const hours = date.getHours();
-    const minutes = date.getMinutes();
+    const hours = date2.getHours();
+    const minutes = date2.getMinutes();
     if (use12Hour) {
       const hour12 = hours === 0 ? 12 : hours > 12 ? hours - 12 : hours;
-      const period = hours >= 12 ? "PM" : "AM";
-      return `${dateStr}, ${hour12}:${minutes.toString().padStart(2, "0")} ${period}`;
+      const period2 = hours >= 12 ? "PM" : "AM";
+      return `${dateStr}, ${hour12}:${minutes.toString().padStart(2, "0")} ${period2}`;
     }
     return `${dateStr}, ${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
   };
   const handleDateChange = useCallback(
-    (date) => {
-      const newDateTime = new Date(date);
+    (date2) => {
+      const newDateTime = new Date(date2);
       newDateTime.setHours(selectedDate.getHours());
       newDateTime.setMinutes(selectedDate.getMinutes());
       setSelectedDate(newDateTime);
@@ -6911,9 +9730,9 @@ const DateTimePicker = ({
     },
     [selectedDate]
   );
-  const getTimeString = (date) => {
-    const hours = date.getHours();
-    const minutes = date.getMinutes();
+  const getTimeString = (date2) => {
+    const hours = date2.getHours();
+    const minutes = date2.getMinutes();
     return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
   };
   const handleClose = useCallback(() => {
@@ -9488,7 +12307,7 @@ const StatDisplay = ({
     center: "items-center",
     right: "items-end"
   };
-  const variantConfig = variantClasses[variant];
+  const variantConfig2 = variantClasses[variant];
   const sizeConfig2 = sizeClasses[size];
   if (iconPosition === "left" && icon) {
     return /* @__PURE__ */ jsxRuntimeExports.jsxs(
@@ -9500,25 +12319,25 @@ const StatDisplay = ({
           className
         ),
         children: [
-          /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: variantConfig.value, children: icon }),
+          /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: variantConfig2.value, children: icon }),
           /* @__PURE__ */ jsxRuntimeExports.jsxs(View, { children: [
             /* @__PURE__ */ jsxRuntimeExports.jsx(
               Text$1,
               {
-                className: cn("font-bold", sizeConfig2.value, variantConfig.value),
+                className: cn("font-bold", sizeConfig2.value, variantConfig2.value),
                 children: value
               }
             ),
-            /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn(sizeConfig2.label, variantConfig.label), children: label })
+            /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn(sizeConfig2.label, variantConfig2.label), children: label })
           ] })
         ]
       }
     );
   }
   return /* @__PURE__ */ jsxRuntimeExports.jsxs(View, { className: cn(alignClasses[align], className), children: [
-    icon && iconPosition === "top" && /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: cn("mb-2", variantConfig.value), children: icon }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("font-bold", sizeConfig2.value, variantConfig.value), children: value }),
-    /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn(sizeConfig2.label, variantConfig.label), children: label })
+    icon && iconPosition === "top" && /* @__PURE__ */ jsxRuntimeExports.jsx(View, { className: cn("mb-2", variantConfig2.value), children: icon }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn("font-bold", sizeConfig2.value, variantConfig2.value), children: value }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx(Text$1, { className: cn(sizeConfig2.label, variantConfig2.label), children: label })
   ] });
 };
 const KeyValuePair = ({
@@ -10166,6 +12985,7 @@ export {
   AvatarGroup,
   Backdrop,
   Badge,
+  Banner,
   Box,
   Breadcrumb,
   BreadcrumbNav,
@@ -10302,6 +13122,7 @@ export {
   getButtonVariantClass,
   mapSizeToVariantKey,
   textVariants2 as textVariants,
+  useBanner,
   useButtonState,
   useScrollSpy,
   useToast,