Contrastive Learning for Efficient Transaction Validation in UTXO-based Blockchains

Alessio Pagani; Hamid Attar; Luigi Lunardon

REVIEW 3 major objections 6 minor 2 references

Contrastive Learning for Efficient Transaction Validation in UTXO-based Blockchains

T0 review · 3 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper claims a UTXO node can route each incoming transaction to the shard containing its parent UTXOs using only features of the incoming transaction, with no blockchain lookups during inference.

desk verdict The no-lookup routing claim is impossible with the proposed features, because a spending transaction does not contain its parent's local features — the idea is novel but the mechanism is broken. read the letter →

arxiv 2506.01614 v1 pith:7ZFYLNBP submitted 2025-06-02 cs.LG cs.AI

Hamid Attar , Luigi Lunardon , Alessio Pagani This is my paper

classification cs.LGcs.AI

keywords UTXOblockchainshardingcontrastivelearningtripletlosstransactionroutingBitcoinscalabilityembeddingparent-childspending

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to remove the most expensive step in validating a transaction on a UTXO-based blockchain: finding the parent UTXOs that the transaction spends. It claims that a neural encoder trained with contrastive learning can store parent-child spending relationships in its weights, so at inference time the features of an incoming transaction alone are enough to embed it near its parents and route it to the correct shard. If true, cross-shard communication would drop sharply, allowing a node to validate transactions in parallel and scale throughput without per-transaction database lookups. The supporting experiments on about 102.8 million BSV transactions report that learned shard assignment beats random allocation, with above 90% accuracy for up to about ten shards and strong recovery of misplaced parents by checking neighboring shards.

What carries the argument

The load-bearing mechanism is a learned embedding space for transaction outpoints, produced by a dual-model architecture. First, a feature vector is assembled per outpoint from global transaction statistics (input and output counts, output-amount statistics, script-size aggregate, encodings of the top unlocking and locking scripts), local outpoint attributes (amount, locking-script size), a Bag of OP Codes encoding of the locking script, and a positional encoding of the outpoint's position in the transaction. A multi-layer perceptron encoder projects these vectors so that, under Euclidean distance, parent-child outpoints are close and unrelated outpoints are separated; this is trained with triplet loss using online selection of semi-hard negatives, with hard negatives introduced later. A clustering model then partitions the learned embedding space and assigns shard IDs, so routing becomes a nearest-cluster lookup in the embedding rather than a lookup into the blockchain database.

What would settle it

The decisive check is to count, on the held-out set, how often the true parent UTXO is the only candidate with the same local features used by the model (amount, locking-script size, OP-code bag); if the parent is usually not unique among candidates, no model can reach high same-shard accuracy at K=0 because the input lacks the parent's identity.

Watch

Extended reading notes

Core claim

The discovery the paper puts forward is that spending relationships in a UTXO ledger can be captured statically, as parameters of a neural embedding, rather than dynamically by querying the ledger. Treating each transaction outpoint as a feature vector built only from data available with the incoming transaction, the framework trains a multi-layer perceptron with triplet loss and online semi-hard-negative mining so that a child outpoint and its parent outpoint are close under Euclidean distance. Parent-child pairs serve as positives; unrelated outpoints serve as negatives; the learned weights then replace the need to fetch parent transaction data at inference time. A separate clustering model partitions the embedding space into shards, and the shard ID of a new outpoint's embedding decides which validation microservice receives the transaction. On BSV data from 6,000 blocks, totaling about 102.8 million transactions, the paper reports parent-child co-location accuracy well above random allocation, with more than 90% accuracy up to roughly 10 shards and improved recovery of misplaced parents by scanning the nearest clusters.

Load-bearing premise

The load-bearing premise is that the feature vector built from data present in an incoming transaction can identify the specific parent UTXO well enough to put child and parent in the same shard; if the parent's identity is not truly in those features, the observed co-location may only reflect script-type similarity, and the claimed lookup-free routing would collapse.

Editorial extensions

If this is right

