Changelog

Source Code Files Organization

This week, we introduced Source Code Files grouping by folders across the Contracts, Classes, and Debugger Preview pages. This makes it easier to navigate large codebases and keep related contracts organized.

More improvements

• Added file names to contract and class pages for quicker identification.
• Improved layout on mobile, so long addresses and names now wrap properly and can be copied.
• Resizable panels have been added to contract and class pages, allowing for a more customizable view.
• Fixed a bug where NaN appeared for the block number after simulating transaction on the latest block.
• Unified header height across all pages for a consistent look.
• Fixed inconsistent transaction errors caused by manually set fee values. We now show same error messages as the chain does, like: Insufficient max fee: max fee: 3298534883328, actual fee: 5833172244412.

Focus on Stability

This week we focused on fixing bugs and edge cases to improve platform reliability and consistency.

More improvements

• Optimized data handling in the Storage View tab to improve transaction debugging performance.
• Fixed a bug that allowed excessive memory allocation when input parameters couldn't be deserialized.
• Calldata is now always shown in raw format, ensuring it's visibility even when argument deserialization fails.
• Removed duplicated raw result entries in the Call Trace Details panel.
• Revert error messages now skip ASCII control characters for cleaner display.
• Fixed an issue where the wrong Sierra version was selected based on class hash.

Brand New Storage Tab

This week, we introduced a new Storage Tab! You can now inspect the previous and current storage states for each contract whenever storage changes occur. For now, values are displayed in raw format.

More improvements

• Upgraded Starknet Provider to stay aligned with the latest ecosystem changes and ensure overall compatibility.
• Increased Nginx payload limit to 2 MB, addressing a user-reported issue where large contract payloads couldn't be processed during verification.
• Added connection timeout for long-running transaction simulations to prevent server overload caused by heavy transactions.

Enhanced Function Call Details Window

This week, we've made function-level debugging clearer and more intuitive. The Function Call Details panel now displays information about the current execution step, including the line number, arguments, and results—making it easier to see what's being passed and returned during CairoVM execution.

More improvements

• Fixed an issue where the result type name was displayed twice in the Function Call Details panel.
• Resolved a problem where some functions were not found during multicall simulation.
• Improved system call mappings, fixing a bug that blocked debugging during simulations.

Starknet Core Dependency Upgrades

This week, we upgraded core dependencies: Cairo compiler, SN Foundry, and Blockifier. This ensures better compatibility, stability, and support for the latest protocol changes.

More improvements

• Fixed a bug in gas computation that made transactions show the wrong status during simulation.
• Updated Simulations docs to align with the new Simulation page.
• Enabled contract verification with sncast verify using --class-hash.

New Simulation Page

This week, we introduced a new Simulation Page that simplifies data entries for transaction simulations. Entry points are now automatically fetched based on the provided contract address and network.

More improvements

• Added support for verifying contracts with Cairo 2.9.4.
• Improved error clarity during verification, providing better insights when an unsupported Cairo version is used or a build failure occurs.
• Fixed an issue where missing memory values wrongly show Transaction hash not found error.

Improved File Explorer

This week, we improved the File Explorer by grouping source files of verified contracts by contract address.

More improvements

• Added a guide to the Dojo documentation on how to debug Dojo Games with Walnut.
• Upgraded Walnut Server to Rust 1.85 to ensure compatibility with the latest snfoundry. This resolved some contract verification failures which required Rust 1.80.1 or higher.
• Fixed a UI bug in the Debugger window where icons and window titles were not displayed correctly.
• Fixed an issue with searching for contracts on Ethereum, where the network was not displayed correctly.
• Fixed a bug where calldata arrays with nested elements were incorrectly decoded, which led to Walnut Server timeout errors in some cases.

L1 Handler Transaction Support

This week, we introduced support for L1 Handler transactions. You can now search for Ethereum L1 transactions and view the corresponding L2 Call Trace for deeper insights.

More improvements

• Added support for Cairo v1 ABI.

Breakpoints in Debugger

This week, Walnut is getting BREAKPOINTS! Now you can pause the execution at any line to quickly inspect what's going on.

More improvements

• Call Trace now displays calldata in auto-decoded and raw formats, eliminating the need for separate hex and decimal views.
• Added the Cairo Version and Networks on the Contract page.
• ContractState type is no longer shown in the debugger memory window, as it is a marker type with empty values.
• Fixed a bug where File Explorer was not visible in certain screen sizes.

Native Data Display in Debugger

This week, we updated the debugger window to display values in their native type format instead of hexadecimal, improving the overall debugging experience.

More improvements

