internal/tools/clickhouse/0012_clickhouse_create_address_transfers.sql (1)

26-45: Add projection keyed by (token_type, chain_id, address, token_id)

Per prior preference, optimize for queries at (token_type, chain_id, address, token_id).

From learnings (#240).

     PROJECTION address_state_projection (
@@
     ),
+    PROJECTION address_token_state_projection (
+        SELECT
+            token_type,
+            chain_id,
+            address,
+            token_id,
+            token_address,
+            count() AS transfer_count,
+            sum(toDecimal256(amount, 0)) AS total_amount,
+            min(block_number) AS min_block_number,
+            min(block_timestamp) AS min_block_timestamp,
+            max(block_number) AS max_block_number,
+            max(block_timestamp) AS max_block_timestamp
+        GROUP BY
+            token_type,
+            chain_id,
+            address,
+            token_id,
+            token_address
+    )

internal/tools/clickhouse/0004_clickhouse_create_insert_null_table.sql (1)

97-99: Consider DateTime64 for higher precision on ingestion timestamps.

If you dedupe/order on insert_timestamp, millisecond precision helps during bursts.

-    insert_timestamp DateTime DEFAULT now(),
+    insert_timestamp DateTime64(3) DEFAULT now(),

internal/tools/clickhouse/0000_clickhouse_create_blocks_table.sql (1)

31-44: Add ORDER BY inside the aggregate projection for better pruning.

Explicit ORDER BY on group keys can improve projection read efficiency.

     PROJECTION chain_state_projection
     (
         SELECT
           chain_id,
           count() AS count,
           uniqExact(block_number) AS unique_block_count,
           min(block_number) AS min_block_number,
           min(block_timestamp) AS min_block_timestamp,
           max(block_number) AS max_block_number,
           max(block_timestamp) AS max_block_timestamp
         GROUP BY
           chain_id
+        ORDER BY
+          chain_id
     )

internal/tools/clickhouse/0001_clickhouse_create_transactions_table.sql (1)

9-11: to_address may be null for contract creations.

If upstream normalizes to zero-address it’s fine; otherwise consider Nullable(FixedString(42)) for fidelity with EVM semantics.

internal/tools/clickhouse/0011_clickhouse_create_address_transactions_mv.sql (1)

39-44: Propagating insert_timestamp/is_deleted is good; consider DateTime64 upstream.

If you adopt DateTime64 in sources, mirror it here automatically.

internal/tools/clickhouse/0002_clickhouse_create_logs_table.sql (1)

28-39: Projections: include minimal identifiers to avoid extra lookups when possible

Current projections only select _part_offset. If frequent queries need address/topic_0 plus block pointers without fetching base columns, add them here to reduce reads.

Example:

-        SELECT
-            _part_offset
+        SELECT
+            _part_offset, address, topic_0

Validate against your workload before adopting.

internal/tools/clickhouse/0010_clickhouse_create_address_transactions.sql (1)

45-59: Add per-direction address projection (address + address_type)

You have totals by address; many queries also slice by direction.

     PROJECTION address_total_count_projection
     (
         SELECT
           chain_id,
           address,
           count() AS tx_count,
           uniqExact(hash) AS unique_tx_count,
           min(block_number) AS min_block_number,
           min(block_timestamp) AS min_block_timestamp,
           max(block_number) AS max_block_number,
           max(block_timestamp) AS max_block_timestamp
         GROUP BY
           chain_id,
           address
     )
+    ,
+    PROJECTION address_direction_count_projection
+    (
+        SELECT
+          chain_id,
+          address,
+          address_type,
+          count() AS tx_count,
+          uniqExact(hash) AS unique_tx_count,
+          min(block_number) AS min_block_number,
+          min(block_timestamp) AS min_block_timestamp,
+          max(block_number) AS max_block_number,
+          max(block_timestamp) AS max_block_timestamp
+        GROUP BY
+          chain_id,
+          address,
+          address_type
+    )

internal/tools/clickhouse/0006_clickhouse_create_token_transfers.sql (1)

5-8: Normalize addresses to lower case at write-time for consistency.

Downstream queries/indexes benefit from canonical casing.

Example:

-`token_address` FixedString(42),
-`from_address` FixedString(42),
-`to_address` FixedString(42),
+`token_address` FixedString(42),
+`from_address` FixedString(42),
+`to_address` FixedString(42),

-- in MVs (0007), wrap with lower()

Also applies to: 11-13, 20-23

internal/tools/clickhouse/0008_clickhouse_create_token_balances.sql (2)

27-40: Consider adding final aggregate projections with MaterializedAggregateFunctions for fast reads.

You’re storing State columns; ensure there are complementary projections with ...Merge() for ready-to-read aggregates if queries expect finalized values.

Also applies to: 42-55

---

14-14: Use same timestamp codec as transfers for compression/scan efficiency.

Keep codecs consistent across sinks/sources.

-`block_timestamp` DateTime,
+`block_timestamp` DateTime CODEC(Delta(4), ZSTD(1)),

internal/tools/clickhouse/0007_clickhouse_create_token_transfers_mv.sql (2)

43-46: Explicitly cast ERC721 amount to UInt256.

Avoid implicit widening.

-  toUInt8(1) AS amount,
+  toUInt256(1) AS amount,

---

158-158: Use '=' instead of '==' for SQL equality.

For portability and consistency.

-  AND length(data) == 2 + 128;
+  AND length(data) = 2 + 128;

internal/tools/clickhouse/0009_clickhouse_create_token_balances_mv.sql (1)

53-61: Cast ERC721 deltas to Int256 to match sink type.

Prevents implicit casts and keeps types uniform.

-  -1 AS balance_delta,
+  -toInt256(1) AS balance_delta,
...
-  1 AS balance_delta,
+  toInt256(1) AS balance_delta,

Also applies to: 66-71

internal/tools/clickhouse_opts/0000_clickhouse_backfill_logs_transfer.sql (2)

145-168: Normalize equality operator and casing; keep rules consistent with realtime MVs.

• Use = instead of ==.
• Consider lower-casing across all token types or none (6909 currently differs).

-  AND length(data) == 2 + 128;
+  AND length(data) = 2 + 128;

Also either add lower() for ERC20/721/1155 addresses or remove it here for consistency.

---

171-201: Dangerous commented instructions: wrong table names.

token_balance/token_balance_* don’t exist in this PR; could mislead ops.

--- DROP TABLE token_transfers, token_balance;
+-- DROP TABLE token_transfers, token_balances;
--- DROP TABLE bf__token_transfers_erc20_mv, bf__token_transfers_erc721_mv, bf__token_transfers_erc1155_mv, bf__token_transfers_erc6909_mv;
+-- DROP TABLE bf__token_transfers_erc20_mv, bf__token_transfers_erc721_mv, bf__token_transfers_erc1155_single_mv, bf__token_transfers_erc1155_batch_mv, bf__token_transfers_erc6909_mv;
--- DROP TABLE token_transfers_erc20_mv, token_transfers_erc721_mv, token_transfers_erc1155_mv, token_transfers_erc6909_mv;
+-- DROP TABLE token_transfers_erc20_mv, token_transfers_erc721_mv, token_transfers_erc1155_single_mv, token_transfers_erc1155_batch_mv, token_transfers_erc6909_mv;
--- DROP TABLE token_balance_erc20_mv, token_balance_erc721_mv, token_balance_erc1155_mv, token_balance_erc6909_mv;
+-- DROP TABLE token_balances_erc20_mv, token_balances_erc721_mv, token_balances_erc1155_mv, token_balances_erc6909_mv;

test/mocks/MockIRPCClient.go (1)

1-1: Pin mock generator to avoid churn across environments.
Recommend adding a pinned mockery invocation (go:generate or Makefile) to keep versions consistent in CI/dev.

internal/handlers/logs_handlers.go (1)

206-213: Minor readability: avoid shadowing logger with variable named 'log'.
Renaming loop var prevents confusion with zerolog’s log.

-    for _, log := range logs {
-      decodedLog := log.Decode(eventABI)
+    for _, lg := range logs {
+      decodedLog := lg.Decode(eventABI)
       if decodedLog.Decoded.Name == "" || decodedLog.Decoded.Signature == "" {
         decodingCompletelySuccessful = false
       }
       decodedLogs = append(decodedLogs, decodedLog)
     }

configs/config.go (1)

328-333: Reduce duplicate logging of chain config.
Interface()+Msgf duplicates the payload; prefer structured + Msg.

-    log.Debug().
-      Interface("chainConfig", clickhouse.ChainBasedConfig).
-      Msgf("Loaded chain config %v", clickhouse.ChainBasedConfig)
+    log.Debug().
+      Interface("chainConfig", clickhouse.ChainBasedConfig).
+      Msg("Loaded chain config")

cmd/orchestrator.go (2)

36-43: Treat http.ErrServerClosed as benign for metrics server.
Avoid noisy error logs during graceful shutdown.

+   // Start Prometheus metrics server
    log.Info().Msg("Starting Metrics Server on port 2112")
    go func() {
        http.Handle("/metrics", promhttp.Handler())
-       if err := http.ListenAndServe(":2112", nil); err != nil {
-           log.Error().Err(err).Msg("Metrics server error")
-       }
+       if err := http.ListenAndServe(":2112", nil); err != nil && err != http.ErrServerClosed {
+           log.Error().Err(err).Msg("Metrics server error")
+       }
    }()

---

26-34: Avoid package-name shadowing for rpc and orchestrator vars.
Reduces confusion and accidental misuse.

-   rpc, err := rpc.Initialize()
+   rpcClient, err := rpc.Initialize()
    if err != nil {
        log.Fatal().Err(err).Msg("Failed to initialize RPC")
    }

-   orchestrator, err := orchestrator.NewOrchestrator(rpc)
+   orch, err := orchestrator.NewOrchestrator(rpcClient)
    if err != nil {
        log.Fatal().Err(err).Msg("Failed to create orchestrator")
    }
...
-   orchestrator.Start()
+   orch.Start()

internal/publisher/publisher.go (1)

74-79: Warn when using SASL/PLAIN without TLS

SASL PLAIN over plaintext exposes credentials. Emit a warning when TLS is disabled.

  if config.Cfg.Publisher.Username != "" && config.Cfg.Publisher.Password != "" {
     opts = append(opts, kgo.SASL(plain.Auth{
       User: config.Cfg.Publisher.Username,
       Pass: config.Cfg.Publisher.Password,
     }.AsMechanism()))
+    if !config.Cfg.Publisher.EnableTLS {
+      log.Warn().Msg("Kafka SASL/PLAIN configured without TLS; credentials may be exposed on the wire")
+    }
   }

internal/orchestrator/failure_recoverer.go (1)

125-133: Skip no-op writes when there’s nothing to store/delete

Avoid unnecessary DB calls when slices are empty.

-  if err := fr.storage.StagingStorage.StoreBlockFailures(newBlockFailures); err != nil {
+  if len(newBlockFailures) > 0 {
+    if err := fr.storage.StagingStorage.StoreBlockFailures(newBlockFailures); err != nil {
       log.Error().Err(err).Msg("Error storing block failures")
       return
-  }
-  if err := fr.storage.StagingStorage.DeleteBlockFailures(failuresToDelete); err != nil {
+    }
+  }
+  if len(failuresToDelete) > 0 {
+    if err := fr.storage.StagingStorage.DeleteBlockFailures(failuresToDelete); err != nil {
       log.Error().Err(err).Msg("Error deleting block failures")
       return
-  }
+    }
+  }

internal/source/source.go (1)

10-14: Go naming: drop the “I” prefix; consider io.Closer

Idiomatic Go prefers “Source” over “ISource”. Also consider embedding io.Closer or returning error from Close() if teardown can fail.

-type ISource interface {
+type Source interface {
   GetFullBlocks(ctx context.Context, blockNumbers []*big.Int) []rpc.GetFullBlockResult
   GetSupportedBlockRange(ctx context.Context) (minBlockNumber *big.Int, maxBlockNumber *big.Int, err error)
-  Close()
+  Close()
 }

internal/orchestrator/committer_test.go (2)

350-351: Prefer assert.Eventually over manual select+timeout

Reduces flakiness and boilerplate.

-  select {
-  case <-deleteDone:
-  case <-time.After(2 * time.Second):
-    t.Fatal("DeleteStagingDataOlderThan was not called within timeout period")
-  }
+  assert.Eventually(t, func() bool {
+    select {
+    case <-deleteDone:
+      return true
+    default:
+      return false
+    }
+  }, 2*time.Second, 10*time.Millisecond)

---

429-429: Nit: comment clarifies expectations

The note about GetChainID being unused here helps future readers of the mock expectations.

internal/common/block.go (1)

103-120: Normalize nil slices: good; ensure callers use it where JSON is persisted.

Consider calling BlockData.Serialize() before persisting to staging/S3 to avoid null arrays leaking into stored JSON.

cmd/root.go (3)

69-70: Doc/default mismatch for poller-s3-maxCacheSize.

Help text says “default 5GB” but default is 0. Either update the text or set 5GB as default.

-rootCmd.PersistentFlags().Int64("poller-s3-maxCacheSize", 0, "Max cache size in bytes for poller archive source (default 5GB)")
+rootCmd.PersistentFlags().Int64("poller-s3-maxCacheSize", int64(5)*1024*1024*1024, "Max cache size in bytes for poller archive source (default 5GB)")

---

152-152: Nit: typo in Redis password flag description.

“orchestator” ➜ “orchestrator”; remove double space.

-rootCmd.PersistentFlags().String("storage-orchestrator-redis-password", "", "Redis password for orchestator storage  metadata")
+rootCmd.PersistentFlags().String("storage-orchestrator-redis-password", "", "Redis password for orchestrator storage metadata")

---

146-149: Standardize TLS flags to kebab-case -enable-tls.
Rename the two camelCase flags and their BindPFlag lookups in cmd/root.go:

• storage-orchestrator-redis-enableTLS → storage-orchestrator-redis-enable-tls
• migrator-destination-kafka-enableTLS → migrator-destination-kafka-enable-tls

Ensure you update the corresponding rootCmd.PersistentFlags().Bool(...) calls and the .Lookup(...) arguments in viper.BindPFlag.

internal/storage/postgres.go (1)

463-473: Confirm boundary semantics for DeleteStagingDataOlderThan.

Name suggests strictly “older than”, but query uses “<=” which also deletes the boundary block. If unintended, switch to “<”.

- AND block_number <= $2
+ AND block_number < $2

internal/storage/block_buffer_badger_test.go (1)

53-55: Compare big.Int values with Cmp to avoid pointer/reflect pitfalls.

Safer and idiomatic for numeric equality.

- assert.Equal(t, big.NewInt(101), maxBlock)
+ assert.Zero(t, maxBlock.Cmp(big.NewInt(101)))
@@
- assert.Equal(t, big.NewInt(99), chainStats.MinBlock)
- assert.Equal(t, big.NewInt(101), chainStats.MaxBlock)
+ assert.Zero(t, chainStats.MinBlock.Cmp(big.NewInt(99)))
+ assert.Zero(t, chainStats.MaxBlock.Cmp(big.NewInt(101)))
@@
- assert.Equal(t, big.NewInt(200), maxBlock)
+ assert.Zero(t, maxBlock.Cmp(big.NewInt(200)))

Also applies to: 66-68, 87-89

internal/orchestrator/orchestrator.go (1)

44-55: Always defer cancel to avoid context leak

Add a defer cancel() right after creation to guarantee resources are released even if nothing triggers o.cancel().

 func (o *Orchestrator) Start() {
   ctx, cancel := context.WithCancel(context.Background())
   o.cancel = cancel
+  defer cancel()

internal/orchestrator/poller.go (1)

198-206: Nil workModeChan would deadlock this select

If WithPollerWorkModeChan isn’t provided, case workMode := <-p.workModeChan blocks forever. Either ensure it’s always set (document) or guard with if p.workModeChan != nil. In this PR, orchestrator sets it, but add a comment or guard.

internal/rpc/batcher.go (1)

54-86: Ordering across chunks is nondeterministic

Results are appended as chunks complete; if callers rely on order matching input keys, process chunks sequentially or re-order at the end. Given worker sorts results later, this is likely fine. Document this behavior.

internal/storage/clickhouse.go (1)

115-123: Minor: Async insert settings

If async insert is enabled, consider making wait_for_async_insert configurable (some deployments prefer fire-and-forget).

internal/worker/worker.go (2)

337-346: Also close the RPC client

Free network resources when closing the worker (useful in tests or alternate lifecycles).

 func (w *Worker) Close() error {
   // Close archive if it exists
   if w.archive != nil {
     log.Debug().Msg("Closing archive connection")
     w.archive.Close()
   }

+  if w.rpc != nil {
+    w.rpc.Close()
+  }
   log.Debug().Msg("Worker closed successfully")
   return nil
 }

---

255-278: Archive decision is conservative (ALL blocks in range)

LGTM. Consider partial-archive + partial-RPC in future for large spans; not required now.

internal/storage/redis.go (1)

57-75: Prefer bounded contexts for Redis ops

All calls use context.Background(); add short timeouts to prevent hangs on network partitions. Consider a per-connector op timeout (e.g., 2–5s) and use context.WithTimeout in Get*/Set*/Close.

Also applies to: 77-81, 83-100, 107-124, 125-129, 131-134

internal/orchestrator/committer.go (1)

529-537: Message typo: “commit” vs “publish”

Wrong error string in getSequentialBlockDataToPublish.

Apply:

-		return nil, fmt.Errorf("error determining blocks to commit: %v", err)
+		return nil, fmt.Errorf("error determining blocks to publish: %v", err)

internal/storage/kafka_publisher.go (1)

292-299: Single-partition publishing limits throughput

Manual partitioner with Partition: 0 forces all traffic to one partition. If ordering requirements allow, prefer key-based partitioning to scale.

Option: remove ManualPartitioner and Partition=0; rely on key to preserve per-chain ordering.

-		kgo.RecordPartitioner(kgo.ManualPartitioner()),
+		// kgo.DefaultProducePartitioner uses key hashing to preserve key ordering
+		kgo.RecordPartitioner(kgo.DefaultProducePartitioner()),

-		Partition: 0,

internal/storage/block_buffer_badger.go (4)

289-313: Full-prefix scan in GetBlocksInRange; seek to start to reduce IO

After padding keys, you can seek directly to start and break once past end.

Apply:

-		for it.Rewind(); it.Valid(); it.Next() {
+		startKey := b.makeKey(chainId, startBlock)
+		for it.Seek(startKey); it.ValidForPrefix(prefix); it.Next() {
 			item := it.Item()
 			err := item.Value(func(val []byte) error {
 				var blockData common.BlockData
 				if err := gob.NewDecoder(bytes.NewReader(val)).Decode(&blockData); err != nil {
 					return err
 				}
 
 				blockNum := blockData.Block.Number
-				if blockNum.Cmp(startBlock) >= 0 && blockNum.Cmp(endBlock) <= 0 {
+				if blockNum.Cmp(endBlock) > 0 {
+					return nil
+				}
+				if blockNum.Cmp(startBlock) >= 0 {
 					result = append(result, blockData)
 				}
 				return nil
 			})

---

232-235: Report total on-disk size (LSM + vlog)

badger.DB.Size() returns (lsm, vlog); you currently ignore vlog.

Apply:

-	lsm, _ := b.db.Size()
-	return lsm, b.blockCount
+	lsm, vlog := b.db.Size()
+	return lsm + vlog, b.blockCount

---

107-121: Potential overcount on duplicate keys

Add increments blockCount and per-chain counts without checking if the key already exists; repeated Add of same block skews stats/flush thresholds.

Consider WriteBatch with Insert-only semantics or a pre-check to avoid double-counting, if duplicates are expected in practice.

Also applies to: 128-157

---

51-70: Comment/value mismatch

ValueThreshold comment says “> 512 bytes” but code sets 1024. Align comment or value.

internal/source/s3.go (4)

99-107: Confusing comment vs. value for MaxCacheSize

Comment says “Increased from 5GB to 10GB” but value is 5GB.

Apply this diff to make intent explicit:

-	if cfg.MaxCacheSize == 0 {
-		cfg.MaxCacheSize = 5 * 1024 * 1024 * 1024 // Increased from 5GB to 10GB
-	}
+	if cfg.MaxCacheSize == 0 {
+		cfg.MaxCacheSize = 10 * 1024 * 1024 * 1024 // 10GB default
+	}

---

901-906: Reduce collision risk in cache filenames

Only 16 hex chars (~64 bits) increases collision risk. Use full hash.

Apply this diff:

-	hash := sha256.Sum256([]byte(fileKey))
-	filename := hex.EncodeToString(hash[:])[:16] + ".parquet"
+	hash := sha256.Sum256([]byte(fileKey))
+	filename := hex.EncodeToString(hash[:]) + ".parquet"
 	return filepath.Join(s.cacheDir, filename)

---

575-660: Block index is built but never used

buildBlockIndex fills s.blockIndex but read path ignores it. Delete it or wire it into selective reads; otherwise it’s wasted work.

Do you want me to remove it or integrate it with readBlocksFromLocalFile?

---

158-170: Use a context with timeout for AWS config load

LoadDefaultConfig uses context.Background(). Prefer a bounded context.

Apply this diff:

-	awsCfg, err := awsconfig.LoadDefaultConfig(context.Background(),
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	awsCfg, err := awsconfig.LoadDefaultConfig(ctx,
 		awsconfig.WithRegion(cfg.Region),
 	)

internal/storage/kafka.go (1)

134-137: Fix doc comment

This closes Kafka publisher, not Redis.

Apply this diff:

-// Close closes the Redis connection
+// Close closes the Kafka publisher

cmd/migrate_valid.go (1)

151-161: Remainder distribution can be simpler

Minor: avoid big.Int allocations in loop.

Apply this diff:

-	remainder := new(big.Int).Mod(totalBlocks, big.NewInt(int64(numWorkers)))
+	remainder := int(new(big.Int).Mod(totalBlocks, big.NewInt(int64(numWorkers))).Int64())
@@
-		if big.NewInt(int64(i)).Cmp(remainder) < 0 {
+		if i < remainder {
 			workerBlockCount.Add(workerBlockCount, big.NewInt(1))
 		}

internal/storage/badger.go (2)

126-134: Iterator perf: disable value prefetch when scanning keys

For scans where most entries are filtered/skipped, set PrefetchValues = false to reduce I/O.

Apply this diff:

-		opts := badger.DefaultIteratorOptions
+		opts := badger.DefaultIteratorOptions
+		opts.PrefetchValues = false

---

494-526: Avoid building large deletion lists; delete inline

To reduce memory spikes on large datasets, delete as you iterate (using KeyCopy(nil)).

Apply this diff:

-		var keysToDelete [][]byte
 		for it.Rewind(); it.Valid(); it.Next() {
 			key := string(it.Item().Key())
 			parts := strings.Split(key, ":")
@@
-			if blockNum.Cmp(blockNumber) <= 0 {
-				keysToDelete = append(keysToDelete, it.Item().KeyCopy(nil))
-			}
+			if blockNum.Cmp(blockNumber) <= 0 {
+				if err := txn.Delete(it.Item().KeyCopy(nil)); err != nil {
+					return err
+				}
+			}
 		}
-
-		for _, key := range keysToDelete {
-			if err := txn.Delete(key); err != nil {
-				return err
-			}
-		}

internal/storage/connector.go (1)

63-67: TODO in exported type

Minor: remove or rephrase the TODO in QueryResult before merging.

internal/storage/block_buffer.go (1)

63-90: Consider using a more efficient size estimation approach

Encoding the entire batch with gob on every Add call could become a performance bottleneck for large batches. Consider estimating size based on known field sizes or using a running average.

Consider implementing a size estimation based on field analysis or maintaining a running average of bytes-per-block ratio from successful encodings. This would avoid the overhead of gob encoding on every Add call while still providing reasonable accuracy for buffer management.

internal/storage/s3.go (1)

71-78: Log a warning when explicit AWS credentials are used
Add a warning under the explicit-credentials branch in internal/storage/s3.go to discourage static credentials in favor of IAM roles:

--- a/internal/storage/s3.go
+++ b/internal/storage/s3.go
@@ -71,6 +71,7 @@
    if cfg.AccessKeyID != "" && cfg.SecretAccessKey != "" {
+       log.Warn().Msg("Using explicit AWS credentials from config; consider using IAM roles for enhanced security.")
        awsCfg.Credentials = aws.CredentialsProviderFunc(func(ctx context.Context) (aws.Credentials, error) {
            return aws.Credentials{
                AccessKeyID:     cfg.AccessKeyID,
                SecretAccessKey: cfg.SecretAccessKey,
            }, nil
        })
    }

No occurrences of logging these credentials were found in the codebase.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: iuwqyir
PR: thirdweb-dev/insight#240
File: internal/tools/clickhouse_create_token_balances_mv.sql:8-17
Timestamp: 2025-07-22T18:30:59.800Z
Learning: In the token_balances table projection design, the user prefers to have the address_projection optimized for queries by (token_type, chain_id, address, token_id) without including owner, as the main table is already optimized for owner-based query paths.