Dart / Flutter

Web3Dart is the primary library for talking to Polygon from Dart and Flutter, letting you ship a single codebase that runs as a cross-platform mobile and web dApp on iOS, Android, and the browser. Polygon PoS is EVM-equivalent, so Web3Dart's standard Ethereum interface works as-is against https://polygon.therpc.io/YOUR_API_KEY. Add it with flutter pub add web3dart in a Flutter project, or dart pub add web3dart for pure Dart. In production apps, always store private keys in flutter_secure_storage — never hardcode keys in source, where they would ship inside your app bundle for anyone to extract.

Web3Dart works in both Flutter and pure Dart projects, so the same Polygon logic can back a mobile app and a command-line tool. Add it with flutter pub add web3dart. For production, manage private keys with flutter_secure_storage and never hardcode keys — a leaked key on Polygon means an attacker can drain the wallet's MATIC and tokens.

Web3Dart Library

Create a Web3Client by passing the Polygon HTTP endpoint https://polygon.therpc.io/YOUR_API_KEY together with an http.Client() instance, and keep one client alive for the lifetime of your service rather than recreating it per call. For production transactions, set explicit gas limits instead of relying purely on auto-estimation — Polygon gas prices can spike during congestion, and a failed estimate can cause a transaction to be rejected or stuck.

import 'package:web3dart/web3dart.dart';
import 'package:http/http.dart';
 
class EthereumService {
  final Web3Client client;
 
  EthereumService() : client = Web3Client('https://polygon.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 Polygon, contract interaction, transaction signing, HD wallet support (BIP-39/44), ENS resolution, ERC-20 and ERC-721 token handling, and gas estimation

Flutter Integration Examples

In Flutter, drive the UI with a StatefulWidget and call setState once a fresh balance arrives from Polygon so the widget rebuilds with the new MATIC value. Be careful not to fire an RPC call on every build() — widgets rebuild often — so cache the last result or debounce refreshes behind an explicit user action or a timer to avoid hammering the endpoint.

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

Smart Contract Integration

To interact with a deployed Polygon contract, build a DeployedContract from the contract's ABI JSON string and its on-chain address (chain ID 137). Read-only view functions go through client.call(), which returns decoded values without spending gas, while state-changing functions go through client.sendTransaction() with signing credentials, which submits a transaction and costs MATIC.

class SmartContractService {
  final Web3Client client;
  final DeployedContract contract;
 
  SmartContractService(String contractAddress, String abi)
      : client = Web3Client('https://polygon.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 on failed Polygon calls in your own domain-specific EthereumException, so the rest of your app catches one clear error type instead of leaking transport details into the UI layer. Pairing that with an EtherAmount extension that formats balances into trimmed, fixed-decimal display strings keeps MATIC values readable in widgets without scattering conversion logic everywhere.

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