Entendre/Crypto-Accounting-Bench

Crypto Accounting Bench

Can a language model read one crypto transaction and reproduce the complete journal entry an organization actually recorded for it?

Not the entry a textbook would prescribe - the entry that is in that organization's ledger, chosen from that organization's own chart of accounts. That is a harder and more realistic problem: the same on-chain movement is booked differently by different organizations, and the model has to infer the convention from the evidence in front of it.

• 123 tasks, one directory each, self-contained
• 7 organizations, each with its own chart of accounts (95-583 accounts)
• 8 transaction types, 21 assets, 11 chains
• Every task carries a frozen weighted rubric and a graded expected answer

Links

Evaluation runner	crypto-accounting-benchmark on GitHub
How this benchmark was built	docs/METHODOLOGY.md
Canonical metric definitions	docs/EVALUATION.md
Reproducibility and audit trail	docs/REPRODUCIBILITY.md
Research paper	forthcoming; the link is added here on publication

This dataset and that runner are one component. The dataset is the evidence and the answer key; the runner is the supported way to execute a model against it, score attempts, and produce a comparable result.

Privacy. This is a transformed public derivative. Every organization, legal entity, person, counterparty, venue, bank, account name, account number, address, transaction identifier, asset ticker, chain, amount, quantity and timestamp has been replaced by a synthetic value, consistently across the whole dataset. Records here must not be read as literal records of any real organization. See TRANSFORMATION_REPORT.md and PUBLICATION_AUDIT.md.

License: Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0). You may share and adapt this dataset with attribution, for non-commercial purposes.

Layout

README.md                     this file
DATASET_CARD.md               dataset card
TRANSFORMATION_REPORT.md      what was transformed, and how
PUBLICATION_AUDIT.md          privacy audit results + authorization status
manifest.json                 counts, composition, per-file checksums
schema/expected_answer.schema.json
examples/example_input.json
examples/example_expected_answer.json
examples/run_benchmark.py     dependency-free scoring harness
tasks/task_0001/
    task.md                   human-readable statement of the task
    prompt.md                 ready-to-send model prompt
    input.json                structured evidence + chart of accounts
    expected_answer.json      graded answer + rubric  (do not show the model)
...
tasks/task_0123/

Task format

Each input.json wraps its evidence in an input object, alongside task metadata:

Top-level key	Meaning
input	the public evidence, described in the table below
requiredOutput	the answer shape the model must return
taskType	crypto_accounting_full_entry for every task
organizationId	which organization's ledger and chart the task comes from
categoryAccountSolvability	admission label: the deciding account is reachable from the visible evidence. Evaluator metadata, not rendered into prompt.md
benchmark, task_id	identity of the benchmark task

So the evidence fields below are read at input.json -> input -> field, for example input.amounts.grossQuantity. Optional fields are absent rather than null when the source record does not resolve them.

input.input holds the public evidence:

Field	Meaning
organizationName	the organization that recorded the transaction (synthetic)
transactionType	the label the source application displays to the accountant. Open vocabulary, may be absent or UNKNOWN, and is not a reliable guide to the treatment
transactionDate	date and time, minute precision
transactionGroupId	identifies the on-chain action. Records sharing a group id came from one transaction
flowDirection	INFLOW (the source received) or OUTFLOW (the source sent)
assetType, chain	synthetic asset ticker and chain
amounts	grossQuantity / netQuantity / feeQuantity in asset units at full precision; grossValueBase / netValueBase / feeValueBase in currency at 2 decimal places; assetUnitPrice; quantityDecimalPlaces
fromAddress, toAddress	the two addresses on the transaction
source	the organization's own wallet or exchange account: name, walletType, chain, sourceType, isStakingAccountWallet, legalEntity
counterparty	the other side as the organization's records resolve it, with legalEntity, isZeroAddress and smartContractMetadata where they resolve
externalSource	the organization's own label for the other side
contractData, functionData, meta	contract, function called, token metadata
relatedTransactions	the organization's other records in the same transaction group
recurrenceProfile	factual summary of similar prior receipts into this wallet
taxLotEvidence	the cost-basis subledger rows: lotsCreated, lotsRelieved, methodology, proceedsBase
chartOfAccounts	the organization's complete ledger. The only accounts you may post to

prompt.md renders exactly the same content as a model prompt, with the reasoning guidance the benchmark uses.

Expected output

A model must return one JSON object:

{
  "journalEntry": {
    "lines": [
      {
        "ledgerAccountName": "<exact ledgerAccountName from the supplied chart of accounts>",
        "drCr": "Debit | Credit",
        "amountBase": "<decimal string, exactly 2 decimal places>",
        "currency": "USD"
      }
    ]
  },
  "assetQuantity": "<the transaction's asset quantity, full precision, as a decimal string>"
}

