Dart / Flutter

Web3Dart is the primary library for reaching Arbitrum One from Dart and Flutter, letting you ship one codebase across iOS, Android, web, and desktop. Since Arbitrum One is an EVM-equivalent Nitro rollup, Web3Dart's standard JSON-RPC calls work against https://arbitrum.therpc.io/YOUR_API_KEY with no chain-specific tweaks. Add it with flutter pub add web3dart (or dart pub add web3dart for a pure Dart project). For production apps, store private keys in flutter_secure_storage, which is backed by the iOS Keychain and Android Keystore — never hardcode a key in source.

Web3Dart runs in both Flutter and pure Dart projects, so a command-line Arbitrum One indexer and a mobile wallet can share the same client code. Add it with flutter pub add web3dart. In production, keep signing keys in flutter_secure_storage rather than in code or plain preferences — a leaked key on an L2 like Arbitrum One drains real ETH just as fast as on mainnet.

Web3Dart Library

Construct a Web3Client with the Arbitrum One HTTP endpoint and an http.Client() instance you keep alive for the app's lifetime. For production transactions, set explicit gas limits rather than relying solely on auto-estimation: Arbitrum One meters gas differently from L1 — its fee blends L2 execution with the cost of posting calldata to Ethereum — so an under-estimate can leave a transaction stuck. Reading the current gas price and bounding the limit yourself gives more predictable behavior.

import 'package:web3dart/web3dart.dart';
import 'package:http/http.dart';
 
class EthereumService {
  final Web3Client client;
 
  EthereumService() : client = Web3Client('https://arbitrum.therpc.io/YOUR_API_KEY', Client());
 
  Future<EtherAmount> getBalance(String address) async {
    final addr = EthereumAddress.fromHex(address);
    return await client.getBalance(addr);
  }
 
  Future<String> sendTransaction({
    required Credentials credentials,
    required String to,
    required BigInt amount,
  }) async {
    final transaction = await client.sendTransaction(
      credentials,
      Transaction(
        to: EthereumAddress.fromHex(to),
        value: EtherAmount.fromBigInt(EtherUnit.wei, amount),
      ),
    );
    return transaction;
  }
}

• GitHub: https://github.com/simolus3/web3dart
• Pub.dev: https://pub.dev/packages/web3dart
• Key features for Arbitrum One apps: cross-platform Flutter mobile dApps, contract interaction, transaction signing, HD wallet support (BIP-39/44), ENS resolution, ERC-20 and ERC-721 helpers, and gas estimation.

Flutter Integration Examples

For a reactive balance display, hold the EtherAmount in a StatefulWidget and call setState when a fresh value arrives from Arbitrum One. Because Flutter can rebuild a widget many times per second, don't trigger an RPC call inside build() — cache the last result and refresh it on an explicit action or a timed interval. Debouncing keeps you well within rate limits even though Arbitrum One's sub-second confirmations make near-real-time updates tempting.

import 'package:flutter/material.dart';
import 'package:web3dart/web3dart.dart';
 
class WalletWidget extends StatefulWidget {
  @override
  _WalletWidgetState createState() => _WalletWidgetState();
}
 
class _WalletWidgetState extends State<WalletWidget> {
  final ethereum = EthereumService();
  EtherAmount? balance;
 
  Future<void> updateBalance() async {
    final newBalance = await ethereum.getBalance('YOUR_ADDRESS');
    setState(() {
      balance = newBalance;
    });
  }
 
  @override
  Widget build(BuildContext context) {
    return Card(
      child: Padding(
        padding: EdgeInsets.all(16.0),
        child: Column(
          children: [
            Text('Balance: ${balance?.getValueInUnit(EtherUnit.ether)} ETH'),
            ElevatedButton(
              onPressed: updateBalance,
              child: Text('Refresh Balance'),
            ),
          ],
        ),
      ),
    );
  }
}

Smart Contract Integration

To interact with a deployed Arbitrum One contract, build a DeployedContract from its ABI JSON string and its address — for example an Aave lending pool or a Camelot router. Use client.call() for view functions, which read the latest sequencer state for free, and client.sendTransaction() for state-changing calls, which submit an L2 transaction paid in ETH. Look up the contract address and verified ABI on https://arbiscan.io before wiring it in.

class SmartContractService {
  final Web3Client client;
  final DeployedContract contract;
 
  SmartContractService(String contractAddress, String abi)
      : client = Web3Client('https://arbitrum.therpc.io/YOUR_API_KEY', Client()),
        contract = DeployedContract(
          ContractAbi.fromJson(abi, 'YourContract'),
          EthereumAddress.fromHex(contractAddress),
        );
 
  Future<List<dynamic>> callFunction(
    String functionName,
    List<dynamic> params,
  ) async {
    final function = contract.function(functionName);
    final result = await client.call(
      contract: contract,
      function: function,
      params: params,
    );
    return result;
  }
}

Error Handling and Utilities

Wrap the raw exceptions Web3Dart throws — RPC failures, reverted Arbitrum One transactions, malformed addresses — in a domain-specific EthereumException so your UI layer catches one predictable type instead of leaking transport details to the screen. An EtherAmount extension that formats values to a fixed number of decimals keeps balance strings tidy, since ETH amounts on Arbitrum One carry the same 18 decimals as on L1.

class EthereumException implements Exception {
  final String message;
  final dynamic originalError;
 
  EthereumException(this.message, [this.originalError]);
 
  @override
  String toString() => 'EthereumException: $message';
}
 
extension EtherAmountExtension on EtherAmount {
  String formatEther([int decimals = 4]) {
    return getValueInUnit(EtherUnit.ether).toStringAsFixed(decimals);
  }
}