Chris Bair, Victor Rohlfs

March 10, 2025 — 7 min read

The proliferation of digital asset ownership across retail and institutional investors — reaching ~650 million owners in 2024 and forecasted to reach 750-900 million in 2025 by one estimate — presents a unique set of challenges for corporate book-keeping.

Compared to reconciling fiat currency in a bank account, companies working with digital assets have to track tokens across different blockchains — many with their own standards, schema, and other quirks — across multiple third-party custodians, exchanges, non-custodial wallets, and onchain protocols.

Quicknode has helped teams across the financial industry build this process from the ground up using the ultimate, unaltered source of truth, with data pulled directly from the blockchain: RPC calls.

In this guide, we’ll dive into how and a step-by-step process.

What’s really important?

First, three essential criteria must be met by any digital asset reconciliation process:

1. Accuracy: Maintaining correct position and transaction data across all sources

2. Completeness: Ensuring all transactions and positions are captured without gaps

3. Timeliness: Accessing and verifying data within required reporting windows

A robust reconciliation process must conform to these criteria to accurately produce Net Asset Value (NAV) calculations and fulfill regulatory compliance.

What are the options?

This is the first question that comes up in our customers’ diligence process. There are so many sources of blockchain data: where do we start?

We’ll summarize the options below and check them against our three essential criteria.

1. Indexed Data

Indexed data is useful for many things, and analytics is chief among them. They aggregate messy onchain data into neat, queryable sources. So, at first glance, they save time and data processing headaches.

Block explorers and query-friendly APIs fall into this category.

But, because additional layers of processing have been used to organize the data, they fail to meet the criteria for Accuracy and Completeness: how do you know that something hasn’t been incorrectly recorded, especially after a re-org or a complex DeFi transaction or missed when dealing with a lesser-used blockchain?

2. Custodian and Exchange APIs

Custodians hold your assets, and exchanges handle your trades—shouldn’t they be the best data source?

While they can be useful during tax season for a retail investor, the problem with using them for high-precision reconciliation workflows again arises with Accuracy and Completeness: how balances or staking rewards are reported differently from one to the next and identifying these discrepancies and then matching them up across multiple sources creates its own issue. Siloed cost basis between wallets, networks, and onchain protocols can also lead to mismatches. Not to mention, if you have assets in an onchain liquidity pool or lending protocol, they’re missed entirely.

With reconciliation, incorrectly recording or missing even a single transaction can throw off an entire NAV calculation.

3. RPC Calls

Whether you’re querying balances, transaction histories, or smart contract interactions, RPC calls give you exactly what’s recorded on-chain from the node itself. This direct, non-intermediated connection to the ledger is indispensable for reconciliation workloads.

Let’s see how it meets our essential criteria:

First, Accuracy: RPC calls pull information directly from the blockchain. There’s no intermediation between you and the data; the integrity of data provenance is maintained.

Next, Completeness: RPCs can extract any type of onchain activity.

Finally, Timeliness: Blockchain data is dynamic; balances change with every block, transactions settle in near real-time, and events fire the moment conditions are met. RPC calls can query the latest state of the blockchain at any moment, ensuring reconciliation doesn’t rely on old information.

So, what’s the catch? RPC calls require technical know-how and an initial resource investment to achieve operational scale.

System Architecture Overview

To reconcile digital assets at scale—accurately, completely, and in real-time—you need an end-to-end workflow that coordinates your on-chain data sources (RPC connections, explorers, indexers) with internal systems (compliance, risk management, reporting).

Below is an expanded look at how each component fits together:

1. Integrations and Real-Time Confirmation

Compliance and Real-Time Asset Management

• Compliance risk audit and asset manager systems handle the policy checks, risk scoring, and overall governance for digital asset operations.

• These platforms integrate with a custodian or wallet to facilitate transaction lifecycles (e.g., purchase orders, transfers).

• Once transactions are submitted or confirmed, these systems pass along transaction details

  (e.g., receipts, confirmations) into the reconciliation pipeline.

Code for Reconciliation

• A dedicated application or microservice (“Code”) receives transaction data from the upstream systems. Rather than driving the transaction lifecycle itself, this service focuses on real-time reconciliation, listening for new transactions and confirmations as they appear onchain.

• When a new or updated transaction is detected, it triggers a reconciliation event

  so the rest of the architecture can retrieve and verify the onchain record.

2. RPC and Data Layer

Primary and Failover RPC

• Connecting to a blockchain node

  gives you direct access to the canonical ledger data. A failover RPC ensures redundancy and high availability if the primary endpoint is temporarily unreachable.

Block Explorer and Streaming

• Block explorers can be employed to validate whether a transaction was successfully recorded in a specific block, providing an extra layer of confirmation for critical transactions.

• Streaming endpoints (like through Quicknode Streams) can be employed to subscribe to real-time events (e.g., logs, new blocks), ensuring the system captures onchain changes the moment they happen.

Verification

• The “Code” service queries the blockchain via RPC calls and cross-checks the results against block explorer or Streaming endpoint data.

• This ensures the transaction data is up-to-date and fully accurate, without intermediaries or indexing layers that might omit or alter raw blockchain information.

3. Data & Processing Layer

Indexer and Database (ETL)

Large-scale reconciliation requires historical insights and aggregations (e.g., multi-year transaction history or cross-chain holdings).

• An indexer service continuously ingests on-chain data (blocks, transactions, logs) via RPC calls, then performs an ETL (Extract, Transform, Load) process into an internal database.

• This provides a “ground truth” store of all relevant on-chain events, allowing the organization to query historical data without redundant RPC calls.

Reporting, Alerting, and Compliance Tools

Once data is consolidated in the database, various processing systems can provide higher-level functionality:

• Reporting: Generate NAV calculations, account statements, and other official reports.

• Alerting Systems: These systems automatically detect discrepancies (e.g., mismatched balances between the blockchain and a custodian) and notify stakeholders in real-time.

• Compliance Tools: Continuously enforce AML/KYC policies, monitor for illicit activities, and adapt to evolving regulatory requirements.

4. Feedback & Auditing

• As each reconciliation cycle completes, monitor/audit logs and status reports flow back into the compliance risk audit systems.

• This feedback loop ensures that potential issues (e.g., unbalanced positions, missing transactions) are escalated for investigation and that the organization maintains an up-to-date, holistic view of onchain asset operations.

• Over time, these logs form a comprehensive audit trail, which is critical for satisfying internal governance policies and external regulatory requirements.

Confident, Compliant, and Complete—At Scale

Putting it all together, this architecture leverages real-time blockchain data (via RPC calls) in tandem with indexing, storage, and compliance workflows to achieve the three core criteria for bullet-proof reconciliation: Accuracy, Completeness, and Timeliness.

By integrating custodial and asset management operations with direct, unaltered onchain data, companies can confidently meet regulatory requirements and maintain a reliable picture of their digital asset positions.

At Quicknode, we’ve helped dozens of financial teams turn blockchain chaos into clean books. Ready to do the same?

Free Consultation

We've helped dozens of teams stand up digital asset reconciliation processes, and we're here to help.

contact us