{"id":"4336d6a7-56f2-47f2-b1e5-a35f9e7bf78b","arxiv_id":"2412.18484","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"A fuzzing-based simulator and two visual views help cryptocurrency investors understand smart contract behavior without reading source code.","lead":"PrettiSmart is a new tool that runs smart contracts in a simulator and turns the results into pictures, so investors can see how money moves before they commit funds. The paper shows two example contracts and interviews 12 investors to argue the pictures are easier to understand than source code.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The 'reliable interpretation' claim rests on fuzz-generated sequences standing in for real investor behavior; the paper's own §9 and §8.3 concede this premise is unsupported, so reliability is not established.","rationale":"The reader's weakest_assumption identifies the same load-bearing concern: the simulation's function-call distribution may not match real-world investor behavior, and the paper itself concedes this. I agree with that assessment. The stronger claim of 'reliable' visual interpretation requires that patterns observed in fuzz-generated simulations correspond to patterns that matter for real contracts and real users. Echidna's coverage-guided search is a reasonable way to explore branches, but it is not a model of investor behavior; the paper provides no quantitative or qualitative evidence that its simulated call distributions are representative. The two case studies are illustrative but cherry-picked, and the user interviews measure subjective understanding rather than correctness of risk classification. The paper's own limitation statements in Sections 8.3 and 9 explicitly acknowledge that legitimate and fraudulent contracts may look alike and that the simulation may differ from reality. These concessions are enough to support a CONDITIONAL verdict, but not enough to reject the paper entirely: the visualization design is thoughtful, the encoding choices are grounded in expert requirements, and the case studies do show that the tool can help users trace mechanics such as owner withdrawal in known contracts. The missing piece is a controlled evaluation against ground truth and against real on-chain behavior. Therefore I recommend keeping the verdict UNCHANGED: the paper should be accepted conditionally, with the requirement that the authors either provide such an evaluation or soften the reliability claim in the abstract and conclusion.","tokens_in":19274,"tokens_out":3846,"duration_ms":42106,"concrete_test":"Use a corpus of at least 10 smart contracts with labeled ground truth and publicly available on-chain history. For each contract, generate two PrettiSmart datasets: (a) the Echidna-based simulation as described in the paper, and (b) a replay of the actual historical function-call sequence from mainnet. Compute the empirical distribution of call sequences (function, caller role, order, value) for each and measure the divergence between (a) and (b), for example via total variation distance. Then run a blinded user study with at least 20 participants who classify each contract as high-risk or low-risk from the two conditions. If the fuzz-based condition is not significantly better than chance, or is significantly worse than the actual-data condition, the simulation premise fails and the 'reliable' part of the central claim should be weakened.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim requires that simulation outputs are a trustworthy proxy for real-world behaviors. This is the weakest link. The simulator uses Echidna, a coverage-guided bug-finding fuzzer, to produce function-call sequences. Echidna optimizes branch coverage, not investor realism; it will happily generate economically nonsensical sequences, such as the owner investing in his own Ponzi contract. All visual patterns in PrettiSmart are downstream of these sequences, so any conclusion drawn from the visualizations inherits the fuzzer's biases. The paper itself flags exactly this: Section 9 states the simulation 'may differ from the function call distribution in the real world' and gives the owner-self-investment example; Section 8.3 says PrettiSmart 'cannot guarantee the accuracy of user-drawn conclusions,' noting that legitimate fundraising and fraudulent contracts may exhibit similar behaviors. These admissions directly undermine 'reliable visual interpretation.' The evaluation does not close the gap: the two case studies use known ground-truth contracts, participants were not blinded, there is no baseline, and there is no comparison against actual on-chain transaction histories. Therefore the load-bearing assumption is untested, not merely imperfect.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents PrettiSmart, a visualization system that takes Solidity smart-contract source code as input, uses Echidna-based fuzzing and the HEVM EVM implementation to generate simulated multi-user function-call sequences and execution traces, and visualizes the results in two linked modules: a barcode-style Simulation Overview Module and a detailed Simulation Detail Module showing function summaries, function-call sequences, cryptocurrency flows, net balance changes, and state-variable changes. The authors report a preliminary design-requirements study with six domain experts, two case studies on known contracts, and semi-structured interviews with twelve investors, concluding that PrettiSmart provides an intuitive and reliable visual interpretation of smart contracts.","tokens_in":19492,"tokens_out":3943,"duration_ms":39922,"significance":"If the central claim is established, PrettiSmart addresses a genuine need: non-programmer investors cannot read Solidity source, and transaction-based visualization tools are unhelpful for contracts with little or no on-chain activity. The paper contributes a concrete simulator-plus-visualization pipeline, a set of design requirements elicited from experts, and a thoughtfully designed visual encoding that links function calls to cryptocurrency flows and state changes. The two case studies are plausible demonstrations, and the interview data provide qualitative evidence that participants could extract meaningful patterns from the system. The authors are also candid about limitations in Sections 8.3 and 9. However, the evidence does not currently support the word 'reliable' in the abstract and conclusion: the load-bearing premise that coverage-guided fuzzing produces realistic investor behavior is untested, and the evaluation has no baseline or control condition. The contribution is therefore best framed as an exploratory visualization approach with promising usability evidence, pending validation of the simulation premise.","major_comments":[{"comment":"The abstract and conclusion claim that PrettiSmart provides 'reliable visual interpretation,' but the evidence does not establish reliability. The simulator in §5 uses Echidna, a coverage-guided fuzzer, to generate function-call sequences; §9 explicitly concedes that this 'may differ from the function call distribution in the real world' and gives the example that owners of fraudulent contracts are unlikely to invest in their own contracts, even though the simulator can generate that behavior. Since the visualization is entirely downstream of these generated sequences, the accuracy of user-drawn conclusions is not guaranteed. The authors should either remove or qualify the term 'reliable' and the phrase 'comprehensively capture most of the possible real-world smart contract behaviors,' or add a validation study that compares simulated function-call sequences against real on-chain transaction histories for comparable contracts, for example by measuring the distribution of called functions, caller profiles, and flow magnitudes.","section":"Abstract, §5, §9, §10"},{"comment":"The user evaluation does not include a baseline or control condition, so the effectiveness claims are not yet comparative. In the two case studies of §7, the participants are two of the twelve interviewees and the ground-truth contracts are known to the authors; there is no indication that the participants were blinded or that their interpretations were independently scored. In §8, participants were only asked to use PrettiSmart and rate it, not to perform the same interpretation task with source code, a transaction explorer, or an existing tool. This supports a qualitative usability conclusion but does not establish that PrettiSmart is more effective than alternatives. Adding a baseline condition and a pre-registered classification task with contract-level ground truth would materially strengthen the paper's main claim.","section":"§7, §8"},{"comment":"The paper itself states that 'a legitimate fundraising contract and a fraudulent one may exhibit similar behaviors, such as granting the owner control over user funds,' and that PrettiSmart 'cannot guarantee the accuracy of user-drawn conclusions.' This is directly relevant to the stated application of risk interpretation, yet the evaluation does not measure false positives or false negatives in participants' risk judgments. The manuscript should report which 12 contracts were selected, how the contract was assigned to each participant, and whether participant classifications were correct, especially for the risk-related conclusions emphasized in the two case studies. Otherwise the claims should be limited to 'comprehension of simulated behaviors' rather than 'identification of fraudulent contracts.'","section":"§8.3"}],"minor_comments":[{"comment":"The Figure 7 caption says 'Q1-Q11 are closed-ended,' while the procedure text states that Q1-Q10 are close-ended and Q11-Q12 are open-ended. This contradiction should be corrected.","section":"Fig. 7 caption and §8.2"},{"comment":"The text says 'the State Variable Changes of F0 (Fig. 6D1) and F1 (Fig. 6D1)'; the second reference should presumably be a different subfigure such as Fig. 6D2, and the later references to D3 and D4 should be checked against the figure layout.","section":"§7.2 and Fig. 6"},{"comment":"The description of the fuzzing configuration is too vague for reproducibility: the paper does not state the default time budget, the number of simulated users, the balance limits, or the function-call mutation strategy used for the reported case studies. Concrete default values or a configuration listing should be provided in an appendix or supplementary material.","section":"§5, Step 2"},{"comment":"The challenge C1 is phrased as obtaining 'all potential behaviors' of a smart contract, but the simulator can only cover branches reachable by Echidna within a time budget. The wording should be aligned with the actual coverage-based claim to avoid an impression of exhaustiveness.","section":"§1 and §10"}],"recommendation":"major_revision","confidential_remarks":"For the editor: the manuscript is honest about its limitations, and the core visualization contribution is reasonable for a venues such as TVCG. The main concern is that the abstract's 'reliable' claim is load-bearing and currently unsupported; this is fixable by reframing and adding validation against real transaction data. I saw no citation or authorship concerns."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"This is a legitimate new visualization system. The combination of Echidna-based fuzzing with HEVM trace execution to generate multi-user interaction sequences, then visualizing them as a barcode overview plus an augmented sequential detail view, is not something I've seen before. The design requirements came from a proper expert study, and the two case studies genuinely show users finding patterns—the gambling contract's repetitive rounds, the Ponzi's chain-like payouts and owner withdrawal. That is real evidence that the visual encodings work for reading patterns. The soft spot is the load-bearing one: the simulation-to-reality gap. Coverage-guided fuzzing optimizes for branch coverage, not for what investors actually do. The paper concedes exactly this in Section 9, saying the simulated call distribution 'may differ from the real world,' and in Section 8.3 that PrettiSmart 'cannot guarantee the accuracy of user-drawn conclusions.' These are not minor caveats; they cut the 'reliable' claim in the abstract. If the fuzzer generates economically implausible sequences, the same visuals could mislead investors in the other direction. The evaluation doesn't close that gap: 12 self-selected users, no baseline, no control condition, no comparison against real on-chain transaction histories, and no released artifacts. For a qualitative usability study that's acceptable, but reliability is asserted, not demonstrated. The citation pattern looks fine, and the machinery is appropriate. No fitting, no circular reasoning. The system does what it claims mechanically; the issue is the leap from 'we can show simulated behaviors' to 'this reliably interprets the contract for you.' This is a paper for visualization and blockchain-HCI researchers, and for anyone building tools for non-programmer investors. It deserves a serious referee. My recommendation: send it to peer review, but expect a moderate revision that tones down the reliability language, moves the simulation-realism limitation up front, and adds either a baseline comparison or a more careful discussion of what the user study can and cannot support. I'd engage with it.","headline":"A genuinely new visualization system with a solid design process, but the abstract's 'reliable' claim outruns the evidence: fuzzed simulations stand in for real investor behavior, and the paper itself concedes that premise is untested.","tokens_in":602,"tokens_out":831,"would_cite":true,"duration_ms":26437,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper claims that simulating many multi-user executions and visualizing them lets investors understand what a smart contract does and spot risky patterns without reading Solidity source code.","keywords":["smart contract visualization","execution simulation","coverage-guided fuzzing","cryptocurrency flow visualization","Ponzi scheme detection","blockchain investor tools","state variable changes","usability study"],"falsifier":"Compare PrettiSmart's simulated function-call sequences for a specific contract, such as the Suicide Watch Ponzi contract, with that contract's actual on-chain transaction history: if the simulation does not reproduce the chain-like payout structure that makes the fraud visible, or if a legitimate fundraising contract produces the same alarming visual patterns, then the claimed reliability of the interpretation is falsified.","tokens_in":19077,"feed_emoji":"📊","tokens_out":6575,"duration_ms":55651,"temperature":0.7,"pith_summary":"PrettiSmart is built on the claim that a smart contract's behavior can be made legible to people who cannot read code by generating many possible multi-user executions and showing the results as pictures. The authors argue that coverage-guided fuzzing can produce function-call sequences that exercise most branches of a contract, and that replaying those sequences on an Ethereum virtual machine yields the money flows, balance changes, and state-variable updates that matter to investors. The paper's central promise is that with the right visual encoding—a barcode-style overview plus a detailed sequence view—a non-programmer can infer what a contract does, including whether it is likely a fair game or a fraud, without the source code. If true, this would give ordinary cryptocurrency investors a practical way to pre-screen irreversible investments.","feed_headline":"Simulation turns smart contract code into risk-revealing pictures","feed_subtitle":"No Solidity needed: simulated money flows and balance changes expose withdrawal and Ponzi-like patterns.","key_machinery":"The carrying mechanism is a two-stage simulation-and-visualization pipeline. The simulator parses the Solidity abstract syntax tree to identify functions and state variables and to insert logging events, then runs coverage-guided fuzzing over the contract to produce many simulations, each a sequence of function calls spread across simulated user addresses; each sequence is replayed on a standalone Ethereum virtual machine to extract internal transactions, cryptocurrency flows, and variable changes for every call. The visualization layer then maps each simulation to a barcode-style balance grid—color-encoded net balance per address per call—and an augmented sequential detail view that layers function call distribution, cryptocurrency flow curves whose width encodes value, net balance area charts, and state-variable change icons aligned on a shared time axis.","core_discovery":"The paper's central claim, stated in its own terms, is that PrettiSmart is a visualization approach via execution simulation that achieves an intuitive and reliable visual interpretation of smart contracts. The authors demonstrate the claim with two case studies: an investor without programming background correctly reads a gambling contract as a fair lottery from its simulated payout rounds, and an investor with programming background correctly identifies the Suicide Watch contract as a typical Ponzi scheme from its chain-like internal transactions, owner-withdrawal function, and uniformly negative user balances. The underlying assertion is that these visual patterns—repetitive invest-and-payout cycles, a function callable only by the owner that drains the balance, state variables storing the last caller—constitute interpretable evidence of contract functionality and risk.","pith_inferences":["Editorial inference: the paper does not compare its simulated function-call sequences to actual transaction histories, so a direct distributional comparison would be the clearest test of whether the pictured patterns reflect real investor behavior rather than fuzzing artifacts.","Editorial inference: the visual grammar could serve as a contract-language-independent medium; if it works for obfuscated or misleadingly named functions, it would be especially useful for scams that hide their intent behind innocuous names.","Editorial inference: the same simulation traces could be compressed into quantitative risk indicators—for example, the fraction of simulations ending with owner withdrawal exceeding investor returns—turning visual inspection into a score that does not depend on the viewer's visual literacy."],"forward_implications":["An investor without a programming background can correctly classify a gambling contract as a fair lottery by reading the simulated payout rounds.","An investor with a programming background can identify a Ponzi scheme from chain-like internal transactions, owner-withdrawal behavior, and negative user balances.","The visualization supports contracts with little or no transaction history, because the simulation generates behaviors from the code rather than from on-chain activity.","The design exposes economic models—who pays, who receives, and who can call which function—that are hard to infer from source code alone."],"supporting_citations":[{"why":"Supplies the fuzzing engine the simulator uses to generate multi-user function-call sequences.","marker":"[25]"},{"why":"Defines the coverage-guided fuzzing and branch-distance feedback that drives the simulator's exploration of contract behaviors.","marker":"[48]"},{"why":"Provides the design-study methodology used to derive and confirm the six visualization requirements.","marker":"[53]"},{"why":"Contributes behavioral simulation for smart contracts and, with [19], supplies the contract set used in the interview task.","marker":"[7]"},{"why":"Supplies the large empirical corpus from which the 12 evaluation contracts were selected.","marker":"[19]"},{"why":"Documents Ponzi-scheme transaction and state patterns used as ground truth for the fraudulent-contract case study.","marker":"[13]"},{"why":"Provides the Solidity compiler and AST parsing that let the simulator identify functions and state variables and insert logging events.","marker":"[22]"},{"why":"Provides the PSSUQ questionnaire framework used for the usability portion of the post-study evaluation.","marker":"[38]"}],"fun_headline_variants":["Simulation draws smart contract behavior for non-coders","Visualized simulations reveal contract traps to investors","See smart contract risks without reading a line of Solidity","PrettiSmart: watch simulated flows to spot contract scams","No code needed to see how smart contracts work"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that fuzzing-generated function-call sequences resemble how real investors actually use a contract closely enough that visual patterns can be read as the contract's real behavior; the paper concedes in its discussion that the simulated call distribution may differ from the real world and that conclusions drawn by users cannot be guaranteed accurate.","fun_headline_variants_meta":{"raw":{"variants":["Simulation draws smart contract behavior for non-coders","Visualized simulations reveal contract traps to investors","See smart contract risks without reading a line of Solidity","PrettiSmart: watch simulated flows to spot contract scams","No code needed to see how smart contracts work"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000314,"raw_usage":{"total_tokens":1786,"prompt_tokens":953,"completion_tokens":833,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":569,"completion_tokens_details":{"reasoning_tokens":758}},"tokens_in":569,"tokens_out":833,"duration_ms":8239,"temperature":1.0,"reasoning_tokens":758,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T04:40:47.054784+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compare PrettiSmart's simulated function-call sequences for a specific contract, such as the Suicide Watch Ponzi contract, with that contract's actual on-chain transaction history: if the simulation does not reproduce the chain-like payout structure that makes the fraud visible, or if a legitimate fundraising contract produces the same alarming visual patterns, then the claimed reliability of the interpretation is falsified.","supporting_citations":[{"cited_title":"Grieco, W","cited_arxiv_id":null,"evidence_quote":"Supplies the fuzzing engine the simulator uses to generate multi-user function-call sequences."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Defines the coverage-guided fuzzing and branch-distance feedback that drives the simulator's exploration of contract behaviors."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Contributes behavioral simulation for smart contracts and, with [19], supplies the contract set used in the interview task."},{"cited_title":"Durieux, J","cited_arxiv_id":null,"evidence_quote":"Supplies the large empirical corpus from which the 12 evaluation contracts were selected."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Documents Ponzi-scheme transaction and state patterns used as ground truth for the fraudulent-contract case study."},{"cited_title":"Foundation","cited_arxiv_id":null,"evidence_quote":"Provides the Solidity compiler and AST parsing that let the simulator identify functions and state variables and insert logging events."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Provides the PSSUQ questionnaire framework used for the usability portion of the post-study evaluation."}],"review_version":1}