A node could validate transactions in parallel across shards without waiting for parent-UTXO fetches, so throughput becomes bounded by local validation instead of cross-shard communication.
Shard assignment and transaction routing would be solved by one embedding, replacing hash-based random allocation with spending-aware placement.
Because inference uses only the incoming transaction's features, routing can be decided at the node's entry point with no extra ledger access per transaction.
When the top shard prediction misses, checking a small number of nearest shards recovers most parents, giving an explicit tunable trade-off between communication cost and co-location accuracy.
The training procedure is ledger-agnostic, consuming only historical spending records and script and amount features, so the same pipeline applies to any UTXO-based blockchain.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

An implication the paper leaves implicit is that its reported accuracy ceiling near ten shards, which roughly matches the number of natural script-type clusters in the embedding, suggests the model may be co-locating by script and amount style as much as by exact lineage; retraining with shuffled parent-child labels would reveal how much true lineage information the features actually carry.
The same embedding space could be reused for tasks the paper lists as future work, such as spending-behavior classification and load balancing, because transactions with similar economic and script shapes would already sit close together in the learned metric.
A practical extension is to make the neighbor-shard fallback confidence-aware: when an incoming outpoint lands near a cluster boundary, the node could speculatively fetch from the next-nearest shard, trading a little communication for a large gain in the probability of finding the parent UTXO.
Live deployment would need to monitor distribution drift, since the model is trained on a historical window and then frozen; a testable safeguard is periodic retraining on rolling blocks while tracking the anchor-positive distance distribution on fresh data.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

First, the punchline: the paper's central claim — that a UTXO node can route transactions to shards using only features available in the incoming transaction, eliminating parent lookups — is not supported by the feature set. The local features listed in Table I (amount, locking-script size) cannot be computed for a parent outpoint at spend time, because a Bitcoin input carries only a txid and output index. Two byte-identical child transactions spending different parents therefore produce identical feature vectors, making exact parent-shard routing impossible.

What is genuinely new: applying contrastive metric learning (triplet loss with online semi-hard mining) to UTXO outpoints for shard affinity is not present in the cited sharding literature, and the Bag-of-OP-Codes encoding is a domain-appropriate feature. The paper correctly identifies cross-shard parent-child dependencies as a real bottleneck in UTXO sharding.

What the paper does well: the writing is clear, the training formulation is standard and sensible, and the random-allocation baselines are a reasonable sanity check. The plots show the embedding does separate parent-child pairs on the training objective.

The soft spots are, however, load-bearing. The feature-sufficiency problem is fundamental, not cosmetic. Even if you granted the feature vectors, the evaluation only measures the probability that held-out parent-child pairs land in the same cluster — which is exactly the objective minimized during training. There are no measurements of throughput, latency, cross-shard communication ratio, or comparisons with hash-based or graph-based sharding. No code or hyperparameters are provided, so the results are not reproducible. The nearest-neighbor tricks in Fig. 3 are a useful diagnostic but do not rescue the routing claim.

Summary: this is a plausible exploratory idea that currently fails on its central promise. A serious referee would need substantial rework — at minimum a clear statement of what features are actually available at routing time, and an evaluation against a real system metric.

My recommendation: desk-reject in current form. The idea might be worth a rewrite, but as submitted the mechanism is broken and the evidence is thin.

Referee Report

3 major / 6 minor

Summary. The paper proposes a machine-learning framework for partitioning the UTXO set of a UTXO-based blockchain into shards and routing incoming transactions to the shard predicted to contain their parent UTXOs. The method encodes transaction outpoints using global features, local outpoint features, and positional encodings (Table I); trains an MLP encoder with triplet loss where positive pairs are parent-child outpoints and negatives are unrelated outpoints (Section III.C); and clusters the resulting embeddings into shards. The evaluation, on a BSV dataset of roughly 100 million transactions split 80/20, measures the probability that parent-child outpoints are assigned to the same shard (Section IV.A, Fig. 3) and reports distributions of positive-pair similarities and distances (Figs. 4-5). The central claim is that the model embeds parent-child spending patterns in its parameters and therefore eliminates real-time parent transaction lookups during inference, reducing cross-shard communication and increasing throughput.

