Release notes from Nethereum

6.0.4

2026-03-18T10:25:06Z

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:

Fetch on-chain bytecode via eth_getCode
Compare against all loaded Foundry artifacts (stripping metadata suffixes)
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

6.0.0

2026-03-07T05:11:20Z

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: 4468c1b, f1e8b00

Nethereum.Blazor — Dynamic Contract Interaction Components

New dynamic contract interaction components: DynamicQueryFunction, DynamicTransactionFunction, DynamicContractDeployment — interact with any smart contract using just its ABI, no code generation required
DynamicStructInput, DynamicArrayInput — recursive input rendering for complex ABI types
DynamicResultOutput, DynamicErrorDisplay, DynamicReceiptDisplay, DynamicGasSettings
Typed base classes: QueryFunctionComponentBase, TransactionFunctionComponentBase, ContractDeploymentComponentBase, ResultOutputBase
EIP-6963 wallet discovery improvements

Commits: 15a0dd5

Nethereum.Blazor.Solidity — EVM Debugger Components

New Blazor components for EVM-level debugging and Solidity source code viewing.

Commits: d28b638

Nethereum.EVM — Major EVM Simulator Upgrade

Significant improvements to the EVM simulator bringing it closer to full Ethereum specification compliance (Prague/Cancun).

Prague support: EIP-7623 gas changes, new precompiles (BLS12-381, KZG Point Evaluation), BN128 curve completed port
Precompiles: Native implementations for ecRecover, MODEXP, BN128 (add, mul, pairing), BLAKE2f, BLS12-381, KZG Point Evaluation
Call frame tracking: Proper call stack with InnerCallResult tracking for internal calls, delegate calls, and static calls
Access list tracker: EIP-2929 warm/cold access tracking for accurate gas calculation
Gas calculation fixes: EXTCODECOPY stack order, EXP gas calculation, maxinitcode 32000 gas, static call enforcement, revert handling
Debugger: Async debugger sessions, function dispatch mapping (_functionMaps), safe hex/chainId parsing
State changes extractor: Extract token balance changes from EVM traces for transaction simulation
Performance: Cached int types, BinaryPrimitives for direct integer decoding

Commits: 17972bd, 04d442b, f3f5be3, 384ca19, 43f682a, 1ad6060, 291ab5a, 77a315a, 879125b, 20dc674, 214b1e3, 5430286, b2e2206, 8d43b6b, 81418a5, 2f853e5, 5a7f743, 6e82704

BlockchainProcessing — Reorg Detection, Token Indexing, Internal Transactions

Major upgrade to the blockchain processing pipeline.

Reorg detection: ReorgDetectedException with automatic block rewind and reprocessing
Token transfer indexing: ERC-20/721/1155 Transfer event processors with dedicated repositories (ITokenTransferLogRepository, ITokenBalanceRepository, ITokenMetadataRepository, INFTInventoryRepository)
Token balance aggregation: Computes running balances from transfer events
Internal transaction support: IInternalTransactionRepository with storage step handler for tracing-derived internal calls
Metrics: Processing rate, block lag, and error counters via System.Diagnostics.Metrics
String-to-long migration: Block numbers and transaction indices changed from string to long for proper sorting and querying in the storage entities
Log storage options: Configurable log storage with bloom filter-based filtering
Retry runner: Configurable retry logic for transient failures

Commits: 68f541f

BlockchainStore — Multi-Provider Database Storage

Complete rewrite of the blockchain storage layer with a shared EF Core base and provider-specific implementations.

BlockchainStore.EFCore (Shared Base)

IBlockchainDbContextFactory factory pattern for scoped DbContext creation
Full entity model: blocks, transactions, transaction logs, contracts, token transfers, token balances, token metadata, NFT inventory, internal transactions
Block progress tracking for resumable indexing

BlockchainStore.Postgres

PostgreSQL provider using Npgsql with snake_case naming conventions
Optimised for high-throughput indexing with batch operations

BlockchainStore.SqlServer

SQL Server provider with configurable schema support
Full indexed blockchain storage

