签名ETH交易

dependencies:
  web3dart: ^2.0.2
  encrypt: ^5.0.0

import 'dart:convert';
import 'package:web3dart/web3dart.dart';
import 'package:encrypt/encrypt.dart' as encrypt;
import 'package:hex/hex.dart';

String decryptPrivateKey(String encryptedPrivateKey, String password) {
  final key = encrypt.Key.fromUtf8(password.padRight(32, ' '));
  final iv = encrypt.IV.fromLength(16); // Adjust based on your actual IV settings
  final encrypter = encrypt.Encrypter(encrypt.AES(key, mode: encrypt.AESMode.cbc));

  final decrypted = encrypter.decrypt64(encryptedPrivateKey, iv: iv);
  return decrypted;
}

Future<String> signEthTransaction({
  required int nonce,
  required String to,
  required double value,
  required int gasLimit,
  required double gasPrice,
  required String encryptedPrivateKey,
  required String password,
  int chainId = 1, // Mainnet by default, you can change it accordingly
}) async {
  // Decrypt the private key
  final privateKeyHex = decryptPrivateKey(encryptedPrivateKey, password);
  final privateKey = EthPrivateKey.fromHex(privateKeyHex);

  // Create transaction parameters
  final transaction = Transaction(
    nonce: nonce,
    to: EthereumAddress.fromHex(to),
    value: EtherAmount.inWei(BigInt.from(value * 1e18)),
    gasPrice: EtherAmount.inWei(BigInt.from(gasPrice * 1e9)),
    maxGas: gasLimit,
  );

  // Connect to Web3 to sign the transaction
  final web3client = Web3Client('', Client());

  try {
    // Sign transaction with the decrypted private key
    final signedTx = await web3client.signTransaction(
      privateKey,
      transaction,
      chainId: chainId,
    );

    // Return the serialized signed transaction in hex format
    return HEX.encode(signedTx);
  } finally {
    web3client.dispose();
  }
}

void main() async {
  String encryptedPrivateKey = "ENCRYPTED_PRIVATE_KEY";
  String password = "PASSWORD";

  String signedTx = await signEthTransaction(
    nonce: 1,
    to: '0xReceiverAddress',
    value: 0.1,
    gasLimit: 21000,
    gasPrice: 20,
    encryptedPrivateKey: encryptedPrivateKey,
    password: password,
  );

  print("Signed Transaction: $signedTx");
}

import 'package:web3dart/web3dart.dart';
import 'package:convert/convert.dart';
import 'package:web3dart/crypto.dart'; // For the bytes padding

Future<String> signEthTokenTransaction({
  required int nonce,
  required EthereumAddress contractAddress,
  required EthereumAddress to,
  required BigInt value,
  required BigInt gasLimit,
  required EtherAmount gasPrice,
  required int wei,
  required String privateKeyHex,
  required int chainId,
}) async {
  // Connect to the Ethereum client
  final client = Web3Client('', Client());

  // Format the 'value' to match the token's decimal places
  final formattedValue = value * BigInt.from(10).pow(wei);

  // Define the transfer function hash: keccak256("transfer(address,uint256)").take(4) => 'a9059cbb'
  final functionSignature = hex.decode('a9059cbb');

  // Format 'to' address (20 bytes) and 'value' (32 bytes)
  final toBytes = hex.decode(to.hexEip55.substring(2)).padLeft(32, 0);
  final valueBytes = hex.decode(formattedValue.toRadixString(16).padLeft(64, '0'));

  // Combine function signature, to address, and value into transaction data
  final transactionData = BytesBuilder();
  transactionData.add(functionSignature);
  transactionData.add(toBytes);
  transactionData.add(valueBytes);

  // Prepare the transaction
  final transaction = Transaction(
    nonce: nonce,
    maxGas: gasLimit.toInt(),
    gasPrice: gasPrice,
    to: contractAddress,
    value: EtherAmount.zero(),  // For token transfer, ETH value is zero
    data: transactionData.toBytes(),
  );

  // Convert private key and sign transaction
  final privateKey = EthPrivateKey.fromHex(privateKeyHex);
  final signedTx = await client.signTransaction(privateKey, transaction, chainId: chainId);

  // Clean up the client and return serialized transaction
  client.dispose();
  return hex.encode(signedTx);
}