Nethereum 6.1.0

Nethereum 6.1.0 introduces a complete zero-knowledge proof infrastructure with native and browser-based Groth16 proof generation, the Privacy Pools SDK for private deposits and withdrawals with Association Set Provider support, new Merkle tree libraries (EIP-7864 Binary Trie, Sparse Merkle Trees with Poseidon hashing), SSZ model improvements, cross-platform BLS runtime updates, and demo applications showcasing the full ZK proof pipeline.

Full Changelog

Nethereum.ZkProofs — ZK Proof Abstractions

New provider-agnostic package defining the core interfaces and models for zero-knowledge proof generation in .NET. All proof providers (browser, native, HTTP) implement these abstractions, making them interchangeable.

• IZkProofProvider — central interface with FullProveAsync(ZkProofRequest, CancellationToken) and Scheme property
• ZkProofRequest — input model carrying circuit WASM, zkey, input JSON, witness bytes, and circuit graph data
• ZkProofResult — output model with ProofJson, PublicSignalsJson, and parsed BigInteger[] PublicSignals
• ZkProofScheme enum — Groth16, Plonk, Fflonk, Stark
• ICircuitArtifactSource — pluggable circuit artifact loading (WASM, zkey)
• ICircuitGraphSource — circuit graph data for native witness generation
• FileCircuitArtifactSource and EmbeddedCircuitArtifactSource — filesystem and in-memory artifact loading
• CircuitArtifactLocator — standard directory layout resolver for circuit artifacts
• HttpZkProofProvider — delegates proof generation to a remote HTTP prover endpoint
• Groth16ProofConverter — parse snarkjs JSON proofs and convert to Solidity-compatible format for on-chain verification

Commits: e28026f

Nethereum.ZkProofsVerifier — Pure C# Groth16 Verification

New package providing Groth16 proof verification using BN128 elliptic curve pairing — entirely in managed C# with no native dependencies. Directly consumes snarkjs/Circom JSON output for one-liner verification.

• CircomGroth16Adapter.Verify(proofJson, vkJson, publicInputsJson) — high-level verification API
• Groth16Verifier — BN128 pairing check implementation using BouncyCastle
• Snarkjs JSON parsers for proofs, verification keys, and public signals
• Returns structured ZkVerificationResult with IsValid and Error properties

Commits: 22fe04a, 6b3858e

Nethereum.ZkProofs.Snarkjs — Node.js Proof Backend

New IZkProofProvider implementation that generates Groth16 proofs by invoking snarkjs via a Node.js child process. Suitable for server-side applications where Node.js is available.

Commits: 6d998f5

Nethereum.ZkProofs.Snarkjs.Blazor — Browser-Based Proof Generation

New IZkProofProvider implementation for Blazor WebAssembly applications. Calls snarkjs via JavaScript interop, enabling client-side proof generation entirely in the browser — private inputs never leave the user's machine.

• SnarkjsBlazorProvider — implements IZkProofProvider and IAsyncDisposable
• Loads snarkjs via <script> tag (UMD bundle) for broad compatibility
• Sends circuit WASM and zkey as base64 to JavaScript, returns proof JSON
• Configurable snarkjs URL (self-hosted or CDN)

Commits: 074a857, e2a6a73

Nethereum.CircomWitnessCalc — Native Witness Generation

New package providing native circuit witness computation via P/Invoke to iden3/circom-witnesscalc (C library). Takes a compiled circuit graph (.graph.bin) and input JSON, returns witness bytes (.wtns format).

• WitnessCalculator.CalculateWitness(byte[] graphData, string inputsJson) — static witness generation
• Cross-platform native libraries: win-x64, linux-x64, android-arm64
• Automatic runtime library resolution via ModuleInitializer
• NuGet package includes native DLLs with buildTransitive targets

Commits: ca76246

Nethereum.ZkProofs.RapidSnark — Native Groth16 Proof Generation

New package providing native Groth16 proof generation via P/Invoke to iden3/rapidsnark (C++ library). Typically 10-50x faster than browser-based snarkjs, making it suitable for server-side proof generation, desktop wallets, and mobile apps.

• RapidSnarkProver.Prove(byte[] zkeyBytes, byte[] witnessBytes) — one-shot proof generation
• Reusable prover pattern: LoadZkey() once, ProveWithLoadedZkey() multiple times
• RapidSnarkProofProvider — implements IZkProofProvider interface
• Cross-platform native libraries: win-x64, linux-x64, android-arm64
• NuGet package includes native DLLs with buildTransitive targets

Commits: e0c27e1

Nethereum.PrivacyPools — Complete Privacy Pools SDK

New comprehensive SDK for the Privacy Pools protocol (0xbow), enabling private deposits and withdrawals with Association Set Provider (ASP) compliance. Cross-compatible with the 0xbow TypeScript SDK.