BlockchainStore.Sqlite

SQLite provider for lightweight/embedded scenarios
Full indexed blockchain storage

BlockchainStorage.Processors (Shared Base)

BlockchainProcessingService — orchestrates block/transaction/log processing into the database
InternalTransactionProcessingService — processes debug traces into internal transaction records
BlockchainProcessingHostedService / InternalTransactionProcessingHostedService — ASP.NET Core hosted service wrappers
BlockchainProcessingOptions — configuration binding (connection strings, batch size, confirmations)

BlockchainStorage.Processors.Postgres / SqlServer / Sqlite

Thin DI wiring projects: AddPostgresBlockchainProcessor(), AddSqlServerBlockchainProcessor(), AddSqliteBlockchainProcessor()

BlockchainStorage.Token.Postgres

Token processing pipeline: ERC-20/721/1155 transfer log processor, balance aggregator, metadata resolver
Token balance denormaliser for fast query access
Safe tokenId parsing for large ERC-721/1155 IDs

Commits: 4f74d19, 7515761, 286ebbc, 2417b18, d075e36, db97ee0, f496d9e, 7769e13

MUD — Processing Services and Reorg Support

Hosted processing services for MUD World record indexing
Reorg support: detect and rewind MUD records on chain reorganisation
Normaliser: denormalise MUD table records into queryable Postgres tables
DynamicTablePredicateBuilder for type-safe MUD table queries
INormalisedTableQueryService for querying normalised MUD data
Blazor component refactoring

Commits: 741eb13

Nethereum.ABI — Int128/UInt128 Support and StateMutability

Int128/UInt128 decoding and encoding: Full support for 128-bit integer types in ABI encoding and decoding
Direct integer decoding: Use BinaryPrimitives for primitive integer types instead of decoding via BigInteger — significant performance improvement
StateMutability support: FunctionABI and ConstructorABI now include StateMutability field from ABI JSON
String decoder boundary fix: Prevent out-of-range exceptions on malformed string data
Null-safe JSON parameter conversion: JsonParameterObjectConvertor handles null values gracefully
ABIJsonDeserialiserSTJ: System.Text.Json ABI deserialiser improvements

Commits: c940936, a425b5d, 6e476ac, b6efed5, 6918a5f

Nethereum.Model — EIP-4844/Prague Block Headers and Transaction7702

EIP-4844 block header fields: BlobGasUsed, ExcessBlobGas, ParentBeaconBlockRoot added to BlockHeader
Prague fields: RequestsHash for the Prague hardfork
Transaction7702: Full EIP-7702 transaction type support in TransactionFactory
Original RLP caching: Cache the original RLP bytes for hash verification without re-encoding
Defensive fixes: Clone RLP cache on copy, deduplicate encode paths, reorder type checks for correctness
Log encoding: Receipt and LogBloomFilter RLP encoding/decoding updates
SignedTransaction extensions: Improved signed transaction handling

Commits: 96093c5, 69f0ed9, 961cd78, 94651016

Nethereum.RPC — Shared Debug Tracing and EIP-4844

Debug tracing moved to shared RPC: DebugTraceTransaction, DebugTraceCall, and all tracer types (CallTracer, OpcodeTracer, PrestateTracer, NoopTracer) moved from Nethereum.Geth to Nethereum.RPC.DebugNode so any node implementation can use them
Tracer DTOs: TraceConfigDto, TraceCallConfigDto, TracerConfigDto, BlockOverridesDto, StateOverrideDto, TracerLogDto
EIP-4844 blob fields: BlobVersionedHashes, MaxFeePerBlobGas added to transaction DTOs
RpcMessage serialisation: System.Text.Json server-side serialisation support

Commits: 8383191, 69d3600, b3c3015

Nethereum.Geth — Tracer Refactoring

Geth-specific tracing types (DebugTraceTransaction, DebugTraceCall, CallTracer, OpcodeTracer, PrestateTracer, NoopTracer, and all DTOs) moved to shared Nethereum.RPC.DebugNode namespace
Remaining Geth-specific tracers updated: BigramTracer, TrigramTracer, UnigramTracer, EvmdisTracer, FourByteTracer, OpcountTracer, CustomTracer

