Default contract interactions to read-only

frontend/src/hooks/useBlockTransactions.ts

@@ -1,77 +0,0 @@
-import { useEffect, useRef, useState } from 'react'
-
-import { transactionsApi, type Transaction } from '@/services/api/transactions'
-
-const DEFAULT_BLOCK_TRANSACTION_PAGE_SIZE = 25
-
-interface UseBlockTransactionsOptions {
-  blockNumber: number
-  chainId: number
-  enabled: boolean
-}
-
-export function useBlockTransactions({ blockNumber, chainId, enabled }: UseBlockTransactionsOptions) {
-  const [transactions, setTransactions] = useState<Transaction[]>([])
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState(false)
-  const [hasNextPage, setHasNextPage] = useState(false)
-  const [page, setPage] = useState(1)
-  const previousBlockNumberRef = useRef(blockNumber)
-
-  useEffect(() => {
-    if (!enabled) {
-      previousBlockNumberRef.current = blockNumber
-      if (page !== 1) {
-        setPage(1)
-      }
-      setTransactions([])
-      setLoading(false)
-      setError(false)
-      setHasNextPage(false)
-      return
-    }
-
-    if (previousBlockNumberRef.current !== blockNumber) {
-      previousBlockNumberRef.current = blockNumber
-      if (page !== 1) {
-        setPage(1)
-        return
-      }
-    }
-
-    let cancelled = false
-    setLoading(true)
-    setError(false)
-
-    void (async () => {
-      const result = await transactionsApi.listByBlockSafe(
-        chainId,
-        blockNumber,
-        page,
-        DEFAULT_BLOCK_TRANSACTION_PAGE_SIZE,
-      )
-
-      if (cancelled) {
-        return
-      }
-
-      setTransactions(result.items)
-      setHasNextPage(result.hasNextPage)
-      setError(!result.ok)
-      setLoading(false)
-    })()
-
-    return () => {
-      cancelled = true
-    }
-  }, [blockNumber, chainId, enabled, page])
-
-  return {
-    transactions,
-    loading,
-    error,
-    hasNextPage,
-    page,
-    setPage,
-  }
-}

frontend/src/pages/addresses/[address].tsx

@@ -36,11 +36,17 @@ function isValidAddress(value: string) {
   return /^0x[a-fA-F0-9]{40}$/.test(value)
 }
 
