#!/bin/bash
# Description: Search for deep recursion, large stack frames, or complex data structures
# that might necessitate the increased stack size

# Look for recursive function calls
echo "Searching for recursive functions..."
ast-grep --pattern 'fn $NAME($$$) {
  $$$
  $NAME($$$)
  $$$
}'

# Look for large struct definitions that might create large stack frames
echo "Searching for large struct definitions..."
rg -A 20 'struct \w+\s*\{' 

#!/bin/bash
# Let's try a different approach to find potential stack-heavy operations

# Look for recursive functions in Rust files only
echo "Searching for recursive functions in Rust files..."
rg -t rust "fn\s+(\w+)[^{]+\{[^}]*\1\s*\(" -A 5

# Look for large struct definitions in Rust files
echo "Searching for large struct definitions in Rust files..."
rg -t rust "struct\s+\w+\s*\{" -A 10

# Check test files that might require more stack
echo "Searching for test functions..."
rg -t rust "#\[test\]" -A 5

# Look for async recursive functions that might stack up
echo "Searching for async recursive functions..."
rg -t rust "async\s+fn\s+(\w+)[^{]+\{[^}]*\1\s*\(" -A 5

#!/bin/bash
# Let's look for evidence of stack-heavy operations and large data structures

# Search for recursive functions that might need stack space
echo "Searching for recursive functions..."
rg -t rust "fn\s+\w+.*\{[\s\S]*?\bself\b.*\}" -A 5

# Look for large arrays or buffers that might need stack space
echo "Searching for large static arrays or buffers..."
rg -t rust "(static|const).*\[[0-9]+\]" -A 2

# Look for test functions that might require more stack
echo "Searching for test functions with large allocations..."
rg -t rust "#\[test\].*fn.*\{[\s\S]*?(vec!\[|Vec::with_capacity)" -A 10

# Look for evidence of deep call stacks in async code
echo "Searching for nested async operations..."
rg -t rust "async\s+fn.*\{[\s\S]*?\.await.*\.await" -A 5

#!/bin/bash
# Let's look for evidence of deep recursion and large memory usage

# Search for recursive functions in test files
echo "Searching for recursive test functions..."
rg -t rust "fn\s+\w+.*\{.*\bself\b.*\}" tests/ -A 5

# Look for large memory allocations
echo "Searching for large memory allocations..."
rg -t rust "(Vec::with_capacity|alloc::alloc|Box::new)" -A 3

# Look for deep async call chains
echo "Searching for deep async call chains..."
rg -t rust "async\s+fn.*\{.*\.await.*\.await.*\.await" -A 5

# Look for test files that might be memory intensive
echo "Searching test files for memory usage..."
rg -t rust "#\[test\]" tests/ -A 10

#!/bin/bash
# Description: Search for deep recursion, large arrays/collections, or heavy stack usage patterns

# Check for recursive functions that might need larger stack
echo "Checking for recursive functions..."
ast-grep --pattern 'fn $NAME($$$) {
  $$$
  $NAME($$$)
  $$$
}'

# Check for large static arrays or collections
echo "Checking for large static arrays..."
rg -A 2 '\[\s*[^]]+\s*;\s*\d{4,}\s*\]'

# Look for stack overflow related issues or discussions
echo "Checking for stack-related comments/issues..."
rg -i "stack.*(overflow|size|limit|exceed)"

#!/bin/bash
# Let's try a different approach to check for potential stack-intensive patterns

# Look for deep recursion patterns in Rust files only
echo "Checking recursive patterns in Rust files..."
rg -t rust "fn\s+\w+.*\{" -A 10 | rg "(?s)fn\s+(\w+).*\{\n.*\b\1\b.*\("

# Check for stack-related configurations or comments in Rust
echo "Checking stack-related configurations..."
rg -t rust -i "(stack|heap).*(size|limit|overflow|exceed)"

# Look for large data structures or collections
echo "Checking for large data structures..."
rg -t rust "(Vec::with_capacity|vec!\[|HashMap::with_capacity)\s*\(\s*\d{4,}\s*\)"

# Check for explicit stack size configurations in build scripts
echo "Checking build configurations..."
fd -e toml -e nix -e sh | xargs rg -i "stack.*(size|limit)"

#!/bin/bash
# Let's check for stack-intensive operations and actual stack usage in Rust code

# Look for recursive functions and deep call stacks
echo "Checking for recursive patterns in Rust code..."
rg -t rust "fn.*\{" -A 5 | rg "(?m)^\s*(self\.)?\w+\s*\(\s*.*\)" -A 5

# Check for stack-related configurations in build files
echo "Checking stack configurations in build files..."
rg -t nix -t toml "stack.*size|RUST_MIN_STACK"