Significance. The idea of learning a static routing function from transaction-local features is potentially interesting, and the scale of the historical dataset (6,000 BSV blocks, ~103 million transactions) is a genuine strength. However, the stated contribution—lookup-free routing to the exact parent UTXO's shard—is not supported by the feature design, and the evaluation is circular with respect to the training objective. The paper reports no throughput, latency, cross-shard ratio, or end-to-end communication measurements, and it does not compare against hash-based sharding (Teranode/Monoxide) or graph-partitioning baselines (Metis/CLPA) that it cites. If the result were to hold, it would be a modest algorithmic contribution to blockchain sharding, but as presented the empirical evidence does not establish the claimed scalability benefits.

major comments (3)

[III.B, Table I] The claimed lookup-free inference is not supported by the feature design. For a spending transaction, the only parent-specific information in the input is the referenced txid and output index, but the feature vector in Table I contains no parent txid, no output index, and no amount or locking-script data of the referenced parent UTXO: the 'Local' features describe the outpoint being considered (its own amount and locking-script size), not the parent outpoint being spent. Consequently, two structurally identical transactions that reference different parent UTXOs receive identical feature vectors and identical embeddings, so the model cannot route them to different parent shards. This is an information-theoretic limitation of the proposed architecture, not a tuning issue, and it invalidates the abstract's claim that the model 'eliminates the need for costly, real-time parent transaction lookups.' At best, the model can cluster by coarse in-transaction statistics and script types, which does not provide exact parent-child routing.
[IV.A, Fig. 3] The evaluation is circular with respect to the central claim. Accuracy is defined as the probability that a parent-child outpoint pair lands in the same shard, which is exactly the quantity minimized by the triplet loss in Eq. (3) on the same historical dataset (80/20 train/test split, Section III.D). A high value on this metric shows only that the model satisfies its own training objective on held-out data; it does not measure cross-shard communication overhead, validation latency, or throughput. The paper reports no end-to-end measurements, no cross-shard ratio, and no comparison with the hash-based sharding of Teranode/Monoxide or with graph-partitioning baselines (Metis, CLPA) discussed in Section II, so the abstract's throughput and scalability conclusions are unsubstantiated.
[IV.A, K-nearest-neighbor paragraph] The K-nearest-neighbor result is not an independent validation and, as stated, undermines the routing claim. The 'nearest shards' are determined by the same learned embedding distances used for the initial prediction, so improved K>0 accuracy is a self-consistency measure on the training objective rather than an evaluation of communication cost. Moreover, checking the 3 or 9 nearest shards to fetch the parent UTXO requires querying multiple shards before validation, which reintroduces the cross-shard communication that the method claims to eliminate; the paper does not quantify how this affects the purported savings.

minor comments (6)

[III.A] The heading 'Duel-Model Architecture' contains a typo; it should read 'Dual-Model Architecture.'
[II] In the Related Work section, 'encodithrough' is a typo for 'encoding through.'
[IV.A] The text says 'Accuracy was measured by the probability of correctly assigning parent-child to the same shard (Fig. 2)', but Fig. 2 illustrates negative samples; the accuracy plot is Fig. 3. The figure references are mismatched.
[III.C.2] The phrase 'resulting in trivial solutions learnt (e.g., c)' refers to an undefined collapsed-embedding symbol; the collapsed constant should be defined explicitly (e.g., c as a constant vector) or the notation introduced.
[III.B, Table I] The positional encoding feature is described only as 'Positional Encoding Vector for a given outpoint position within a transaction', but the construction is not explained; please specify how positional encodings are generated for outpoints and why they differentiate 'identical outpoints.'
[IV.A] The statement 'we saw ~10 distinct point clusters in the embedding space' is anecdotal and unsupported by any cluster-analysis or visualization; either provide a reproducible clustering analysis or remove the claim.

Circularity Check

2 steps flagged · score 6.0 of 10

