Research question: in the FLOP devnet runtime (tzkv-runtime, spec 1014014), exactly how does pallet FlopSessionKeys decide what a session's delegate may call and how much it may spend, and how are ComputeChannel payments counted by it? As far as we know the pallet source is not published, so the answer has to be read out of the runtime code that the chain itself serves.

Why: uxp-labs/flop-devnet-lab builds a daily cap for an IMD worker's FLOP spend that the chain enforces. The design: the seat owner's account S creates a session for the worker's device key D with ComputeChannel as the only allowed pallet, and D opens and funds compute channels through execute_via_session. Your earlier report (https://github.com/Identity-md/research/tree/main/jobs/7350b953-b817-4a46-bc2c-a38eab44de55) described the pallet from the metadata and left the points below unknown. We then tested on devnet (https://github.com/uxp-labs/flop-devnet-lab/tree/main/research/2026-11-11-session-probe): a session with allowed_pallets ["ComputeChannel"] let ComputeChannel.timeout through to the pallet (ChannelNotFound) and refused System.remark (PalletNotAllowed); a failed inner call left the session nonce and counters unchanged and the delegate still paid the fee. FLOP Labs has not answered our questions. Our code will implement what you find and we will send real devnet transactions on the strength of it, so be exact. Label every statement [code] (read from the runtime code: give the function index or data offset and how you found it), [RPC] (read from the node or its metadata), [source] (public source or docs, with URL and commit), [inference] or [unknown].

The input:

  • RPC wss://rpc.devnet.flop.network (public archive node, zkVerify 1.1.0, genesis 0x99c172c095340ace980631f9123544c6bebd4839f3437e463533422d8be2d631). Read only. Do not send transactions and do not use the faucet.
  • The runtime code: state_getStorage("0x3a636f6465"). At finalized block 0xbb72c32265f39382b97e3b438c6cda181cf64fdb4015534457259d43a5b139ab it is 2538890 bytes, state_getStorageHash gives 0x6d47bb492fb404e33d7ea8feedf4ddf5a04ffbc9d5d3a64235641cd06144c1df, and it starts with the 8 bytes 52bc537646db8e05 followed by a zstd frame (28b52ffd). Check the hash, strip the prefix, decompress, and treat the result as WebAssembly. State the sha256 of the decompressed module.
  • Metadata V14 from state_getMetadata: 482132 bytes, sha256 f4fd2addba7fff1129483d0e66b8e6bc69141292f56443e201d3f073aab03444. Pallet indexes: System 0, Balances 4, Utility 30, Multisig 31, Proxy 32, FlopSessionKeys 94, AgentWallet 95, MinerStaking 97, ModelRegistry 101, ComputeChannel 103, AgentIdentity 106.
  • FlopSessionKeys calls: 0 create_session(delegate, spending_cap, per_tx_limit, daily_cap, duration_blocks, allowed_pallets), 1 revoke_session, 2 execute_via_session(owner, call, spend_amount, nonce), 3 force_revoke, 4 force_reset_circuit_breaker, 5 update_session_limits. Errors: 4 SpendingCapExceeded, 5 PerTxLimitExceeded, 6 DailyCapExceeded, 7 PalletNotAllowed, 15 InvalidSessionNonce, 18 SpendExceedsDeclared. Constants: SessionEpochLength 86400, MaxSessionDuration 864000, MaxAllowedPallets 16, CircuitBreakerPeriod 60, MaxTxs 100, MaxSpend 250 FLOP, MaxSessionRotationsPerHour 3.
  • ComputeChannel calls: 0 open_channel, 1 top_up_escrow, 2 settle, 3 force_settle, 4 finalize, 5 timeout(channel_id), 9 force_open(miner, model_hash, measured_root, decode_policy_hash, precision, agent_key, sla, escrow, nonce), 10 force_ack(channel_id, enclave_key), 11 expire_force_open(channel_id). Constants: AckWindow 600 blocks, MinForceOpenEscrowForFailedAck 0.05 FLOP, RefundPenalty 20 percent, EscrowPerReservationSlot 50 FLOP, pallet account "modlflop/chn". Events: 20 ForceOpenRequested(channel_id, agent, miner, escrow, ack_deadline), 21 ForceOpenExpired(channel_id, miner, refunded, failed_acks), 25 TimedOutRefunded(channel_id, refunded).
  • Public material that may help: github.com/flop-labs (yellowpaper, network, sdk, cli), docs.flop.network (for example /docs/send-to-specific-miner), the zkVerify runtime source, Substrate FRAME. If any FLOP pallet source is public after all, cite it at a commit and show that it matches the code on chain. Questions.

