Tac

Tac

Dart / Flutter

Web3Dart is the primary library for reaching TAC from Dart and Flutter, letting you ship one codebase to iOS, Android, web, and desktop that talks to the same EVM chain (ID 239). Add it with flutter pub add web3dart in a Flutter project, or dart pub add web3dart for pure Dart. For any production app that signs TAC transactions, store private keys in flutter_secure_storage (backed by the iOS Keychain and Android Keystore) — never hardcode a key in source or ship it in your bundle.

Web3Dart works in both Flutter apps and standalone Dart programs, so the same TAC integration code serves a mobile wallet and a backend script alike. Add it with flutter pub add web3dart. In production, keep signing keys in flutter_secure_storage rather than in code or shared preferences — a leaked key on chain 239 means a drained account.

Web3Dart Library

Create a Web3Client by passing the TAC HTTP endpoint https://tac.therpc.io/YOUR_API_KEY together with a Client() from the http package — Web3Dart uses that for every JSON-RPC round-trip. In production transactions, set an explicit gas limit rather than relying solely on auto-estimation: estimation can fail or return a misleading value for contract-heavy calls, and a hard limit keeps a TAC transfer from stalling at submission time.

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

Flutter Integration Examples

To show a live TAC balance in the UI, use a StatefulWidget and call setState once the balance comes back so the widget repaints with fresh data. Be careful not to fire an RPC call on every build — Flutter rebuilds widgets often, and an unguarded fetch will hammer your TAC endpoint. Trigger the call from an explicit action (a refresh button or initState), and cache or debounce results so chain 239 is queried only when the data actually needs refreshing.

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

Smart Contract Integration

To interact with a contract on TAC, build a DeployedContract from the ABI JSON string (wrapped in ContractAbi.fromJson) and the contract's on-chain address. Read-only functions go through client.call(), which queries the node without spending gas, while state-changing functions are submitted with client.sendTransaction() using signed credentials and confirmed once the block reaches finality on chain 239.

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

Wrapping raw Web3Dart exceptions in a domain-specific EthereumException keeps your TAC error handling clean: callers catch one well-named type instead of a grab-bag of low-level transport and RPC errors. Pairing that with an EtherAmount extension gives you formatted, human-readable balance strings (for example, trimming a TAC amount to four decimals) without scattering conversion logic across your widgets.

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