• PrivacyPoolAccount — deterministic HD wallet-derived accounts from BIP-39 mnemonic
• PrivacyPoolProofProvider — orchestrates witness input construction, circuit artifact loading, and proof generation via any IZkProofProvider
• PrivacyPoolProofVerifier — verifies ragequit and withdrawal proofs using the pure C# BN128 verifier
• PrivacyPoolService — full protocol orchestration: deploy, deposit, withdraw, recover
• PoseidonMerkleTree — LeanIMT Merkle tree for on-chain commitment tracking
• ASPTreeService — Association Set Provider tree management
• ERC-20 token pool support alongside native ETH pools
• Direct withdrawal without ASP attestation (ragequit path)
• Switch to native proof generation pipeline (no Node.js required)
• Cross-platform E2E tests validated against 0xbow TypeScript SDK

Commits: 2ecc2a4, 3488581, 922469a, a45f718, 616a118

Nethereum.PrivacyPools.Circuits — Embedded Circuit Artifacts

New package providing pre-compiled Privacy Pools Circom circuit artifacts as embedded resources. Implements ICircuitArtifactSource and ICircuitGraphSource.

• Commitment circuit: WASM, zkey, graph.bin, verification key JSON
• Withdrawal circuit: WASM, zkey, graph.bin, verification key JSON
• PrivacyPoolCircuitSource — loads artifacts from embedded assembly resources

Commits: 99884c1

Nethereum.Merkle.Binary — EIP-7864 Binary Merkle Trie

New library implementing the EIP-7864 binary trie for stateless Ethereum execution.

• Stem-based structure with 256 colocated values per stem node
• BLAKE3 hashing for trie nodes
• Key derivation following the EIP specification
• Compact inclusion proofs for state verification

Commits: 022388a, 54254f4

Nethereum.Merkle — Sparse Merkle Trees and LeanIMT Improvements

Major additions to the Merkle library for ZK-circuit-compatible data structures.

• SparseMerkleBinaryTree<T> — ZK-optimised sparse Merkle tree with pluggable hashing
• PoseidonSmtHasher — Poseidon hash provider for ZK circuits
• CelestiaSha256SmtHasher — Celestia-compatible SHA-256 hasher
• Persistent storage support with lazy node loading
• ILeanIMTNodeStorage interface for external node persistence
• PoseidonPairHashProvider — Poseidon-based pair hashing for LeanIMT trees
• CircomT1 and CircomT2 Poseidon presets added to Nethereum.Util
• LeanIMT Poseidon Merkle tree integration tests

Commits: 7f27650, 513b9db, b24e2a0, b333caf, b3f47d1, c34d42f, 2504dc1

Nethereum.Model.SSZ and Nethereum.Ssz — SSZ Improvements

New Nethereum.Model.SSZ library providing separate model types for SSZ serialisation, plus fixes and extensions to the core SSZ library.

• New Model.SSZ library with dedicated consensus-layer model types
• Merkleize padding fixes for correct tree hashing
• Progressive Merkleize operations for streaming data
• Union type support in SSZ encoding/decoding
• Test vectors validation

Commits: 7ff7557, 08f4029, eb8c3e3, f200079

ZK Proof Demo Applications

Two working demo applications showcasing the full ZK proof pipeline with educational UI explaining what zero-knowledge proofs are, how Privacy Pools work, and what each step does.

• Blazor WebAssembly Demo (src/demos/Nethereum.ZkProofs.Blazor.Demo/) — browser-based proof generation via snarkjs JS interop, MudBlazor UI, with expandable educational panels
• Avalonia Desktop Demo (src/demos/Nethereum.ZkProofs.Avalonia.Demo/) — native proof generation via circom-witnesscalc + rapidsnark P/Invoke, Fluent dark theme, with per-step timing breakdown
• Both demos generate and verify Privacy Pools commitment proofs with the same circuit artifacts
• Educational content covers: ZK proof concepts, Privacy Pools protocol, Groth16 mechanics, public vs private signals, and Nethereum package roles

Commits: d004a56, 209ee61

Nethereum.Signer.Bls.Herumi — Runtime Updates

Updated BLS Herumi native package with additional platform runtimes for broader cross-platform support.

• Added osx-arm64 (Apple Silicon) native library
• Added osx-x64 native library
• Added linux-arm64 native library
• Updated Windows x64 DLL

Commits: cd944d0, b398cdb

Nethereum.TokenServices — Pricing Improvements

• Added retry policy for pricing service calls with configurable retry count and delay
• Fixed Coingecko API compatibility between System.Text.Json and Newtonsoft.Json serialisation for numeric overflow handling

Commits: e46587c, 29361b4

Nethereum.Wallet.UI.Components.Maui — .NET 10 Support

• Updated to support .NET 10 StaticWebAssetsEndPoints for Maui projects

Commits: 535f7d4

Nethereum.Mud.Repositories.Postgres — Runtime Configuration

• Updated runtime configuration for Postgres MUD repository

Commits: 80b8b83

Nethereum.DevChain — Mapping Update

• Updated DevChain mapping configuration

Commits: 5af44f8

Bug Fixes

• Contract deployment race condition: Fixed DeployContractAndWaitForReceiptAsync failing when contract code wasn't...

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, 818cc8a, 9c68e08, 4828ebd

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, d348e40, 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: ce72174

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: bb5b220

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