ef-dai-team/wallet-eval-benchmark

Wallet tool-calling eval benchmark

The eval side of the wallet fine-tuning work: what the models are scored on.

The training rows are deliberately not published. These cases are held out from them by construction, and that is the only reason a score here means anything. If you train on this benchmark, say so — a number from a contaminated run is not comparable to the ones below.

The model these cases were used to select is public: ef-dai-team/gemma-4-E4B-wallet-ft-v5, which scores ~95% on v5-1000. gpt-5 scores 92.8% on the same cases. Beating it on-device is the interesting target.

Three benchmark generations are published side by side, because the difference between them is the point:

	v1-307	v4	v5-1000
cases	307	429 + 140 protocol	1000 (the benchmark)
tool contract	executeTx(chainId, to, value, function, args)	transfer, swap	same as v4
amount units	base units (wei)	human decimal units	human decimal units
recipient	resolved to a 0x… address	passed through verbatim	passed through verbatim
system prompt	the harness's own ~4 KB scaffold	the wallet app's verbatim prompt bytes	same
abstention	not scored	88 cases	120 cases (12.0%)
conversation depth	1 turn	1-2 turns	1-6 turns, 66.4% multi-round
Aave/Safe	—	140, run separately	removed (no such tool ships)

Why v1-307 was replaced

v1-307 measured a contract the macOS wallet never registers. Grep executeTx in WalletToolLayer/ToolDefinitions.swift and you get nothing: the app exposes transfer and swap, takes amounts in human units, and resolves ENS itself. A model could score 80.1% on v1-307 and still be unable to drive the wallet — and the shipped fine-tune, trained against that contract, did exactly that: 71.9% of its outputs produced a signable UserOperation.

Fixing the schema was necessary but not sufficient. The remaining gap was the prompt: the app renders its prompt through each model's own chat template (llama.cpp converts OpenAI-shape tools into the FunctionGemma DSL in C++), which Python reproduces only via apply_chat_template(..., enable_thinking=True) plus a <bos> strip. v4 therefore ships the app's rendered prompt as a checked-in artifact — v4/app_contract_reference.json (Gemma) and .qwen.json (Qwen) — emitted by the wallet's own wallet-eval prompt-dump command. Byte-parity against those files is asserted in three places: at provider load, inside the training container before any GPU spend, and in a standalone CPU job.

Two latent defects surfaced from that assertion, and both had been silently present in every earlier fine-tune: enable_thinking was never passed (so no model had ever trained with the <|think|> marker the app emits), and the eval provider was rendering 2925 characters where the app sends 2935.

Contents

v1-307/
  tests.generated.yaml     307 cases, executeTx contract
  prompt.py  tools.json  assert.py    the harness that scored them
v4/
  tests.app-contract.yaml  429 wallet cases (341 tool-call + 88 abstain)
  tests.protocols.yaml     140 Aave/Safe cases (builder contract, see below)
  tests.combined.yaml      569 = the two above (kept; not the default)
  tests.refusals.yaml      49-case safety subset, for fast iteration
  prompt.py                per-case prompt/tool branching
  tools.app.json           the app's two tools, synced from the app
  tools.json               the builder contract, for protocol cases only
  app_contract_reference.json / .qwen.json   the app's verbatim prompt bytes
  assert.py                the scorer
v5-1000/
  tests.combined.yaml      1000 cases = the 429 below + 571 multi-round
  tests.app-contract.yaml  429 single/2-turn wallet cases
  tests.conversations.yaml 571 2-6 round conversations, six mechanisms
  prompt.py  assert.py  tools.app.json  tools.json
  app_contract_reference.json / .qwen.json   the app's verbatim prompt bytes
  lookup.json              token symbols, decimals, mainnet addresses
  csv/                     one row per case, for spreadsheet review
results/
  summary.md               headline numbers, both harnesses

What v5-1000 adds

v4 measures the right contract on the right prompt, but it is a shallow benchmark: 429 cases, almost all one or two turns. v5-1000 keeps the same contract and prompt and asks whether accuracy survives depth.

• 571 multi-round cases, 2-6 turns. A round is one user turn plus the assistant's reply, and only the model's reply to the last user turn is scored. Round mix: 1: 336, 2: 273, 3: 150, 4: 110, 5: 80, 6: 51.
• Six mechanisms. Four test conversational memory — progressive (fields revealed one per round), correction (values revised mid-conversation; gold takes the LATEST, and a revision never returns a field to its original value), distractor (off-topic interruptions, some carrying numbers that must not reach the call), switch (a completed request abandoned for another; gold is the final intent ALONE). Two test the contract boundary: exact_output (32) and token_address (24).
• Aave/Safe removed. The wallet ships no lending or multisig tool, so executeTx gold scored a capability the product does not expose — and it was ~25% of the old combined number.

Two gold fields that could not discriminate

Found by reading the dataset, not by any test — which is why v5-1000 ships a test that fails on the whole class:

field	was	why it mattered
swap.amount_side	"input" in 436/436 golds	a model hardcoding the string scored it perfectly
arithmetic/transfer.to	vitalik.eth in 36/36	and 51.5% of transfer golds overall

The second was invisible in the whole-dataset view, where to had 63 distinct values — so the checks run per slice as well as globally.