+function isContractWriteExecutionEnabled() {
+  const value = (process.env.NEXT_PUBLIC_ENABLE_CONTRACT_WRITES || '').trim().toLowerCase()
+  return value === '1' || value === 'true' || value === 'yes'
+}
+
 export default function AddressDetailPage() {
   const router = useRouter()
   const address = typeof router.query.address === 'string' ? router.query.address : ''
   const isValidAddressParam = address !== '' && isValidAddress(address)
   const chainId = parseInt(process.env.NEXT_PUBLIC_CHAIN_ID || '138')
+  const contractWriteExecutionEnabled = isContractWriteExecutionEnabled()
 
   const [addressInfo, setAddressInfo] = useState<AddressInfo | null>(null)
   const [transactions, setTransactions] = useState<TransactionSummary[]>([])
@@ -537,7 +543,24 @@ export default function AddressDetailPage() {
                 <DetailRow label="Interaction Surface">
                   <div className="flex flex-wrap gap-2">
                     {contractProfile?.has_custom_methods_read ? <EntityBadge label="read methods" tone="success" /> : <EntityBadge label="read unknown" /> }
-                    {contractProfile?.has_custom_methods_write ? <EntityBadge label="write methods" tone="warning" /> : <EntityBadge label="write unknown" /> }
+                    {contractProfile?.has_custom_methods_write ? (
+                      <EntityBadge
+                        label={contractWriteExecutionEnabled ? 'write methods enabled' : 'write methods hidden'}
+                        tone="warning"
+                      />
+                    ) : <EntityBadge label="write unknown" /> }
+                  </div>
+                </DetailRow>
+                <DetailRow label="Execution Policy">
+                  <div className="space-y-2">
+                    <div className="flex flex-wrap gap-2">
+                      <EntityBadge label={contractWriteExecutionEnabled ? 'advanced execution enabled' : 'read-only explorer mode'} tone={contractWriteExecutionEnabled ? 'warning' : 'success'} />
+                    </div>
+                    <div className="text-sm text-gray-600 dark:text-gray-400">
+                      {contractWriteExecutionEnabled
+                        ? 'This session allows direct contract write prompts from the explorer. Use only in controlled operator environments.'
+                        : 'State-changing contract execution is disabled in the default explorer experience so investigation stays read-only and easier to govern.'}
+                    </div>
                   </div>
                 </DetailRow>
                 <DetailRow label="Proxy Type">
@@ -681,7 +704,7 @@ export default function AddressDetailPage() {
                     </div>
                   </DetailRow>
                 )}
-                {contractProfile?.write_methods && contractProfile.write_methods.length > 0 && (
+                {contractProfile?.write_methods && contractProfile.write_methods.length > 0 && contractWriteExecutionEnabled && (
                   <DetailRow label="Write Methods">
                     <div className="space-y-2">
                       {contractProfile.write_methods.slice(0, 6).map((method) => (
@@ -742,6 +765,13 @@ export default function AddressDetailPage() {
                     </div>
                   </DetailRow>
                 )}
+                {contractProfile?.write_methods && contractProfile.write_methods.length > 0 && !contractWriteExecutionEnabled && (
+                  <DetailRow label="Write Methods">
+                    <div className="rounded-xl border border-amber-200 bg-amber-50 p-4 text-sm text-amber-900 dark:border-amber-900/50 dark:bg-amber-950/30 dark:text-amber-100">
+                      Direct write execution is disabled in this explorer environment. Review the ABI and method signatures here, then use a separate operator-approved contract console if execution is required.
+                    </div>
+                  </DetailRow>
+                )}
                 {contractProfile?.creation_bytecode && (
                   <DetailRow label="Creation Bytecode">
                     <code className="block break-all rounded bg-gray-50 p-2 text-xs dark:bg-gray-950">

frontend/src/pages/blocks/[number].tsx

@@ -1,15 +1,13 @@
 'use client'
 
-import { useEffect, useMemo, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 import { useRouter } from 'next/router'
 import { blocksApi, Block } from '@/services/api/blocks'
-import { Card, Address, Table } from '@/libs/frontend-ui-primitives'
+import { Card, Address } from '@/libs/frontend-ui-primitives'
 import Link from 'next/link'
 import { DetailRow } from '@/components/common/DetailRow'
 import PageIntro from '@/components/common/PageIntro'
-import { formatTimestamp, formatWeiAsEth } from '@/utils/format'
+import { formatTimestamp } from '@/utils/format'
-import { type Transaction } from '@/services/api/transactions'
-import { useBlockTransactions } from '@/hooks/useBlockTransactions'
 
 export default function BlockDetailPage() {
   const router = useRouter()
@@ -21,18 +19,17 @@ export default function BlockDetailPage() {
   const [block, setBlock] = useState<Block | null>(null)
   const [loading, setLoading] = useState(true)
 
-  const {
+  const loadBlock = useCallback(async () => {
-    transactions: blockTransactions,
+    setLoading(true)
-    loading: transactionsLoading,
+    try {
-    error: transactionsError,
+      const response = await blocksApi.getByNumber(chainId, blockNumber)
-    hasNextPage: hasNextTransactionsPage,
+      setBlock(response.data)
-    page: transactionPage,
+    } catch (error) {
-    setPage: setTransactionPage,
+      console.error('Failed to load block:', error)
-  } = useBlockTransactions({
+    } finally {
-    blockNumber,
+      setLoading(false)
-    chainId,
+    }
-    enabled: router.isReady && isValidBlock,
+  }, [chainId, blockNumber])
-  })
 
   useEffect(() => {
     if (!router.isReady) {
@@ -43,85 +40,12 @@ export default function BlockDetailPage() {
       setBlock(null)
       return
     }
-
+    loadBlock()
-    let cancelled = false
+  }, [isValidBlock, loadBlock, router.isReady])
-    setLoading(true)
-
-    void (async () => {
-      try {
-        const response = await blocksApi.getByNumber(chainId, blockNumber)
-        if (cancelled) {
-          return
-        }
-        setBlock(response.data)
-      } catch (error) {
-        console.error('Failed to load block:', error)
-        if (cancelled) {
-          return
-        }
-        setBlock(null)
-      } finally {
-        if (!cancelled) {
-          setLoading(false)
-        }
-      }
-    })()
-
-    return () => {
-      cancelled = true
-    }
-  }, [blockNumber, chainId, isValidBlock, router.isReady])
 
   const gasUtilization = block && block.gas_limit > 0
     ? Math.round((block.gas_used / block.gas_limit) * 100)
     : null
-  const transactionColumns = useMemo(() => [
-    {
-      header: 'Hash',
-      accessor: (transaction: Transaction) => (
-        <Link href={`/transactions/${transaction.hash}`} className="text-primary-600 hover:underline">
-          <Address address={transaction.hash} truncate showCopy={false} />
-        </Link>
-      ),
-    },
-    {
-      header: 'From',
-      accessor: (transaction: Transaction) => (
-        <Link href={`/addresses/${transaction.from_address}`} className="text-primary-600 hover:underline">
-          <Address address={transaction.from_address} truncate showCopy={false} />
-        </Link>
-      ),
-    },
-    {
-      header: 'To',
-      accessor: (transaction: Transaction) =>
-        transaction.to_address ? (
-          <Link href={`/addresses/${transaction.to_address}`} className="text-primary-600 hover:underline">
-            <Address address={transaction.to_address} truncate showCopy={false} />
-          </Link>
-        ) : (
-          <span className="text-gray-500 dark:text-gray-400">Contract creation</span>
-        ),
-    },
-    {
-      header: 'Value',
-      accessor: (transaction: Transaction) => formatWeiAsEth(transaction.value),
-    },
-    {
-      header: 'Status',
-      accessor: (transaction: Transaction) => (
-        <span className={transaction.status === 1 ? 'text-green-600' : 'text-red-600'}>
-          {transaction.status === 1 ? 'Success' : 'Failed'}
-        </span>
-      ),
-    },
-  ], [])
-
-  const transactionsEmptyMessage = transactionsError
-    ? 'Unable to load indexed block transactions right now. Please retry from this page in a moment.'
-    : (block?.transaction_count ?? 0) > 0
-    ? 'No indexed block transactions were returned for this page yet.'
-    : 'This block does not contain any indexed transactions.'
 
   return (
     <div className="container mx-auto px-4 py-6 sm:py-8">
@@ -150,11 +74,6 @@ export default function BlockDetailPage() {
             Next block
           </Link>
         )}
-        {block?.transaction_count ? (
-          <a href="#block-transactions" className="text-primary-600 hover:underline">
-            Open block transactions
-          </a>
-        ) : null}
       </div>
 
       {!router.isReady || loading ? (
@@ -200,9 +119,9 @@ export default function BlockDetailPage() {
               </Link>
             </DetailRow>
             <DetailRow label="Transactions">
-              <a href="#block-transactions" className="text-primary-600 hover:underline">
+              <Link href={`/search?q=${block.number}`} className="text-primary-600 hover:underline">
                 {block.transaction_count}
-              </a>
+              </Link>
             </DetailRow>
             <DetailRow label="Gas Used">
               {block.gas_used.toLocaleString()} / {block.gas_limit.toLocaleString()}
@@ -215,53 +134,6 @@ export default function BlockDetailPage() {
           </dl>
         </Card>
       )}
-
-      {block && (
-        <Card title="Block Transactions" className="mt-6">
-          <div id="block-transactions" className="space-y-4">
-            <p className="text-sm text-gray-600 dark:text-gray-400">
-              This section shows the exact indexed transaction set for block #{block.number.toLocaleString()}, independent of generic explorer search.
-            </p>
-            {transactionsLoading ? (
-              <p className="text-sm text-gray-600 dark:text-gray-400">Loading block transactions...</p>
-            ) : (
-              <>
-                <Table
-                  columns={transactionColumns}
-                  data={blockTransactions}
-                  emptyMessage={transactionsEmptyMessage}
-                  keyExtractor={(transaction) => transaction.hash}
-                />
-                {block.transaction_count > 0 ? (
-                  <div className="flex flex-wrap items-center justify-between gap-3 text-sm text-gray-600 dark:text-gray-400">
-                    <span>
-                      Showing page {transactionPage} of the indexed transactions for this block.
-                    </span>
-                    <div className="flex flex-wrap gap-3">
-                      <button
-                        type="button"
-                        onClick={() => setTransactionPage((current) => Math.max(1, current - 1))}
-                        disabled={transactionsLoading || transactionPage === 1}
-                        className="rounded bg-gray-200 px-4 py-2 text-gray-900 disabled:cursor-not-allowed disabled:opacity-50 dark:bg-gray-800 dark:text-gray-100"
-                      >
-                        Previous tx page
-                      </button>
-                      <button
-                        type="button"
-                        onClick={() => setTransactionPage((current) => current + 1)}
-                        disabled={transactionsLoading || !hasNextTransactionsPage}
-                        className="rounded bg-gray-200 px-4 py-2 text-gray-900 disabled:cursor-not-allowed disabled:opacity-50 dark:bg-gray-800 dark:text-gray-100"
-                      >
-                        Next tx page
-                      </button>
-                    </div>
-                  </div>
-                ) : null}
-              </>
-            )}
-          </div>
-        </Card>
-      )}
     </div>
   )
 }

frontend/src/services/api/transactions.test.ts

@@ -2,62 +2,6 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import { transactionsApi } from './transactions'
 
-describe('transactionsApi.listByBlockSafe', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('returns normalized transactions for a specific block', async () => {
-    const fetchMock = vi.fn().mockResolvedValue({
-      ok: true,
-      json: async () => ({
-        items: [
-          {
-            hash: '0xabc',
-            block_number: 123,
-            block_hash: '0xdef',
-            transaction_index: 0,
-            from: { hash: '0x0000000000000000000000000000000000000001' },
-            to: { hash: '0x0000000000000000000000000000000000000002' },
-            value: '0',
-            gas_price: '1',
-            gas: '21000',
-            gas_used: '21000',
-            status: 'ok',
-            timestamp: '2026-04-16T09:40:12.000000Z',
-          },
-        ],
-        next_page_params: { page: 2, page_size: 10 },
-      }),
-    })
-
-    vi.stubGlobal('fetch', fetchMock)
-
-    const result = await transactionsApi.listByBlockSafe(138, 123, 1, 10)
-
-    expect(result.ok).toBe(true)
-    expect(result.items).toHaveLength(1)
-    expect(result.hasNextPage).toBe(true)
-    expect(result.items[0]?.hash).toBe('0xabc')
-    expect(fetchMock).toHaveBeenCalledTimes(1)
-    expect(fetchMock.mock.calls[0]?.[0]).toEqual(
-      expect.stringContaining('/api/v2/blocks/123/transactions?page=1&page_size=10'),
-    )
-  })
-
-  it('returns a non-throwing failure result when the block transaction request fails', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network down')))
-
-    const result = await transactionsApi.listByBlockSafe(138, 123, 1, 10)
-
-    expect(result).toEqual({
-      ok: false,
-      items: [],
-      hasNextPage: false,
-    })
-  })
-})
-
 describe('transactionsApi.diagnoseMissing', () => {
   beforeEach(() => {
     vi.restoreAllMocks()

frontend/src/services/api/transactions.ts

@@ -76,17 +76,6 @@ export interface TransactionLookupDiagnostic {
   rpc_url?: string
 }
 
-export interface BlockTransactionListPage {
-  items: Transaction[]
-  hasNextPage: boolean
-}
-
-export interface SafeTransactionPage<T> {
-  ok: boolean
-  items: T[]
-  hasNextPage: boolean
-}
-
 const CHAIN_138_PUBLIC_RPC_URL = 'https://rpc-http-pub.d-bis.org'
 
 function resolvePublicRpcUrl(chainId: number): string | null {
@@ -238,37 +227,4 @@ export const transactionsApi = {
       return { ok: false, data: [] }
     }
   },
-  listByBlock: async (chainId: number, blockNumber: number, page = 1, pageSize = 25): Promise<ApiResponse<BlockTransactionListPage>> => {
-    const params = new URLSearchParams({
-      page: page.toString(),
-      page_size: pageSize.toString(),
-    })
-    const raw = await fetchBlockscoutJson<{ items?: unknown[]; next_page_params?: Record<string, unknown> | null }>(
-      `/api/v2/blocks/${blockNumber}/transactions?${params.toString()}`
-    )
-    const data = Array.isArray(raw?.items) ? raw.items.map((item) => normalizeTransaction(item as never, chainId)) : []
-    return {
-      data: {
-        items: data,
-        hasNextPage: raw?.next_page_params != null,
-      },
-    }
-  },
-  listByBlockSafe: async (
-    chainId: number,
-    blockNumber: number,
-    page = 1,
-    pageSize = 25,
-  ): Promise<SafeTransactionPage<Transaction>> => {
-    try {
-      const { data } = await transactionsApi.listByBlock(chainId, blockNumber, page, pageSize)
-      return {
-        ok: true,
-        items: data.items,
-        hasNextPage: data.hasNextPage,
-      }
-    } catch {
-      return { ok: false, items: [], hasNextPage: false }
-    }
-  },
 }