The no-lookup routing claim is circular: the input feature vector is defined to include the parent output's amount and locking-script data, which is exactly the information a real-time parent lookup would supply, and the headline accuracy metric directly re-measures the training objective.

self definitional [Section III.B, Table I (Feature Extraction from Bitcoin Transactions)]
"Local features focus on outpoint-specific attributes, such as the amount and the size of the locking script. ... This constraint limits our features to those available with the incoming transaction."

The feature vector defined in Table I includes 'Local Amount' and 'Local Locking Script Size' for an outpoint. For a spending input, the referenced parent outpoint is identified only by txid and output index; the parent's amount and locking script are not in the incoming transaction. Thus the no-lookup routing claim is assumed by construction: the model's input is specified to include exactly the parent-output attributes that a real-time lookup would return. The shard of the parent is therefore determined by information that is unavailable at inference, so the claimed elimination of lookups reduces to the definition of the input features rather than to a learned result.
fitted input called prediction [Section IV.A (Results, Accuracy of Clustering)]
"Accuracy was measured by the probability of correctly assigning parent-child to the same shard ... Results show a substantial improvement over random methods, especially up to 10 shards (red vertical line), achieving >90% accuracy in shard assignment."

The model is trained with triplet loss whose positive pairs are parent-child outpoints and whose objective is to minimize their embedding distance (Section III.C.1). The reported accuracy—the fraction of parent-child pairs placed in the same shard by the learned embedding—is a direct readout of that same objective on a held-out split of the same dataset. It is the fitted quantity renamed as 'accuracy' for routing. No end-to-end benchmark measures actual cross-shard message reduction or routing from a raw incoming transaction without parent data, so the headline result does not independently support the no-lookup communication-savings claim.

full rationale

The paper's central derivation chain is: define outpoint features, train an embedding with triplet loss on parent-child positive pairs, then cluster embeddings into shards and report the fraction of parent-child pairs landing in the same shard as evidence that lookups can be eliminated. The first link is circular: the feature vector for an input outpoint is defined using that outpoint's amount and locking-script size, but a Bitcoin spending input does not carry those attributes; only txid:vout is present. The no-lookup property is therefore baked into the feature definition rather than learned. The second link is a fitted-input-called-prediction pattern: the reported accuracy is the same parent-child proximity objective that was optimized during training, re-measured on the test split, and the paper presents this as validation of reduced cross-shard communication without any live throughput or message-count measurement. There is no load-bearing self-citation chain; the references to FaceNet and transformers are standard external methods. The score is 6 rather than higher because the embedding itself is genuinely trained, but the central operational claim reduces to the input definition and the evaluation objective, making the headline result substantially circular.

Assumptions & free parameters 4 free parameters · 3 assumptions · 0 invented entities

The central claim rests on hand-chosen features and hyperparameters, on the untested sufficiency of local features, and on the generalizability of historical transaction patterns. The model weights themselves are fitted to data and are not released, so the reader cannot audit what the learned mapping actually encodes.

free parameters (4)

Triplet loss margin m = not reported
Margin in triplet loss chosen to balance separation and collapse; no value is given, so the loss in Eq. (3) is not reproducible.
Number of shards / clusters = evaluated over 1-100
The cluster count is a system parameter tied to validator topology; no criterion or sensitivity analysis is given, and the paper notes around 10 natural clusters.
Bag-of-OP-Codes vocabulary = 7 codes (six named plus 'Other')
Hand-chosen vocabulary of OP codes for script encoding; alternative vocabularies would change the input features.
MLP encoder weights = trained, not shared
All learned parameters of the MLP are fitted to the training split; without the model artifact, no reproduction or audit is possible.

assumptions (3)