# Look for test files that might stress stack usage
echo "Checking test files for stack usage patterns..."
fd -e rs -t f "test" | xargs rg -l "test.*fn"

#!/bin/bash
# Description: Check for timeout-related error handling and configurations

# Look for timeout-related error handling
rg -A 3 "timeout|timed out" 

# Check for RPC-related configurations that might need timeout adjustments
rg -A 3 "request_timeout|http.*timeout"

#!/bin/bash
# Search for RPC timeout configurations and related code
rg -A 3 "Duration::from_secs\(30\)|Duration::from_secs\(5\)" chain/rpc/src/lib.rs

# Look for RPC-related error handling and timeout usage
rg -A 3 "eth_getLogs|timeout.*eth" chain/rpc/src/lib.rs

#!/bin/bash
# Search for HTTP timeout usage in RPC client implementations
rg -A 5 "http.*client.*timeout|request.*timeout" chain/

# Look for any RPC error handling related to timeouts
rg -A 3 "error.*timeout|timeout.*error" chain/

#!/bin/bash
# Check for any other consumers of get_block_number that might be affected
rg -A 3 "get_block_number|latest.*block" 

#!/bin/bash
# Search for HTTP timeout configuration
rg -l "timeout.*=.*30|DEFAULT_TIMEOUT"

#!/bin/bash
# Check ethers provider configuration for timeout settings
rg -A 5 -B 5 "timeout.*=.*30|DEFAULT_TIMEOUT" vendor/cargo/ethers-providers-2.0.14/src/rpc/transports/retry.rs

#!/bin/bash
# Look for HTTP client configuration in the chain crate
rg -A 5 -B 5 "timeout|eth_getLogs" chain/

#!/bin/bash
# Search for configuration structs or settings
ast-grep --pattern 'struct $name {
  $$$
  timeout: $_,
  $$$
}'

#!/bin/bash
# Description: Verify the block numbers returned by get_logs_block_numbers.

# Expect: Block numbers [1]
grep -rn 'get_logs_block_numbers' src/ | grep 'Some(1), Some(0)'

#!/bin/bash
# Let's first locate the correct file path since we're in the repository root
fd "logs.rs$"

# Then search for the function definition and its usage
rg -n "get_logs_block_numbers" -A 5

#!/bin/bash
# Let's examine the implementation and test context more thoroughly
rg -B 10 -A 20 "async fn get_logs_block_numbers" db/sql/src/logs.rs

#!/bin/bash
# Let's examine the full test context to understand the test setup and assertions
rg -B 20 -A 20 "test_get_logs_block_numbers" db/sql/src/logs.rs

#!/bin/bash
# Let's see the complete test case including all assertions
rg -B 50 -A 10 "assert_eq!\(block_numbers\[0\], 1\)" db/sql/src/logs.rs

#!/bin/bash
# Description: Verify that block_offset is handled correctly.

# Expect: The function retrieves logs for block_number 1 only.
grep -rn 'get_logs' src/ | grep 'Some(1), Some(0)'

#!/bin/bash
# Let's first locate the correct file path and then analyze the get_logs implementation
fd logs.rs

# After finding the file, let's examine the get_logs implementation
ast-grep --pattern 'fn get_logs($$$) {
  $$$
}'

#!/bin/bash
# Let's examine the get_logs implementation in the specific file
rg -A 20 "fn get_logs" "db/sql/src/logs.rs"

# Also check the test context around the specific test case
rg -B 5 -A 5 "get_logs\(Some\(1\), Some\(0\)\)" "db/sql/src/logs.rs"

#!/bin/bash
# Description: Check typical result set sizes for get_logs queries
# Look for query implementations and any size limits

# Search for get_logs implementations
ast-grep --pattern 'async fn get_logs($$$) { $$$}'

# Look for any LIMIT clauses in SQL queries
rg -i 'select.*from.*logs.*limit'

# Search for any pagination or batch size constants
rg -i '(page_size|batch_size|limit)'

#!/bin/bash
# Let's try a different approach to find implementations and size limits

# Find SQL implementation files
fd "logs.rs" --type f

# Look for implementations with different patterns
rg -A 10 "impl.*Logs" 

# Search for query implementations with potential LIMIT clauses
rg -A 10 "get_logs.*async"

# Look for any constants or configuration related to batch sizes
rg "(PAGE_SIZE|BATCH_SIZE|MAX_LOGS)"

#!/bin/bash
# Let's search for the SQL implementation and any query size limits
# Focus on the specific implementation files we found

# Check the SQL implementation
rg -A 20 "impl.*Logs.*for" db/sql/src/logs.rs

# Look for any query size limits or pagination in the implementation
rg -A 10 "get_logs" db/sql/src/logs.rs