A. The deny list. Which pallets or single calls can execute_via_session never dispatch, whatever allowed_pallets says? Give the full list as it sits in the code. How is the inner call's pallet matched against allowed_pallets (the metadata pallet name as bytes, case, an index)? What happens to wrapping calls: Utility batch, batch_all, force_batch, as_derivative, Proxy.proxy, Multisig, Sudo, and a nested execute_via_session? Are the inner calls of a batch checked one by one, or is the wrapper refused, or let through unchecked? Can a session call create_session, update_session_limits or revoke_session for its owner?

B. The spend meter. What does execute_via_session measure as spent: the owner's free balance before and after, free plus reserved, total issuance moves, or the declared spend_amount alone? Whose account is measured, the owner's or the delegate's? Which origin does the inner call run under? Are reserves and holds counted, or only transfers out? Is the transaction fee of the outer call counted, and who pays it? When the declared spend_amount is larger than the real fall, which of the two is added to the lifetime, daily and per call counters and to the circuit breaker? When the real fall is larger than declared, is the whole call rolled back (SpendExceedsDeclared)? When the owner's balance rises during a call, what happens? Does money that comes back later (a refund from expire_force_open, timeout or settle) ever lower the session's counters?

C. The order of checks in execute_via_session and what each failure leaves behind: expiry, revoked, nonce, allowed pallet, per call limit, daily cap, lifetime cap, circuit breaker (per delegate, MaxTxs and MaxSpend per CircuitBreakerPeriod), then the dispatch and the check after it. Which storage changes survive a failed inner call? How does the daily window reset (lazy, from which block, on which call)? What trips the circuit breaker, what does a tripped breaker block, and how does it clear?

D. ComputeChannel money, because this is what a session will pay. For open_channel, top_up_escrow and force_open: which account pays the escrow, is it a transfer to the pallet account or a reserve on the payer, and so would the meter in B see it? What must be true for force_open to succeed: must the miner be registered or staked, must model_hash, measured_root, decode_policy_hash and precision match a registered model or the miner's attestation, is there a smallest escrow, how is the channel id derived, what does nonce guard? What exactly does expire_force_open pay back and to whom: the full escrow, or the escrow less RefundPenalty? What does RefundPenalty apply to? What does MinForceOpenEscrowForFailedAck gate: is an expired force open with a smaller escrow accepted but not counted as a failed ack against the miner? What does a failed ack do to a miner (a counter, a penalty, a suspension, a slash) and where is it stored? Who may call expire_force_open and timeout, and when? We want to test a session on a real channel without harming a miner: say what the smallest harmless test is.

E. A test plan. For each answer in A to D that you could not read with certainty, name the smallest devnet transaction or read that would settle it, with the expected outcome for each possible answer.

The deliverable: report.md with a short answer table first (question, answer, label, confidence), then the evidence per question. Put beside it the scripts you used (fetch, check the hash, decompress, find the functions) so that we can run them again, and the function indexes and data offsets you relied on. If the module has a name section or debug strings, use them. Where the code does not answer, say [unknown] and what you tried.

Published · Report

FlopSessionKeys (pallet index 94) in tzkv-runtime spec 1014014: decided from the on-chain wasm

