USDT support

func requiresApproval(_ actions: [Action]?) -> Bool {
    actions?.contains { $0.walletRpc.method == "eth_sendTransaction" } ?? false
}

function requiresApproval(actions: readonly Action[] | null): boolean {
  return !!actions?.some(a => a.walletRpc?.method === "eth_sendTransaction");
}

bool requiresApproval(List<Action>? actions) =>
    actions?.any((a) => a.walletRpc.method == 'eth_sendTransaction') ?? false;

func estimateApprovalFee(
    chainId: String,
    txParams: [String: Any]
) async -> BigUInt? {
    do {
        let gasLimit = try await rpc.estimateGas(chainId: chainId, tx: txParams)
        let maxFeePerGas = try await rpc.maxFeePerGas(chainId: chainId)
        return gasLimit * maxFeePerGas
    } catch {
        return nil
    }
}

async function estimateApprovalFee(
  provider: providers.JsonRpcProvider,
  tx: providers.TransactionRequest,
): Promise<BigNumber | null> {
  try {
    const [gasLimit, feeData] = await Promise.all([
      provider.estimateGas(tx),
      provider.getFeeData(),
    ]);
    return feeData.maxFeePerGas ? gasLimit.mul(feeData.maxFeePerGas) : null;
  } catch {
    return null;
  }
}

Future<BigInt?> estimateApprovalFee(Map<String, dynamic> txParams) async {
  try {
    final gasLimit = await ethClient.estimateGas(/* tx params */);
    final fees = await ethClient.getFeeData();
    return gasLimit * fees.maxFeePerGas.getInWei;
  } catch (_) {
    return null;
  }
}

var signatures: [String] = []

for action in actions {
    let rpc = action.walletRpc
    let result: String
    switch rpc.method {
    case "eth_sendTransaction":
        let txHash = try await wallet.sendTransaction(chainId: rpc.chainId, params: rpc.params)
        try await wallet.awaitReceipt(chainId: rpc.chainId, txHash: txHash)
        result = txHash
    case "eth_signTypedData_v4":
        result = try await wallet.signTypedData(chainId: rpc.chainId, params: rpc.params)
    default:
        throw PaymentError.unsupportedMethod(rpc.method)
    }
    signatures.append(result)
}

const signatures: string[] = [];

for (const action of actions) {
  const { chainId, method, params } = action.walletRpc;
  const parsed = JSON.parse(params);
  switch (method) {
    case "eth_sendTransaction": {
      const tx = await wallet.sendTransaction(chainId, parsed[0]);
      await tx.wait();
      signatures.push(tx.hash);
      break;
    }
    case "eth_signTypedData_v4":
      signatures.push(await wallet.signTypedData(chainId, parsed));
      break;
    default:
      throw new Error(`Unsupported method: ${method}`);
  }
}

final signatures = <String>[];

for (final action in actions) {
  final rpc = action.walletRpc;
  switch (rpc.method) {
    case 'eth_sendTransaction':
      // sendPayTransaction broadcasts and waits for the receipt
      final params = (jsonDecode(rpc.params) as List).first as Map;
      signatures.add(await service.sendPayTransaction(
        Map<String, dynamic>.from(params),
      ));
      break;
    case 'eth_signTypedData_v4':
      signatures.add(service.ethSignTypedDataV4(rpc.params));
      break;
    default:
      throw UnimplementedError('Unsupported method: ${rpc.method}');
  }
}