Rules the grader assumes:

• include all and only the lines the recorded treatment affects - the wallet/asset line and every non-wallet treatment line the evidence supports;
• copy ledgerAccountName exactly as it appears in the chart, including the leading account number and separator;
• amountBase is a base-currency amount with exactly two decimal places;
• assetQuantity is not rounded;
• total debits must equal total credits per currency;
• line order does not matter;
• relatedTransactions are context, not additional accounting targets.

expected_answer.json adds grading metadata: keyLineAccounts (the deciding non-wallet account - the hard half of the task), realizedGainLoss, entryShape, tags, a plain-language explanation, reasoningEvidence (which signals in the evidence support the answer), and the task's rubric. Full schema in schema/expected_answer.schema.json.

Evaluation

Each task carries a frozen, task-specific rubric: ordered binary criteria with weights that sum to 1.0. The stored passThreshold of 0.85 is an attempt-level diagnostic; it is not the benchmark's headline Pass@k rule. The rubric families and criteria used across the dataset:

Rubric family	Tasks
TRANSFER	37
INCOME_EXPENSE	27
INTERCOMPANY	21
SWAP	16
REALIZED_GAIN_LOSS_B	7
FEE	12
REALIZED_GAIN_LOSS_A	3

Headline metrics, as the benchmark defines them. These names are canonical and are the same names the runner reports; the full definitions live in docs/EVALUATION.md, and if any summary disagrees with that file, that file wins.

Metric	Definition
Mean Score	average rubric score over every expected attempt. Missing and failed attempts stay in the denominator with score zero
Best@k	average of each task's best rubric score over k attempts
Pass@k	share of tasks with at least one attempt that earns the full 100% rubric score and clears every required gate
Exact@k	share of tasks with at least one strict complete-entry exact match
Deciding account@k	share of tasks where an attempt produces every keyLineAccounts entry - the hard half
Wallet account@k	share of tasks where an attempt produces every expected wallet/counter account - the easier half
Amount@k, Dr/Cr@k, Quantity@k, Balanced@k	component diagnostics over the same attempts

Pass@k requires a full rubric score and every gate. An attempt that returns an unbalanced entry, an unparseable response, a rounded asset quantity, or the wrong currency does not pass. The gate list is in docs/EVALUATION.md.

The upstream benchmark scores rubric criteria with an LLM judge and sums the weights locally; exact-match and deciding-account accuracy are audit diagnostics. This dataset ships examples/run_benchmark.py, which computes the same weighted structure deterministically - it decides each criterion from account/side/amount equality rather than by judgement. It is a faithful lower bound, not an identical reimplementation: a judge can credit a correct treatment expressed through a different-but-defensible account, and the deterministic scorer cannot. Report which scorer you used.

Two implementations of that deterministic scorer exist, and they are not independent claims: cab in the evaluation runner is canonical, and examples/run_benchmark.py here is a zero-dependency mirror for readers who want to score without installing anything. Both are held to the same self-test - score the expected answers and require 1.0 - so a normalization defect in either shows up as a self-test failure rather than as a quietly different leaderboard.

Run it with the official runner

The supported path is the evaluation runner, which downloads and verifies this dataset, executes a configured model, scores every attempt, and writes an HTML report and a cross-model leaderboard:

git clone https://github.com/EntendreFinance/BENCHMARKS.git
cd BENCHMARKS/crypto-accounting-evaluation
pip install -e ".[openai]"

cab dataset download          # pulls this dataset
cab dataset verify            # checksums, task count, rubric totals, chart membership
cab self-test                 # expected answers must score 1.0

cp pipelines/openai-responses.example.yaml pipelines/my-model.yaml
cab benchmark --pipeline pipelines/my-model.yaml --attempts 3 --max-concurrent 4

Pin a dataset revision when you publish a result, so the run is reproducible against exactly these files:

cab dataset download --revision DATASET_REVISION

Scoring without the runner

# 1. self-test the scorer (expected answers must score 1.0)
python examples/run_benchmark.py --tasks tasks --out selftest.json

# 2. score a model: the command receives prompt.md on stdin, prints JSON on stdout
python examples/run_benchmark.py \
    --tasks tasks --attempts 3 \
    --model-command 'my-model-cli --stdin' \
    --out results.json

Or drive it yourself: for each tasks/task_NNNN/, send prompt.md to the model, parse the JSON it returns, compare against expected_answer.json, and aggregate. Nothing outside this directory is needed - no credentials, no network, no services.

