Nethereum 6.0.4

Nethereum 6.0.4 adds the new nethereum-dapp Aspire template for full-stack dApp development (Solidity + C# + Blazor + EIP-6963 wallet), fixes Explorer ABI auto-discovery from Foundry artifacts, resolves blazor.web.js compatibility with .NET 10 NuGet-packaged Razor components, improves EIP-6963 wallet CSS and interop, adds a parallel NuGet build script, and introduces GitHub Actions CI with prerelease publishing.

Full Changelog

Nethereum.Aspire.TemplatePack — New nethereum-dapp Template

New full-stack dApp template creating a complete development environment with 9 projects — Solidity contracts (Foundry), C# typed services (code generation), Blazor WebApp with EIP-6963 wallet integration, embedded TDD and E2E tests, and the full DevChain + Indexer + Explorer infrastructure, all orchestrated by .NET Aspire.

• WebApp with EIP-6963 wallet discovery, chain validation, and wallet_addEthereumChain switching
• Three UI states: not connected → wrong chain → correct chain (deploy/mint/transfer/balance)
• Light-themed CSS with card-based layout, form styling, and wallet CSS custom properties
• Foundry contracts project with starter ERC-20 (MyToken + mint), Forge tests, and deploy scripts
• ContractServices with pre-generated C# typed contract access from Solidity ABI
• Tests project with fast TDD using embedded DevChain (no Docker needed)
• IntegrationTests project for E2E testing against the running AppHost
• LoadGenerator with random mint/transfer/ETH send operations
• Code generation scripts (generate-csharp.ps1 / .sh) invoking Nethereum.Generator.Console
• AppHost configures Explorer ABI auto-discovery from contracts/out/ Foundry artifacts
• Local Explorer App.razor override to fix blazor.web.js compatibility with NuGet-packaged Razor components on .NET 10

Commits: f500fcc, 818cc8af, 9c68e081, 4828ebda

Nethereum.Aspire.TemplatePack — DevChain Template Fixes

• Fixed project references from old NethereumDevChain_ prefixed names to clean Projects.DevChain, Projects.Indexer, Projects.Explorer
• Updated to async MapDevChainEndpointsAsync() matching library API changes
• Added local Explorer App.razor override for blazor.web.js .NET 10 compatibility
• Updated Aspire version to 13.1.1 in README examples
• Updated default Nethereum version to 6.0.4

Commits: 76c796e, d348e405, 60e76cc

Nethereum.Explorer — Runtime Bytecode ABI Matching

The Explorer now automatically discovers contract ABIs by matching on-chain runtime bytecode against locally loaded Foundry/Hardhat artifacts. Previously, FileSystemABIInfoStorage loaded artifacts but only matched by contract address (which required prior registration). Now the AbiStorageService falls back to bytecode-based matching:

1. Fetch on-chain bytecode via eth_getCode
2. Compare against all loaded Foundry artifacts (stripping metadata suffixes)
3. On match: bind the ABI to the contract address, persist to the database, and serve decoded function calls

This means: deploy a contract from the dApp WebApp or via forge script, navigate to its address in the Explorer, and the ABI is available immediately — no manual upload needed.

• Added FileSystemABIInfoStorage and IWeb3 dependencies to AbiStorageService
• New bytecode matching fallback in GetContractAbiAsync after address-based and external source lookups fail
• Registers matched contract address for future direct lookups via RegisterContractAddress
• Persists matched ABI to the Contracts database table

Commits: 6e1921f

Nethereum.Explorer — Wallet CSS Fix

Fixed wallet button and dropdown styling in the Explorer when using the EIP6963Wallet component with Theme="None". The Blazor scoped CSS from EIP6963Wallet.razor.css had higher specificity than the Explorer's unscoped .no-theme overrides, causing oversized fonts and icons in the navbar.

• Added !important to all .no-theme wallet CSS rules (button, dropdown, icon sizing)
• Compact 0.8rem font, 1.25em icons, proper dropdown positioning now wins over scoped styles

Commits: 6e1921f

Nethereum.EIP6963WalletInterop — personal_sign Fix

Fixed personal_sign passing a JSON string instead of the raw address parameter, which caused MetaMask to reject the signing request.

Commits: ce721746

Nethereum.DevChain — Hosting Improvements

• Moved hosting extension types from Nethereum.DevChain.Server to the core Nethereum.DevChain library
• Added reusable WebApplicationExtensions for MapDevChainEndpointsAsync() — async endpoint mapping
• Enables any ASP.NET Core host to serve DevChain endpoints without depending on the Server package

Commits: ef3e25e

Contract Deployment Race Condition Fix

Fixed a race condition where DeployContractAndWaitForReceiptAsync could fail because the contract code wasn't yet available at the deployed address. Now polls eth_getCode to verify the contract is deployed before returning.

Commits: bb5b2209

Wallet Price Refresh & Overflow Fixes

• Price refresh service with two-threshold model for stale/expired prices
• Fixed overflow in ValidateUpperBytes preventing incorrect integer decoding

Commits: 5d391e3, 2dcb306

MinimalHdWallet Moved to Nethereum.Accounts

Moved MinimalHdWallet from standalone package to Nethereum.Accounts for .NET 6+ frameworks, reducing dependency count for common wallet operations.

Commits: fbfcbf6, 76e56c0

SparseMerkleTree Optimisations

Performance improvements to the Sparse Merkle Tree implementation used by the EVM and state verification.

Commits: 4026d4a

Build & CI

• Version bump: 6.0.0 → 6.0.4
• Herumi native packages: 6.0.2, 6.0.3, 6.0.4 packed to nativeartifacts/
• nuget.bat: Fixed Herumi output path from ..\nativeartifacts to ..\..\nativeartifacts
• nuget-fast.ps1: New parallel PowerShell build script — builds all projects once then packs with --no-build using ForEach-Object -Parallel (PowerShell 7+). Configurable thread count via -MaxParallel.
• GitHub Actions: Updated workflow with .NET 6/8/9/10, MAUI workload, prerelease publishing to GitHub Packages on push to master

Commits: c5830e8

Documentation

• New Aspire Templates documentation section with 12 guides covering the complete developer journey:
  • Getting Started: DevChain template, dApp template
  • Solidity Development: VS Code setup, writing contracts, Forge testing, Forge deploy
  • C# Integration: code generation, unit testing, integration testing
  • dApp Development: wallet integration, token interaction UI, Explorer ABI discovery
• Plugin skills: aspire-devchain, aspire-dapp
• Updated global pages: What Do You Want To Do, Component Catalog, Landing Page
• [NethereumDocExample] attribute and tagged tests for core-foundation README examples
• EIP-7702 skill and tagged tests for query-blocks guides
• README rewrites across multiple packages

Commits: 23b931e, c4dc7ea, a91964f, ee9f693, afd0da8, cb466c9, 4d3a7a8

All Commits Since 6.0.0

4828ebda Fix template README version references to 6.0.4
9c68e081 Aspire Template Pack: Update README with nethereum-dapp template docs, wallet flow, ABI auto-discovery, and troubleshooting
d348e405 DevChain Template: Add local Explorer App.razor to fix blazor.web.js compatibility with NuGet-packaged Razor components
818cc8af Dapp Template: Add local Explorer App.razor to fix blazor.web.js compatibility with NuGet-packaged Razor components, update templates to default NuGet 6.0.4
bb5b2209 Fix contract deployment race condition by polling eth_getCode (#1082)
ce721746 Fix EIP6963 personal_sign passing JSON string instead of address (#1080)
76c796ef DevChain Template: Fix project references, update to async MapDevChainEndpointsAsync, and update Aspire version to 13.1.1 in README
60e76cc3 Remove old template
63e29eb5 update validate documentation section skill
c5830e83 Bump version to 6.0.4, add Herumi native packages, parallel nuget-fast.ps1 build script, fix nuget.bat Herumi output path, and GitHub Actions CI with prerelease publishing to GitHub Packages
6e1921f8 Explorer: Add runtime bytecode ABI matching for Foundry artifacts and fix wallet CSS specificity with !important overrides for scoped Blazor styles
f500fcc0 Aspire Templates: Add nethereum-dapp template with EIP-6963 wallet chain validation, light-themed WebApp UI, and Foundry contract integration; update DevChain template and template pack to 6.0.4
ef3e25ee DevChain: Move hosting types from Server tool to library, add reusable web extensions
5d391e3a Wallet: Price refresh service with two-threshold model and overflow fixes
3a9f214a Update readme
b3fab9b7 update geth and start bat
8127d576 Project folder LightClient Consensus
2bd97f0e skills update
bbafb371 Readme Update
2dcb306c Adding validate UpperBytes to prevent overflows decoding ints
4026d4a7 SparseMerkleTree optimisations
d106e500 Readme updates
fbfcbf64 Moving MinimalHdWallet to Nethereum.Accounts
76e56c0b MinimalHd Wallet moved to Nethereum.Accounts for frameworks 6 and above
4d3a7a89 examples and docs tagging in tests
cb466c9c Aspire Template Pack
afd0da8a Tests: Fix KeyStore doc examples to use DocSection.Signing
ee9f693c Docs: Add EIP-7702 skill and tag tests for query-blocks and EIP-7702 guides
3f6c490c Intial plugin claude skills
3fc3645b update commit and validate docs sections
a91964fb Skills: Add documentation propagation checks to commit skill
c4dc7ea3 Tests: Add [NethereumDocExample] attribute and tagged tests for all core-foundation README examples
23b931ed README rewrite, org profile, and documentation plan
e8a72ed9 Readme Update

Nethereum 6.0.0

Nethereum 6.0.0 is a major release introducing the CoreChain (full in-process Ethereum node), DevChain (development chain with SQLite persistence), AppChain (multi-node application chain stack), Account Abstraction (ERC-4337 bundler + ERC-7579 modular accounts), a Blazor Server blockchain Explorer, multi-provider blockchain storage (Postgres, SQL Server, SQLite), .NET Aspire orchestration, and significant EVM simulator improvements bringing it closer to full Ethereum specification compliance.

Full Changelog

Nethereum.CoreChain — In-Process Ethereum Node

New project providing a full in-process Ethereum execution layer node with JSON-RPC support, state management, block production, and transaction processing.

• Full JSON-RPC handler suite: eth_call, eth_estimateGas, eth_getBalance, eth_getCode, eth_getStorageAt, eth_sendRawTransaction, eth_getTransactionByHash, eth_getTransactionReceipt, eth_getBlockByHash, eth_getBlockByNumber, eth_getBlockReceipts, eth_getLogs, eth_newFilter, eth_getFilterChanges, eth_getFilterLogs, eth_feeHistory, eth_gasPrice, eth_createAccessList, eth_coinbase, eth_mining, eth_syncing, net_listening, net_peerCount, web3_sha3
• debug_traceTransaction and debug_traceCall with opcode and call tracers
• Historical state support with state diff tracking and pruning
• In-memory and persistent storage backends (via IBlockStore, ITransactionStore, IReceiptStore, ILogStore, IStateStore, IStateDiffStore, IFilterStore)
• Block producer with configurable block production options
• Transaction pool (TxPool) with gas price ordering
• Metrics instrumentation via System.Diagnostics.Metrics
• P2P interfaces for consensus and synchronisation
• WebSocket subscription support (eth_subscribe/eth_unsubscribe)
• State root calculation with Patricia Merkle Trie integration
• Consensus abstraction interfaces (pluggable PoA, Clique, etc.)

Commits: 652b4b7, f6c0777, 328672f, b040698

Nethereum.CoreChain.RocksDB — Persistent Storage

RocksDB-backed persistent storage for CoreChain including block, transaction, receipt, log, and state stores. Includes state diff store for historical state reconstruction, message result caching, and bloom filter-based log querying.

Commits: 2dccead, 2371cba

Nethereum.DevChain — Development Chain

Full-featured Ethereum development chain built on CoreChain, designed for local development and testing.

• SQLite persistent storage (default) — chain state survives restarts; in-memory mode also available
• Pre-funded dev accounts (10,000 ETH each)
• Auto-mine mode (block per transaction)
• EIP-1559 transaction support
• Thread-safe account impersonation
• evm_increaseTime and evm_setNextBlockTimestamp dev RPC methods
• Hosted service pattern for ASP.NET Core integration

Commits: 652b4b7, 3bc0939, 90bce97

Nethereum.DevChain.Server — HTTP Server

ASP.NET Core HTTP server wrapper for DevChain with CORS, health checks, configurable chain ID, and dev account management. Provides the JSON-RPC POST endpoint compatible with MetaMask, Foundry, Hardhat, and any Ethereum tooling.

Commits: 90bce97

Nethereum.AppChain — Application Chain Stack (Preview)

Nethereum.AppChain extends the CoreChain and DevChain to provide an application-specific chain layer. The idea is that applications can run their own chain as an extension of Ethereum, handling domain-specific data and business rules at this layer while users retain the ability to exit with their data at any time. Financial assets and high-value state remain on L1s and L2s where they benefit from full Ethereum security, while application data — game state, social graphs, content, governance — lives on the AppChain where it can be processed cheaply and with custom rules. This separation lets developers build fully decentralised applications without forcing all data onto expensive shared infrastructure.

This project is currently in Preview.

• Clique PoA consensus integration
• P2P networking with DotNetty transport and security fixes
• Sequencer for transaction ordering
• L1 anchoring with Postgres persistence for data availability and exit proofs
• Policy engine for chain governance and custom transaction validation rules
• Sync protocol for multi-node state synchronisation
• Account Abstraction integration for AA-native chains (gasless UX, session keys)
• Key vault integration via IWeb3 constructor overloads
• Template support for scaffolding new AppChain projects

Commits: b1c5806, 0677068

Nethereum.AccountAbstraction — ERC-4337 + ERC-7579

Major upgrade to the Account Abstraction stack with full ERC-4337 bundler implementation and ERC-7579 modular smart account support.

• Bundler: Full ERC-4337 bundler with user operation validation, mempool management, gas estimation, BLS aggregator support, and reputation tracking
• Bundler RPC Server: Standalone JSON-RPC server for the bundler (eth_sendUserOperation, eth_estimateUserOperationGas, eth_getUserOperationByHash, eth_getUserOperationReceipt, eth_supportedEntryPoints)
• Bundler RocksDB Storage: Persistent mempool and reputation storage using RocksDB
• Gas Estimation: Improved gas estimation for user operations including verification gas, call gas, and pre-verification gas
• Validation Helper: ValidationDataHelper for parsing validation data timestamps and aggregator addresses
• ERC-7579 Modular Accounts: NethereumAccount smart account with modular architecture — validators, executors, hooks, and fallback handlers
• Smart Contract Factory: NethereumAccountFactory with governance controls
• Modules: ECDSAValidator, Rhinestone modules (OwnableValidator, SocialRecovery, DeadmanSwitch, MultiFactor, HookMultiPlexer, OwnableExecutor, RegistryHook), SmartSessions with policies (SudoPolicy, ERC20SpendingLimitPolicy, UniActionPolicy)
• Paymaster Contracts: VerifyingPaymaster, DepositPaymaster, TokenPaymaster, BasePaymaster
• Contract Handlers: IContractHandlerService enabling standard contract services to be switched to AA mode
• Batch Call Refactoring: Improved batch operation support for user operations

Commits: ce0e537, 9aaafa2, b844e03, 8ee6c33, e692fc1, bcccaf5, b356d6b, bcae91c, 934d48f, 81f7870, 53c76a2, b8087e8

Nethereum.AccountAbstraction Smart Contracts (Solidity)

New Solidity smart contracts for the Account Abstraction system, compiled with Foundry (Solc 0.8.28, Cancun EVM).

• NethereumAccount.sol — ERC-7579 modular smart account with sentinel-list module management
• NethereumAccountFactory.sol — CREATE2 factory with governance controls
• BasePaymaster.sol, VerifyingPaymaster.sol, DepositPaymaster.sol, TokenPaymaster.sol — Paymaster contracts
• ECDSAValidator.sol — ECDSA signature validation module
• Rhinestone module ports: OwnableValidator, SocialRecovery, DeadmanSwitch, MultiFactor, HookMultiPlexer, OwnableExecutor, RegistryHook
• SmartSessions: SmartSession.sol with SudoPolicy, ERC20SpendingLimitPolicy, UniActionPolicy

Commits: b356d6b

Nethereum.Explorer — Blazor Server Blockchain Explorer

New Blazor Server component library providing a full blockchain explorer UI.

• Block list and detail pages
• Transaction list, detail, and input data decoding with ABI resolution
• Log list with event decoding
• Account page (balance, transactions, code)
• Contract interaction: read/write functions via EIP-6963 wallet integration
• Token pages: ERC-20/721/1155 transfers, balances, and metadata
• MUD table browser (World addresses, table IDs, records)
• ABI resolution (Sourcify, local storage)
• Security: CSV injection protection, SQL injection prevention in MUD queries, query bounds validation

Commits: 4468c1b977...

Nethereum 5.8.0 - 10 Year Anniversary Release

Celebrating 10 years of .NET Ethereum integration! (November 2015 - November 2025)

Nethereum was created to enable all .NET developers to build new applications and integrate existing ones with Ethereum.

From the beginning, the thought was simple: Ethereum would not succeed without developers. Not just blockchain specialists, but application developers of all kinds. If Ethereum was going to grow, every developer, regardless of skill set, needed to be able to build on top of it and integrate with it. The same ideas led to the creation of the VS Code Solidity extension… (obviously not just .NET. Java, PHP, Python, JavaScript, any IDE, any developer).

Helping .NET developers was not just about providing an API. Understanding Ethereum was (and still is) complex, so it meant providing support when needed… the blockchain space requires a completely different way of thinking about applications and integration. Now with LLMs this has simplified dramatically the entry point for everyone, and we have seen now there is no much need for community support. Hopefully I have been able to help you all these years. Support to me, it has also meant providing examples and integrations across the entire .NET ecosystem, from backend and enterprise systems to web, mobile, desktop, and gaming, so Ethereum could be part of real applications rather than something separate. And leveraging new innovations… I still think it’s pretty amazing that we can have a Blazor server-side application interacting with the MetaMask extension, a playground compiling and executing in the browser through WASM and interacting with Ethereum that way… seeing those complex games built with MUD, or having full wallets in Blazor and dApp browsers. There are also some projects that never came to an end like the SAP integration examples, or the commerce examples.

When designing Nethereum, I knew developers would need everything a blockchain node client provides, and more. Not just RPC calls, but cryptography, encoding, execution, verification, wallets, indexing, data processing, and application tooling. All of this needed to be available so developers could work at whatever level made sense for their use case, from low-level primitives to high-level abstractions. This will never be finished, as new changes continue to arrive in the EVM, storage, Merkle structures, verification, transaction types, and in .NET itself.

Another goal was that developers fully understand how Ethereum works, while also having simple ways to get started, such as code generation and front-end integration, without needing to learn everything at once. You may have noticed that I have always been obsessed with code generators ... although LLMs might do a lot of work now, the deterministic side is still very important (and those will always be there). We experimented with living documentation (workbooks) but eventually the playground was (I think) the better option. I thought also that gaming, hence my love for Unity will teach anyone what blockchain can achieve, in sometimes much more complex scenarios that any financial DeFi application, creating complete and complex worlds that can simulate rea life without exposure to its dangers, I am pretty glad that Nethereum has helped build some of these fully on chain games.

A longer-term goal was that, once the architecture was in place, any application could stand on its own: using Ethereum primitives directly, acting as a small light client if needed, remaining decentralised, while still integrating easily with the real protocols and smart contracts that make up the Ethereum ecosystem. In this latest release, we now have those verification pieces in place… let’s see how this grows in the future.

Finally another thought was the need to provide another entry point to common smart contracts, to have a real "protocol" or standard, all common languages should be able to interact with it, hence making ENS or smart contract wallets like Gnosis Safe a real protocol and standard, but not just that, but ensuring that we can provide a real Exit or alternative integration (or ui) that provides that real decentralisation.

In the end, Nethereum is many things for many people (and myself :)) depending on how you are going to use it and what you need from it.

Nethereum after 10 years has:

Protocol foundations
Native implementations of RLP, SSZ, Ethereum tries, hashing, Merkle structures, and reusable cryptographic primitives used across execution, indexing, and consensus-related workflows.

Cryptography & verification
Transaction and message signing, EIP-712 typed data, signature recovery, receipt/log/state proof verification, Merkle and Patricia proofs, and execution validation utilities — enabling verification rather than blind trust.

Light client & trust-minimised reads
A .NET light-client direction focused on block, receipt, and state verification, supporting verifiable reads, audit systems, embedded clients, and partial-trust environments.

Execution layer & EVM
A native .NET EVM with opcode-level execution, execution simulation for testing, indexing, validation, and education.

Contracts & ABI tooling
ABI encoding/decoding, typed contract services, event decoding, multicall support, deployment helpers, reflection-based APIs, and code generation that produces real, editable code.

Wallets & identity (full stack)
A complete wallet offering out of the box: mnemonics, HD wallets, keystores, vault-based accounts, view-only accounts, hardware wallet support, external wallets (MetaMask, WalletConnect, EIP-6963, Azure Key Vault, AWS), SIWE, multisig, and Gnosis Safe integration.

Smart-contract ecosystem integration
Established integration patterns for ENS, Uniswap, Safe, ERC standards, x402 and others.

MUD as a full backend
Complete support for MUD: typed Store access, systems, tables, indexing, code generation, and data-driven application backends — usable beyond games as a general on-chain backend model.

Indexing & deterministic data processing
Block, transaction, and log processors; reorg-safe pipelines; deterministic processing; change tracking; and support for multiple databases including PostgreSQL, SQL Server, Azure, and others — designed to integrate with existing systems.

UI & application frameworks
Native support for Blazor, Blazor Hybrid, MAUI, Unity, Avalonia, desktop, and mobile, with reusable components for queries, transactions, deployments, and ABI-driven forms.

Code generation & templates
Multi-format generators producing editable application code (smart contract integration, MUD, unity and blazor front ends) with templates for web, desktop, mobile, games, and playground scenarios.

Production & enterprise readiness
Designed for long-running services, background workers, deterministic execution, auditing, observability hooks, and real-world system and ERP integration.

Release notes

Highlights

• Added a full Ethereum consensus light client + execution state verification stack (Beacon REST client, SSZ, BLS, light client sync, and verified eth_* reads).
• Introduced Nethereum.Wallet as a complete, reusable wallet platform: vault storage, account types, chain management, permissions, RPC request handlers, and UI components.
• Major hardware wallet upgrade with end-to-end Trezor support, including EIP-712 signing and Android USB support for MAUI.
• Expanded protocol integrations, including X402, Uniswap (Permit2 + Universal Router) and additional ecosystem libraries (Circles, Safe utilities improvements).
• Updated and expanded data services (ChainList, CoinGecko, Etherscan v2), plus continued improvements across core libraries.

New packages and major additions

Ethereum Light Client & Verification

• Nethereum.Beaconchain — Beacon Chain REST client with light client endpoints.
• Nethereum.Consensus.LightClient — light client sync (finality/optimistic/standard), sync committee verification, persistent store abstraction.
• Nethereum.Consensus.Ssz + Nethereum.Ssz — consensus types and SSZ infrastructure, Merkleization and proof verification.
• Nethereum.ChainStateVerification — verified execution-layer reads (balance, code, storage, nonce) with an interceptor for transparent Web3 integration.
• Nethereum.Signer.Bls + Nethereum.Signer.Bls.Herumi — pluggable BLS verification with a production native implementation.

Wallet platform

• Nethereum.Wallet — vaults, account management, chain/rpc management, permissions, host provider + interceptor.
• Nethereum.Wallet.RpcRequests — MetaMask-compatible wallet RPC method handlers (request accounts, send tx, sign, switch/add chain, permissions, etc.).
• Nethereum.Wallet.UI.Components — framework-agnostic ViewModels with a plugin-based dashboard approach.
• Nethereum.Wallet.UI.Components.Blazor + ...Maui — production UI integration layers.

Hardware wallet

• Nethereum.Signer.Trezor — major upgrade (firmware/protobuf updates, EIP-712 signing, cross-platform improvements).
• Nethereum.Wallet.Trezor + UI integrations (...UI.Components.*.Trezor).
• Nethereum.Maui.AndroidUsb — Android USB device layer enabling Trezor on Android MAUI.

DeFi and protocol integrations

• Nethereum.Uniswap — Permit2 signing + Universal Router command model.
• Nethereum.X402 — HTTP 402 payment flow tooling for paid APIs.
• Nethereum.Circles — Circles protocol integration on Gnosis Chain.
• Nethereum.GnosisSafe — utility improvements for hashes/signatures/import-export.

Data & utilities

• Nethereum.DataServices — ChainList + CoinGecko integrations; Etherscan v2 and Sourcify v2 updates.
• Nethereum.KeyStore — generic keystore encryption for arbitrary data.
• Continued updates across EIP-712 signing, EI...

EIP7022

Model:

• New Transaction7702
• New Transaction7702Encoder (RLP encoding / decoding)
• TransactionFactory update to create 7702 transactions directly, from a generic input or rlp
• New transaction Type (0x04)
• Authorisation7702 and Authorisation7702Signed both supported by Encoders, First one used to sign authorisations
  RPC:
• New Authorisation RPC object and Model mappers
• Changes to TransactionInput and Transaction to include Authorisations
• Changes to TransactionManagerBase to include identification of EIP7022 transaction types if included the authorisation list, also include common methods to Add authorisations or remove authorisations to the next request, default gas calculation optimised to add extra 2500 per authorisation if either present on the transaction input or in the next requests to be appended to the transaction

Signer:
New: Transaction7702Signer similar generic same as 1059

• Authorisation7702Signer signer to authorise items requests before including them into the 7022 transaction.
• EthECKeyBuilderFromSignedAuthorisation to recover the the signer from Authorisation7702Signed authorisation
• DecodeRLPToAuthorisation7702 to validate the rlp that is being signed by the user... (what am I authorising)

Updates:

• EthECKeyBuilderFromSignedTransaction update to recover from Transaction7702 transaction
• EthExternalSignerBase generic external signer support of 7702.
• Aws, Azure enable generic signing of 7702
• Ledger, Trezor, marked as unsupported

Accounts:

• AccountSignerTransactionManager at the time of nonce allocation, does the signing of all the authorisations to ensure correct nonces in sequencing order based on the nonce manager, authorisations are merged from the request queue onto the transaction input.
• OfflineTransactionSigner update.
• ExternalAccount signing partial support whilst it can sign the 7702 this needs to be implemented to SignAuthorisationAsync and nonce flow

Contracts

• Added AuthorisationList to the common contract object and encoding services

Tests

• Signing Integration tests, included smart contracts examples BatchCall as a contract to be used as 7702 (enabling multiple calls) and delegation.

Services

• 7022SponsorAuthorisationService (Sign authorisations for multiple external accounts),
• AuthorisationGasCalculator (core gas calculator),
• AuthorisationSigner batch key signing support
• Tests to batch creation / authorisation

Commits: 906f165, e88fb13, 8a20bce,
2343277

Muticall RPC batch support improvements

• MulticallInputOuputRpcBatchItem and CreateMulticallInputOutputRpcBatchItems
  To be able to send batches of rpc calls and decode them the MultiQueryBatchRpcHandler includes CreateMulticallInputOutputRpcBatchItems. This method using the multicalls creates a set of MulticallInputOutputRpcBatchItems that contains both the multicallinputouput for decoding the call data and the newly created based on the multicallinputoutput rpcRequestResponseBatchItem.
  MulticallInputOuputRpcBatchItem implements the interface of IRpcRequestResponseBatchItem by wrapping the rpcRequestResponseBatchItem so it can be used as any other normal batch request

• Allowing partial success in batch requests. by @dlebee in #1070

Commits: 633474d, 11c5945

Utils Random

New shuffler and bytes shuffler specialised to help when creating random sets of bytes / numbers (or anything), based on the card shuffling strategy, so no consecutive values can be guessed based on a generic set or rng if guessed.

Commits: cfe1ff4

EVM Simulator update

• The EVM simulator includes a Gas counter.
• New Op codes supported: BASEFEE- BLOBHASH - BLOBBASEFE- TLOAD - TSTORE
  Commits: ee6b4d7

Nethereum.Merkles LeanIncrementalMerkleTree

• New tree / trie LeanIncrementalMerkleTree to support zk proofs
  Commit: adb2872

Nethereum.Geth update

• New DTOs for debug and tracer options/responses added and changes to the Debug api services.
  Thanks to @SolidityNinja pull: #1068
• Nethereum.Geth use StateChange from the core RPC project
  Commit: ec4c916

Bouncy Castle update

• Change of package and version to BouncyCastle.Cryptography 2.5.1, but open to any version up to 3.0.0, targeting frameworks net90, net80, net60 and net472, leaving portable to other versions (previous) due to compatibility issues.
• fix issue in ToDER() method, thanks to the pull request by @tmm360 in #1071
  Commits: 62affe5, a184667

.NET AOT Native support, Nethereum.JsonRpc.SystemTextJsonRpcClient and Example.

.NET Native (now part of Native AOT in .NET) compiles .NET applications ahead-of-time into platform-specific machine code, eliminating the need for a JIT compiler and reducing startup time, memory usage, and deployment size. To enable this and continue to be backwards compatible requires many changes (at core), mostly caused by JSON encoding and decoding.

• Nethereum.JsonRpc.SystemTextJsonRpcClient is a brand new project and AOT-friendly JSON-RPC client for Ethereum, using System.Text.Json.

This provides new RPC Client component and Simple RPC Client component, including also Nethereum RPC Context for generated serialisation of RPC types to provide the RPC transport with System.Text.Json instead of Newtonsoft making it suitable for AOT Native builds using .net9.

Commits: e99d174

• Update all the Nethereum.RPC DTOs, Nethereum.JsonRpc.RpcClient Messages and Nethereum.Hex HexTypes to dual support Newtonsoft.Json and System.Text.Json

   [JsonProperty(PropertyName = "decimals")]
#if NET6_0_OR_GREATER
[System.Text.Json.Serialization.JsonPropertyName("decimals")]
#endif
        public uint Decimals { get; set; }

• Transaction Receipt does not use JArray that couples it to Newtonsoft, it uses now the typed version, FilterLog, and to avoid migration issues all the extensions from receipt has been upgraded, and in scenarios the type conversion remains the same, but just returns the same object.

• All Clients now include a DecodeMethod, so any response message can be combined with the client deserialiser and settings (ie System.Text.Json specific).

• New ContractABI deserialiser ABIJsonDeserialiserSTJ to support System.Text.Json, this is an optin deserialiser, enabling to interact with smart contracts using abi strings in Native mode. Note: To workaround the fact that newtonsoft is more flexible and allows for single quotes when using Json and backwards compatibility, the deserialiser if it finds single quotes it replaces them with double quotes.

To enable it use:

AbiDeserializationSettings.UseSystemTextJson = true;

Commits: 8466e44, 5eccd83, 2b0407d

• Nethereum.ABI.SourceGenerators, (WIP) to avoid ABI decoding using the attributes and reflection when using typed FunctionMessages, Events etc. Nethereum.ABI.SourceGenerators experimental project generates the code to convert set and get the values directly when encoding and decoding at compilation time. This works very well native mode as the code is normally stripped from this scenarios. The current early implementation works on Functions and Structs, but further refining is required to allow for anonymous methods, implementation of other types and most importantly integrate it an option within the deserialising workflow.

Commits: 48a2302

• .NET Native example and test project
  The dotnet native example, provides many common scenarios and tests to validate the native support of Nethereum.
  Source: https://github.com/Nethereum/Nethereum/blob/master/consoletests/Nethereum.AOTSigningTest/Program.cs

A simple example of usage:

Include the namespace for the SystemTextJsonRpcClient.

using Nethereum.JsonRpc.SystemTextJsonRpcClient;

Using the RpcClient from SystemTextJsonRpcClient, and work as usual.

var localClient = new RpcClient("http://localhost:8545");
            var account = new Nethereum.Web3.Accounts.Account("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7");
            var web3Local = new Web3.Web3(account, localClient);

            var localBalance = await web3Local
                .Eth
                .GetBalance.SendRequestAsync("0x12890d2cce102216644c59daE5baed380d84830c");

            var ethSenderService = web3Local.Eth.GetEtherTransferService();
            var transactionHash = await ethSenderService.TransferEtherAsync("0x12890d2cce102216644c59daE5baed380d84830c", 0.01m);

Note...

Nethereum.Blazor

• New project, to be used as the basis for integrating with Blazor.
• EIP6963 support, enabling multi wallet browser extension support, like Metamask, Coinbase, Brave, Rabby etc Example of Blazor Project
• EthereumAuthenticationProvider, common class to provide authentication support, this should work if you use EIP963, Metamask standalone or Reown
• SiweAuthenticationServerStateProvider, common class to provide further authentications support if using SIWE, so whilst a user might be connected, it can be authenticated in certain areas of the application.
• LocalStorageAccessTokenService and LocalStorageHelper, generic helpers to manage the SIWE access tokens on generic LocalStorage.

Commits: b534f8f

Nethereum.Unity.EIP6963

• Unity support for EIP6963, including custom WeglHostProvider, Interop, etc.
• Full example in the Unity Template https://github.com/Nethereum/Unity3dSampleTemplate/

Commits: b534f8f, Nethereum/Unity3dSampleTemplate@a321511

Account Abstraction RPC Bundler

Rpc Service and requests to integrate with 4337 Account Abstraction

Commits: 7116733

Other Additions

• Add TryParse method to BigDecimal struct by @AnzeS in #1066
• Support NUGET_PACKAGES environment variable in Nethereum.Autogen.ContractApi by @zakhard90 in #1067

Full Changelog: 4.28.0...4.29.0

Code generator (.net, typescript, vscode solidity)

• Services now inherit from a base class with the core implementation, all methods are virtual, allowing to be overriden on the main class to add custom logic like validation.
• Mud Table Service is extended to include Set and Get methods using parameters, so now Keys Values are needed.
• Mud Table, includes accessors for both Keys and Value properties at top level, this way it can be easily accessed the data, but also in future
  use these properties as entities to get the data from a different storage or Api.
  Commits: 1beb31c

public partial class ItemTableService : TableService<ItemTableRecord, ItemTableRecord.ItemKey, ItemTableRecord.ItemValue>
    { 
        public ItemTableService(IWeb3 web3, string contractAddress) : base(web3, contractAddress) {}
        public virtual Task<ItemTableRecord> GetTableRecordAsync(uint id, BlockParameter blockParameter = null)
        {
            var _key = new ItemTableRecord.ItemKey();
            _key.Id = id;
            return GetTableRecordAsync(_key, blockParameter);
        }
        public virtual Task<string> SetRecordRequestAsync(uint id, uint price, string name, string description, string owner)
        {
            var _key = new ItemTableRecord.ItemKey();
            _key.Id = id;

            var _values = new ItemTableRecord.ItemValue();
            _values.Price = price;
            _values.Name = name;
            _values.Description = description;
            _values.Owner = owner;
            return SetRecordRequestAsync(_key, _values);
        }
        public virtual Task<TransactionReceipt> SetRecordRequestAndWaitForReceiptAsync(uint id, uint price, string name, string description, string owner)
        {
            var _key = new ItemTableRecord.ItemKey();
            _key.Id = id;

            var _values = new ItemTableRecord.ItemValue();
            _values.Price = price;
            _values.Name = name;
            _values.Description = description;
            _values.Owner = owner;
            return SetRecordRequestAndWaitForReceiptAsync(_key, _values);
        }
    }
    
    public partial class ItemTableRecord : TableRecord<ItemTableRecord.ItemKey, ItemTableRecord.ItemValue> 
    {
        public ItemTableRecord() : base("MyWorld", "Item")
        {
        
        }
        /// <summary>
        /// Direct access to the key property 'Id'.
        /// </summary>
        public virtual uint Id => Keys.Id;
        /// <summary>
        /// Direct access to the value property 'Price'.
        /// </summary>
        public virtual uint Price => Values.Price;
        /// <summary>
        /// Direct access to the value property 'Name'.
        /// </summary>
        public virtual string Name => Values.Name;
        /// <summary>
        /// Direct access to the value property 'Description'.
        /// </summary>
        public virtual string Description => Values.Description;
        /// <summary>
        /// Direct access to the value property 'Owner'.
        /// </summary>
        public virtual string Owner => Values.Owner;

        public partial class ItemKey
        {
            [Parameter("uint32", "id", 1)]
            public virtual uint Id { get; set; }
        }

        public partial class ItemValue
        {
            [Parameter("uint32", "price", 1)]
            public virtual uint Price { get; set; }
            [Parameter("string", "name", 2)]
            public virtual string Name { get; set; }
            [Parameter("string", "description", 3)]
            public virtual string Description { get; set; }
            [Parameter("string", "owner", 4)]
            public virtual string Owner { get; set; }          
        }
    }

Code generator .NET

Now supports GeneratorSets or ".nethereum-gen.multisettings" as a library and console, the same as the typescript and vscode-solidity version.

Commit: a211387

Console usage Nethereum.Generator.Console generate from-config defaults to ".nethereum-gen.multisettings" and current folder.
See --help for more info.

[
{
    "paths": ["out/ERC20.sol/Standard_Token.json"],
        "generatorConfigs": [
            {
                "baseNamespace": "MyProject.Contracts",
                "basePath": "codeGenNodeTest/GeneratorSets/Example2/MyProject.Contracts",
                "codeGenLang": 0,
                "generatorType": "ContractDefinition"
            },
            {
                "baseNamespace": "MyProject.Contracts",
                "basePath": "codeGenNodeTest/GeneratorSets/Example2/MyProject.Contracts",
                "codeGenLang": 0,
                "generatorType": "UnityRequest"
            }
        ]
},
{
    "paths": ["out/IncrementSystem.sol/IncrementSystem.json"],
        "generatorConfigs": [
            {
                "baseNamespace": "MyProject.Contracts.MyWorld1.Systems",
                "basePath":  "codeGenNodeTest/GeneratorSets/Example2/MyProject.Contracts/MyWorld1/Systems",
                "codeGenLang": 0,
                "generatorType": "ContractDefinition",
                 "mudNamespace": "myworld1"
            },
            {
                "baseNamespace": "MyProject.Contracts.MyWorld1.Systems",
                "basePath":  "codeGenNodeTest/GeneratorSets/Example2/MyProject.Contracts/MyWorld1/Systems",
                "codeGenLang": 0,
                "generatorType": "MudExtendedService",
                "mudNamespace": "myworld1"
            }
        ]
},
{
    "paths": ["mudMultipleNamespace/mud.config.ts"],
        "generatorConfigs": [
            {
                "baseNamespace": "MyProject.Contracts.MyWorld1.Tables",
                "basePath":  "codeGenNodeTest/GeneratorSets/Example2/MyProject.Contracts/MyWorld1/Tables",
                "generatorType": "MudTables",
                "mudNamespace": "myworld1"
               
            }
        ]
},
{
    "paths": ["mudMultipleNamespace/mud.config.ts"],
        "generatorConfigs": [
            {
                "baseNamespace": "MyProject.Contracts.MyWorld2.Tables",
                "basePath":  "codeGenNodeTest/GeneratorSets/Example2/MyProject.Contracts/MyWorld2/Tables",
                "generatorType": "MudTables",
                "mudNamespace": "myworld2"

            }
        ]
}
]

(Gnosis) Safe

• Safe smart contract upgrade, signing and new contract handler extension.
  The new contract handler extension allows you to convert any smart contract service into a safe request signer using your private key (or keys).

Commits:: 255b574, 66da017, dddba5f,

            var privateKeySigner = "";
            var privatekeySender = "";
            var web3 = new Web3(new Nethereum.Web3.Accounts.Account(privateKey), "https://rpc.aboutcircles.com/");
            var hubService = new HubService(web3, v2HubAddress);
            hubService.ChangeContractHandlerToSafeExecTransaction(humanAddress1, privateKeySigner);

Other fixes

• Mud Call From and Batching removing the namespace prefixes from the generated function messages, and other general improvements Commits: 7019a21, 0b73515, 3fcd9ae, 69d4fa1,
  69345dc

Unity Release

The unity release can be found here, follow the instructions for installation.
https://github.com/Nethereum/Nethereum.Unity/

Full Changelog: 4.27.1...4.28.0

Patch to rollback the Bouncy Castle upgrade (Reported Issues)

Full Changelog: 4.27.0...4.27.1

Reown Appkit Blazor support

• Add Reown AppKit library and Blazor example by @Magehernan (Many Thanks!!!) in #1056
  This works the same as Metamask Blazor / Wallet Connect Blazor here is the example https://github.com/Nethereum/Nethereum/blob/master/consoletests/NethereumReownAppKitBlazor/Pages/Index.razor

Updates

• .Net 9 Target, removal of dotnetcore 2 and dotnetcore 3 (this should use netstandard if needed)
• Support for Microsoft.Extensions.Logging.Abstractions in .net 9 by @andresgutierrez in #1054
• Use BouncyCastle.Cryptography for net6.0 and later by @raymens in #1057

General changes / Fixes

• Custom Error exceptions typed changes / handling and factories to enable casting and straight decoding
• BigInteger explicit cast and FloorToBigInteger for BigDecimal by @ethanrushh in #1055
• Mud Normaliser Postgres dbnull fix / support

Unity release

The unity release can be found here, follow the instructions for installation.
https://github.com/Nethereum/Nethereum.Unity/

Full Changelog: 4.26.0...4.27.0

Mud Postgres Normaliser

The Mud Postgres Normaliser is a service that processes data from the StoredRecords table, which is populated by Store event logs, and normalizes it in PostgreSQL.

Key Features:

Table Creation:
For each record, the service ensures that the corresponding table based on the tableId is created. If the table doesn’t exist, it is created using schema information retrieved from the blockchain, including appropriate column types.
Data Decoding and Persistence:

The service decodes and inserts or updates the blockchain event data into the PostgreSQL database.

Singleton Tables:
Singleton tables are created with a single key of 1, simplifying their structure.

Progress Tracking:
A Progress table tracks the last processed blockNumber and rowId, allowing the service to pick up from where it left off and process data in batches.

Configurable Pagination:
The service supports configurable batch sizes, making it flexible for different use cases.

Example

public class Program
{
    public static async Task Main(string[] args)
    {
        // Set up the necessary services
        var connection = new NpgsqlConnection("Host=myserver;Username=mylogin;Password=mypass;Database=mydatabase");
        var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
        var logger = loggerFactory.CreateLogger<MudPostgresNormaliserProcessingService>();

        // Create the repository (assuming it's already implemented and registered)
        var storeRecordsTableRepository = new MudPostgresStoreRecordsTableRepository(connection, logger);

        // Create an instance of the processing service
        var processingService = new MudPostgresNormaliserProcessingService(
            storeRecordsTableRepository,
            connection,
            logger
        )
        {
            RpcUrl = "https://localhost:8545",
            Address = "0xYourContractAddress",
            PageSize = 1000 // Optional: configure the number of records processed per batch
        };

        // Execute the normalisation process
        var cancellationToken = new CancellationTokenSource().Token;
        await processingService.ExecuteAsync(cancellationToken);
    }
}

Commits: 99f16f7

Mud General

• EF Stored records can be retrieved all by BlockNumber and RowId Commits 6e2ae82
• Stored records Key is now a combination of all the keys padded to 32 bytes (for byte or hex storage), this allows to decode the key without knowing the schema before hand. Commits f860291
• TableSchema Generic table schema object that can be built from TableTableRecord (by retrieving the schema from the chain Commit 5b0ab1c
• Value Decoder defaults to default values for remaining schema fields when there are no more bytes to decode. Commit 5b0ab1c

Blockchain Log Processor

• Adding extra logging on the Log Processor to track progress of each internal block range processed. Commit a5eb2ea

Full Changelog: 4.25.0...4.26.0

Unity release in openupm.com https://github.com/Nethereum/Nethereum.Unity

4.25.0

IRestHttpHelper / RestHttpHelper and UnityTaskRestHttpHelper

This release introduces a IRestHttpHelper interface and a simple implementation of a REST API client for use across both .NET and Unity Nethereum projects. Key features include:

• Cross-Platform Support: The utility works in both .NET and Unity, ensuring flexibility across different platforms.
• Dynamic JSON Deserialization:
  • Utilizes System.Text.Json (STJ) for .NET 8 and newer versions.
  • Falls back to Newtonsoft.Json for Unity and older .NET versions.
• New Dependency: A new project, Nethereum.Util.Rest, has been added to handle REST client operations for DataServices and Contracts

Commits 0b4d51b

Upgrade of Nethereum.DataServices and Nethereum.Contracts

Nethereum.DataServices and Nethereum.Contracts are upgraded to use the new RestHttpHelper by default or any other implementation that implements the interface.

Fixes to Etherscan are also included.
Commits aeaa446

TablePredicateBuilder

The TablePredicateBuilder introduces a fluent API to build predicates for querying Mud storage tables that have been synchronized to an external repository (such as a PostgreSQL database). It allows developers to construct complex queries with minimal effort using chainable methods.

Key Features:

• Fluent API for Predicate Construction:

  • Easily create complex queries using chainable .AndEqual(), .OrEqual(), .AndNotEqual(), and other methods.
  • Supports flexible predicate building that can target specific table fields or conditions.

• Reusable across Storage Types:

  • Predicates are built on a custom set of objects, enabling them to be reused for different storage backends (e.g., PostgreSQL, SQLite).

• REST API Integration:

  • Predicates can be serialized into JSON for making REST API calls. The server can then deserialize the predicate and query the internal database storage using the same predicate structure.

Example Usage:

var predicateBuilder = new TablePredicateBuilder<ItemTableRecord, ItemTableRecord.ItemKey, ItemTableRecord.ItemValue>("0xABC123");

var predicate = predicateBuilder
                .AndEqual(x => x.Id, 1)         // AND key0 = '0x1'
                .AndEqual(x => x.Id, 2)         // AND key0 = '0x2'
                .OrEqual(x => x.Id, 3)          // OR key0 = '0x3'
                .AndNotEqual(x => x.Id, 4)      // AND key0 != '0x4'
                .Expand();                      // Finalize the predicate

The TablePredicateBuilder simplifies querying complex storage structures and provides flexibility for different storage systems, allowing predicates to be reused and transported as needed for various scenarios such as querying a database or sending queries via REST APIs.

Commits ad9ac4c 4ddb6d4 af16f6b

Mud.Repositories.EntityFramework

The Mud.Repositories.EntityFramework project offers a foundational framework to integrate with a Mud repository using Entity Framework (EF). It includes various utilities and features to support efficient querying and storage of blockchain data.

Key Features:

• Custom Predicate Builder:

  • Provides a predicate builder that creates SQL queries using key hex values. The queries are compiled into a SqlPredicateResult, which includes the SQL statement and arguments to safely prevent SQL injection.

• MudEFTableRepository:

  • A MudTableRepository using keys as hex and EF supporting any context that implements IMudStoreRecordsDbSets, which includes the StoreRecords and BlockProgress entities.

• BlockProgressRepository:

  • Custom implementation of the BlockProgresRepository for EF Mud

Commits dc4be4c

Mud Repository Postgres

Provides an extended Entity Framework (EF) repository implementation for PostgreSQL.
Key features include:

• Log Processing Service: Synchronizes and processes blockchain logs into a PostgreSQL database.
• Custom DbContext and TableRepository: A custom DbContext and TableRepository are included to manage all fields stored as bytea (PostgreSQL binary format).
• PredicateBuilder: Enables dynamic querying by constructing predicates that can be used to efficiently filter data within the repository.

Commits: 13edbfa

NethereumMudLogProcessing, NethereumMudStoredRecordsRestApi, and NethereumMudStoreRestApiClient Examples

Source:
https://github.com/Nethereum/Nethereum/tree/master/consoletests/NethereumMudLogProcessing
https://github.com/Nethereum/Nethereum/tree/master/consoletests/NethereumMudStoreRestApiClient
https://github.com/Nethereum/Nethereum/tree/master/consoletests/NethereumMudStoredRecordsRestApi

End-to-end examples for processing and querying data from blockchain store records using a PostgreSQL database. The solution includes:

Log Processing: Blockchain store records are processed and stored in a PostgreSQL database using the LogProcessor. The solution leverages Entity Framework (EF) migrations for database schema management.

REST API Integration: A flexible REST API is provided to query the stored records. The API receives requests containing predicates (in JSON format), which are converted into queries for PostgreSQL using the table repository.

Data Transformation: The queried results are transformed into Data Transfer Objects (DTOs) and further converted into table format, which is then outputted to the console.

Commits: 73fbd59

Extra fetures:

• Mud Log processing creation of Log processor: 13edbfa

Fixes

• 712 ToJson - Prefix bytes for 1271 AA Type Messages by @0xFirekeeper in #1041
• Exceptions when validating v indicate that TransactionChainId should be used by @psavva in #1043

Full Changelog: 4.21.4...4.25.0