Inputs checked at block 0xbb72c322…b139ab through the public node https://rpc.devnet.flop.network, using scripts/fetch.sh:

  • :code is 2,538,890 bytes. blake2_256 = 0x6d47bb49…44c1df, which equals state_getStorageHash [RPC]. The prefix 52bc537646db8e05 is followed by zstd 28b52ffd [RPC].
  • The decompressed module is 16,823,341 bytes with sha256 bb19074278e9e14e1a30a8be3399ae5fdb7b5cafbe57e297b49b150502aba2f0 [code].
  • Metadata is 482,132 bytes with sha256 f4fd2add…3444, which matches the brief [RPC]. The runtime version is tzkv-runtime / zkv-node, spec 1014014, tx 2 [RPC].
  • The module has a name custom section (file offset 0xd29f80, 12,176 function names) [code]. The pallet crate is pallet_session_keys. Function indexes below are wasm function indexes, counting the 46 imports. Byte offsets are file offsets into the decompressed module.
  • Key functions [code]:
    • 5182 = the with_transaction closure of Pallet::execute_via_session, body 0x624f..–0x625e.., disassembled with scripts/disasm.py.
    • 5183 = the Iterator::any closure over allowed_pallets (BoundedVec<u8,64> entries).
    • 11236 = check_and_update_circuit_breaker.
    • 4609 = RuntimeCall::get_call_metadata.
    • 4666 = RuntimeCall::dispatch.
    • 10588 / 10589 = Currency::free_balance / total_balance.
    • 12087 = From<Error> for DispatchError.
    • 11404 = consume_session_spend (the interface AgentWallet uses).
  • Error mapping [code + RPC]: the argument passed to function 12087 is the metadata error index + 1. The check is that i32.const 16 precedes InvalidSessionNonce (15) and i32.const 19 precedes SpendExceedsDeclared (18).

Short answer table

#QuestionAnswerLabelConfidence
A1Deny listPallets Utility, Proxy, Multisig, Sudo, Scheduler, EmergencyOverride, FlopSessionKeys are refused with PalletNotAllowed (7), whatever allowed_pallets says. The refusal is per pallet, not per call.[code]high
A2How the pallet is matchedThrough GetCallMetadata::pallet_name, the construct_runtime/metadata name as bytes. The deny list is an exact byte compare. For the allow list, the name is ASCII-lowercased into a 64-byte buffer. The comparison closure (fn 5183) also contains the A–Z lowercasing constants (-65, 26), so the match is ASCII case-insensitive.[code]high / medium-high
A3Wrapping callsUtility (batch, batch_all, force_batch, as_derivative), Proxy., Multisig., Sudo., Scheduler. and a nested execute_via_session are all refused as wrappers. Inner calls are never inspected or let through.[code]high
A4Can a session manage sessions?No. Every FlopSessionKeys call (create_session, update_session_limits, revoke_session, …) is on the deny list.[code]high
B1What is meteredThe owner's free_balance and total_balance, read before and after the dispatch (saturating falls). SpendExceedsDeclared is raised if a fall exceeds spend_amount.[code]high (owner as the measured account: medium-high)
B2Inner call originRuntimeOrigin::from(OriginCaller) built just before dispatch, i.e. Signed(owner).[code] + [RPC probe] / [inference]medium-high
B3Reserves and holdsA reserve or hold lowers free but not total, so it is seen through the free-balance fall.[code] / [inference]medium
B4Outer feePaid by the delegate (the signer) before dispatch. It is outside the measured window and not counted.[inference] + lab probehigh
B5Which amount is countedThe declared spend_amount. The session record (lifetime, daily, per-tx) and the nonce are written before the dispatch. The post-dispatch step only compares.[code]high
B6Real fall > declaredError SpendExceedsDeclared. The whole extrinsic's storage layer is rolled back (with_transaction).[code]high
B7Owner balance risesThe saturating subtraction gives 0, so no error and no credit.[code] / [inference]medium
B8Later refundsNo call path from ComputeChannel into FlopSessionKeys counters was found. Counters are never lowered.[inference]medium
COrder of checksSession exists → not revoked → nonce == expected → not expired (System::Number) → per-tx limit → daily cap (86,400-block epoch, lazy reset) → lifetime cap → deny list → allow list → circuit breaker → write session + nonce+1 → measure → dispatch → measure → compare → event.[code]high for the order
C2After a failed inner callEverything is rolled back, including nonce, counters and breaker. Only the delegate's fee and the extrinsic's own system events remain.[code] + lab probehigh
C3Circuit breakerPer delegate; MaxTxs 100 / MaxSpend 250 FLOP per CircuitBreakerPeriod 60 blocks; error 13 CircuitBreakerTripped; cleared by period reset or force_reset_circuit_breaker. Internals of function 11236 were not read.[RPC]+[inference]medium
DComputeChannel money flows, force_open preconditions, penaltiesNot read from code in this run.[unknown]—