amount_side gets no "output" gold, deliberately: the wallet rejects that value in two places (ChatDashboardView.swift:3335, SlashCommandParser.swift:66), so such gold would score models on a call the app throws on. Dropping the field from scoring is also worse than it looks — a model emitting "output" correctly fails today. Instead the 32 exact_output cases expect no call, so hardcoding "input" now costs 32 cases.

vitalik.eth was also the only ENS name in the training set, making "handles ENS" indistinguishable from "memorised one string". v5 draws from a 14-name bank that excludes it — disjoint from training by construction — and now has 13 distinct ENS names with vitalik.eth at 14% of transfer golds, all inside the frozen subset. A model fine-tuned on the older data should be expected to score lower here on transfers; that drop is the memorisation being measured.

Auditing this turned up three wallet bugs

pf/tools.app.json documents argument forms the executor rejects, so a model following the schema correctly produces an unexecutable call. Filed as local-wallet-mac#92, #93 and #94.

schema says	executor does	in v5?
token: "or a 0x contract address"	token(matching:) resolves it	yes — token_address
amount: 'the literal "all"'	guard rawAmount != "all" throws	no
to: "or a contact name"	guard rawRecipient.contains(".") throws	no

Whole-balance sends and contact-name recipients were proposed as slices and dropped for this reason. Gold must be a call the wallet can execute — check the executor, not just the schema.

No v5 scores are published here yet

The four-model run (gemma base / gemma ft-v4 / qwen base / qwen ft-v4) is in progress. No previously published number is comparable: v5 is 1000 cases, drops 140 Aave/Safe, adds 571 harder ones, and its no-call floor is 12.0% rather than v4's 20.5%. Read the call/no-call split, not a bare headline.

The protocol cases are a separate run

v4/tests.protocols.yaml (90 Aave + 50 Safe) keeps the builder contract — executeTx, base units, resolved addresses — and its reference blocks. These are capabilities the wallet does not have today, kept so the roadmap stays measurable.

They are not part of the benchmark headline and are not averaged into any number on this page. Run them deliberately:

EVAL_DATASET=v4/tests.protocols.yaml scripts/eval.sh -c <config> -o out.json -j 1

No protocol scores are published here

An earlier version of this page reported 0/140 for base, gemma-v4 and qwen-v4 alike and drew a conclusion from it. That figure came from a broken scorer and is withdrawn rather than corrected.

parsing._coerce_args ran json.loads on the args payload and returned [] on failure. Gemma-4's own chat template serializes an array argument element-wise in its DSL quote markers — [<|"|>0x8DbC…5Cb<|"|>,<|"|>3<|"|>] — which is not JSON, so a byte-perfect answer was reported as args: expected [...] got [], indistinguishable from no answer at all.

It was almost purely a base-model bug: base emitted the DSL-wrapped array in 136 of 140 protocol outputs, gemma-v4 in 18, qwen-v4 and ft-old in none. The fine-tunes were trained to emit bare JSON. So the loss fell entirely on the baseline the fine-tunes were being compared against.

Fixed in the harness (_decode_dsl_quoted_array restored; an undecodable payload now surfaces as UndecodableArgs instead of []). No replacement protocol figure is published until it has been measured cleanly.

Results

Scored on the app's verbatim prompt, local Q4_K_M GGUF at the quant the wallet runs.

slice	n	base	ft-v4 (gemma)	ft-v4 (qwen)
transfer (single-turn)	129	91.5%	96.1%	93.0%
swap (single-turn)	120	95.8%	97.5%	95.0%
multi-turn slot-filling	92	94.6%	96.7%	97.8%
ablation / arithmetic	39	89.7%	100.0%	97.4%
safety refusal	49	61.2%	91.8%	87.8%
total	429	89.7%	96.5%	94.4%

The benchmark above is a proxy. The binding measurement is the wallet's own wallet-eval userop funnel, which runs each generation through the app's real parse → tool → intent → build path and checks that a signable ERC-4337 UserOperation comes out the other end:

model	signable UserOp (341)	correct abstention (88)	combined (429)
ft-old (ships today)	71.9%	—	—
base	88.6%	79.5%	86.7%
gemma-4 E4B ft-v4	97.1%	95.5%	96.7%
qwen3-8B ft-v4	96.5%	93.2%	95.8%

Reproducing

git clone https://github.com/Ethereum-dAI/evals-local-llm
cd evals-local-llm
EVAL_DATASET=pf/tests.app-contract.yaml scripts/eval.sh \
  -c promptfooconfig.gemma4-fourway.yaml -o out.json -j 1

-j 1 is required: the providers are local llama.cpp processes sharing one Metal device, so concurrency contends for the GPU rather than speeding anything up. scripts/eval.sh (not bare npx promptfoo) is also required — it exports PROMPTFOO_PYTHON so the scorer can import wallet_evals; without it every case fails with ModuleNotFoundError while still burning the run.

Related

• Models: gemma-4-E4B-wallet-ft (v1, shipping) · gemma-4-E4B-wallet-ft-v4 (v4 candidate, recommended) · qwen3-8b-wallet-ft-v4 (v4, same training data, different base)
• Training data: wallet-tool-calling-ft