Skip to main content

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.

Portal’s Android SDK provides comprehensive security scanning capabilities through the portal.security.hypernative API. This integration allows you to detect malicious transactions, flagged addresses, compromised tokens, and suspicious URLs before users interact with them.

​
Overview

The Hypernative integration enables you to:
  • Scan transactions before signing or submission (EVM, EIP-712, Solana)
  • Scan addresses for known malicious actors or compromised contracts
  • Validate tokens to detect scams, honeypots, or security risks
  • Check NFTs for fraudulent collections or suspicious activity
  • Verify URLs to prevent phishing attacks

​
Prerequisites

Before using Hypernative security scanning, ensure you have:
  • A properly initialized Portal client
  • Hypernative integration enabled in your Portal Dashboard (see Hypernative Integration)

​
Scanning EVM Transactions

Use scanEVMTx to analyze standard Ethereum transactions before signing or sending. This method scans EVM transactions for malicious contract interactions, suspicious token approvals, and other security risks. EVM transactions are standard Ethereum transactions that include a chain ID to prevent replay attacks across different networks. 
lifecycleScope.launch {
    val transaction = ScanEVMTransaction(
        chain = "eip155:1",
        fromAddress = "0x7C01728004d3F2370C1BBC36a4Ad680fE6FE8729",
        toAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
        input = "0x095ea7b300000000000000000000000066ba61be3bab35c0c00038f335850a390b086fe300000000000000000000000000000000000000000fffffffffffffffffffffff",
        value = 0,
        nonce = 2340,
        gas = 3000000,
        gasPrice = 3000000
    )
    
    val request = ScanEVMRequest(transaction = transaction)
    
    val result = portal.security.hypernative.scanEVMTx(request)
    
    result.onSuccess { response ->
        val rawResponse = response.data?.rawResponse
        println("Success: ${rawResponse?.success}")
        rawResponse?.data?.let { data ->
            println("Recommendation: ${data.recommendation}")
            println("Assessment ID: ${data.assessmentId}")
            data.findings?.forEach { finding ->
                println("Finding: ${finding.title} (${finding.severity})")
            }
        }
    }.onFailure { error ->
        println("Error scanning EVM transaction: ${error.message}")
    }
}

​
Scanning EIP-712 Typed Messages

Use scanEip712Tx to analyze typed structured data before signing. This method is critical for detecting malicious permit signatures, phishing attempts, and unauthorized token approvals. EIP-712 defines a standard for hashing and signing typed structured data, commonly used for gasless approvals and off-chain signatures. 
lifecycleScope.launch {
    val types = mapOf(
        "EIP712Domain" to listOf(
            ScanEip712TypeProperty("name", "string"),
            ScanEip712TypeProperty("version", "string"),
            ScanEip712TypeProperty("chainId", "uint256"),
            ScanEip712TypeProperty("verifyingContract", "address")
        ),
        "Permit" to listOf(
            ScanEip712TypeProperty("owner", "address"),
            ScanEip712TypeProperty("spender", "address"),
            ScanEip712TypeProperty("value", "uint256"),
            ScanEip712TypeProperty("nonce", "uint256"),
            ScanEip712TypeProperty("deadline", "uint256")
        )
    )
    
    val domain = ScanEip712Domain(
        name = "MyToken",
        version = "1",
        chainId = "eip155:1",
        verifyingContract = "0xa0b86991c6218b36c1d19d4a2e9Eb0cE3606eB48"
    )
    
    val message = mapOf<String, Any>(
        "owner" to "0x7b1363f33b86d16ef7c8d03d11f4394a37d95c36",
        "spender" to "0x67beb4dd770a9c2cbc7133ba428b9eecdcf09186",
        "value" to 3000,
        "nonce" to 0,
        "deadline" to 50000000000L
    )
    
    val typedData = ScanEip712TypedData(
        primaryType = "Permit",
        types = types,
        domain = domain,
        message = message
    )
    
    val request = ScanEip712Request(
        walletAddress = "0x7b1363f33b86d16ef7c8d03d11f4394a37d95c36",
        chainId = "eip155:1",
        eip712Message = typedData
    )
    
    val result = portal.security.hypernative.scanEip712Tx(request)
    
    result.onSuccess { response ->
        val rawResponse = response.data?.rawResponse
        println("Success: ${rawResponse?.success}")
        rawResponse?.data?.let { data ->
            println("Recommendation: ${data.recommendation}")
            println("Assessment ID: ${data.assessmentId}")
        }
    }.onFailure { error ->
        println("Error scanning EIP-712 transaction: ${error.message}")
    }
}

​
Scanning Solana Transactions