A. Deny list and pallet matching (function 5182)

  • [code] At 0x6254fa the code calls get_call_metadata (fn 4609) on the inner call. It then switches on the pallet-name length (br_table at 0x625520, length − 4) and compares the bytes against inline constants:

    LengthConstant comparedOffset
    40x6F647553 = "Sudo"0x62558c
    50x786F7250 + y = "Proxy"0x625558
    70x6C697455 / 0x7974696C = "Utility"0x625537
    8i64 7451613955223221581 = "Multisig"0x625576
    9i64 7308345369373991763 + r = "Scheduler"0x62559d
    15data at linear address 0x19251c (file 0xceb7bd) = "FlopSessionKeys"0x6255fd
    17"EmergencyOverrid" + e = "EmergencyOverride"0x6255c2

    A match falls through to i32.const 8; call 12087 at 0x62561e, which raises PalletNotAllowed. Every other length (br_table target 9) goes on to the allow list.

  • [code] The function name is not consulted, so the deny list covers whole pallets. As a result:

    • Utility.batch, batch_all, force_batch and as_derivative are refused at the wrapper. Inner calls are not inspected.
    • Proxy.proxy, Multisig.* and Scheduler.* are refused.
    • Sudo.* is refused, if Sudo exists in this runtime.
    • Nested execute_via_session and every create_session, update_session_limits or revoke_session made through a session are refused.
    • Balances, System and others are not on the deny list. They are blocked only when absent from allowed_pallets, which matches the lab's System.remark result.
  • [code] Allow list: from 0x62563c a 64-byte zeroed buffer is filled with the pallet name. Bytes 'A'..'Z' (-65, <26) are OR-ed with 0x20, i.e. lowercased (0x6256c7–0x6256db). Iterator::any (fn 5183) is called at 0x625764. On no match it raises i32.const 8 → PalletNotAllowed (0x625770).

    • [code] fn 5183 contains the same i32.const -65 / i32.const 26 lowercasing pattern (6 hits), so entries are lowercased before comparing. [inference] The match is case-insensitive. The lab's "ComputeChannel" entry passed. Store entries exactly as the metadata name ("ComputeChannel"), which works under either reading.
    • Test E1 confirms this cheaply.

B. Spend meter (fn 5182)

  • [code] 0x6259ab / 0x6259c6: free_balance and total_balance of the account at frame slot 320. This is the same slot the origin is built from at 0x625a19 (RuntimeOrigin::from(OriginCaller)). After dispatch (0x625a3d), the same two reads happen at 0x625a8f / 0x625aaa.
    • Code 0x625aaf–0x625b4b computes saturating before − after for both values and compares with spend_amount. If greater, i32.const 19 → SpendExceedsDeclared (0x625b54).
    • [inference + lab probe] That account is the owner S, and the inner call runs as Signed(S). The ComputeChannel.timeout probe reached the pallet's own ChannelNotFound check, which needs a signed origin.
  • [code] Before the dispatch, at 0x625988, SessionTokens::insert writes the updated session record. At 0x6259a0 the nonce map is written with nonce + 1 (i64.const 1; i64.add). Both happen after the cap checks at 0x625403–0x6254e7, and those checks add the declared amount. So the declared spend_amount is what is added to the counters, never the measured fall.
  • [inference] Over-declaring is safe but consumes cap. Under-declaring aborts the call.
  • [inference] Reserves and holds lower free balance and are caught. A transfer lowers both values. A balance rise saturates to 0.
  • [inference] Fee: transaction-payment withdraws the fee from the signer D before dispatch. D is not the measured account, so the fee is not metered.
  • Refunds: [inference] fn 5182 is the only writer of session spend seen besides consume_session_spend (fn 11404, for AgentWallet). No ComputeChannel function calls into pallet_session_keys by name. Refunds therefore do not lower counters. Not exhaustively proven.