ad hoc to paper Transaction outpoint feature vectors constructed only from locally available transaction data contain enough signal to identify the shard of the parent UTXO.
Assumed in Section III.B and in the accuracy evaluation; if false, the no-lookup routing claim fails.
domain assumption Triplet loss with online semi-hard negative mining yields an embedding where Euclidean distance is a reliable proxy for parent-child spend relationships on unseen transactions.
Standard ML assumption, invoked in Section III.C, but not demonstrated beyond the training distribution.
domain assumption Historical BSV transaction data from 2024-06-21 to 2024-08-01 is representative of future UTXO workloads and validator configurations.
The split and evaluation in Section IV assume generalizability beyond the 42-day window.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Contrastive Learning for Efficient Transaction Validation in UTXO-based Blockchains." pith.science (2026). https://pith.science/paper/7ZFYLNBP

@misc{pith2026250601614,
  author       = {Pith},
  title        = {Pith review of: Contrastive Learning for Efficient Transaction Validation in UTXO-based Blockchains},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/7ZFYLNBP}},
  note         = {Machine review of arXiv:2506.01614}
}

read the original abstract

This paper introduces a Machine Learning (ML) approach for scalability of UTXO-based blockchains, such as Bitcoin. Prior approaches to UTXO set sharding struggle with distributing UTXOs effectively across validators, creating substantial communication overhead due to child-parent transaction dependencies. This overhead, which arises from the need to locate parent UTXOs, significantly hampers transaction processing speeds. Our solution uses ML to optimize not only UTXO set sharding but also the routing of incoming transactions, ensuring that transactions are directed to shards containing their parent UTXOs. At the heart of our approach is a framework that combines contrastive and unsupervised learning to create an embedding space for transaction outputs. This embedding allows the model to group transaction outputs based on spending relationships, making it possible to route transactions efficiently to the correct validation microservices. Trained on historical transaction data with triplet loss and online semi-hard negative mining, the model embeds parent-child spending patterns directly into its parameters, thus eliminating the need for costly, real-time parent transaction lookups. This significantly reduces cross-shard communication overhead, boosting throughput and scalability.

Figures

Figures reproduced from arXiv: 2506.01614 by the authors.

**Figure 1.** Since must efficiently shard incoming transactions in real-time, it relies solely on immediately available data when receiving an incoming transaction. This constraint limits our features to those available with the incoming transaction. To encode the locking script information for outpoint features, we propose Bag of OP Codes - an encoding like bag of words in Natural Language Processing (NLP) but applied to Bitcoi… view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

2 extracted references

[2]

The margin defines a buffer zone that maintains separation between positive and negative pairs, ensuring significant discrimination rather than mere proximity

Selection of Negative Pairs: Incorporating the margin mmm and the online selection of negative samples is vital for creating well-separated and generalisable embeddings. The margin defines a buffer zone that maintains separation between positive and negative pairs, ensuring significant discrimination rather than mere proximity. Negative samples challenge ...

arXiv 2024
[9]

Zheng et al.Blockchain Transactions via StaIEEE Transactions on Industrial Informatics, 2022

P. Zheng et al.Blockchain Transactions via StaIEEE Transactions on Industrial Informatics, 2022. [10] International Conference on Distributed Computing Systems, 2019. [11] H. Huang et al.-Shard Blockchain Protocol for Account/Balance-IEEE Computer and Communications Societies, 2022. [12] [Online]. Available: https://coingeek.com/under-the-bitcoin-hood-her...

arXiv 2022

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [2]

The margin defines a buffer zone that maintains separation between positive and negative pairs, ensuring significant discrimination rather than mere proximity

Selection of Negative Pairs: Incorporating the margin mmm and the online selection of negative samples is vital for creating well-separated and generalisable embeddings. The margin defines a buffer zone that maintains separation between positive and negative pairs, ensuring significant discrimination rather than mere proximity. Negative samples challenge ...

arXiv 2024

[2] [9]

Zheng et al.Blockchain Transactions via StaIEEE Transactions on Industrial Informatics, 2022

P. Zheng et al.Blockchain Transactions via StaIEEE Transactions on Industrial Informatics, 2022. [10] International Conference on Distributed Computing Systems, 2019. [11] H. Huang et al.-Shard Blockchain Protocol for Account/Balance-IEEE Computer and Communications Societies, 2022. [12] [Online]. Available: https://coingeek.com/under-the-bitcoin-hood-her...

arXiv 2022