Skip to main content

EGLD Transfers

Transfer native EGLD tokens between addresses.

Simple Transfer​

import 'package:abidock_mvx/abidock_mvx.dart';
import 'dart:typed_data';

void main() async {
  final provider = GatewayNetworkProvider.devnet();
  final account = await Account.fromMnemonic('your mnemonic...');
  
  // Get network info
  final config = await provider.getNetworkConfig();
  final accountInfo = await provider.getAccount(account.address);
  
  // Create transfer
  final tx = Transaction(
    sender: account.address,
    receiver: Address.fromBech32('erd1...recipient...'),
    value: Balance.fromEgld(1.0),
    nonce: accountInfo.nonce,
    gasLimit: GasLimit(50000),
    gasPrice: GasPrice(1000000000),
    chainId: ChainId(config.chainId),
    version: TransactionVersion(1),
    data: Uint8List(0),
  );
  
  // Sign and send
  final signature = await account.signTransaction(tx);
  final signed = tx.copyWith(newSignature: Signature.fromUint8List(signature));
  final hash = await provider.sendTransaction(signed);
  
  print('Sent: $hash');
}

EGLD Denominations​

DenominationAmountIn EGLD
1 EGLD10^181
0.1 EGLD10^170.1
0.01 EGLD10^160.01

Balance Class​

Use the Balance class for EGLD amounts:

// Create from EGLD
final amount1 = Balance.fromEgld(1.5);  // 1.5 EGLD

// Create from string (atomic units)
final amount2 = Balance.fromString('1500000000000000000');  // 1.5 EGLD

// Create zero balance
final zero = Balance.zero();

// Access raw value
print(amount1.value);  // BigInt: 1500000000000000000

Transfer with Message​

Add a message to your transfer:

import 'dart:convert';

final message = 'Thank you for dinner!';
final data = Uint8List.fromList(utf8.encode(message));

final tx = Transaction(
  sender: account.address,
  receiver: Address.fromBech32('erd1...'),
  value: Balance.fromEgld(0.1),
  nonce: accountInfo.nonce,
  gasLimit: GasLimit(
    config.minGasLimit + data.length * config.gasPerDataByte,
  ),
  gasPrice: GasPrice(config.minGasPrice),
  chainId: ChainId(config.chainId),
  version: TransactionVersion(1),
  data: data,
);
Gas Calculation

The data-movement cost is minGasLimit + gasLimitPerByte * data.length, and it counts bytes, not characters -- a multi-byte UTF-8 message costs more than its string length suggests. config.minGasLimit and config.gasPerDataByte carry the live values (50,000 and 1,500 by default). The transaction factories add this term automatically on top of an endpoint's execution gas.

Check Balance Before Transfer​

void main() async {
  final provider = GatewayNetworkProvider.devnet();
  final accountInfo = await provider.getAccount(account.address);
  
  final amount = Balance.fromEgld(1.0);
  final gasEstimate = Balance.fromString('50000000000000'); // ~50k gas
  
  // Balance supports arithmetic and comparison operators directly.
  final totalNeeded = amount + gasEstimate;
  
  if (accountInfo.balance < totalNeeded) {
    print('Insufficient balance!');
    return;
  }
  
  // Proceed with transfer...
}

Batch Transfers​

Send to multiple recipients:

void main() async {
  final provider = GatewayNetworkProvider.devnet();
  final account = await Account.fromMnemonic('...');
  
  final config = await provider.getNetworkConfig();
  var accountInfo = await provider.getAccount(account.address);
  var nonce = accountInfo.nonce;
  
  final recipients = [
    ('erd1...alice...', Balance.fromEgld(0.1)),
    ('erd1...bob...', Balance.fromEgld(0.2)),
    ('erd1...charlie...', Balance.fromEgld(0.3)),
  ];
  
  for (final (recipientBech32, amount) in recipients) {
    final tx = Transaction(
      sender: account.address,
      receiver: Address.fromBech32(recipientBech32),
      value: amount,
      nonce: nonce,
      gasLimit: GasLimit(50000),
      gasPrice: GasPrice(1000000000),
      chainId: ChainId(config.chainId),
      version: TransactionVersion(1),
      data: Uint8List(0),
    );
    
    final signature = await account.signTransaction(tx);
    final signed = tx.copyWith(newSignature: Signature.fromUint8List(signature));
    final hash = await provider.sendTransaction(signed);
    print('Sent: $hash');
    
    // Increment nonce for next transaction
    nonce = nonce.increment();
  }
}

Complete Example​

import 'package:abidock_mvx/abidock_mvx.dart';
import 'dart:typed_data';

void main() async {
  print('=== EGLD Transfer Demo ===\n');
  
  final provider = GatewayNetworkProvider.devnet();
  final account = await Account.fromMnemonic('your 24 word mnemonic phrase...');
  
  print('Sender: ${account.address.bech32}');
  
  // Get account info
  final config = await provider.getNetworkConfig();
  final accountInfo = await provider.getAccount(account.address);
  
  print('Balance: ${accountInfo.balance.value}');
  print('Nonce: ${accountInfo.nonce.value}');
  
  // Recipient
  final recipient = Address.fromBech32(
    'erd1spyavw0956vq68xj8y4tenjpq2wd5a9p2c6j8gsz7ztyrnpxrruqzu66jx'
  );
  final amount = Balance.fromEgld(0.01);
  
  // Create transaction
  final tx = Transaction(
    sender: account.address,
    receiver: recipient,
    value: amount,
    nonce: accountInfo.nonce,
    gasLimit: GasLimit(50000),
    gasPrice: GasPrice(1000000000),
    chainId: ChainId(config.chainId),
    version: TransactionVersion(1),
    data: Uint8List(0),
  );
  
  print('  To: ${recipient.bech32.substring(0, 20)}...');
  print('  Amount: ${amount.value} (0.01 EGLD)');
  print('  Gas: 50000');
  
  // Sign
  final signature = await account.signTransaction(tx);
  final signed = tx.copyWith(newSignature: Signature.fromUint8List(signature));
  
  // Send
  final hash = await provider.sendTransaction(signed);
  print('Sent! Hash: $hash');
  
  // Wait for confirmation
  final watcher = TransactionWatcher(networkProvider: provider);
  final result = await watcher.awaitCompleted(hash);
  
  
  // Check new balance
  final newAccountInfo = await provider.getAccount(account.address);
  print('New balance: ${newAccountInfo.balance.value}');
}

Next Steps​