C. Order of checks and side effects (fn 5182, in code order)

  1. [code] SessionTokens::get(owner, delegate) (0x6251c2). If missing → SessionNotFound (arg 2, 0x62562d).
  2. [code] Revoked flag (& 1) → SessionRevoked (arg 4, 0x625305).
  3. [code] Nonce (double map, u64, 0x625330) must equal the supplied nonce → InvalidSessionNonce (arg 16, 0x625382).
  4. [code] Expiry: compared against System::Number (raw key built from i64 constants at 0x62538a) → SessionExpired (arg 3, 0x6253f9).
  5. [code] Per-tx limit (spend_amount ≤ per_tx_limit) → PerTxLimitExceeded (arg 6, 0x625429).
  6. [code] Daily cap: uses constant 86400 (0x625460). If now ≥ day_start + 86400 the daily counter is treated as 0 and day_start is reset; otherwise daily_spent + spend is compared with daily_cap → DailyCapExceeded (arg 7, 0x625498).
    • [inference] The reset is lazy and happens only inside execute_via_session. The epoch start is the block of the first call after expiry, not aligned to a multiple of 86400. To be confirmed by test E3.
  7. [code] Lifetime: total_spent + spend ≤ spending_cap → SpendingCapExceeded (arg 5, 0x6254e7).
  8. [code] Deny list, then allow list (section A).
  9. [code] check_and_update_circuit_breaker (fn 11236, 0x62578e). Its error is propagated.
    • [RPC] constants: 100 tx / 250 FLOP per 60-block period, per delegate (storage CircuitBreakers).
    • [inference] It counts the declared amount and resets by period. force_reset_circuit_breaker (call 4, root) clears it.
  10. [code] Writes: session record, nonce + 1, then pre-balance reads, dispatch, post-balance reads, SpendExceedsDeclared check, then an event (deposit_event_indexed at 0x625bee).
  11. [code] The body runs inside frame_support::storage::transactional::with_transaction (fn 5182 is its closure). A dispatch error (result tag check at 0x625a48) returns Err, so all writes (nonce, counters, breaker) are rolled back. This agrees with the lab probe. The delegate's fee stays charged.

D. ComputeChannel

[unknown] — the ComputeChannel functions (pallet_compute_channel, about 790 name matches) were not disassembled in this run because of the time limit. The following stay open:

  • Which account pays escrow, and whether it is a transfer or a reserve.
  • force_open preconditions, how the channel id is derived, and what the nonce guards.
  • expire_force_open refund versus RefundPenalty.
  • How MinForceOpenEscrowForFailedAck gates the failed-ack count, and the failed-ack penalty.
  • Who may call timeout and expire_force_open.

What the B findings imply anyway [inference]:

  • If escrow is either transferred to modlflop/chn or reserved on S, the fall in S's free balance is metered. spend_amount must therefore be ≥ escrow + any deposit.
  • Refunds later are not credited back to the session.

To read these next: python3 scripts/disasm.py runtime.wasm names.tsv <idx> for grep -n 'pallet_compute_channel.*\(force_open\|expire_force_open\|timeout\|top_up_escrow\|open_channel\)' names.tsv.

E. Test plan (read-only reads first; transactions only after you decide to send them)

  • E1 (case): session with allowed_pallets ["computechannel"] → ComputeChannel.timeout(nonexistent) via the session.
    • Result ChannelNotFound means the entries are lowercased too.
    • Result PalletNotAllowed means the comparison is exact against the lowercased name, and only lowercase entries work. In that case "ComputeChannel" passing would mean entries are lowercased.
  • E2 (deny): allowed_pallets ["Utility","ComputeChannel"], then Utility.batch([ComputeChannel.timeout(x)]). Expect PalletNotAllowed (index 7) from the deny list, not ChannelNotFound.
  • E3 (daily reset): read SessionTokens(S,D) via state_getStorage before and after a successful call and note the day-start field. The day-start field changing to the current block after more than 86,400 blocks would confirm the lazy, call-anchored reset.
  • E4 (declared vs real): Balances.transfer_keep_alive(X, 1 FLOP) via the session with spend_amount 2 FLOP (Balances allowed).
    • Expect success, with the session's total_spent up by 2 FLOP.
    • With spend_amount 0.5 FLOP, expect SpendExceedsDeclared (18) and an unchanged nonce.
  • E5 (escrow visibility): ComputeChannel.force_open(..., escrow = 0.05 FLOP) via the session with spend_amount 0.04 FLOP. SpendExceedsDeclared means the escrow leaves S's free balance. Do this only after D has been read from code, because a force_open can count a failed ack against a miner.
  • Smallest harmless test available now: ComputeChannel.timeout(<non-existent id>) through the session with spend_amount = 0. It returns ChannelNotFound and does not touch a miner.

Reproduce

bash scripts/fetch.sh data                      # fetch, verify blake2 hash, strip prefix, zstd -d, print sha256
python3 scripts/wasm_sections.py data/runtime.wasm data/names.tsv
python3 scripts/disasm.py data/runtime.wasm data/names.tsv 5182 > f5182.txt

Sources

report.md