Commits: 69d3600

Nethereum.Merkle — FrontierMerkleTree, Poseidon, and Fixes

FrontierMerkleTree: New append-only Merkle tree optimised for blockchain use (stores only the frontier nodes)
LeanIncrementalMerkleTree: Optimised with cached layers and dirty-node persistence
Poseidon hash provider: ZK-friendly hash function for sparse Merkle trees
Patricia Merkle Trie: Dirty node tracking, nibble extension fixes
Fixes: VerifyProof direction correction, empty root handling, capacity overflow prevention

Commits: 530f723, 9e06cc2, adeea45, 0d3fd55, 6848840, e5ee4d6, 2d3bae3

Nethereum.Wallet — StateChanges Preview and Transaction Executor

StateChangesPreviewService: Simulate transactions via EVM and display predicted state changes (ETH balance changes, token transfers) before signing
TransactionExecutor: Unified transaction execution with CallMode option for EVM simulation vs live execution

Commits: 20a1140, 81418a5, 6f2f803

Nethereum.ABI DataServices — Sourcify V2

Sourcify upgrade to V2 APIs
Parquet download support for bulk ABI data
Postgres EF database for ABI storage
ABIInfoStorageFactory with composite pattern: cache, Sourcify, Etherscan, 4Byte

Commits: 312c258

Code Generator

Support for referencedTypesNamespaces — when a struct type is shared across contracts (e.g. PackedUserOperation), the code generator skips regenerating it and adds the namespace import instead
JavaScript transpile update

Commits: 3afba9d, 3132ac1, f27dc10

.NET Aspire Integration

New Aspire orchestration for spinning up a complete Ethereum development environment with a single dotnet run.

AppHost: Orchestrates DevChain + PostgreSQL + Indexer + Explorer with service discovery, health checks, and OpenTelemetry
Indexer: Background worker crawling blocks, transactions, logs, token transfers (ERC-20/721/1155), token balances, and MUD World records into PostgreSQL
Explorer: Full blockchain explorer UI connected via Aspire service discovery
dotnet new nethereum-devchain template: Generates a standalone Aspire solution using only NuGet packages with configurable --NethereumVersion, --ChainId, and --AspireVersion parameters
ServiceDefaults: Shared OpenTelemetry, health checks, and resilient HTTP client configuration

Commits: 0b6e91e

.NET 10 Target Framework Support

Nethereum.Signer and Nethereum.KeyStore: Added net10.0 to BouncyCastle conditional framework lists
Nethereum.Maui.AndroidUsb: Updated target framework from net9.0 to net10.0
Wallet UI components: Upgraded target frameworks and packages to .NET 10
Microsoft.Extensions.Logging.Abstractions: Version constraint relaxed to support any version above minimum

Commits: e9459bc, 9ab1aca, ee46846, 741a401

EIP-7702 Support

Full EIP-7702 (Set EOA Account Code) support across the stack:

Transaction7702 model and encoder
TransactionFactory update for 7702 transaction creation
Signer support for 7702 authorisation lists
CoreChain integration tests and spec tests
Bundler validation support for delegated accounts

Commits: 48a9884, 1aaae6f, b844e03

Test Coverage

EVM specification tests: stCallCodes, stCreate2, stRefundTest, stBadOpcode, stExtCodeHash, stStaticCall, precompiles test vectors — validated against Ethereum test suite
RLP tests: Using Geth test vectors for encoding/decoding validation
Signer tests: EIP-2930 transaction signing with Geth test vectors
Account Abstraction: Integration tests for ERC-4337 bundler, ERC-7579 modules, gas estimation, and end-to-end user operation flows
CoreChain: Integration tests for RPC handlers, access list creation, debug tracing, blockchain test vectors
EVM benchmarks: Performance benchmarking project

Commits: 5a67625, 779349b, 35920bd, 9b998b1, e818b79, 6e82704