• Added decoding support for byte arrays.
• The Transaction Detail section now displays the transaction’s position in the block, along with the total number of transactions in the block.
• In the Call Trace, data tables for calldata now have proper borders, improving readability and navigation.
• Updated broken documentation link.

Enums Decoded in Internal Function Call

This week, we added Enums decoding for internal functions, making it easier to understand values during debugging.

More improvements

• The Call Trace Preview in the debugger no longer shows Errors, improving navigation.
• Errors are now always visible in the Call Trace. Previously, they were sometimes collapsed, making them hard to find.
• The Call Trace now displays Events with argument data.
• The call trace now uses different colors for Delegate and Event frames, improving differentiation.
• Contract verification now correctly generates debug info for inline functions, even when both [cairo] and [profile.dev.cairo] sections are in Scarb.toml.

Call Trace Preview in Debugger

This week, we improved the debugging experience by integrating the Call Trace directly into the debugger window. Users can now track code execution and the full call trace side by side, making it easier to analyze transactions and debug complex interactions.

More improvements

• The debugger window now has three panels: Function Call Details, Call Trace Preview, and File Explorer.
• Events are now visible in the Call Trace, linked to their corresponding function calls.
• Enhanced Events tab with Contract address and Event selector information.
• Added horizontal scrolling in the Events tab.

Verification Status Page with Build Logs

This week, we enhanced the contract verification process by preventing sensitive information leaks and displaying the full build log for failed projects.

More improvements

• Improved error visibility by showing the full build log on the verification status page when a project build failed.
• Prevented exposure of private keys by ignoring the [env] section in dojo_*.dev.toml files, ensuring no sensitive data is transmitted during contract verification.
• Added support for functions inlined by the compiler, which is available starting from Cairo version 2.8.2, making them visible in the call trace.
• Updated the function details window to display values for inline functions as well.

Brand New Events Tab

This week, we introduced an Events Tab, allowing users to view all emitted events by a given transaction. This helps track contract interactions and debug more efficiently.

More improvements

• List of Events for both failed and successful transactions.
• Each Event shows emitted data, allowing users to inspect event contents directly.
• Improved colors in the Call Trace and made them more consistent:
  • Types — Orange
  • Names — Green
  • Values — Dark Orange

Support for *ALL* Sozo versions

This week, we built an automation that allows our Contract Verification Service to automatically support new Sozo versions as soon as they are released. No more "unsupported Dojo version" messages during contract verification on Starknet!

More improvements

• Updated documentation on how to Debug Dojo with Walnut.
• Added build profile into the verification status page, allowing users to see which build profile was used to generate a given class_hash during contract verification.

Reduced number of RPC calls

This week, we reduced the number of RPC calls to improve application efficiency and ensure smoother functionality.

More improvements

• The aggregated search is now faster by implementing a stream-based approach, allowing RPC calls to run in parallel.
• Removed duplicate and unnecessary RPC calls to avoid redundant execution.
• Added support for Dojo 1.0.12.
• Removed the requirement for an API Key during class verification.

Dojo Worlds Contract Verification on Walnut

Walnut is now natively integrated with Sozo, a CLI tool for Dojo developers. This integration allows developers to verify contracts on Walnut and access the step-by-step debugger directly from their native tooling

More improvements

• Updated the Walnut Verification flow in the sncast command in Starknet Foundry to prompt users not to expose private keys during contract verification. Also updated docs acordingly.
• Fixed a search bug in the Call Trace that prevented certain characters from being searchable when the debugger window was open.

Walnut Beta Launch 🚀

This week, after one year of developement, we finally launched the Beta version of Walnut! Dive in and let us know your thoughts as we continue to improve. We have a Telegram group here.

More improvements

• Brand new landing page with all the bell and whistles. Check it out!
• New Docs.
• Added paymaster_data and resource_bounds to transaction info section in simulations.
• In the Call Trace, DCALL Frame type is now split into DELEGATE and CALL, making it easier to differentiate between entry point and library functions with identical names.

New GitHub Sign-In

This week, we added the ability to sign up to Walnut using a GitHub Account.

More improvements

• Added proper handling for transactions that REVERT due to "run out of resources" error.
• Improved syntax highlighting in Walnut Docs, making code snippets more readable.
• Removed the Events Tab. We plan to bring events back later.

Support for *ALL* Cairo versions

This week, we built an automation that allows our Contract Verification Service to automatically support new Cairo versions as soon as they are released. No more "unsupported Cairo version" messages during smart contract verification on Starknet!

More improvements