Dataset composition

Transaction type	Tasks
WITHDRAWAL	29
INTERCOMPANY TRANSFER	23
DEPOSIT	29
FEE	15
SWAP	16
INTERNAL TRANSFER	7
BORROW	1
REALIZED_PNL	3

Rubric family	Tasks
TRANSFER	37
INCOME_EXPENSE	27
INTERCOMPANY	21
SWAP	16
REALIZED_GAIN_LOSS_B	7
FEE	12
REALIZED_GAIN_LOSS_A	3

Non-zero journal-entry lines	Tasks
2	113
4	10

Deciding-account solvability	Tasks
inferable_from_visible_evidence	123

Property	Count
tasks with tax-lot evidence	43
tasks with a realized gain/loss line	10
tasks with related records in the same group	65
distinct synthetic assets	21
distinct synthetic chains	11

Synthetic assets

Asset identity is synthetic, but asset class is preserved, because the class is what the accounting turns on.

Ticker	Class
BRT	chain-native / protocol asset
DVL	chain-native / protocol asset
DVLX	chain-native / protocol asset
KRN	chain-native / protocol asset
OSK	chain-native / protocol asset
SYL	chain-native / protocol asset
TFND	asset recorded at or close to par against the base currency
USD1	asset recorded at or close to par against the base currency
USD1e	asset recorded at or close to par against the base currency
USD2	asset recorded at or close to par against the base currency
USD4	asset recorded at or close to par against the base currency
USD5	asset recorded at or close to par against the base currency
USD6	asset recorded at or close to par against the base currency
VLD	chain-native / protocol asset
WRF	organization / protocol governance token
brUSD1	asset recorded at or close to par against the base currency
brUSD2	asset recorded at or close to par against the base currency
brVLD	bridged representation of another chain's asset
gvVLD	yield-vault share token
stDVLX	liquid-staking receipt token
wVLD	wrapped form of a native asset

Prefixes are meaningful and consistent. Used in this dataset: st = liquid-staking receipt, w = wrapped, br = bridged, gv = vault share. The transformation vocabulary also reserves av = lending-market deposit receipt and vd = variable-debt receipt; no asset in this dataset carries either prefix.

Synthetic chains

Chain	Class
brint	independent L1, UTXO model
cedron	EVM-compatible settlement network
dorval	EVM sidechain settling to veldt
korrin	independent L1, EVM
marnet	EVM rollup settling to veldt
oskil	independent L1, non-EVM proof-of-stake
quill	EVM rollup settling to veldt
sylva	EVM application rollup settling to veldt
tarnis	EVM rollup settling to veldt
veldt	L1, EVM, settlement chain for veldt-family rollups

Limitations

• This is an accounting-reasoning benchmark, not a market, trading or price-prediction benchmark, and not a test of what the correct accounting treatment is in the abstract. It measures reproduction of a recorded treatment.
• The public dataset is transformed. Amounts, quantities, prices, dates, identifiers, names and asset/chain identities are synthetic. Do not treat any record as a factual statement about a real organization, transaction, person or counterparty, and do not attempt to match records against public chain data.
• Expected answers reflect one set of accounting conventions - those of the organizations whose ledgers the tasks derive from. A different-but-defensible treatment scores as wrong. That is deliberate: the task is reproduction.
• Coverage is uneven. Organizations, transaction types and rubric families are not balanced; 41 of 123 tasks come from a single organization. Aggregate scores are not a uniform sample of crypto accounting.
• Task difficulty is not labelled at a useful grain. Some tasks are decidable from a single strong signal (a counterparty label that effectively names the account) and others require combining several. The dataset does not tell you which is which: categoryAccountSolvability carries the single value inferable_from_visible_evidence on all 123 tasks, because reaching the deciding account from visible evidence was an admission requirement rather than a property that varies. Treat it as a guarantee about the dataset, not as a difficulty label.
• Answers are graded by account name, so an equally valid account under a different name in the same chart scores as wrong.
• The deterministic scorer shipped here is a lower bound on a judge-based score.

Citation

The research paper is not yet public. Its citation, DOI, and URL will be added here and to CITATION.cff after publication. Until then, cite the dataset:

@misc{crypto_accounting_bench_2026,
  title        = {Crypto Accounting Bench},
  author       = {{Entendre Finance}},
  year         = {2026},
  note         = {Public benchmark dataset. Research paper forthcoming},
  howpublished = {\url{https://huggingface.co/datasets/Entendre/Crypto-Accounting-Bench}}
}

State the scorer you used when reporting a result, for example: "Crypto Accounting Bench, public deterministic lower-bound scorer".