Other Changes

Hex extensions: Small optimisations for hex string operations
Commit: e9c5ddb
BigDecimal: Support parsing e-notation (scientific notation)
Commit: 0ee4b8d
ENS: Update ADRaffy.ENSNormalize
Commit: 66e7a77
Poseidon hasher: Nethereum.Util.PoseidonHasher for ZK-friendly hashing
Commit: 6848840

New Contributors

@langebo made their first contribution in #1093
@0xInnominatus made their first contribution in #1100

Full Changelog: 5.8.0...6.0.0

5.8.0

2026-01-05T10:25:04Z

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, EIP-6963 interop, MUD change tracking, Merkle utilities, and Unity helpers.

Package Readmes
All packages have now a Readme file to help getting started or get LLMs the right introduction to them.

Compatibility notes

This is a large release with new packages and expanded surface area; if you upgrade from 5.0.0, review any wallet/RPC interception and serializer behaviour changes relevant to your applications.

10 years thanks

I would like to dedicate this to my father, who passed away 10 years ago. Nethereum, and much of my work since, has been inspired by that event.

Many thanks to my family for the support they have provided and the sacrifices that this has meant for them.
To all the friends who have been there and provided emotional support, daily, when needed, or in the background, encouraging and providing help to continue (or sometimes encourage to stop ;) ).
To everyone who has worked directly with Nethereum: Gael, Dave and Kevin
To those who have always been there Caleb, Aaron and Jim
To all the great and small contributors.
To everyone in Gitter, Discord, and the community spaces who has been part of the journey and provided great feedback from the start
To everyone at ConsenSys, Ujo, Maker, Microsoft, Etherscan, CafeCosmos, dev tools community and the wider Ethereum community .... too many to mention, but you know who you are.

"The One Piece" was the friends we made along the way.

All the love Juan

Example of all the wallet components

5.0.0

2025-05-30T16:20:13Z

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 the project settings that do include TrimmerRootAssembly to avoid stripping of attribute based types.

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
	  <OutputType>Exe</OutputType>
	  <TargetFramework>net9.0</TargetFramework>
	  <PublishAot>true</PublishAot>
	  <SelfContained>true</SelfContained>
	  <RuntimeIdentifier>win-x64</RuntimeIdentifier>
	  <InvariantGlobalization>true</InvariantGlobalization>
	  <PublishTrimmed>true</PublishTrimmed>
  </PropertyGroup>
 <!-- other settings -->
  <ItemGroup>
    <TrimmerRootAssembly Include="Nethereum.Contracts" />
    <TrimmerRootAssembly Include="Nethereum.ABI" />
    <TrimmerRootAssembly Include="Nethereum.Hex" />
    <TrimmerRootAssembly Include="Nethereum.AOTSigningTest" />
  </ItemGroup>
  
  </Project>

Nethereum.MudBlazorComponent

New project providing different Blazor components in (MudBlazor) to provide simple data input for smart contracts and Mud (Mud.Dev) Tables.

QueryFunctionComponent you can query any smart contract by providing the FunctionMessageType, SmartContractAddress and the Output, or a service type and the query method.
TransactionFunctionComponent you can submit any transaction in the same way as the QueryFunctionComponent, the service will be used to decode all the events output after the transaction submission, you can also provide a set of event types for decoding
ContractDeploymentComponent as per the Transactions but to deploy smart contracts.
MudDevTableComponent using a TableServiceType it can be used to both query by key a table and upsert a value.
MudDevTableServicesComponent scans an assembly for all the TableServiceTypes and creates a user interface (collection) of MudTableComponents per each table found.

     <ContractDeploymentComponent TDeploymentMessage="SoftTokenDeployment"
         HostProvider="selectedHostProviderService"
         ServiceType="typeof(SoftTokenService)"
         ContractAddressChanged="ContractAddressChanged" />

     <QueryFunctionComponent TFunctionMessage="AllowanceFunction" TFunctionOutput="BigInteger"
         Title="allowance"
         ContractAddress="@ContractAddress"
         HostProvider="selectedHostProviderService"
         ServiceType="typeof(SoftTokenService)"
         ServiceMethodName="AllowanceQueryAsync" />

     <TransactionFunctionComponent TFunctionMessage="ApproveFunction"
         Title="approve"
         ContractAddress="@ContractAddress"
         HostProvider="selectedHostProviderService"
         ServiceType="typeof(SoftTokenService)"
         ServiceRequestMethodName="ApproveRequestAsync"
         ServiceRequestAndWaitForReceiptMethodName="ApproveRequestAndWaitForReceiptAsync" />

       <MudDevTableComponent TService="ItemsTableService"
                          ContractAddress="@ContractAddress"
                          HostProvider="HostProvider" />

