Evaluate a transaction

Portal provides the function portal.api.evaluateTransaction, which gives you insights into what will happen upon executing the transaction. This function can perform transaction simulation, security validation, or both. Here’s how it works:

5.x.x
3.x.x

suspend fun evaluateTransaction(): Result<String> {
    // Basic transaction evaluation
    runCatching {
        val transaction = EvaluateTransactionParam(
            to = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
            value = "1000000000000000000", // 1 ETH
            data = null,
            maxFeePerGas = "30000000000",
            maxPriorityFeePerGas = "1500000000",
            gas = "21000",
            gasPrice = null
        )

        val evaluation = portal.api.evaluateTransaction(
            chainId = "eip155:1",
            transaction = transaction,
            operationType = ALL
        ).getOrThrow()

        // Check validation results
        evaluation.validation?.let { validation ->
            println("Security Status: ${validation.status}")

            if (validation.status != "VALIDATED") {
                println("Warning: ${validation.description ?: "Unknown issue"}")

                // Print detected security features
                validation.features.forEach { feature ->
                    println("Security Feature: ${feature.type}")
                    println("Description: ${feature.description}")
                }
            }
        }

        // Check simulation results
        evaluation.simulation?.let { simulation ->
            println("Simulation Status: ${simulation.status}")

            // Print asset changes
            simulation.assetsDiffs.forEach { (token, diffs) ->
                println("\nToken: $token")
                diffs.forEach { diff ->
                    println("Incoming transfers:")
                    diff.`in`.forEach { transfer ->
                        println(transfer)
                    }
                    println("Outgoing transfers:")
                    diff.out.forEach { transfer ->
                        println(transfer)
                    }
                }
            }
        }
    }.onFailure { error ->
        println("Evaluation failed: $error")
        return Result.failure(error)
    }

    // Contract interaction evaluation
    runCatching {
        val transaction = EvaluateTransactionParam(
            to = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
            value = "0",
            data = "0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e0000000000000000000000000000000000000000000000000de0b6b3a7640000", // ERC20 transfer
            maxFeePerGas = null,
            maxPriorityFeePerGas = null,
            gas = "65000",
            gasPrice = "20000000000"
        )

        // Validate only
        val evaluation = portal.api.evaluateTransaction(
            chainId = "eip155:1",
            transaction = transaction,
            operationType = VALIDATION
        ).getOrThrow()

        evaluation.validation?.let { validationResult ->
            // Handle potential security issues
            when (validationResult.status) {
                "VALIDATED" -> {
                    println("Transaction is safe")
                }
                "WARNING" -> {
                    println("Warning: ${validationResult.description ?: "Unknown warning"}")
                }
                "BLOCKED" -> {
                    println("Blocked: ${validationResult.reason ?: "Unknown reason"}")
                }
                else -> {
                    println("Unknown status: ${validationResult.status}")
                }
            }
        }
    }.onFailure { error ->
        println("Validation failed: $error")
        return Result.failure(error)
    }

    return Result.success("")
}

The operationType parameter determines what type of evaluation is performed. It can be one of the following values:

SIMULATION: Perform transaction simulation only
VALIDATION: Perform security validation only
ALL: Perform both validation and simulation

suspend fun handleSimulateTransaction() {
    // First, create a transaction.
    val transaction = SimulateTransactionParam(
        to = "0xRecipientAddressHere",  // The recipient address.
        value = "0x10DE4A2A",           // The value to be sent in Wei.
        data = null,                    // Data for the transaction (for contract interactions).
        maxFeePerGas = null,            // Maximum fee per gas.
        maxPriorityFeePerGas = null,    // Maximum priority fee per gas.
        gas = null,                     // The gas limit.
        gasPrice = null                 // Gas price in Wei.
    )

    // Next, simulate the transaction.
    val simulatedResult = portal.api.simulateTransaction(transaction)

    // Finally, handle or display the simulation results.
    when {
        simulatedResult.requestError != null -> {
            print("Request error: ${simulatedResult.requestError.message}")
        }
        simulatedResult.error != null -> {
            print("Transaction will have error: ${simulatedResult.error.message}")
        }
        else -> {
            print("Simulated transaction results: ${simulatedResult.changes}")
        }
    }
}

This function returns a BlockaidValidateTrxRes containing:

simulation: Transaction simulation results including:
- accountAddress: Address being analyzed
- accountSummary: Summary of account state changes
- addressDetails: Detailed information about involved addresses
- assetsDiffs: Asset balance changes, containing:
  - asset: Asset information
  - in: Incoming transfers
  - out: Outgoing transfers
- exposures: Risk exposure analysis
- status: Simulation status
- totalUsdDiff: Total USD value change
- totalUsdExposure: Total USD value at risk
validation: Security validation results (when operationType is VALIDATION or ALL) including:
- classification: Type of potential security issue
- description: Detailed description of the validation results
- features: Array of detected security features
- status: Validation status
block: Block number used for evaluation
chain: Chain identifier

By incorporating transaction simulations, you can provide your users with a preview of the transaction outcomes and preemptively detect and handle errors, ensuring a smoother user experience.

And now you are evaluating transactions with Portal! 🙌 🚀 Next, we’ll explore how to back up the wallet for recovery if the user loses device access.

Getting Started

SDKs

APIs

Integrations

Resources