diff --git a/src/components/chat/MessageInput.tsx b/src/components/chat/MessageInput.tsx
index 43e6625b..d937792b 100644
--- a/src/components/chat/MessageInput.tsx
+++ b/src/components/chat/MessageInput.tsx
@@ -17,11 +17,12 @@ export function MessageInput() {
   const [showGifPicker, setShowGifPicker] = useState(false);
   const { login, address, isAuthenticated } = useAuth();
   const room = useRoomStore((state) => state.room);
-  const version = useRoomStore((state) => state.version); // Subscribe to version changes
+  const version = useRoomStore((state) => state.version);
   const { hasAccess, isLoading: checkingAccess } = useTokenGate(
     room?.token_address || null,
     room?.required_tokens || 0,
-    address
+    address,
+    room?.token_network || 'base'
   );
   const addMessage = useMessagesStore((state) => state.addMessage);
   const emojiButtonRef = useRef<HTMLButtonElement>(null);
@@ -94,7 +95,8 @@ export function MessageInput() {
     return <div className="text-center p-4">Checking access...</div>;
   }
 
-  if (!hasAccess && room?.token_address) {
+  // Only show the token gate warning if the user is authenticated and doesn't have access
+  if (!hasAccess && room?.token_address && isAuthenticated) {
     return (
       <div className="text-center p-4 bg-yellow-50 text-yellow-800 rounded-lg">
         Must hold {room.required_tokens} of token {room.token_address} to join chat
diff --git a/src/components/room/RoomHeader.tsx b/src/components/room/RoomHeader.tsx
index b2424139..c0e481ed 100644
--- a/src/components/room/RoomHeader.tsx
+++ b/src/components/room/RoomHeader.tsx
@@ -46,6 +46,7 @@ export function RoomHeader({ room }: RoomHeaderProps) {
           <TokenGateTooltip
             tokenAddress={room.token_address}
             requiredTokens={room.required_tokens}
+            network={room.token_network}
             isOwner={isOwner}
             onManageGate={() => setShowTokenGateModal(true)}
           />
diff --git a/src/components/room/TokenGateInfo.tsx b/src/components/room/TokenGateInfo.tsx
index bd5754f7..fd27fa0d 100644
--- a/src/components/room/TokenGateInfo.tsx
+++ b/src/components/room/TokenGateInfo.tsx
@@ -3,31 +3,35 @@ import { useTokenSymbol } from '../../lib/hooks/useTokenSymbol';
 import { useTokenGate } from '../../lib/hooks/useTokenGate';
 import { useAuth } from '../../components/auth/useAuth';
 import { useRoomStore } from '../../lib/store/room';
+import { SUPPORTED_NETWORKS, type SupportedNetwork } from '../../lib/config';
 import { useEffect } from 'react';
 
 type TokenGateInfoProps = {
   tokenAddress: string | null;
   requiredTokens: number;
+  network?: SupportedNetwork;
   isOwner: boolean;
   onManageGate?: () => void;
 };
 
 export function TokenGateInfo({ 
   tokenAddress: initialTokenAddress, 
-  requiredTokens: initialRequiredTokens, 
+  requiredTokens: initialRequiredTokens,
+  network: initialNetwork = 'base',
   isOwner,
   onManageGate 
 }: TokenGateInfoProps) {
   const { address } = useAuth();
   const room = useRoomStore(state => state.room);
-  const version = useRoomStore(state => state.version); // Subscribe to version changes
+  const version = useRoomStore(state => state.version);
 
   // Use room store values, falling back to props
   const tokenAddress = room?.token_address ?? initialTokenAddress;
   const requiredTokens = room?.required_tokens ?? initialRequiredTokens;
+  const network = (room?.token_network ?? initialNetwork) as SupportedNetwork;
 
-  const { symbol, isLoading } = useTokenSymbol(tokenAddress);
-  const { hasAccess } = useTokenGate(tokenAddress, requiredTokens, address);
+  const { symbol, isLoading } = useTokenSymbol(tokenAddress, network);
+  const { hasAccess } = useTokenGate(tokenAddress, requiredTokens, address, network);
 
   // Debug logging
   useEffect(() => {
@@ -35,9 +39,10 @@ export function TokenGateInfo({
       version,
       tokenAddress,
       requiredTokens,
+      network,
       roomState: room
     });
-  }, [version, tokenAddress, requiredTokens, room]);
+  }, [version, tokenAddress, requiredTokens, network, room]);
 
   if (!tokenAddress) {
     if (isOwner && onManageGate) {
@@ -53,8 +58,12 @@ export function TokenGateInfo({
     return null;
   }
 
-  const baseScanUrl = `https://basescan.org/token/${tokenAddress}`;
+  const explorerUrl = network === 'polygon' 
+    ? `https://polygonscan.com/token/${tokenAddress}`
+    : `https://basescan.org/token/${tokenAddress}`;
+  
   const tokenDisplay = isLoading ? '...' : symbol || 'tokens';
+  const networkDisplay = SUPPORTED_NETWORKS[network].name;
 
   return (
     <div className="flex items-center gap-2 text-sm mt-3">
@@ -65,13 +74,15 @@ export function TokenGateInfo({
       <span className="text-gray-600">
         Required: {requiredTokens}{' '}
         <a 
-          href={baseScanUrl}
+          href={explorerUrl}
           target="_blank"
           rel="noopener noreferrer"
           className="text-indigo-600 hover:text-indigo-700"
         >
           {tokenDisplay}
         </a>
+        {' '}on{' '}
+        <span className="font-medium">{networkDisplay}</span>
       </span>
       {isOwner && onManageGate && (
         <button
diff --git a/src/components/room/TokenGateModal.tsx b/src/components/room/TokenGateModal.tsx
index 8a30a3e2..67accf54 100644
--- a/src/components/room/TokenGateModal.tsx
+++ b/src/components/room/TokenGateModal.tsx
@@ -1,9 +1,10 @@
 import { useState, useEffect } from 'react';
-import { X } from 'lucide-react';
+import { X, AlertCircle } from 'lucide-react';
 import { isAddress } from 'viem';
 import { supabase } from '../../lib/auth/supabase';
 import { useAuth } from '../../components/auth/useAuth';
 import { useRoomStore } from '../../lib/store/room';
+import { type SupportedNetwork, SUPPORTED_NETWORKS } from '../../lib/config';
 
 type TokenGateModalProps = {
   roomName: string;
@@ -21,6 +22,7 @@ export function TokenGateModal({
   const { address } = useAuth();
   const [tokenAddress, setTokenAddress] = useState(currentTokenAddress || '');
   const [requiredTokens, setRequiredTokens] = useState(currentRequiredTokens);
+  const [network, setNetwork] = useState<SupportedNetwork>('base');
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const setRoom = useRoomStore(state => state.setRoom);
@@ -66,7 +68,8 @@ export function TokenGateModal({
         userAddress: normalizedAddress,
         roomName: normalizedRoomName,
         tokenAddress: tokenAddress || null,
-        requiredTokens: tokenAddress ? requiredTokens : 0
+        requiredTokens: tokenAddress ? requiredTokens : 0,
+        network
       });
 
       // First verify the room exists and user owns it
@@ -74,7 +77,7 @@ export function TokenGateModal({
         .from('rooms')
         .select('name, owner_address')
         .eq('name', normalizedRoomName)
-        .eq('owner_address', normalizedAddress)
+        .ilike('owner_address', normalizedAddress) // Use case-insensitive comparison
         .single();
 
       if (checkError) {
@@ -92,9 +95,10 @@ export function TokenGateModal({
         .update({
           token_address: tokenAddress || null,
           required_tokens: tokenAddress ? requiredTokens : 0,
+          token_network: tokenAddress ? network : null,
         })
         .eq('name', normalizedRoomName)
-        .eq('owner_address', normalizedAddress)
+        .ilike('owner_address', normalizedAddress) // Use case-insensitive comparison
         .select('*')
         .single();
 
@@ -152,22 +156,44 @@ export function TokenGateModal({
           </div>
 
           {tokenAddress && (
-            <div>
-              <label className="block text-sm font-medium text-gray-700 mb-1">
-                Required Tokens
-              </label>
-              <input
-                type="number"
-                value={requiredTokens}
-                onChange={(e) => setRequiredTokens(Number(e.target.value))}
-                min="0"
-                className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
-              />
-            </div>
+            <>
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  Network
+                </label>
+                <select
+                  value={network}
+                  onChange={(e) => setNetwork(e.target.value as SupportedNetwork)}
+                  className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                >
+                  {Object.entries(SUPPORTED_NETWORKS).map(([key, chain]) => (
+                    <option key={key} value={key}>
+                      {chain.name}
+                    </option>
+                  ))}
+                </select>
+              </div>
+
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-1">
+                  Required Tokens
+                </label>
+                <input
+                  type="number"
+                  value={requiredTokens}
+                  onChange={(e) => setRequiredTokens(Number(e.target.value))}
+                  min="0"
+                  className="w-full px-3 py-2 border rounded-lg focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500"
+                />
+              </div>
+            </>
           )}
 
           {error && (
-            <p className="text-red-600 text-sm">{error}</p>
+            <div className="flex items-center gap-2 text-red-600 text-sm bg-red-50 p-3 rounded-lg">
+              <AlertCircle size={16} />
+              <p>{error}</p>
+            </div>
           )}
 
           <div className="flex justify-end gap-2 pt-4">
diff --git a/src/components/room/TokenGateTooltip.tsx b/src/components/room/TokenGateTooltip.tsx
index 5f0a82d1..d25c76ad 100644
--- a/src/components/room/TokenGateTooltip.tsx
+++ b/src/components/room/TokenGateTooltip.tsx
@@ -4,23 +4,26 @@ import { useTokenSymbol } from '../../lib/hooks/useTokenSymbol';
 import { useTokenGate } from '../../lib/hooks/useTokenGate';
 import { useAuth } from '../../components/auth/useAuth';
 import { useRoomStore } from '../../lib/store/room';
+import { SUPPORTED_NETWORKS, type SupportedNetwork } from '../../lib/config';
 
 type TokenGateTooltipProps = {
   tokenAddress: string | null;
   requiredTokens: number;
+  network?: SupportedNetwork;
   isOwner: boolean;
   onManageGate?: () => void;
 };
 
 export function TokenGateTooltip({ 
   tokenAddress: initialTokenAddress, 
-  requiredTokens: initialRequiredTokens, 
+  requiredTokens: initialRequiredTokens,
+  network: initialNetwork = 'base',
   isOwner,
   onManageGate 
 }: TokenGateTooltipProps) {
   const { address } = useAuth();
   const room = useRoomStore(state => state.room);
-  const version = useRoomStore(state => state.version); // Subscribe to version changes
+  const version = useRoomStore(state => state.version);
   const [showTooltip, setShowTooltip] = useState(false);
   const tooltipRef = useRef<HTMLDivElement>(null);
   const timeoutRef = useRef<number>();
@@ -28,9 +31,10 @@ export function TokenGateTooltip({
   // Use room store values, falling back to props
   const tokenAddress = room?.token_address ?? initialTokenAddress;
   const requiredTokens = room?.required_tokens ?? initialRequiredTokens;
+  const network = (room?.token_network ?? initialNetwork) as SupportedNetwork;
 
-  const { symbol, isLoading } = useTokenSymbol(tokenAddress);
-  const { hasAccess } = useTokenGate(tokenAddress, requiredTokens, address);
+  const { symbol, isLoading } = useTokenSymbol(tokenAddress, network);
+  const { hasAccess } = useTokenGate(tokenAddress, requiredTokens, address, network);
 
   // Debug logging
   useEffect(() => {
@@ -38,9 +42,10 @@ export function TokenGateTooltip({
       version,
       tokenAddress,
       requiredTokens,
+      network,
       roomState: room
     });
-  }, [version, tokenAddress, requiredTokens, room]);
+  }, [version, tokenAddress, requiredTokens, network, room]);
 
   useEffect(() => {
     return () => {
@@ -84,8 +89,12 @@ export function TokenGateTooltip({
     return null;
   }
 
-  const baseScanUrl = `https://basescan.org/token/${tokenAddress}`;
+  const explorerUrl = network === 'polygon' 
+    ? `https://polygonscan.com/token/${tokenAddress}`
+    : `https://basescan.org/token/${tokenAddress}`;
+  
   const tokenDisplay = isLoading ? '...' : symbol || 'tokens';
+  const networkDisplay = SUPPORTED_NETWORKS[network].name;
 
   return (
     <div 
@@ -112,13 +121,15 @@ export function TokenGateTooltip({
           <div className="text-sm text-gray-600">
             Required: {requiredTokens}{' '}
             <a 
-              href={baseScanUrl}
+              href={explorerUrl}
               target="_blank"
               rel="noopener noreferrer"
               className="text-indigo-600 hover:text-indigo-700"
             >
               {tokenDisplay}
             </a>
+            {' '}on{' '}
+            <span className="font-medium">{networkDisplay}</span>
           </div>
           {isOwner && onManageGate && (
             <button
diff --git a/src/lib/api/rooms.ts b/src/lib/api/rooms.ts
index f8cb40f9..1ccd1dd9 100644
--- a/src/lib/api/rooms.ts
+++ b/src/lib/api/rooms.ts
@@ -2,6 +2,7 @@ import { supabase } from '../auth/supabase';
 import { isAddress } from 'viem';
 import { getTokenOwner } from '../contracts/owner';
 import type { Database } from '../types/supabase';
+import type { SupportedNetwork } from '../config';
 
 type Room = Database['public']['Tables']['rooms']['Row'];
 
@@ -22,7 +23,8 @@ export async function getRoom(name: string): Promise<Room | null> {
 export async function upsertRoom(
   name: string, 
   ownerAddress: string | null, 
-  tokenAddress: string | null
+  tokenAddress: string | null,
+  network: SupportedNetwork = 'base'
 ): Promise<Room | null> {
   try {
     // Normalize room name to lowercase
@@ -35,14 +37,20 @@ export async function upsertRoom(
     // If no owner address is provided and room name is a contract address
     // try to get its owner
     if (!ownerAddress && isAddress(normalizedName)) {
-      const contractOwner = await getTokenOwner(normalizedName);
+      console.log(`Attempting to detect owner for token ${normalizedName} on ${network}`);
+      const contractOwner = await getTokenOwner(normalizedName, network);
+      
       if (contractOwner) {
+        console.log(`Found owner ${contractOwner} for token ${normalizedName} on ${network}`);
         ownerAddress = contractOwner;
+      } else {
+        console.log(`No owner found for token ${normalizedName} on ${network}`);
       }
     }
 
     // If we still don't have an owner address, return null to prompt for input
     if (!ownerAddress) {
+      console.log('No owner address found, will prompt for manual input');
       return null;
     }
 
@@ -53,6 +61,7 @@ export async function upsertRoom(
         name: normalizedName,
         owner_address: ownerAddress.toLowerCase(),
         token_address: tokenAddress,
+        token_network: isAddress(normalizedName) ? network : null,
         required_tokens: 0,
         use_contract_avatar: isAddress(normalizedName)
       })
@@ -87,6 +96,7 @@ export async function getPopularRooms(limit = 11): Promise<Room[]> {
         name,
         owner_address,
         token_address,
+        token_network,
         required_tokens,
         avatar_url,
         use_contract_avatar
diff --git a/src/lib/config.ts b/src/lib/config.ts
index ffc66889..026eb565 100644
--- a/src/lib/config.ts
+++ b/src/lib/config.ts
@@ -1,4 +1,12 @@
 import { GiphyFetch } from '@giphy/js-fetch-api';
+import { type Chain, base, polygon } from 'viem/chains';
+
+export const SUPPORTED_NETWORKS = {
+  base,
+  polygon
+} as const;
+
+export type SupportedNetwork = keyof typeof SUPPORTED_NETWORKS;
 
 export const config = {
   privyAppId: import.meta.env.VITE_PRIVY_APP_ID,
@@ -8,6 +16,11 @@ export const config = {
   supabaseAnonKey: import.meta.env.VITE_SUPABASE_ANON_KEY,
   etherscanApiKey: import.meta.env.VITE_ETHERSCAN_API_KEY,
   giphyApiKey: import.meta.env.VITE_GIPHY_API_KEY || 'your-api-key',
+  polygonscanApiKey: import.meta.env.VITE_POLYGONSCAN_API_KEY,
+  rpcEndpoints: {
+    base: `https://base-mainnet.g.alchemy.com/v2/${import.meta.env.VITE_ALCHEMY_API_KEY}`,
+    polygon: `https://polygon-mainnet.g.alchemy.com/v2/${import.meta.env.VITE_ALCHEMY_API_KEY}`,
+  },
 } as const;
 
 // Validate required environment variables
@@ -19,6 +32,7 @@ const requiredEnvVars = {
   VITE_SUPABASE_ANON_KEY: config.supabaseAnonKey,
   VITE_ETHERSCAN_API_KEY: config.etherscanApiKey,
   VITE_GIPHY_API_KEY: config.giphyApiKey,
+  VITE_POLYGONSCAN_API_KEY: config.polygonscanApiKey,
 } as const;
 
 Object.entries(requiredEnvVars).forEach(([key, value]) => {
diff --git a/src/lib/contracts/client.ts b/src/lib/contracts/client.ts
index bc827ff2..59161245 100644
--- a/src/lib/contracts/client.ts
+++ b/src/lib/contracts/client.ts
@@ -1,8 +1,22 @@
 import { createPublicClient, http } from 'viem';
-import { base } from 'viem/chains';
-import { config } from '../config';
+import { SUPPORTED_NETWORKS, config } from '../config';
 
-export const publicClient = createPublicClient({
-  chain: base,
-  transport: http(`https://base-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`),
-});
\ No newline at end of file
+// Create a public client for each supported network
+export const publicClients = Object.entries(SUPPORTED_NETWORKS).reduce((acc, [network, chain]) => {
+  acc[network] = createPublicClient({
+    chain,
+    transport: http(config.rpcEndpoints[network]),
+  });
+  return acc;
+}, {} as Record<keyof typeof SUPPORTED_NETWORKS, ReturnType<typeof createPublicClient>>);
+
+// Get the appropriate client for a given token address and network
+export function getClientForToken(tokenAddress: string, network?: keyof typeof SUPPORTED_NETWORKS) {
+  // If network is specified, use that client
+  if (network && network in publicClients) {
+    return publicClients[network];
+  }
+
+  // Default to Base network if not specified
+  return publicClients.base;
+}
\ No newline at end of file
diff --git a/src/lib/contracts/owner.ts b/src/lib/contracts/owner.ts
index a55611ff..a5d4cbb4 100644
--- a/src/lib/contracts/owner.ts
+++ b/src/lib/contracts/owner.ts
@@ -1,102 +1,101 @@
 import { createPublicClient, http, parseAbi } from 'viem';
-import { base } from 'viem/chains';
-import { config } from '../config';
+import { config, SUPPORTED_NETWORKS, type SupportedNetwork } from '../config';
 import { getContractCreator } from '../etherscan/client';
+import { publicClients } from './client';
 
-const publicClient = createPublicClient({
-  chain: base,
-  transport: http(`https://base-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`),
-});
-
-async function tryDeployer(address: string): Promise<string | null> {
+async function tryDeployer(address: string, network: SupportedNetwork): Promise<string | null> {
   try {
-    console.log('Attempting to read deployer() for:', address);
-    const result = await publicClient.readContract({
+    console.log(`[${network.toUpperCase()}] Attempting to read deployer() for: ${address}`);
+    const client = publicClients[network];
+    const result = await client.readContract({
       address: address as `0x${string}`,
       abi: parseAbi(['function deployer() view returns (address)']),
       functionName: 'deployer',
     });
     const deployerAddress = (result as string).toLowerCase();
-    console.log('Found deployer address:', deployerAddress);
+    console.log(`[${network.toUpperCase()}] Found deployer address:`, deployerAddress);
     return deployerAddress;
   } catch (error) {
-    console.log('No deployer function found:', error);
+    console.log(`[${network.toUpperCase()}] No deployer function found:`, error);
     return null;
   }
 }
 
-async function tryOwner(address: string): Promise<string | null> {
+async function tryOwner(address: string, network: SupportedNetwork): Promise<string | null> {
   try {
-    console.log('Attempting to read owner() for:', address);
-    const result = await publicClient.readContract({
+    console.log(`[${network.toUpperCase()}] Attempting to read owner() for: ${address}`);
+    const client = publicClients[network];
+    const result = await client.readContract({
       address: address as `0x${string}`,
       abi: parseAbi(['function owner() view returns (address)']),
       functionName: 'owner',
     });
     const ownerAddress = (result as string).toLowerCase();
-    console.log('Found owner address:', ownerAddress);
+    console.log(`[${network.toUpperCase()}] Found owner address:`, ownerAddress);
     return ownerAddress;
   } catch (error) {
-    console.log('No owner function found:', error);
+    console.log(`[${network.toUpperCase()}] No owner function found:`, error);
     return null;
   }
 }
 
-async function tryCreator(address: string): Promise<string | null> {
+async function tryCreator(address: string, network: SupportedNetwork): Promise<string | null> {
   try {
-    console.log('Attempting to read creator() for:', address);
-    const result = await publicClient.readContract({
+    console.log(`[${network.toUpperCase()}] Attempting to read creator() for: ${address}`);
+    const client = publicClients[network];
+    const result = await client.readContract({
       address: address as `0x${string}`,
       abi: parseAbi(['function creator() view returns (address)']),
       functionName: 'creator',
     });
     const creatorAddress = (result as string).toLowerCase();
-    console.log('Found creator address:', creatorAddress);
+    console.log(`[${network.toUpperCase()}] Found creator address:`, creatorAddress);
     return creatorAddress;
   } catch (error) {
-    console.log('No creator function found:', error);
+    console.log(`[${network.toUpperCase()}] No creator function found:`, error);
     return null;
   }
 }
 
-export async function getTokenOwner(tokenAddress: string): Promise<string | null> {
+export async function getTokenOwner(
+  tokenAddress: string, 
+  network: SupportedNetwork = 'base'
+): Promise<string | null> {
   const address = tokenAddress.toLowerCase();
-  console.log('Getting token owner for address:', address);
+  console.log(`[${network.toUpperCase()}] Getting token owner for address: ${address}`);
   
   try {
-    // 1. Try deployer()
-    const deployer = await tryDeployer(address);
+    // Try each method on the specified network
+    const deployer = await tryDeployer(address, network);
     if (deployer) {
-      console.log('Using deployer address:', deployer);
+      console.log(`[${network.toUpperCase()}] Using deployer address:`, deployer);
       return deployer;
     }
 
-    // 2. Try owner()
-    const owner = await tryOwner(address);
+    const owner = await tryOwner(address, network);
     if (owner) {
-      console.log('Using owner address:', owner);
+      console.log(`[${network.toUpperCase()}] Using owner address:`, owner);
       return owner;
     }
 
-    // 3. Try creator()
-    const creator = await tryCreator(address);
+    const creator = await tryCreator(address, network);
     if (creator) {
-      console.log('Using creator address:', creator);
+      console.log(`[${network.toUpperCase()}] Using creator address:`, creator);
       return creator;
     }
 
-    // 4. Fallback to Etherscan API
-    console.log('Attempting to get creator from Etherscan');
-    const etherscanCreator = await getContractCreator(address);
-    if (etherscanCreator) {
-      console.log('Using Etherscan creator address:', etherscanCreator);
-      return etherscanCreator;
+    // Fallback to explorer API
+    console.log(`[${network.toUpperCase()}] Attempting to get creator from explorer`);
+    const explorerCreator = await getContractCreator(address, network);
+    if (explorerCreator) {
+      console.log(`[${network.toUpperCase()}] Using explorer creator address:`, explorerCreator);
+      return explorerCreator;
     }
 
-    console.log('No owner found for token:', address);
+    console.log(`[${network.toUpperCase()}] No owner found for token:`, address);
     return null;
   } catch (error) {
-    console.error('Error getting token owner:', error);
+    console.error(`[${network.toUpperCase()}] Error getting token owner:`, error);
     throw new Error(`Failed to determine token owner: ${error instanceof Error ? error.message : 'Unknown error'}`);
   }
 }
\ No newline at end of file
diff --git a/src/lib/etherscan/client.ts b/src/lib/etherscan/client.ts
index f880d5ae..e688baef 100644
--- a/src/lib/etherscan/client.ts
+++ b/src/lib/etherscan/client.ts
@@ -1,8 +1,16 @@
-import { config } from '../config';
+import { config, type SupportedNetwork } from '../config';
 
-const ETHERSCAN_API_URL = 'https://api.basescan.org/api';
+const EXPLORER_URLS = {
+  base: 'https://api.basescan.org/api',
+  polygon: 'https://api.polygonscan.com/api',
+} as const;
 
-type EtherscanResponse = {
+const API_KEYS = {
+  base: config.etherscanApiKey,
+  polygon: config.polygonscanApiKey,
+} as const;
+
+type ExplorerResponse = {
   status: string;
   message: string;
   result: Array<{
@@ -11,22 +19,25 @@ type EtherscanResponse = {
   }>;
 };
 
-export async function getContractCreator(contractAddress: string): Promise<string | null> {
+export async function getContractCreator(
+  contractAddress: string,
+  network: SupportedNetwork = 'base'
+): Promise<string | null> {
   try {
-    console.log('Fetching contract creator from Etherscan for:', contractAddress);
+    console.log(`Fetching contract creator from ${network} explorer for:`, contractAddress);
     
     const response = await fetch(
-      `${ETHERSCAN_API_URL}?module=contract&action=getcontractcreation&contractaddresses=${contractAddress}&apikey=${config.etherscanApiKey}`
+      `${EXPLORER_URLS[network]}?module=contract&action=getcontractcreation&contractaddresses=${contractAddress}&apikey=${API_KEYS[network]}`
     );
 
     if (!response.ok) {
       const errorText = await response.text();
-      console.error('Etherscan API error:', errorText);
-      throw new Error(`Etherscan API request failed: ${response.status} ${response.statusText}`);
+      console.error(`${network} explorer API error:`, errorText);
+      throw new Error(`${network} explorer API request failed: ${response.status} ${response.statusText}`);
     }
 
-    const data: EtherscanResponse = await response.json();
-    console.log('Etherscan API response:', data);
+    const data: ExplorerResponse = await response.json();
+    console.log(`${network} explorer API response:`, data);
     
     if (data.status === '1' && data.result.length > 0) {
       const creatorAddress = data.result[0].contractCreator.toLowerCase();
@@ -35,14 +46,13 @@ export async function getContractCreator(contractAddress: string): Promise<strin
     }
 
     if (data.status === '0') {
-      console.warn('Etherscan API returned error:', data.message);
+      console.warn(`${network} explorer API returned error:`, data.message);
     }
 
     console.log('No contract creator found');
     return null;
   } catch (error) {
-    console.error('Error fetching contract creator from Etherscan:', error);
-    // Don't throw, return null to allow the calling code to handle the failure
+    console.error(`Error fetching contract creator from ${network} explorer:`, error);
     return null;
   }
 }
\ No newline at end of file
diff --git a/src/lib/hooks/useRoom.ts b/src/lib/hooks/useRoom.ts
index e9433cd3..8a95fe99 100644
--- a/src/lib/hooks/useRoom.ts
+++ b/src/lib/hooks/useRoom.ts
@@ -2,6 +2,7 @@ import { useEffect, useState } from 'react';
 import { upsertRoom } from '../api/rooms';
 import { isAddress } from 'viem';
 import type { Database } from '../types/supabase';
+import type { SupportedNetwork } from '../config';
 
 type Room = Database['public']['Tables']['rooms']['Row'];
 
@@ -29,11 +30,23 @@ export function useRoom(roomName: string | null, ownerAddress: string | null) {
         setError(null);
         
         // First try to get the room without creating it
-        const roomData = await upsertRoom(
-          roomName, 
-          ownerAddress, 
-          isAddress(roomName) ? roomName : null
-        );
+        let roomData = null;
+
+        // If it's a contract address, try both networks
+        if (isAddress(roomName) && !ownerAddress) {
+          // Try Polygon first
+          console.log('Attempting to detect owner on Polygon first');
+          roomData = await upsertRoom(roomName, null, roomName, 'polygon');
+          
+          // If no owner found on Polygon, try Base
+          if (!roomData) {
+            console.log('No owner found on Polygon, trying Base');
+            roomData = await upsertRoom(roomName, null, roomName, 'base');
+          }
+        } else {
+          // For non-contract rooms or when owner is provided
+          roomData = await upsertRoom(roomName, ownerAddress, null);
+        }
         
         if (!mounted) return;
 
diff --git a/src/lib/hooks/useTokenGate.ts b/src/lib/hooks/useTokenGate.ts
index fefa2221..90ad5f48 100644
--- a/src/lib/hooks/useTokenGate.ts
+++ b/src/lib/hooks/useTokenGate.ts
@@ -1,12 +1,7 @@
 import { useEffect, useState } from 'react';
-import { createPublicClient, http, formatUnits } from 'viem';
-import { base } from 'viem/chains';
-import { config } from '../config';
-
-const publicClient = createPublicClient({
-  chain: base,
-  transport: http(`https://base-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`),
-});
+import { formatUnits } from 'viem';
+import { type SupportedNetwork } from '../config';
+import { publicClients } from '../contracts/client';
 
 const erc20Abi = [
   {
@@ -25,48 +20,88 @@ const erc20Abi = [
   },
 ] as const;
 
-export function useTokenGate(tokenAddress: string | null, requiredTokens: number, userAddress: string | undefined) {
+export function useTokenGate(
+  tokenAddress: string | null, 
+  requiredTokens: number, 
+  userAddress: string | undefined,
+  network: SupportedNetwork = 'base'
+) {
   const [hasAccess, setHasAccess] = useState(false);
   const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
 
   useEffect(() => {
     if (!tokenAddress || !userAddress || requiredTokens <= 0) {
       setHasAccess(true);
       setIsLoading(false);
+      setError(null);
       return;
     }
 
+    let mounted = true;
+
     async function checkBalance() {
       try {
+        setIsLoading(true);
+        setError(null);
+
+        console.log(`Checking token balance on ${network} for:`, {
+          tokenAddress,
+          userAddress,
+          requiredTokens
+        });
+
+        const client = publicClients[network];
         const [balance, decimals] = await Promise.all([
-          publicClient.readContract({
+          client.readContract({
             address: tokenAddress as `0x${string}`,
             abi: erc20Abi,
             functionName: 'balanceOf',
             args: [userAddress as `0x${string}`],
           }),
-          publicClient.readContract({
+          client.readContract({
             address: tokenAddress as `0x${string}`,
             abi: erc20Abi,
             functionName: 'decimals',
           }),
         ]);
 
+        if (!mounted) return;
+
         // Format the balance to a decimal number considering token decimals
         const formattedBalance = Number(formatUnits(balance, decimals));
         
+        console.log(`Token balance on ${network}:`, {
+          rawBalance: balance.toString(),
+          decimals,
+          formattedBalance,
+          requiredTokens
+        });
+
         // Compare the formatted balance with required tokens
-        setHasAccess(formattedBalance >= requiredTokens);
-      } catch (error) {
-        console.error('Error checking token balance:', error);
+        const hasEnoughTokens = formattedBalance >= requiredTokens;
+        console.log(`Access check on ${network}:`, {
+          hasEnoughTokens,
+          formattedBalance,
+          requiredTokens
+        });
+
+        setHasAccess(hasEnoughTokens);
+        setError(null);
+      } catch (err) {
+        console.error(`Error checking token balance on ${network}:`, err);
+        setError(err instanceof Error ? err : new Error('Failed to check token balance'));
         setHasAccess(false);
       } finally {
-        setIsLoading(false);
+        if (mounted) {
+          setIsLoading(false);
+        }
       }
     }
 
     checkBalance();
-  }, [tokenAddress, requiredTokens, userAddress]);
+    return () => { mounted = false; };
+  }, [tokenAddress, requiredTokens, userAddress, network]);
 
-  return { hasAccess, isLoading };
+  return { hasAccess, isLoading, error };
 }
\ No newline at end of file
diff --git a/src/lib/hooks/useTokenSymbol.ts b/src/lib/hooks/useTokenSymbol.ts
index 6c8aa19c..a79a2ebf 100644
--- a/src/lib/hooks/useTokenSymbol.ts
+++ b/src/lib/hooks/useTokenSymbol.ts
@@ -1,22 +1,20 @@
 import { useEffect, useState } from 'react';
-import { createPublicClient, http } from 'viem';
-import { base } from 'viem/chains';
-import { config } from '../config';
+import { type SupportedNetwork } from '../config';
+import { publicClients } from '../contracts/client';
 
 const erc20Abi = [{
   constant: true,
   inputs: [],
   name: 'symbol',
+  type: 'function',
   outputs: [{ name: '', type: 'string' }],
   type: 'function',
 }] as const;
 
-const publicClient = createPublicClient({
-  chain: base,
-  transport: http(`https://base-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`),
-});
-
-export function useTokenSymbol(tokenAddress: string | null) {
+export function useTokenSymbol(
+  tokenAddress: string | null,
+  network: SupportedNetwork = 'base'
+) {
   const [symbol, setSymbol] = useState<string | null>(null);
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<Error | null>(null);
@@ -32,18 +30,21 @@ export function useTokenSymbol(tokenAddress: string | null) {
 
     async function fetchSymbol() {
       try {
-        const result = await publicClient.readContract({
+        console.log(`Fetching token symbol on ${network} for:`, tokenAddress);
+        const client = publicClients[network];
+        const result = await client.readContract({
           address: tokenAddress as `0x${string}`,
           abi: erc20Abi,
           functionName: 'symbol',
         });
         
         if (mounted) {
+          console.log(`Found symbol on ${network}:`, result);
           setSymbol(result);
           setError(null);
         }
       } catch (err) {
-        console.error('Error fetching token symbol:', err);
+        console.error(`Error fetching token symbol on ${network}:`, err);
         if (mounted) {
           setError(err instanceof Error ? err : new Error('Failed to fetch token symbol'));
           setSymbol(null);
@@ -57,7 +58,7 @@ export function useTokenSymbol(tokenAddress: string | null) {
 
     fetchSymbol();
     return () => { mounted = false; };
-  }, [tokenAddress]);
+  }, [tokenAddress, network]);
 
   return { symbol, isLoading, error };
 }
\ No newline at end of file
diff --git a/supabase/migrations/20250127204340_curly_rain.sql b/supabase/migrations/20250127204340_curly_rain.sql
new file mode 100644
index 00000000..423ce5ca
--- /dev/null
+++ b/supabase/migrations/20250127204340_curly_rain.sql
@@ -0,0 +1,44 @@
+/*
+  # Add token network support
+  
+  1. Changes
+    - Add `token_network` column to rooms table to track which network the token is on
+    - Default to 'base' for existing tokens
+    - Add check constraint to ensure valid networks
+  
+  2. Data Migration
+    - Set existing token gates to use Base network
+*/
+
+-- Add token_network column with check constraint
+ALTER TABLE rooms
+ADD COLUMN token_network text;
+
+-- Create an enum-like check constraint for network values
+ALTER TABLE rooms
+ADD CONSTRAINT valid_token_network
+CHECK (token_network IS NULL OR token_network IN ('base', 'polygon'));
+
+-- Set default network to 'base' for existing token gates
+UPDATE rooms 
+SET token_network = 'base' 
+WHERE token_address IS NOT NULL AND token_network IS NULL;
+
+-- Add trigger to ensure token_network is set when token_address is set
+CREATE OR REPLACE FUNCTION ensure_token_network()
+RETURNS trigger AS $$
+BEGIN
+  IF NEW.token_address IS NOT NULL AND NEW.token_network IS NULL THEN
+    NEW.token_network := 'base';
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER set_token_network
+BEFORE INSERT OR UPDATE ON rooms
+FOR EACH ROW
+EXECUTE FUNCTION ensure_token_network();
+
+-- Add comment explaining the column
+COMMENT ON COLUMN rooms.token_network IS 'The blockchain network where the token contract is deployed (base or polygon)';
\ No newline at end of file
diff --git a/supabase/migrations/20250127212954_wild_snowflake.sql b/supabase/migrations/20250127212954_wild_snowflake.sql
new file mode 100644
index 00000000..3dd893f5
--- /dev/null
+++ b/supabase/migrations/20250127212954_wild_snowflake.sql
@@ -0,0 +1,24 @@
+/*
+  # Convert owner addresses to lowercase
+
+  1. Changes
+    - Updates all existing room owner addresses to lowercase
+    - Ensures consistent case handling for owner addresses
+
+  2. Notes
+    - Safe migration that preserves data while normalizing case
+    - No data loss or structural changes
+*/
+
+-- Convert all existing owner addresses to lowercase
+UPDATE rooms
+SET owner_address = LOWER(owner_address)
+WHERE owner_address != LOWER(owner_address);
+
+-- Add a check constraint to ensure owner addresses are always lowercase
+ALTER TABLE rooms
+ADD CONSTRAINT owner_address_lowercase
+CHECK (owner_address = LOWER(owner_address));
+
+-- Add comment explaining the constraint
+COMMENT ON CONSTRAINT owner_address_lowercase ON rooms IS 'Ensures owner addresses are always stored in lowercase format';
\ No newline at end of file