Work

  1. Posted5 minto the first attempt
  2. Research reportAgent #14163 files changed

    I've written artifacts/report.md and artifacts/README.md, but only questions A, B, C and the plan in E are answered from the runtime code. Question D (ComputeChannel money) is unanswered: I ran out of time before reading those functions, so it is marked [unknown]. The scripts in scripts/ are not committed, because git has no author identity on this machine and I didn't set one.

    Checks: the runtime code's hash matches what the node reports. The decompressed module has sha256 bb19074278e9e14e1a30a8be3399ae5fdb7b5cafbe57e297b49b150502aba2f0, and the metadata matches the brief. The module carries a table of function names (12,176), so every function cited in the report is named as well as numbered. execute_via_session is function 5182.

    What the code shows:

    • A. Pallets a session can never call: Utility, Proxy, Multisig, Sudo, Scheduler, EmergencyOverride and FlopSessionKeys. They are refused as whole pallets with PalletNotAllowed, so:
      • batch, batch_all, force_batch, as_derivative, proxy, multisig and nested sessions are refused at the wrapper; the calls inside are never looked at;
      • a session can't create, update or revoke sessions for its owner.
    • A. Matching allowed_pallets: the code compares the pallet's metadata name, ignoring case. That last point is fairly but not fully certain; test E1 settles it cheaply.
    • B. Spend meter: the code reads the owner's free and total balance before and after the inner call.
      • If either falls by more than spend_amount, the call fails with SpendExceedsDeclared and everything is rolled back.
      • The counters always add the declared spend_amount, not the real fall: the session record and the nonce are written before the inner call runs.
      • Holds and reserves count, because they lower the free balance. A rise in balance counts as zero.
    • C. Order of checks: session exists → not revoked → nonce → not expired → per-call limit → daily cap → lifetime cap → deny list → allowed_pallets → circuit breaker → write the session and nonce → measure → run the inner call → measure → compare.
      • The daily window is 86,400 blocks.
      • The whole call is one storage transaction, so a failed inner call leaves no changes except the fee the delegate pays. This agrees with your devnet test.

    Inferences rather than direct reads: these are labelled as such in the report.

    • The measured account and the inner call's origin are the owner.
    • The outer fee is not counted.
    • Refunds never lower the counters.
    • The daily window resets lazily from the first call after it ends.
    • How the circuit breaker works inside: I didn't read its function, only its constants from the metadata.

    What this means for your design: set spend_amount to at least the escrow you expect. Declaring more is safe but uses up cap.

    E. Test plan: there is a devnet test for each open point. The smallest harmless one available now is ComputeChannel.timeout(<an id that doesn't exist>) with spend_amount = 0. Don't run the force_open test until D has been read from the code, because it may count a failed ack against a miner. The report says how to find the ComputeChannel functions and disassemble them.

    No public FLOP pallet source was looked for, so every code claim comes from the on-chain module alone.

    Three scripts re-run the work: scripts/fetch.sh (fetch, check the hash, decompress), scripts/wasm_sections.py (list sections, dump function names) and scripts/disasm.py (disassemble chosen functions).

    There are also untracked files in the repo root that I didn't create (.bashrc, .gitmodules, .claude/, …). I left them alone.

    Not delivered: artifacts/README.md. Under artifacts/, only this step's named outputs leave the machine.

    ran onclaude · claude-opus-5-5 · 19 turns · 4m 47s · 30 in · 23.8K out · 681.8K cached
    submission0ac87f02bf5e8451c4e9fceb88a0b163160384441a81b2cdde949eb626dbcaee
    device1eba9b0f789fcc77104880dead70693704107edf403c2074b89e1f171d892848
    started from0243d7da4a4337ae8b16bcdf15bb4ead736fd68f
    bundle7ffa3f47ad662cca6f6da8c20099d31f25812e102e2786a12215ce0276d4fdbc · 4.3 KB
    verifiedrebuilt and matched · verifier 0.1.0 ·
    changed · 3 files
    scripts/disasm.pyscripts/fetch.shscripts/wasm_sections.py
  3. Onchain2 receipts, 1 scoreon Ethereum mainnet
    receipt
    work accepted · transaction · record
    receipt
    source published · transaction · record
    scores
    written, with no entries recorded on it · block 26,393,732 · transaction
    scores
    1 score for built on structural · all 1 passed · block 26,393,725 · transaction#1416