Commits: 4433d11, d34cd7a

Code Generator updates (Blazor generation, common types folder) and full Refactoring

Support to have a common folder and shared namespace for shared Structs, Errors, etc across different contracts.
New Blazor Page generator, per generated smart contract service now you have a blazor web page to deploy, query and create transactions for all functions for both Typescript and DotNet versions
Refactoring the code generator to remove generics, Dotnet console, generator and unit test fixes.
The code generator output to Typescript was having errors resolving generics after adding the blazor page, now all the generics have been removed where possible (keeping just a generic class) to avoid errors. (Eventually found the error and long fix)

Example of multi-settings support for Blazor:

[
  {
    "paths": ["out/ERC20.sol/Standard_Token.json"],
    "generatorConfigs": [
      {
        "baseNamespace": "MyProject.Contracts",
        "basePath": "codeGenNodeTest/GeneratorSets/Example1/MyProject.Contracts",
        "codeGenLang": 0,
        "sharedTypesNamespace": "SharedTypes",
        "sharedTypes": ["events", "errors"],
        "generatorType": "ContractDefinition"
      },
      {
        "baseNamespace": "MyProject.Contracts",
        "basePath": "codeGenNodeTest/GeneratorSets/Example1/MyProject.Blazor",
        "codeGenLang": 0,
        "sharedTypesNamespace": "SharedTypes",
        "generatorType": "BlazorPageService"
      },
      {
        "baseNamespace": "MyProject.Contracts",
        "basePath": "codeGenNodeTest/GeneratorSets/Example1/MyProject.Contracts",
        "codeGenLang": 0,
        "sharedTypesNamespace": "SharedTypes",
        "sharedTypes": ["events", "errors"],
        "generatorType": "UnityRequest"
      }
    ]
  },

and output:

@using System.Numerics
@using Nethereum.UI
@using MyProject.Contracts.Standard_Token
@using MyProject.Contracts.Standard_Token.ContractDefinition

@page "/standard_token"
@rendermode InteractiveWebAssembly
@inject SelectedEthereumHostProviderService selectedHostProviderService

<MudContainer MaxWidth="MaxWidth.Medium" Class="mt-4">

        <MudText Typo="Typo.h5" Class="mb-4">Standard_Token</MudText>

        <MudTextField @bind-Value="ContractAddress" Label="Standard_Token Contract Address" Variant="Variant.Outlined" Class="mb-4" />

        <ContractDeploymentComponent TDeploymentMessage="StandardTokenDeployment"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenPage)"
            ContractAddressChanged="ContractAddressChanged" />

        <QueryFunctionComponent TFunctionMessage="AllowanceFunction" TFunctionOutput="BigInteger"
            Title="allowance"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="AllowanceQueryAsync" />

        <QueryFunctionComponent TFunctionMessage="AllowedFunction" TFunctionOutput="BigInteger"
            Title="allowed"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="AllowedQueryAsync" />

        <TransactionFunctionComponent TFunctionMessage="ApproveFunction"
            Title="approve"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceRequestMethodName="ApproveRequestAsync"
            ServiceRequestAndWaitForReceiptMethodName="ApproveRequestAndWaitForReceiptAsync" />

        <QueryFunctionComponent TFunctionMessage="BalanceOfFunction" TFunctionOutput="BigInteger"
            Title="balanceOf"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="BalanceOfQueryAsync" />

        <QueryFunctionComponent TFunctionMessage="BalancesFunction" TFunctionOutput="BigInteger"
            Title="balances"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="BalancesQueryAsync" />

        <QueryFunctionComponent TFunctionMessage="DecimalsFunction" TFunctionOutput="byte"
            Title="decimals"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="DecimalsQueryAsync" />

        <QueryFunctionComponent TFunctionMessage="NameFunction" TFunctionOutput="string"
            Title="name"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="NameQueryAsync" />

        <QueryFunctionComponent TFunctionMessage="SymbolFunction" TFunctionOutput="string"
            Title="symbol"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="SymbolQueryAsync" />

        <QueryFunctionComponent TFunctionMessage="TotalSupplyFunction" TFunctionOutput="BigInteger"
            Title="totalSupply"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceMethodName="TotalSupplyQueryAsync" />

        <TransactionFunctionComponent TFunctionMessage="TransferFunction"
            Title="transfer"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceRequestMethodName="TransferRequestAsync"
            ServiceRequestAndWaitForReceiptMethodName="TransferRequestAndWaitForReceiptAsync" />

        <TransactionFunctionComponent TFunctionMessage="TransferFromFunction"
            Title="transferFrom"
            ContractAddress="@ContractAddress"
            HostProvider="selectedHostProviderService"
            ServiceType="typeof(StandardTokenService)"
            ServiceRequestMethodName="TransferFromRequestAsync"
            ServiceRequestAndWaitForReceiptMethodName="TransferFromRequestAndWaitForReceiptAsync" />

