Payments & Transfers

The core of on-chain payment and settlement operations is reliably managing the full fund flow — from transaction submission and status tracking to asset movement confirmation and downstream notifications. Nodit combines JSON-RPC-based direct node calls, normalized data APIs, and event-driven notifications to support implementation of the entire payment processing pipeline within a single infrastructure.

---

Use Cases

Payment Settlement Systems
Submit on-chain payment transactions and verify receipts to integrate with internal settlement systems. Confirming final transaction status via receipt after submission enables automated payment completion verification.

Multi-Chain Asset Transfer Tracking
The normalized Transfer API enables unified tracking of from/to asset movement flows without manually parsing chain-specific data structures. Even across environments with fundamentally different transfer models — UTXO-based chains, XRP Ledger variants, and Aptos — a consistent tracking interface is available, making it advantageous for designing institutional ledger and reconciliation systems.

Treasury Operations
When moving corporate funds across a multi-chain environment, use gas fee history retrieval based on the EIP-1559 fee model to establish gas price policies. The same API pattern applies across EVM-compatible networks, enabling unified treasury operations without chain-specific implementations.

Bulk Transaction Batch Processing
Use the nonce retrieval API to look up the next nonce per account in advance, then construct transactions sequentially to handle bulk transfers without nonce conflicts. Rather than implementing nonce management logic directly, query the latest state via API.

Payment Gateways
Handle the full pipeline — gas estimation, nonce retrieval, transaction construction and signing, submission, and status confirmation — through a single Nodit Elastic Node endpoint. Build a payment gateway using standard JSON-RPC interfaces without separate node infrastructure.

Real-Time Post-Payment Processing
Receive payment transaction success or failure via Webhook or Stream to asynchronously update internal ledgers, notification systems, and customer UIs. This eliminates polling and reduces operational latency in downstream processing workflows.

Key Capabilities

The on-chain payment pipeline consists of two essential components: Execute and Track & React.

Execute Value Transfer Execution

Fee Estimation and Policy Definition

Before submitting a transaction, estimate the execution gas and analyze network fee history. Incorrect maxFeePerGas settings lead to transaction delays or excessive fees. Use Node API to retrieve gas estimates and EIP-1559 fee history to establish fee policies before submission.

Nonce Management and Batch Transfers

Nonce conflicts when submitting multiple consecutive transactions result in invalidated transactions or stuck pending states. Querying the next nonce per account via API provides precise control over submission order and guarantees sequential processing even in large batch transfers.

Transaction Construction, Submission, and Status Verification

Key signing is completed client-side before the signed transaction is passed to Nodit, so private keys are never exposed externally. After submission, retrieve the receipt to verify block inclusion and execution results, then integrate with internal settlement.

Track & React Tracking and Post-Processing

Transfer History Tracking and Settlement Verification

Each chain has a different transfer model, requiring chain-specific parsing implementations if handled directly. The normalized Transfer API delivers asset movement flows in a consistent from/to structure, enabling a unified settlement reconciliation pipeline even in multi-chain environments.

Payment Completion Event Delivery

Periodic polling to check payment completion status accumulates unnecessary requests. Receiving transaction success, failure, and block inclusion events via Webhook as they occur enables asynchronous triggering of internal ledger updates and customer notifications.

Condition-Based Payment Event Filtering

Receiving all payment events and filtering internally increases processing load. Use Flexible Webhook's CEL expressions to pre-filter events matching specific contracts, amount ranges, or token types before delivery, reducing internal system load.

Implementation Example

API Use Cases

Scenario	API to Use	Reason
Gas cost estimation	eth_estimateGas	Estimate the gas units required for transaction execution
EIP-1559 fee history retrieval	eth_feeHistory	Establish maxFeePerGas policy based on baseFee trends
Current gas price retrieval	eth_gasPrice	Set gasPrice reference for legacy transactions
Next nonce retrieval per account	getNextNonceByAccount	Prevent nonce conflicts during batch transfers
Transaction submission	eth_sendRawTransaction	Submit after client-side signing is complete
Transaction status verification	eth_getTransactionReceipt	Retrieve block inclusion status and execution result
TX history retrieval per account	getTransactionsByAccount	Reconstruct transaction history for settlement reconciliation
Token transfer history tracking	getTokenTransfersByAccount	Normalized ERC-20 asset movement flow retrieval
Payment completion notification	Webhook — SUCCESSFUL_TRANSACTION	Receive immediate HTTP callback on transaction success
Payment failure notification	Webhook — FAILED_TRANSACTION	Trigger reprocessing workflow on transaction failure
Deposit detection	Webhook — ADDRESS_ACTIVITY	Detect all asset inflows to a designated address
ERC-20 deposit condition filtering	Flexible Webhook — erc20.transfer	Pre-filter by specific token and amount criteria
Real-time transaction status	Stream	Maintain WebSocket connection; receive TX receipts in real time

When Submitting a Payment Transaction — Execute

Gas estimation, nonce management, and transaction construction and submission flow:

1. Use eth_estimateGas to estimate the gas required for execution.
2. Use eth_feeHistory to establish an EIP-1559-based maxFeePerGas policy.
3. Use getNextNonceByAccount to retrieve the next nonce for the account.
4. Construct the transaction and complete key signing on the client side.
5. Submit the signed transaction using eth_sendRawTransaction.
6. Use eth_getTransactionReceipt to verify block inclusion and final status.

When Transfer History Tracking and Post-Processing Are Required — Track & React

Settlement verification and event-driven downstream processing flow:

1. Use getTokenTransfersByAccount or getTransactionsByAccount to retrieve asset transfer history and reconcile with the internal settlement ledger.
2. Configure Webhook to receive payment completion, failure, and deposit events asynchronously.
3. If amount or token conditions apply, use Flexible Webhook's CEL expressions to pre-filter before delivery.
4. After receiving events, forward results to the internal ledger, customer notification system, and risk engine.

Execute + Track Combination

For scenarios like payment gateways that require both submission and post-processing, submit the transaction via the Execute track and trigger downstream workflows by receiving completion events via Webhook.

Related Guides

• Elastic Node — JSON-RPC endpoint configuration and supported networks
• Web3 Data API — Nonce retrieval and indexed Transfer API-based asset movement tracking that abstracts chain-specific structures
• Webhook — Post-payment processing and event-driven notification automation
• Stream — Real-time transaction status streaming
• API Reference — Full API parameter specifications and response schemas