> ## Documentation Index
> Fetch the complete documentation index at: https://docs.portalhq.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Evaluate a transaction

> Before committing to a transaction, it's often useful to simulate its outcome to understand the potential changes and detect any errors preemptively.

Portal provides the function **`portal.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:

```swift theme={null}
// Basic transaction evaluation
do {
    let transaction = EvaluateTransactionParam(
        to: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        value: "1000000000000000000", // 1 ETH
        data: nil,
        maxFeePerGas: "30000000000",
        maxPriorityFeePerGas: "1500000000",
        gas: "21000",
        gasPrice: nil
    )

    let evaluation = try await portal.evaluateTransaction(
        chainId: "eip155:1",
        transaction: transaction,
        operationType: .all
    )

    // Check validation results
    if let validation = evaluation.validation {
        print("Security Status: \(validation.status)")

        if validation.status != "VALIDATED" {
            print("Warning: \(validation.description ?? "Unknown issue")")

            // Print detected security features
            validation.features.forEach { feature in
                print("Security Feature: \(feature.type)")
                print("Description: \(feature.description)")
            }
        }
    }

    // Check simulation results
    if let simulation = evaluation.simulation {
        print("Simulation Status: \(simulation.status)")

        // Print asset changes
        simulation.assetsDiffs.forEach { (token, diffs) in
            print("\nToken: \(token)")
            diffs.forEach { diff in
                print("Incoming transfers:")
                diff.in.forEach { transfer in
                    print(transfer)
                }
                print("Outgoing transfers:")
                diff.out.forEach { transfer in
                    print(transfer)
                }
            }
        }
    }
} catch {
    print("Evaluation failed: \(error)")
}

// Contract interaction evaluation
do {
    let transaction = EvaluateTransactionParam(
        to: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
        value: "0",
        data: "0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b844bc454e4438f44e0000000000000000000000000000000000000000000000000de0b6b3a7640000", // ERC20 transfer
        maxFeePerGas: nil,
        maxPriorityFeePerGas: nil,
        gas: "65000",
        gasPrice: "20000000000"
    )

    // Validate only
    let validation = try await portal.evaluateTransaction(
        chainId: "eip155:1",
        transaction: transaction,
        operationType: .validation
    )

    if let validationResult = validation.validation {
        // Handle potential security issues
        switch validationResult.status {
        case "VALIDATED":
            print("Transaction is safe")
        case "WARNING":
            print("Warning: \(validationResult.description ?? "Unknown warning")")
        case "BLOCKED":
            print("Blocked: \(validationResult.reason ?? "Unknown reason")")
        default:
            print("Unknown status: \(validationResult.status)")
        }
    }
} catch {
    print("Validation failed: \(error)")
}
```

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

```swift theme={null}
public enum EvaluateTransactionOperationType: String, CaseIterable {
  case validation  // Perform security validation only
  case simulation  // Perform transaction simulation only
  case all         // Perform both validation and simulation
}
```

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 simulating transactions with Portal! 🙌 🚀 Next, we'll explore how to back up the wallet for recovery if the user loses device access.

**Related Documentation**

* [evaluateTransaction function reference](../reference/evaluatetransaction)