• Retro-added support for Cairo versions 2.9.1 and 2.9.2.
• Updated the Transaction Simulation Form to use transaction version 3 as the default option.

Bug Fixes 🐛🐞🪲🕷️🪳🦟

This week, we focused on bug fixing. And we also extended our Contract Verification service to support Cairo 2.8.5.

Improvements

• Fixed a bug that caused simulation to fail when performed on the latest block number.
• Resolved an issue where the call trace was not displayed for reverted transactions.
• Improved handling of the execute account function when it fails due to an undeployed contract. The transaction status now shows REVERTED with a clear error indicator.
• Added sierra-replace-ids to the Scarb.toml configuration, ensuring sierra_program_debug_info is included in the contract class during the build process.

Loop Removal from Call Traces

This week, we streamlined loop handling in the call trace by removing loops and ensuring function calls within them are displayed at the correct level.

More Improvements

• Adjusted the build configuration during Contract Verification to use the release profile, aligning with Starknet Foundry's setup.
• Fixed an issue in Transaction Simulations where errors weren’t shown for undeployed contracts.
• Updated the documentation Walnut Verification Guide with the new Walnut API Contract Verification service, ensuring users are up to date with the latest functionality.
• Improved frontend performance by removing regexes from Call Trace function formatting.

New Verification Flow

We've enhanced the contract verification process by enabling users to verify contracts using only the source code, simplifying the process and making it more user-friendly.

More Improvements

• Added a verification request information to the verifcation status response. Look example here.
• Added support for contract verification with Cairo version 2.8.4.
• Improved the contract page to support custom networks.
• Resolved an issue where the presence of the license-file field in Scarb.toml caused verification to fail.
• Fixed an issue where error traces for contract calls were missing.
• Introduced minor UI adjustments and performance optimizations to enhance overall usability and responsiveness.

New Memory Window

We're excited to introduce a brand new Memory Window in the Debugger to display function call arguments and results.

More Improvements

• Made debugger windows resizable, giving you more control over your workspace and helping you focus on what matters.
• Core Starknet functions in the call trace are now collapsed by default, making large transactions easier to navigate.
• Added support for class hash verification, a feature requested by StarkWare.
• Fixed contract display issues in the call trace to make the application more reliable.

Brand New Page for Class Details

In this release, we've introduced a new Class Page that displays details about the class, including the Class Hash, the list of networks where the class is declared, and the associated source code.

More Improvements

• Added form validation to the Transaction Simulation dialog to help users avoid errors and ensure correct input.
• Included ContractState function argument in the Call Trace, enabling users to explore these values.
• Fixed a bug that caused inconsistent state when declare, deploy, and invoke transactions occurred within the same block. This improvement ensures accurate and reliable transaction processing in this scenario.
• Improved the loading state text in the Contract Verification window for clarity.

Clearer Arguments and Results representation

This week, we simplified the Call Trace by removing argument and result namespaces and skipping system arguments. This reduces visual complexity, making it easier for users to navigate function calls!

More Improvements

• Added Debugger Keyboard Shortcuts:
  • b — Step Back
  • n — Step Into
  • o — Step Over
• Improved error messages in the Transaction Simulation Dialog to help users complete the form more easily.
• Fixed a bug in fetching CASM instructions. Previously, some instructions were missed, causing issues in specific transactions. Now, all CASM instructions are reliably retrieved, resolving the issue.
• Resolved issues with transaction inconsistencies on custom networks by adding the chain ID of custom networks to the transaction execution context.
• Enhanced the mobile experience by fixing the navigation burger menu on the home screen and ensuring the footer remains anchored at the bottom of the page.

Step Over Button in Debugger

We finally added the 'Step Over' button, one of the most requested features from our early users. It speeds up the debugging experience by allowing developers to skip over functions and focus on the main logic, saving time and reducing the need to manually step through each line in deeply nested code.

More Improvements

• Enhanced the Call Trace with __validate__ Account call, to better express Starknet's Account Abstraction model.
• Updated the copy and added a link to the Walnut Verification Guide in the debugger window for non-verified contracts.
• Addressed and resolved minor bugs to improve overall application stability and performance.

New Homepage with easier access to Transaction Simulations and Settings

This week, we updated the homepage to enable users to simulate transactions and configure custom networks directly, without opening a tranasction first.

More Improvements

• Resolved an issue with content width in the Call Trace, eliminating unnecessary horizontal scrolling.
• The Transaction Simulation dialog will now use the "latest" block by default if none is provided.
• Added support for Dojo Alpha 14 and 16.
• Other minor optimizations and ongoing work to prepare for upcoming improvements in the debugger window.