</MudContainer>

@code
    {
        private string ContractAddress;

        private void ContractAddressChanged(string address)
        {
            ContractAddress = address;
        }
    }

Commits: ef74cf6, c7f645a, 0b0d023, c4e8e08

Code Signing of Nugets and dlls

New code signing certificate of Nugets and dlls has been created to the name of ObjectSpaces LTD and verified by Microsoft. Use this to verify dlls are from the correct source. Also all unity dlls are signed the same to avoid any tampering.

General improvements fixes

712 Fix Invalid Type Encoding with complex struct.
Issue: When having multiple structs all referencing the same type, the Distinct usage was not picking up all the Objects when iterating across all the inner objects (ie A-> B, A->B[] -> A->C) (B->C, B-> C[], B->D) (C->D, C-D[]) will cause duplicates. Solution.. Ensure Distinct on return.. Commit: 730542d
GnosisSafe updates to extend the 712 hash encoding. Commit: 9e224f9

Account Abstraction (WIP .. Updates)

Continue work on AA support, RPC is available, other changes in the code.

Account abstraction PackedUserOperation, UserOperation, UserOperationBuilder (packing and 712 hashing) ERC4337Domain
Account Abstraction Simple Account (WIP)
Utils to to validate if the initcode is a 7702, update the InitCode with delegateAddresss, hashing etc, EntryPoint Service enabling to InitialiseUserOperation with different estimates for gas, and handling EIP7702, SignUserOperation including checks for 7702
RPC Account Abstraction changes to support 0.6 and 0.7 (not just 0.7)
Account abstraction BaseAccount as a generic service, AccountAbstractionExecuteBuilder, helper class to create execute calls with Function Messages, both single and batch

Commits: 207ae70, cbe118c, 96829d5, 27c63db, d6ef243, 0c3af2f, e65660c, d96b617, 746c6d0

Contributions

Allowing partial success in batch requests. by @dlebee in #1070
fix issue in ToDER() method with latest bouncycastle by @tmm360 in #1071
debug_trace... endpoints improved by @SolidityNinja in #1068

Unity release

The Unity release can be found at https://github.com/Nethereum/Nethereum.Unity or installed using OpenUpm https://openupm.com/packages/?sort=downloads&q=nethereum

Nuget packages can be found in nuget.org https://www.nuget.org/profiles/nethereum

Full Changelog: 4.29.0...5.0.0

4.29.0

2025-02-10T17:23:05Z

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

