Dart / Flutter

Web3Dart is the primary library for reaching the Avalanche C-Chain from Dart and Flutter, letting you ship one codebase across iOS, Android, and web that talks to the EVM at chain ID 43114 with AVAX as gas. Add it with flutter pub add web3dart in a Flutter project, or dart pub add web3dart for a pure Dart backend or CLI. For anything that touches production funds, store private keys in flutter_secure_storage (Keychain on iOS, Keystore on Android) — never hardcode a key in source or bundle it into the app.

Web3Dart works in both Flutter apps and pure Dart projects, so the same C-Chain integration covers a mobile wallet and a headless service. Add it with flutter pub add web3dart. In production, keep private keys in flutter_secure_storage and never hardcode them — a leaked key on Avalanche means an attacker can drain AVAX and any token holdings immediately.

Web3Dart Library

Create a Web3Client by passing the C-Chain HTTP endpoint https://avalanche.therpc.io/YOUR_API_KEY together with a standard http.Client() from the http package. For production transactions, set an explicit maxGas rather than relying on auto-estimation: estimation occasionally fails or under-quotes on contract-heavy calls against busy Avalanche DeFi protocols, and an explicit limit keeps the transaction from being rejected mid-flight.

import 'package:web3dart/web3dart.dart';
import 'package:http/http.dart';
 
class EthereumService {
  final Web3Client client;
 
  EthereumService() : client = Web3Client('https://avalanche.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: cross-platform Flutter mobile dApps on the Avalanche C-Chain, contract interaction, transaction signing, HD wallet (BIP-39/44), ENS resolution, ERC-20 and ERC-721 helpers, and gas estimation

Flutter Integration Examples

To show a live AVAX balance in the UI, use a StatefulWidget and call setState once the C-Chain query resolves so the widget rebuilds with the new value. Flutter rebuilds widgets frequently, so never fire an RPC call directly from build() — cache the last result and debounce refreshes (for example, on a button press or a timer) to avoid hammering the endpoint on every frame.

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)} AVAX'),
            ElevatedButton(
              onPressed: updateBalance,
              child: Text('Refresh Balance'),
            ),
          ],
        ),
      ),
    );
  }
}

Smart Contract Integration

To interact with a C-Chain contract, build a DeployedContract from the ABI JSON string and the deployed address — the same pattern whether you target a Trader Joe router or your own contract. Read-only view functions go through client.call(), which costs no AVAX and returns decoded values; state-changing functions go through client.sendTransaction() with signing credentials, returning the transaction hash you can confirm against Snowtrace.

class SmartContractService {
  final Web3Client client;
  final DeployedContract contract;
 
  SmartContractService(String contractAddress, String abi)
      : client = Web3Client('https://avalanche.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

Web3Dart throws a range of low-level exceptions for RPC timeouts, reverted C-Chain transactions, and malformed input. Wrapping them in a domain-specific EthereumException gives your app a single, predictable error type to catch and present to users. A small EtherAmount extension is also handy for turning raw wei into a trimmed, human-readable AVAX string for the UI.

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);
  }
}