New Search in the Call Trace

This week, we added a search feature to the call trace, allowing developers to search by contract address, contract name, entrypoint, or any Cairo function name.

More Improvements

• Users can now search by contract name and address, with search results showing source file names and line numbers.
• Enhanced the copy-to-clipboard functionality across the app, with a toast notification confirming when content is copied.
• Added short transaction hash formatting for a better mobile experience.
• Fixed an issue with the horizontal scroll bar in the call trace, ensuring it always appears.

Improvements in Search

In the latest release, we added a footer to search results that shows the networks being queried, making it easier to recognize when a custom network should be set if the search doesn't return expected results.

More Improvements

• As part of ongoing improvements to the Call Trace, we removed the "Unknown Function" frame which was only causing confusion.
• Collaborated with Dojo to support Katana blocks with multiple transactions. Thanks Dojo for your help on this issue #2458.
• Added support for Dojo Alpha 13.
• Updated the Contract Verification service to support Cairo 2.8.2.

Improvements in the Call Trace

Last week, we introduced several updates to enhance the Call Trace feature and improve overall product quality.

More Improvements

• Introduced expand and collapse buttons to the Call Trace, making navigation between call frames easier and more intuitive.
• Fixed several bugs, resulting in improved stability and overall product quality.
• Added special handling to the call trace to report cases where source code locations are missing.
• The Cairo VM and Cairo compiler crates were upgraded to the latest versions, allowing simulations of transactions with contracts up to Cairo v2.8.2.

Multiple Classes Verification

In the latest release, we introduced support for verifying multiple classes in a single request. This improves the Class Verification user experience and boosts performance.

More Improvements

• Added support for Dojo Alpha 12, to support the latest on-chain game developers.
• Increased server resources to ensure faster response time and handle high-demand requests.
• Improved error handling by mapping errors, leading to clearer and more detailed debugging information.
• Addressed several Class Verification issues reported primarily by DOJO game developers. These include configuring Scarb caching for Sozo and applying the default namespace from the Dojo configuration.

Contract calls in Debugger Window

The step-by-step debugger now supports nested contract flows. When you reach a contract call in the source code, just hit “Next” to seamlessly move into the new contract and continue debugging.

More Improvements

• Integrated Walnut into Sozo and added support for contract verification directly from Sozo.
• Added contract verification for custom networks, including support for hosted Slot instances.
• Chain information has been added to the transaction simulation context, fixing occasional data inconsistencies in simulations.
• Updated the app UI to support full screen mode, making it easier to debug large codebases.

Debugging on Custom Networks

This week we added support for debugging transactions on custom networks, a key request from DOJO on-chain game developers. Walnut now connects to any Starknet network via custom RPC URLs, with full support for debugging, simulating, and verifying smart contracts. Next week, we will pilot custom networks with hosted Slot instances in New York, meeting DOJO game developers and demonstrating Walnut.

More Improvements

• Created a new Settings page to configure custom RPC URLs, enabling debugging transactions on custom networks.
• Aggregated search now displays transactions and verified contracts from mainnet, testnet, and custom networks.
• Fixed a caching bug that caused state mismatches and inconsistencies in transaction simulations.
• Extended Call Trace to include function call arguments, results, and interface names for internal calls.
• Improved regex parsing for function call names in the Call Trace for better readability.

More Resilient Contract Class Verification

In the latest release, we moved contract class verification to run in the background, making the service more resilient when verifying larger contracts or multiple contracts.

More Improvements

• Introduced a new API endpoint to check the verification status of a contract class. Available at /v1/verification/{:id}/status. Try it here.
• Enhanced the accuracy of simulated transactions by applying state transitions for all preceding transactions within the same block.
• Updated the nudge verification link from the Walnut app to direct users to the Walnut documentation.

Code and Attribute Highlighting in Debugger

In the latest release, we introduced highlighting for both Cairo attributes and Code snippets in the step-by-step debugger.

More Improvements

• Debugger windows automatically open to the nearest verified contract.
• Fixed a bug related to incorrect block timestamp.

Aggregated Search

In the latest release, we introduced aggregated search, allowing users to search for transactions, contracts, or classes across all networks.

More Improvements

• New contract page displays verified contract source files and code.
• A new API endpoint for verification that does not require chain_id is available at /v1/verify/. This is an important prerequisite for making Walnut work with fully on-chain games deployed to appchains like Slot.
• Added support for contract verification with Cairo version 2.7.0.
• Enhanced code highlighting with additional Cairo location mapping in the execution trace.
• Launched Walnut Documentation, with contract verification guide.