Screenshot of Blazor application

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

Screenshot of Unity application

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

4.28.0

2025-01-07T17:45:43Z

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

Example of code generated file for both Mud table service and table

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.

Example of ".nethereum-gen.multisettings"

[
{
    "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

4.27.1

2024-12-24T12:24:19Z

Patch to rollback the Bouncy Castle upgrade (Reported Issues)

Full Changelog: 4.27.0...4.27.1

4.27.0

2024-12-24T09:58:36Z

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

4.26.0

2024-10-01T17:30:44Z

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

2024-10-01T16:39:18Z

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

Release notes from Nethereum

6.0.4

Nethereum 6.0.4

Nethereum.Aspire.TemplatePack — New nethereum-dapp Template

Nethereum.Aspire.TemplatePack — DevChain Template Fixes

Nethereum.Explorer — Runtime Bytecode ABI Matching

Nethereum.Explorer — Wallet CSS Fix

Nethereum.EIP6963WalletInterop — personal_sign Fix

Nethereum.DevChain — Hosting Improvements

Contract Deployment Race Condition Fix

Wallet Price Refresh & Overflow Fixes

MinimalHdWallet Moved to Nethereum.Accounts

SparseMerkleTree Optimisations

Build & CI

Documentation

All Commits Since 6.0.0

6.0.0

Nethereum 6.0.0

Nethereum.CoreChain — In-Process Ethereum Node

Nethereum.CoreChain.RocksDB — Persistent Storage

Nethereum.DevChain — Development Chain

Nethereum.DevChain.Server — HTTP Server

Nethereum.AppChain — Application Chain Stack (Preview)

Nethereum.AccountAbstraction — ERC-4337 + ERC-7579

Nethereum.AccountAbstraction Smart Contracts (Solidity)

Nethereum.Explorer — Blazor Server Blockchain Explorer

Nethereum.Blazor — Dynamic Contract Interaction Components

Nethereum.Blazor.Solidity — EVM Debugger Components

Nethereum.EVM — Major EVM Simulator Upgrade

BlockchainProcessing — Reorg Detection, Token Indexing, Internal Transactions

BlockchainStore — Multi-Provider Database Storage

BlockchainStore.EFCore (Shared Base)

BlockchainStore.Postgres

BlockchainStore.SqlServer

BlockchainStore.Sqlite

BlockchainStorage.Processors (Shared Base)

BlockchainStorage.Processors.Postgres / SqlServer / Sqlite

BlockchainStorage.Token.Postgres

MUD — Processing Services and Reorg Support

Nethereum.ABI — Int128/UInt128 Support and StateMutability

Nethereum.Model — EIP-4844/Prague Block Headers and Transaction7702

Nethereum.RPC — Shared Debug Tracing and EIP-4844

Nethereum.Geth — Tracer Refactoring

Nethereum.Merkle — FrontierMerkleTree, Poseidon, and Fixes

Nethereum.Wallet — StateChanges Preview and Transaction Executor

Nethereum.ABI DataServices — Sourcify V2

Code Generator

.NET Aspire Integration

.NET 10 Target Framework Support

EIP-7702 Support

Test Coverage

Other Changes

New Contributors

5.8.0

Nethereum 5.8.0 - 10 Year Anniversary Release

Nethereum after 10 years has:

Release notes

Highlights

New packages and major additions

Compatibility notes

10 years thanks

Example of all the wallet components

5.0.0

EIP7022

Muticall RPC batch support improvements

Utils Random

EVM Simulator update

Nethereum.Merkles LeanIncrementalMerkleTree

Nethereum.Geth update

Bouncy Castle update

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

Nethereum.MudBlazorComponent

Code Generator updates (Blazor generation, common types folder) and full Refactoring

Code Signing of Nugets and dlls

General improvements fixes

Account Abstraction (WIP .. Updates)

Contributions

Unity release

Nuget packages can be found in nuget.org https://www.nuget.org/profiles/nethereum

4.29.0

Nethereum.Aspire.TemplatePack — New `nethereum-dapp` Template