Use scanSolanaTx to analyze Solana transactions before signing. This method detects malicious program invocations, suspicious token transfers, and other Solana-specific security risks. 
lifecycleScope.launch {
    val transaction = ScanSolanaTransaction(
        message = null,
        signatures = null,
        rawTransaction = "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAQADCQkVR3SiiKbW0l4c3NBsEn6+zn1o0YsyypPwN0GUhg4K5HK0Tb5GckDLYW+MsovQASt5EZ3bSH3nluRJAE69H61w0BRUDTrpYQcXosUun6/z2BROkRoH/1bL7KLU9s4lCav6k3ZZgV6qeZFwu4pu89WoIGaqUxG4C93XwVmmDy81v8qBaCSP4/UZfdo3q1bud/W+ixymkH8IMe0laQZYrSx4Uhyxec67hYm1VqLV7JTSSYaC/fm7KvWtZOSRzEFT2gMGRm/lIRcy/+ytunLDm+e8jOW7xfcSayxDmzpAAAAAT4tlY/P4mFG1wDJl0ektVggHiZf73lTlHBVJ3fK0nDoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANG5fPtlMEOI/eXV7aPDlpcdLUKm8L3VoW6k/oJlCNLaBQYABQLARQQABgAJAwYAAAAAAAAABzwACQoLCwgyMzQMNQ0ONjcPEDg5EgETFBUWOhEXGBkaGxwdHh8gISI7IyQlJicCKCkqKywtAwQuLzAxPBFVCg8JAQcHBgYBAAAAAwHwCgYBExUbBgICAAAPAwIAAAYBISMoEQQBGQAPAwIAAAYBLjA2DwMCAAAGAgIAAAAIBgYICAADAQkGCQUFBgACBQAEBwEAAAgCAAUMAgAAADwaAAAAAAAABgAFBGDMBQAEPPm21Wu6wrmHu23/ZFNIumpp+ADooZjd4JQgvjnBxkUJAgEDBqWqCgmmCAUIBwu1tp+gcP/+Ri3C1tRXUbPdgqo6rVsj/qnqC959wTdC/mRARysLz9HS09TW19jZ2tsC1QYsNrdxMcm5Nq5FXZrM0IXpEA+ApFa+pz/JvkLz0+2vnwuztLW2t7i5uru8vgAPvBv8VUeRwDy9yD1NHIH5Ji6ZA+zrmpHejKOz4MP8SwrKy8zNzs/S09TVAdY=",
        version = "0"
    )
    
    val request = ScanSolanaRequest(
        transaction = transaction,
        showFullFindings = true
    )
    
    val result = portal.security.hypernative.scanSolanaTx(request)
    
    result.onSuccess { response ->
        val rawResponse = response.data?.rawResponse
        println("Success: ${rawResponse?.success}")
        rawResponse?.data?.let { data ->
            println("Recommendation: ${data.recommendation}")
            println("Assessment ID: ${data.assessmentId}")
        }
    }.onFailure { error ->
        println("Error scanning Solana transaction: ${error.message}")
    }
}

​
Scanning Addresses

Use scanAddresses to check multiple addresses for known security risks. This method identifies malicious contracts, compromised wallets, sanctioned addresses, and other flagged entities. 
lifecycleScope.launch {
    val request = ScanAddressesRequest(
        addresses = listOf(
            "0x31c05d73f2333b5a176cfdbb7c5ef96ec7bb04ac",
            "0x2753a0d37a2ad09be3ccc0afcb650bea8ea57a8f"
        )
    )
    
    val result = portal.security.hypernative.scanAddresses(request)
    
    result.onSuccess { response ->
        response.data?.rawResponse?.forEach { item ->
            println("Address: ${item.address}")
            println("Recommendation: ${item.recommendation}")
            println("Severity: ${item.severity}")
            item.flags?.forEach { flag ->
                println("Flag: ${flag.title} (${flag.severity})")
            }
        }
    }.onFailure { error ->
        println("Error scanning addresses: ${error.message}")
    }
}

​
Scanning NFTs

Use scanNfts to validate NFT collections before displaying or allowing interactions. This method detects fraudulent collections, compromised contracts, and suspicious NFT activity. 
lifecycleScope.launch {
    val request = ScanNftsRequest(
        nfts = listOf(
            ScanNftsRequestItem(
                address = "0x5C1B9caA8492585182eD994633e76d744A876548",
                evmChainId = "eip155:1"
            ),
            ScanNftsRequestItem(
                address = "0xC2e0cA5FE0b9AbE1B86f3cC0b865448908D20A16",
                evmChainId = "eip155:1"
            )
        )
    )
    
    val result = portal.security.hypernative.scanNfts(request)
    
    result.onSuccess { response ->
        response.data?.rawResponse?.data?.nfts?.forEach { nft ->
            println("NFT: ${nft.address}")
            println("Accept: ${nft.accept}")
            println("Chain: ${nft.evmChainId ?: nft.chain}")
        }
    }.onFailure { error ->
        println("Error scanning NFTs: ${error.message}")
    }
}

​
Scanning Tokens

Use scanTokens to validate ERC-20 tokens before allowing swaps, transfers, or approvals. This method detects honeypots, scam tokens, and compromised token contracts. 
lifecycleScope.launch {
    val request = ScanTokensRequest(
        tokens = listOf(
            ScanTokensRequestItem(
                address = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  // USDC
                evmChainId = "eip155:1"
            )
        )
    )
    
    val result = portal.security.hypernative.scanTokens(request)
    
    result.onSuccess { response ->
        response.data?.rawResponse?.data?.tokens?.forEach { token ->
            println("Token: ${token.address}")
            println("Chain: ${token.evmChainId ?: token.chain}")
            println("Reputation: ${token.reputation?.recommendation ?: "N/A"}")
        }
    }.onFailure { error ->
        println("Error scanning tokens: ${error.message}")
    }
}

​
Scanning URLs

Use scanURL to detect phishing sites and malicious domains before users navigate to them. This method is critical for protecting users from social engineering attacks. 
lifecycleScope.launch {
    val request = ScanUrlRequest(url = "curve.fi")
    
    val result = portal.security.hypernative.scanURL(request)
    
    result.onSuccess { response ->
        val isMalicious = response.data?.rawResponse?.data?.isMalicious ?: false
        val status = if (isMalicious) "⚠️ MALICIOUS" else "✅ SAFE"
        
        println("URL: curve.fi")
        println("Status: $status")
        println("Is Malicious: $isMalicious")
    }.onFailure { error ->
        println("Error scanning URL: ${error.message}")
    }
}

​
Next Steps