C#

Nethereum is the primary .NET library for talking to Arbitrum One. Because Arbitrum One is a Nitro-based Optimistic Rollup that exposes the standard Ethereum JSON-RPC interface, Nethereum works against it unchanged — you simply point it at https://arbitrum.therpc.io/YOUR_API_KEY. The library targets .NET Standard 2.0+, so the same code runs across Unity3D games, Xamarin mobile apps, ASP.NET Core services, and Blazor front ends. Add it to your project with dotnet add package Nethereum.Web3.

Nethereum builds on .NET Standard 2.0+, which makes it portable across Unity3D, Xamarin, ASP.NET Core, and Blazor — useful when an Arbitrum One dApp shares wallet logic between a desktop service and a mobile or in-game client. Install it from NuGet with dotnet add package Nethereum.Web3.

Nethereum

Create a single new Web3("https://arbitrum.therpc.io/YOUR_API_KEY") instance and reuse it across your service. Every network-bound call — GetBalance, GetEtherTransferService, contract reads and writes — returns an async Task, so always await it. Avoid blocking on .Result or .Wait(): on Arbitrum One, where the sequencer returns soft confirmations in well under a second, the temptation to block is real, but doing so risks deadlocks in ASP.NET and Unity contexts. Keep the call chain async end to end.

using Nethereum.Web3;
using Nethereum.Web3.Accounts;
using Nethereum.Util;
using Nethereum.Hex.HexTypes;
 
public class EthereumService
{
    private readonly Web3 _web3;
 
    public EthereumService(string url)
    {
        _web3 = new Web3(url);
    }
 
    public async Task<decimal> GetBalanceAsync(string address)
    {
        var balance = await _web3.Eth.GetBalance.SendRequestAsync(address);
        return Web3.Convert.FromWei(balance.Value);
    }
 
    public async Task<string> SendTransactionAsync(
        string privateKey,
        string toAddress,
        decimal etherAmount)
    {
        var account = new Account(privateKey);
        var web3 = new Web3(account, _web3.Client.Url);
 
        var transaction = await web3.Eth.GetEtherTransferService()
            .TransferEtherAsync(toAddress, etherAmount);
 
        return transaction;
    }
}

• GitHub: https://github.com/Nethereum/Nethereum
• Docs: https://docs.nethereum.com
• Key features for Arbitrum One builders: full JSON-RPC integration with the Nitro stack, smart contract deployment and interaction, HD wallet support, Unity3D and Xamarin targets, and transports over IPC, RPC, and WebSocket.

Smart Contract Integration

To work with a deployed contract — say a GMX or Camelot pool on Arbitrum One — get a handle with _web3.Eth.GetContract(abi, contractAddress). From there, GetFunction(name) gives you a typed function you can either read with CallAsync<T>() (no gas, no state change) or write with SendTransactionAsync(). Reads resolve against the latest sequencer state almost instantly; writes are L2 transactions whose fee combines L2 execution cost with the L1 calldata posting cost, both paid in ETH.

public class SmartContractService
{
    private readonly Web3 _web3;
    private readonly Contract _contract;
 
    public SmartContractService(string url, string contractAddress, string abi)
    {
        _web3 = new Web3(url);
        _contract = _web3.Eth.GetContract(abi, contractAddress);
    }
 
    public async Task<T> CallFunctionAsync<T>(string functionName, params object[] parameters)
    {
        var function = _contract.GetFunction(functionName);
        return await function.CallAsync<T>(parameters);
    }
 
    public async Task<string> ExecuteFunctionAsync(
        string functionName,
        string fromAddress,
        params object[] parameters)
    {
        var function = _contract.GetFunction(functionName);
        return await function.SendTransactionAsync(fromAddress, parameters);
    }
}

ASP.NET Integration

In an ASP.NET Core API, register EthereumService as a singleton in Program.cs (or Startup.ConfigureServices) so the single Web3 instance pointed at Arbitrum One is shared across requests, then resolve it through constructor injection in your controllers. Wrap each await in a try/catch and return BadRequest(ex.Message) on failure — RPC errors, a malformed address, or a rejected transaction should surface as a clean 400 rather than an unhandled 500.

[ApiController]
[Route("api/[controller]")]
public class EthereumController : ControllerBase
{
    private readonly EthereumService _ethereumService;
 
    public EthereumController(EthereumService ethereumService)
    {
        _ethereumService = ethereumService;
    }
 
    [HttpGet("balance/{address}")]
    public async Task<ActionResult<decimal>> GetBalance(string address)
    {
        try
        {
            var balance = await _ethereumService.GetBalanceAsync(address);
            return Ok(balance);
        }
        catch (Exception ex)
        {
            return BadRequest(ex.Message);
        }
    }
}

Event Handling

To watch contract events on Arbitrum One — a Swap from a Uniswap pool or a Transfer from an ERC-20 — define an event DTO and use _web3.Eth.GetEvent<YourEventDTO>(contractAddress) together with CreateFilterInput() to build a filter, then poll for changes. The block explorer at https://arbiscan.io is handy for confirming the event signatures and topics you expect before wiring up the subscription.

public class EventMonitorService
{
    private readonly Web3 _web3;
 
    public async Task MonitorEventsAsync(string contractAddress, string eventName)
    {
        var filterAll = _web3.Eth.GetEvent<YourEventDTO>(contractAddress)
            .CreateFilterInput();
 
        var subscription = _web3.Eth.GetEvent<YourEventDTO>(contractAddress)
            .GetFilterChanges(filterAll);
 
        subscription.Subscribe(evt =>
        {
            Console.WriteLine($"New event: {evt.Event}");
        });
    }
}

Unity3D Integration

In Unity3D, initialize Web3 once in Awake() or Start() with the Arbitrum One endpoint so a blockchain-backed game can read balances and submit transactions without per-frame setup cost. Be careful with async void: it is acceptable only for the top-level Start() entry point. Push the real work into Task-returning helpers like InitializeWalletAsync and await them, so exceptions are caught and logged through Debug.LogError rather than silently lost. Arbitrum One's sub-second sequencer confirmations keep these awaits short enough to feel responsive in-game.

public class EthereumUnityManager : MonoBehaviour
{
    private Web3 _web3;
 
    private async void Start()
    {
        _web3 = new Web3("https://arbitrum.therpc.io/YOUR_API_KEY");
        await InitializeWalletAsync();
    }
 
    private async Task InitializeWalletAsync()
    {
        try
        {
            var balance = await _web3.Eth.GetBalance.SendRequestAsync("YOUR_ADDRESS");
            Debug.Log($"Wallet Balance: {Web3.Convert.FromWei(balance.Value)} ETH");
        }
        catch (Exception ex)
        {
            Debug.LogError($"Failed to initialize wallet: {ex.Message}");
        }
    }
}