# Check for any configuration or constants that might limit result sizes
rg "(limit|offset|batch|page)" db/sql/src/logs.rs

#!/bin/bash
# Description: Search for deep recursion or stack-intensive operations
# that might require increased stack size

# Look for recursive function calls
echo "Searching for recursive functions..."
ast-grep --pattern 'fn $NAME($$$) {
  $$$
  $NAME($$$)
  $$$
}'

# Look for deep async/await chains
echo "Searching for deep async/await chains..."
rg -A 5 '\.await'

# Look for test functions with complex operations
echo "Searching for complex test functions..."
ast-grep --pattern '#[test]
fn $NAME($$$) {
  $$$
}'

#!/bin/bash
# Let's try a different approach to find stack-intensive operations

# Look for test files and their content
echo "Searching for test files..."
fd -e rs "test" -x rg -l "^#\[test\]" {} \;

# Look for large data structures and complex types
echo "Searching for large structs/enums..."
rg -B 2 "^(struct|enum) \w+ \{" --type rust

# Look for deep nested async blocks
echo "Searching for nested async blocks..."
rg "async .*\{" --type rust -A 2

# Look for recursive type definitions
echo "Searching for recursive types..."
rg "type \w+(\s*=\s*.*self|where.*self)" --type rust

# Search for stack overflow related issues in git history
echo "Searching for stack overflow mentions in commits..."
git log --grep="stack" --grep="overflow" --oneline

#!/bin/bash
# Let's search for test files and test functions that might require large stack space

# Look for test files with complex operations or large data structures
echo "Searching for test files with potentially stack-intensive operations..."
rg -B 2 -A 2 "(#\[test\].*fn.*\{|struct.*\{|enum.*\{)" --type rust tests/

# Look for recursive function calls in test files
echo "Searching for recursive calls in test files..."
rg -l "fn.*\{" --type rust tests/ | xargs rg -A 5 "self\.\w+\(|rec\w*\("

# Look for test files that might deal with large data structures
echo "Searching for test files with large data structures..."
rg -B 2 -A 2 "Vec<|HashMap<|BTreeMap<" --type rust tests/

# Look for any explicit stack size configurations
echo "Searching for other stack size configurations..."
rg -i "stack.*size|RUST_MIN_STACK" --type nix --type rust

#!/bin/bash
# Let's look for evidence of stack-intensive operations in the codebase

# Search for test files that might require large stack space
echo "Searching for test files with deep recursion or large allocations..."
rg -A 5 "(fn.*test.*\{|#\[test\])" tests/ | rg -B 2 -A 5 "(Vec::with_capacity|recursion|stack|alloc)"

# Look for any stack overflow or stack size related issues in git history
echo "Searching for stack-related issues in git history..."
git log --oneline -S"stack" --pickaxe-regex -p

# Look for any stack size configurations in build files
echo "Searching for stack size configurations in build files..."
rg -i "(RUST_MIN_STACK|stack.*size)" --type make --type nix --type toml

# Look for any stack overflow prevention mechanisms
echo "Searching for stack overflow prevention code..."
rg "(recursion.*limit|stack.*overflow|STACK_SIZE)" --type rust

#!/bin/bash
# Description: Check for other timeout configurations that might need adjustment
# and verify that the new timeout is properly propagated to RPC clients

# Search for other timeout configurations
rg -i "timeout.*sec|duration.*sec"

# Search for HttpPostRequestorConfig usage to ensure proper propagation
ast-grep --pattern 'HttpPostRequestorConfig { $$ }'

#!/bin/bash
# Let's search for HttpPostRequestorConfig usage and timeout configurations in the codebase
# to verify the impact of the timeout change

# Search for HttpPostRequestorConfig usage
rg -A 5 "HttpPostRequestorConfig" 

# Search for timeout-related configurations in the RPC module
rg -A 5 "timeout|duration" chain/rpc/

#!/bin/bash
# Search for tests covering rapid head movement during sync
rg -A 5 "test.*sync.*progress" 
ast-grep --pattern 'fn $_(){ $$$head$$$progress$$$}'

#!/bin/bash
# Let's search for test files related to indexer and block processing
fd "test.*\.rs" chain/indexer/src/

# Then look for sync progress related code in indexer tests
rg -l "sync.*progress|progress.*sync" chain/indexer/src/

# Search for mock implementations that might simulate head movement
ast-grep --pattern 'mock!($$$)'

#!/bin/bash
# Let's examine the block processing logic more closely
rg -A 10 "update_chain_head" chain/indexer/src/block.rs

# Look for error handling around head updates
rg -A 5 "Error.*head|head.*Error" chain/indexer/src/block.rs

# Check how the sync state is managed
rg -A 5 "is_synced" chain/indexer/src/block.rs