Improvements to the Debugger Window

In the latest release, we improved the debugging experience by allowing switching between source files in the debug window.

More Improvements

• The Cairo version is now displayed in the contract details view.
• Improved error handling for contract verification.
• Added a message when no execution trace is found, instead of nudging users for verification.

Improvements to the Transaction Information Box

In the latest release, we focused on enhancing the information box on the transaction page. We now display the transaction type, timestamp, and transaction version.

More Improvements

• Added support for Declare transactions.
• Input and output data can now be switched between Hexadecimal and Decimal formats, and vice versa.
• Improved handling of transaction simulation errors.

Improvements to the Call Trace

In the latest release, we focused on improving the call trace. Concretely, we worked on displaying contract calls within internal function calls. In the screenshot above, you can see the IVerificationHelper.calculation_proof correctly placed right after the internal function call IVerificationHelperDispatcherImpl::calculation_proof.

More Improvements

• If the Contract Name is not present, the app now uses Interface Name as a fallback.
• Added human readable Chain ID to transaction details.

Contract Verification

In the latest release, we added full support for contract verification to Walnut. Developers can verify their contracts to get detailed call traces, step-by-step debugging, and execution mapping to the source code in the Cairo contracts.

Improvements

• Added a new alert message in the debugger tab and the call trace to prompt contract verification if the contract is not yet verified.
• Errors in the call traces now show details about the error.
• Opening the debugger from the call trace line now moves the execution to the corresponding line.
• Renamed "testnet" to "sepolia".

Internal Function Call with Error

In the latest release, we focused on displaying errors in the call trace.

Improvements

• Added error details below the deepest internal function call where the panic occurred.
• In collaboration with Software Mansion, we added contract verification into foundry. Check the guide documentation here.

Added Argument and Result Values to the Debugger

Function arguments and return results are now visible in the step-by-step-debugger. In the screenshot above, the extract_age function returns a single result: 18.

Improvements

• The debugger now shows arguments and return values. Some data might be missing in specific places, which will be improved in the future.
• Internal function calls in the Call Trace now display the argument and result values.
• New API endpoint for querying the source code of verified contracts via API using Class ID. Available at the /{network_id}/classes/{class_id} endpoint. Try it here.
• Added support for the Sepolia testnet and deprecated Goerli.

Contract Verification API

In the latest release, we have introduced the contract class verification API endpoint.

Improvements

• Launched new API at api.walnut.dev with a /verify endpoint for Cairo Smart Contract Verification.
• In the Call Trace, the DELEGATE and CALL functions have now been merged and are displayed as DCALL.

Debugger for Starknet Transactions

In the latest release, we finally launched the first version of the step by step debugger. It comes with support for multiple contracts in the transaction, and moves the code execution accordingly.

Improvements

• External calls now also present the source code of the contract in Cairo.

Contract Source Code in Call Trace

In the latest release, we added support for displaying the corresponding Cairo source code for each call in the call trace.

Improvements

• Each call trace now displays the associated Cairo line and the corresponding code snippet where the call occurred. This only works for verified contracts.
• The new events tab showcases all emitted events for simulated transactions.
• Data for arguments and results is now also available in view functions.

Transaction Simulations

In this release we added support for transaction simulations into Walnut. You can simulate a new transaction, or re-simulate an existing one.

Improvements

• New transaction simulation screen that allows to re-run existing transactions or simulate new ones on the Starknet Mainnet network
• Simulations support modification of the following transaction parameters: sender address, calldata, block number, chain id, and transaction version

Internal functions in the call trace

In this release we added support for internal function calls in the call trace. After verifying contracts, the call trace presents calls to every Cairo function, and will also present details about each call's arugments and return values.

Improvements

• Support for different colors in the call trace to visually separate certain elements. For example contract names, entrypoints, arguments.
• After clicking on a call trace item, you get details about argument and return values.

Walnut v0.1.0

This is our first changelog message. We started building Walnut to make transaction debugging and simulations on Starknet easier. In the initial version, we plan the following features:

Transaction Call Trace

• Support for any transaction, including failed transactions
• The call trace will include calls to internal functions within each contract involved in the simulated transaction
• Each call will present decoded arguments with names and values, as well as the return value
• For verified contracts, ability to see the exact call location mapped to the Cairo source code.

Contract Verification

• Ability to upload the contract source code to Walnut for verification

Step by step debugger

• Visual debugger that will allow to re-run the transaction line-by-line, mapped to the original source code in Cairo.

Transaction Simulations

• Visual debugger that will allow to re-run the transaction line-by-line, mapped to the original source code in Cairo.