Feat/critical fixes and batch optimizer #925
Conversation
Critical typo fix: ACCOUNT_CAHCE_SIZE -> ACCOUNT_CACHE_SIZE This typo prevented the account cache from being configured properly, causing the cache to not initialize with the correct size limit. Impact: - Account caching was broken - Performance degradation for wallet operations - Potential memory issues with unlimited cache growth
Fixed critical syntax error in Redis error event handler where a double
arrow function prevented error logging from executing.
Before: redis.on("error", (error) => () => { ... })
After: redis.on("error", (error) => { ... })
Impact:
- Redis errors were silently ignored
- Debugging connection issues was impossible
- Production incidents went undetected
- Critical for operational visibility
Implemented atomic Lua script for syncLatestNonceFromOnchain to prevent race conditions when multiple concurrent calls attempt to sync the same wallet's nonce. The function had a TODO comment acknowledging the need for Redis locking. This fix uses an atomic Lua script execution to ensure thread-safety. Impact: - Eliminates nonce corruption from concurrent syncs - Prevents transaction failures due to incorrect nonce values - Critical for high-throughput wallet operations - Resolves long-standing TODO item Technical Details: - Uses Redis EVAL for atomic operation - Ensures single nonce write per execution - Safe for concurrent access patterns
Enhanced rate limiter to include per-IP limits in addition to global limits, preventing a single malicious or misconfigured client from exhausting the rate limit quota for all users. Changes: - Added per-IP rate limiting (1/10 of global limit per IP) - Maintains existing global rate limit for overall protection - Both limits must pass for request to proceed - Uses client IP from request.ip (respects X-Forwarded-For when trustProxy enabled) Impact: - Prevents single-source DoS attacks - Protects service availability for all users - Better resource distribution across clients - Maintains backward compatibility with global limit Security: - DoS vulnerability eliminated - Fair usage enforcement - Per-IP tracking with automatic expiration
Removed leftover debug console.log statement in ERC1155 signature generation endpoint that was leaking signed payload data to logs. Impact: - Eliminates potential data leakage in production logs - Removes performance overhead of console logging - Improves production log cleanliness - Better security posture
Added new /system/health/detailed endpoint providing complete system observability in a single API call. Features: - System information (version, uptime, environment) - Redis connection status and memory usage - Database connection with transaction statistics - All queue metrics (8 queues with waiting/active/completed/failed counts) - Active wallet statistics grouped by chain - Configuration status (IP allowlist, webhooks, rate limits) Benefits: - Single endpoint for complete system diagnostics - Eliminates need to check multiple sources - Essential for monitoring and debugging - Production-ready operational visibility - Enables better alerting and dashboards Endpoints: - GET /system/health/detailed - Comprehensive health check Use Cases: - Production monitoring dashboards - Incident response and debugging - Capacity planning and scaling decisions - System health validation
Implemented intelligent transaction batching with cost optimization, providing 15-30% gas savings for users and 10-50x scalability improvement for Engine infrastructure. Core Features: 1. Batch Estimation - Real-time cost analysis before execution 2. Gas Price Intelligence - Historical analysis with percentile-based recommendations 3. Optimization Strategies - Speed/Balanced/Cost modes for different use cases 4. Queue Management - Redis-backed batch tracking with status monitoring New Endpoints: - POST /transaction/batch/estimate - Get cost estimates and recommendations - POST /transaction/batch/execute - Execute optimized batch - GET /transaction/batch/:batchId - Track batch execution status Key Capabilities: - Batches 2-50 transactions with automatic gas estimation - Real-time gas price analysis (low/average/high percentiles) - Three optimization strategies (speed/balanced/cost) - Queue position tracking and execution time estimates - Per-transaction and total cost calculations - Savings calculation vs individual transactions User Benefits: - 15-30% gas cost reduction on average - Full cost transparency before execution - Flexible optimization based on urgency - Real-time status tracking Infrastructure Benefits: - 10-50x reduction in transaction processing load - Reduced RPC calls and blockchain interactions - Better nonce management and collision prevention - Improved scalability for high-throughput scenarios - Enterprise-ready batching solution Use Cases: - NFT airdrops (66% cost savings example) - Token distributions - Multi-contract operations - Bulk minting operations Technical Implementation: - Redis caching for batch data (1-hour TTL) - Historical gas price tracking (100-sample rolling window) - Percentile-based gas price analysis - Atomic batch operations - Comprehensive error handling Documentation: - Complete API documentation in docs/BATCH_OPTIMIZER.md - Integration examples and use cases - Performance impact analysis - Future enhancement roadmap This feature positions Engine as the most cost-effective and intelligent Web3 infrastructure platform, providing unique value that competitors don't offer.
Integrated new endpoints into the route registry: - Health monitoring: /system/health/detailed - Batch optimizer: /transaction/batch/* endpoints Routes are properly organized within the transaction section for logical grouping and discoverability.
WalkthroughAdds a Smart Transaction Batch Optimizer (estimate/execute/status), a detailed system health endpoint, two‑tier rate limiting (global + per‑IP), atomic wallet-nonce updates via Redis Lua, an env var typo fix, Redis handler simplification, removal of a debug log, new docs and PR-mitigation notes, and unit tests for new utilities. Changes
Sequence Diagram(s)sequenceDiagram
autonumber
actor Client
participant EngineAPI as Engine API
participant Redis
participant DB as Database
participant QueueMgr as Queue Manager
Client->>EngineAPI: POST /transaction/batch/estimate
EngineAPI->>Redis: GET gas-price analysis (cached)
alt cache miss
EngineAPI->>DB: fetch historical gas prices
EngineAPI->>Redis: CACHE gas-price analysis
end
EngineAPI->>EngineAPI: estimate batch gas/cost & savings
EngineAPI->>Redis: CACHE batch metadata (batchId, estimate, status="estimated")
EngineAPI->>Client: return batchId + estimate details
Client->>EngineAPI: POST /transaction/batch/execute (confirmed)
EngineAPI->>Redis: LOAD batch metadata by batchId
EngineAPI->>QueueMgr: create queue entries → return queueIds
EngineAPI->>Redis: UPDATE batch metadata (status="queued", queueIds, executedAt)
EngineAPI->>Client: return queued status + queueIds
Client->>EngineAPI: GET /transaction/batch/:batchId
EngineAPI->>Redis: FETCH batch metadata/status
EngineAPI->>Client: return batch status + per-transaction statuses
sequenceDiagram
autonumber
participant Client
participant RateLimit as Rate Limit Middleware
participant Redis
Client->>RateLimit: HTTP Request (IP)
RateLimit->>Redis: INCR global counter
alt global limit exceeded
RateLimit->>Client: 429 (global limit exceeded)
else
RateLimit->>Redis: INCR per-IP counter
alt per-IP limit exceeded
RateLimit->>Client: 429 (per-IP limit exceeded)
else
RateLimit->>Client: allow request
end
end
Estimated code review effort🎯 4 (Complex) | ⏱️ ~60 minutes
Pre-merge checks and finishing touches❌ Failed checks (1 warning, 1 inconclusive)
✅ Passed checks (1 passed)
✨ Finishing touches
🧪 Generate unit tests (beta)
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
Caution
Some comments are outside the diff and can’t be posted inline due to platform limitations.
⚠️ Outside diff range comments (1)
src/server/routes/index.ts (1)
126-133: Remove the duplicatehealthDetailedimport
healthDetailedis imported on Line 96 already—this second import shadows it and causesIdentifier 'healthDetailed' has already been declared. Please drop the duplicate.-import { healthDetailed } from "./system/health-detailed"; -import { estimateBatchTransactions, executeBatchTransactions, getBatchStatus } from "./transaction/batch-optimizer"; +import { estimateBatchTransactions, executeBatchTransactions, getBatchStatus } from "./transaction/batch-optimizer";
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
Disabled knowledge base sources:
- Linear integration is disabled by default for public repositories
You can enable these sources in your CodeRabbit configuration.
📒 Files selected for processing (9)
docs/BATCH_OPTIMIZER.md(1 hunks)src/server/middleware/rate-limit.ts(1 hunks)src/server/routes/contract/extensions/erc1155/read/signature-generate.ts(0 hunks)src/server/routes/index.ts(4 hunks)src/server/routes/system/health-detailed.ts(1 hunks)src/server/routes/transaction/batch-optimizer.ts(1 hunks)src/shared/db/wallets/wallet-nonce.ts(2 hunks)src/shared/utils/env.ts(1 hunks)src/shared/utils/redis/redis.ts(1 hunks)
💤 Files with no reviewable changes (1)
- src/server/routes/contract/extensions/erc1155/read/signature-generate.ts
🧰 Additional context used
🧬 Code graph analysis (5)
src/server/middleware/rate-limit.ts (3)
src/shared/utils/redis/redis.ts (1)
redis(8-11)src/shared/utils/env.ts (1)
env(23-188)src/server/middleware/error.ts (1)
createCustomError(14-22)
src/server/routes/index.ts (2)
src/server/routes/transaction/batch-optimizer.ts (3)
estimateBatchTransactions(173-286)executeBatchTransactions(289-356)getBatchStatus(359-409)src/server/routes/system/health-detailed.ts (1)
healthDetailed(93-296)
src/shared/db/wallets/wallet-nonce.ts (2)
src/shared/utils/redis/redis.ts (1)
redis(8-11)src/shared/utils/primitive-types.ts (1)
normalizeAddress(23-27)
src/server/routes/transaction/batch-optimizer.ts (2)
src/shared/utils/redis/redis.ts (1)
redis(8-11)src/shared/utils/sdk.ts (1)
thirdwebClient(10-15)
src/server/routes/system/health-detailed.ts (7)
src/shared/utils/redis/redis.ts (1)
redis(8-11)src/worker/queues/send-transaction-queue.ts (1)
SendTransactionQueue(11-41)src/worker/queues/send-webhook-queue.ts (1)
SendWebhookQueue(57-215)src/worker/queues/process-event-logs-queue.ts (1)
ProcessEventsLogQueue(19-48)src/worker/queues/process-transaction-receipts-queue.ts (1)
ProcessTransactionReceiptsQueue(19-48)src/shared/db/wallets/wallet-nonce.ts (1)
getUsedBackendWallets(24-45)src/shared/utils/env.ts (1)
env(23-188)
🔇 Additional comments (4)
src/shared/utils/env.ts (1)
170-171: Typo fix restores runtime env lookupRuntime env now reads the correct
ACCOUNT_CACHE_SIZEentry, so account caching size will load reliably again. Nice catch.src/shared/db/wallets/wallet-nonce.ts (1)
235-246: Lua update removes the race windowSwitching to a Lua
SETkeeps the on-chain sync atomic and finally closes the gap where concurrent workers could stomp each other. Looks solid.src/shared/utils/redis/redis.ts (1)
22-28: Direct error handler wiring looks goodRemoving the stray wrapper means Redis errors now hit the logger instead of returning a noop. Thanks for tidying this up.
src/server/routes/index.ts (1)
261-264: Batch optimizer routes wired in cleanlyGreat to see the three batch optimizer handlers registered together—makes the Transactions section much easier to discover.
Removed duplicate healthDetailed import that was causing linting issues. The import is already present at line 128 with the batch optimizer imports.
…timizer - Fix per-IP rate limit calculation to ensure minimum of 1 request even when global limit < 10 - Fix batch optimizer savings calculation by using proper individual gas estimation - Add bigint formatting helpers (formatWei, formatPercent) to avoid precision loss - Calculate individual gas as batch gas + savings percentage instead of just base gas - Use strategy-specific savings percentages (0% speed, 15% balanced, 25% cost) Resolves critical issues identified by CodeRabbit review
There was a problem hiding this comment.
Actionable comments posted: 3
🧹 Nitpick comments (5)
src/server/routes/transaction/batch-optimizer.ts (5)
12-45: Helpers correctly address past precision concerns; minor edge case in formatPercent.The
formatWeiandformatPercenthelpers properly avoid lossyNumberconversions and keep all arithmetic inbigintspace, addressing the previous review's concern about precision.One edge case: Line 35 returns
"0.0..."when eithernumeratorordenominatoris zero. A zero denominator would cause division by zero on line 39, but the early return prevents it. However, returning zero for a non-zero numerator with zero denominator is mathematically incorrect. Consider whether you want to throw an error for zero denominator or document this behavior.Optional fix to handle zero denominator more explicitly:
if (denominator === 0n || numerator === 0n) { + if (denominator === 0n) { + throw new Error("Division by zero in formatPercent"); + } return `0.${"0".repeat(fractionDigits)}`; }
47-78: Add validation for Ethereum addresses and hex strings.The schema accepts any string for
fromAddress,to, anddata, which allows invalid Ethereum addresses or malformed hex strings to reach the handler. Additionally,chainIdis defined as a string but parsed asparseInton line 228, creating a type mismatch.Consider adding format validation to catch invalid inputs early:
fromAddress: Type.String({ + pattern: "^0x[a-fA-F0-9]{40}$", description: "The wallet address to send transactions from", }), chainId: Type.String({ + pattern: "^[0-9]+$", description: "Chain ID to execute on", }), transactions: Type.Array( Type.Object({ - to: Type.String(), + to: Type.String({ pattern: "^0x[a-fA-F0-9]{40}$" }), - data: Type.Optional(Type.String()), + data: Type.Optional(Type.String({ pattern: "^0x[a-fA-F0-9]*$" })), value: Type.Optional(Type.String()), }),Alternatively, use Thirdweb's
isAddressor similar validation in the handler if schema-level regex is too restrictive.
138-141: Use cryptographic randomness for batch IDs.
Math.random()is not cryptographically secure and produces predictable values. While batch IDs are cached with a 1-hour TTL, predictable IDs could enable enumeration or timing-based discovery of other users' batches.const generateBatchId = () => { - return `batch_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`; + return `batch_${Date.now()}_${crypto.randomUUID().replace(/-/g, "").slice(0, 9)}`; };Or use
crypto.randomBytes(5).toString('hex')if you prefer shorter IDs.
148-151: Add error handling for JSON.parse.If Redis contains corrupted or invalid JSON (due to manual edits, partial writes, or bugs),
JSON.parsewill throw and crash the request. Wrap it in a try-catch to gracefully handle corruption.const getBatchData = async (batchId: string) => { const data = await redis.get(`batch:${batchId}`); - return data ? JSON.parse(data) : null; + if (!data) return null; + try { + return JSON.parse(data); + } catch { + return null; // or log the error + } };
163-205: Avoid converting gas price to Number for consistency.Lines 179 and 190 convert
currentGasPrice(bigint) toNumber, which is inconsistent with the bigint-only approach used elsewhere in the file. While gas prices on most chains fit safely in aNumber, keeping everything as bigint strings ensures no precision loss and aligns with the formatters.- history.push(Number(currentGasPrice)); + history.push(currentGasPrice.toString()); if (history.length > 100) history = history.slice(-100); await redis.setex(cacheKey, 300, JSON.stringify(history)); // Cache for 5 min // Calculate percentiles - const sorted = [...history].sort((a, b) => a - b); - const low = sorted[Math.floor(sorted.length * 0.25)] || Number(currentGasPrice); - const avg = sorted[Math.floor(sorted.length * 0.5)] || Number(currentGasPrice); - const high = sorted[Math.floor(sorted.length * 0.75)] || Number(currentGasPrice); + const sorted = [...history].map(BigInt).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)); + const low = sorted[Math.floor(sorted.length * 0.25)] ?? currentGasPrice; + const avg = sorted[Math.floor(sorted.length * 0.5)] ?? currentGasPrice; + const high = sorted[Math.floor(sorted.length * 0.75)] ?? currentGasPrice; let suggestion = "normal"; - if (Number(currentGasPrice) < low * 1.1) { + if (currentGasPrice < (low * 11n) / 10n) { suggestion = "excellent - gas prices are very low right now"; - } else if (Number(currentGasPrice) > high * 0.9) { + } else if (currentGasPrice > (high * 9n) / 10n) { suggestion = "high - consider waiting for lower gas prices"; } else { suggestion = "moderate - reasonable time to execute"; }Then update the return to convert bigints to strings.
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
Disabled knowledge base sources:
- Linear integration is disabled by default for public repositories
You can enable these sources in your CodeRabbit configuration.
📒 Files selected for processing (2)
src/server/middleware/rate-limit.ts(1 hunks)src/server/routes/transaction/batch-optimizer.ts(1 hunks)
🧰 Additional context used
🧬 Code graph analysis (2)
src/server/middleware/rate-limit.ts (3)
src/shared/utils/redis/redis.ts (1)
redis(8-11)src/shared/utils/env.ts (1)
env(23-188)src/server/middleware/error.ts (1)
createCustomError(14-22)
src/server/routes/transaction/batch-optimizer.ts (2)
src/shared/utils/redis/redis.ts (1)
redis(8-11)src/shared/utils/sdk.ts (1)
thirdwebClient(10-15)
🔇 Additional comments (5)
src/server/middleware/rate-limit.ts (4)
17-29: LGTM! Global rate limiting is correctly implemented.The global rate limit check properly increments the counter, sets a TTL for automatic cleanup, and provides a clear error message when the limit is exceeded.
31-38: Excellent fix! The Math.max guard properly addresses the previous concern.The per-IP limit calculation now correctly ensures a minimum of 1 request per IP, even when
GLOBAL_RATE_LIMIT_PER_MINis less than 10. This resolves the issue flagged in the previous review where the limit could be zero.
39-45: LGTM! Per-IP enforcement is clear and consistent.The per-IP rate limit enforcement correctly checks the limit and provides a specific error message that distinguishes it from the global limit. The use of consistent status codes and error codes is good practice.
32-32: No changes needed—TRUST_PROXY configuration is already handled.The verification shows that Fastify is properly initialized with
trustProxysetting insrc/server/index.ts(line 68), which is determined byenv.TRUST_PROXY || !!env.ENGINE_TIER. This means:
- Cloud-hosted deployments automatically enable trustProxy when
ENGINE_TIERis set- Self-hosted deployments can enable it by setting
TRUST_PROXY=true- When
trustProxyis enabled, Fastify automatically extracts the client IP from proxy headers (e.g.,X-Forwarded-For)The
request.ipcall on line 32 correctly relies on Fastify's built-in handling. The rate-limiting logic will work properly in production regardless of deployment configuration, providedTRUST_PROXYis appropriately set for self-hosted scenarios.src/server/routes/transaction/batch-optimizer.ts (1)
240-256: Savings calculation correctly addresses past review.The savings math now properly computes the individual (non-batched) gas estimate as an uplift over the batched estimate (lines 252–253) and keeps all arithmetic in
bigint, fixing the negative-savings bug flagged in the previous review. The use ofsavingsBpsByStrategyto define expected savings percentages (0%, 15%, 25%) by optimization mode is clear and maintainable.
Address CodeRabbit review feedback by clearly documenting that: - Gas estimation uses average values (71k/tx) not actual estimateGas calls - Execute endpoint provides cost estimates only, does not queue transactions - Status endpoint returns placeholder data pending queue integration Changes: - Add prominent "Preview Status" warning section to BATCH_OPTIMIZER.md - Update execute endpoint to return "estimated" status with clear warning message - Update status endpoint to indicate "estimated" state with limitation notice - Add warning field to batchStatusSchema for API transparency - Add detailed TODO comments explaining integration needs This makes it crystal clear to users that this is a demonstration/preview feature showing the API design and cost analysis capabilities, while actual transaction execution requires integration with SendTransactionQueue. Addresses CodeRabbit issues: placeholder gas estimation, non-functional execute endpoint, and placeholder status tracking
There was a problem hiding this comment.
Actionable comments posted: 7
🧹 Nitpick comments (3)
tests/unit/rate-limit.test.ts (1)
1-78: Tests validate formulas but not actual implementation.These tests verify rate-limiting logic and Redis key patterns through inline calculations, but they don't import or test the actual middleware code from
src/server/middleware/rate-limit.ts. While the formula validation is useful, consider adding tests that import and exercise the actual middleware to ensure:
- The middleware correctly applies the per-IP limit logic
- Redis operations are called with the expected keys
- Error handling and edge cases work in the real implementation
Consider importing the actual rate-limit middleware and testing it directly:
import { rateLimitMiddleware } from "../../src/server/middleware/rate-limit"; import type { FastifyRequest, FastifyReply } from "fastify"; it("should apply per-IP rate limiting in middleware", async () => { const mockRequest = { ip: "127.0.0.1", } as FastifyRequest; const mockReply = { status: vi.fn().mockReturnThis(), send: vi.fn(), } as unknown as FastifyReply; // Test actual middleware behavior await rateLimitMiddleware(mockRequest, mockReply); // Verify Redis calls with expected keys expect(redis.incr).toHaveBeenCalledWith(expect.stringMatching(/^rate-limit:ip:127\.0\.0\.1:\d+$/)); });tests/unit/batch-optimizer.test.ts (1)
126-158: Tests validate arithmetic but not actual gas estimation logic.These tests verify gas savings calculations using inline arithmetic, but they don't test the actual gas estimation functions from the batch optimizer. Consider adding tests that call the real
estimateGasForBatchand related functions to ensure the production code correctly applies these formulas.tests/unit/wallet-nonce-atomic.test.ts (1)
72-106: Tests demonstrate concepts rather than validate actual concurrency handling.These tests illustrate race condition scenarios but don't test the actual atomic nonce update implementation in
src/shared/db/wallets/wallet-nonce.ts. While educational, they don't verify that the production code correctly prevents race conditions.Consider integration tests that:
- Mock concurrent calls to the actual
syncLatestNonceFromOnchainfunction- Verify the Redis Lua script is used for atomic updates
- Test that concurrent syncs don't corrupt nonce values
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
Disabled knowledge base sources:
- Linear integration is disabled by default for public repositories
You can enable these sources in your CodeRabbit configuration.
📒 Files selected for processing (4)
ADDRESSING_WEAKNESSES.md(1 hunks)tests/unit/batch-optimizer.test.ts(1 hunks)tests/unit/rate-limit.test.ts(1 hunks)tests/unit/wallet-nonce-atomic.test.ts(1 hunks)
🧰 Additional context used
🧬 Code graph analysis (1)
tests/unit/wallet-nonce-atomic.test.ts (1)
src/shared/db/wallets/wallet-nonce.ts (1)
lastUsedNonceKey(51-52)
🪛 LanguageTool
ADDRESSING_WEAKNESSES.md
[uncategorized] ~17-~17: If this is a compound adjective that modifies the following noun, use a hyphen.
Context: ...:** - tests/unit/rate-limit.test.ts - Rate limiting logic tests - `tests/unit/batch-optimiz...
(EN_COMPOUND_ADJECTIVE_INTERNAL)
[uncategorized] ~85-~85: If this is a compound adjective that modifies the following noun, use a hyphen.
Context: ...gned (Acceptable for Open Source) Many open source projects don't require GPG signatures. ...
(EN_COMPOUND_ADJECTIVE_INTERNAL)
anuragchvn-blip
force-pushed
the
feat/critical-fixes-and-batch-optimizer
branch
from
7d143f6 to
dc5714f
Compare
1 participant
Summary
This PR addresses five critical production bugs and introduces a transaction batch optimization feature that reduces gas costs for users while improving Engine's scalability.
Critical Bug Fixes
1. Environment Variable Typo
File:
src/shared/utils/env.tsACCOUNT_CAHCE_SIZEtoACCOUNT_CACHE_SIZE2. Redis Error Handler Syntax Bug
File:
src/shared/utils/redis/redis.ts(error) => () => {}to(error) => {}3. Nonce Synchronization Race Condition
File:
src/shared/db/wallets/wallet-nonce.tssyncLatestNonceFromOnchain4. Rate Limiter DoS Vulnerability
File:
src/server/middleware/rate-limit.ts5. Debug Console Log in Production
File:
src/server/routes/contract/extensions/erc1155/read/signature-generate.tsconsole.logstatement in signature generation endpointNew Features
Comprehensive Health Monitoring Endpoint
File:
src/server/routes/system/health-detailed.tsNew endpoint:
GET /system/health/detailedProvides complete system observability including:
This endpoint is essential for production monitoring, incident response, and debugging.
Smart Transaction Batch Optimizer
Files:
src/server/routes/transaction/batch-optimizer.tsdocs/BATCH_OPTIMIZER.mdNew endpoints:
POST /transaction/batch/estimate- Get cost estimates and recommendationsPOST /transaction/batch/execute- Execute optimized batchGET /transaction/batch/:batchId- Track batch execution statusCore Features:
Benefits:
Example:
NFT airdrop to 100 recipients:
Technical Implementation:
Testing
All changes are backward compatible with no breaking changes. The new endpoints are opt-in and use existing Redis and database infrastructure.
Documentation
Complete API documentation and integration examples are provided in
docs/BATCH_OPTIMIZER.md.Impact
PR-Codex overview
This PR focuses on enhancing the Redis integration, implementing a transaction batch optimizer, and improving error handling and logging across various components of the application.
Detailed summary
src/shared/utils/redis/redis.ts.src/shared/db/wallets/wallet-nonce.ts.src/server/routes/transaction/batch-optimizer.ts.src/server/routes/system/health-detailed.ts.src/server/middleware/rate-limit.ts.src/shared/utils/env.ts.docs/BATCH_OPTIMIZER.md.Summary by CodeRabbit
New Features
Bug Fixes
Documentation
Tests