Manage Token Delegations

Portal’s Android SDK provides token delegation capabilities through the portal.delegations API. This enables approving token spending, revoking approvals, checking delegation status, and transferring tokens as a delegate on both EVM and Solana chains.

Overview

The delegations functionality allows you to:

Approve other addresses to spend tokens on behalf of your wallet
Revoke existing delegations to remove spending permissions
Check status of active delegations and balances
Transfer tokens as a delegate from another address

Prerequisites

Before using delegation operations, ensure you have:

A properly initialized Portal client
An active wallet with tokens on the target network (see Create a wallet)
Understanding of token delegations concepts

Delegations apply to ERC-20 tokens (EVM) and SPL Tokens (Solana) only. Native assets like ETH, MON, and SOL cannot be delegated — they have no on-chain approve / transferFrom (or SPL delegate) semantics. Calls using a native asset identifier will be rejected. See Delegations for the protocol-level reason and workarounds.

High-Level Methods

Use approveAndSubmit, revokeAndSubmit, and transferAndSubmit when you want one call for the whole flow: build the delegation transaction(s), then sign and broadcast each one in order and collect the resulting hashes. Portal installs a working signer on portal.delegations for you, so the common case needs no configuration at all.

approveAndSubmit, revokeAndSubmit, and transferAndSubmit broadcast each transaction and return as soon as it is accepted by the network. They do not wait for on-chain confirmation. A hash in DelegationSubmitResult.hashes means the transaction was submitted, not that it succeeded — an approval can still revert. If your flow depends on the delegation being active, wait for the receipt yourself, or poll getStatus before proceeding.This is different from Yield.xyz, where you wait for each transaction to confirm before moving on to the next step. Do not carry that assumption over to delegations.

Signatures

fun setSignAndSendTransaction(fn: DelegationSignAndSend)

suspend fun approveAndSubmit(
    request: ApproveDelegationRequest,
    options: DelegationSubmitOptions = DelegationSubmitOptions()
): Result<DelegationSubmitResult>

suspend fun revokeAndSubmit(
    request: RevokeDelegationRequest,
    options: DelegationSubmitOptions = DelegationSubmitOptions()
): Result<DelegationSubmitResult>

suspend fun transferAndSubmit(
    request: TransferFromRequest,
    options: DelegationSubmitOptions = DelegationSubmitOptions()
): Result<DelegationSubmitResult>

options is defaulted, so portal.delegations.approveAndSubmit(request) is a complete call. All three return Result<DelegationSubmitResult> — handle failures via onSuccess / onFailure (or fold), since errors are returned in the Result rather than thrown. The request types are the same ones the low-level methods take — see EVM Approval, EVM Revoke, and EVM Transfer From below for their fields.

Configuring the signer

A signer signs and broadcasts one transaction and returns its hash:

typealias DelegationSignAndSend = suspend (transaction: DelegationTransaction, chainId: String) -> String

DelegationTransaction is a sealed class covering both ecosystems:

sealed class DelegationTransaction {
    data class Evm(val transaction: ConstructedEipTransaction) : DelegationTransaction()
    data class Solana(val encodedTransaction: String) : DelegationTransaction()
}

Solana.encodedTransaction is base64-encoded. Because it is a sealed class, a when over it is exhaustive and needs no else. Portal installs a default signer that routes Evm transactions to eth_sendTransaction and Solana transactions to sol_signAndSendTransaction:

val delegations: Delegations by lazy {
    Delegations(this.api.delegations).also { d ->
        d.setSignAndSendTransaction(::signDelegationTransaction)
    }
}

So this works with zero setup:

portal.delegations.approveAndSubmit(request)

Use setSignAndSendTransaction(fn) to replace the signer for the instance, or DelegationSubmitOptions.signAndSendTransaction to override it for a single call. The precedence is per-call option → instance signer → Portal default.

Options and progress

DelegationSubmitOptions is the second argument to each submit method:

Parameter	Type	Required	Description
`signAndSendTransaction`	`DelegationSignAndSend?`	No	Per-call signer override. Takes priority over the instance signer set with `setSignAndSendTransaction(fn)`. Defaults to `null`.
`onProgress`	`((DelegationSubmitProgress) -> Unit)?`	No	Called as each transaction is signed and submitted. Defaults to `null`.

DelegationSubmitProgress carries:

Field	Type	Description
`step`	`DelegationSubmitStep`	`SIGNING` or `SUBMITTED`.
`index`	`Int`	The 0-based index of this transaction in the sequence.
`total`	`Int`	The total number of transactions in the sequence.
`hash`	`String?`	`null` on `SIGNING`, and the broadcast transaction hash on `SUBMITTED`.

DelegationSubmitStep has exactly two members — SIGNING and SUBMITTED. There is no confirming or confirmed step, because nothing is awaited on-chain.

DelegationSubmitStep members are uppercase (DelegationSubmitStep.SIGNING), while YieldSubmitStep members are lowercase (YieldSubmitStep.signing). Both shipped in 9.1.0. Write each one the way its own type declares it.

Return value

DelegationSubmitResult carries only the hashes:

Field	Type	Description
`hashes`	`List<String>`	One hash per broadcast transaction, in submission order.

There is no status field, and no partial-success concept: a hash is present because the network accepted the transaction, and nothing beyond that has been checked.

Example (approve and submit)

This builds the same approval as EVM Approval below, but signs and broadcasts it for you.

import io.portalhq.android.api.data.delegations.ApproveDelegationRequest
import io.portalhq.android.delegations.DelegationSubmitOptions
import io.portalhq.android.delegations.DelegationSubmitStep

lifecycleScope.launch {
    val request = ApproveDelegationRequest(
        chain = "eip155:11155111", // Sepolia testnet
        token = "USDC",
        delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee",
        amount = "0.01"
    )

    portal.delegations.approveAndSubmit(
        request = request,
        options = DelegationSubmitOptions(
            onProgress = { progress ->
                when (progress.step) {
                    DelegationSubmitStep.SIGNING ->
                        println("Signing ${progress.index + 1}/${progress.total}")
                    DelegationSubmitStep.SUBMITTED ->
                        println("Submitted: ${progress.hash}")
                }
            }
        )
    ).onSuccess { result ->
        // These are broadcast, not confirmed.
        println("Submitted hashes: ${result.hashes}")
    }.onFailure { error ->
        println("approveAndSubmit failed: ${error.message}")
    }
}

The when over progress.step is exhaustive with no else — there really are only two steps.

Example (revoke and submit)

Same RevokeDelegationRequest as EVM Revoke below, submitted end to end.

import io.portalhq.android.api.data.delegations.RevokeDelegationRequest

lifecycleScope.launch {
    val request = RevokeDelegationRequest(
        chain = "eip155:11155111",
        token = "USDC",
        delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee"
    )

    portal.delegations.revokeAndSubmit(request).onSuccess { result ->
        println("Revoke submitted: ${result.hashes}")
    }.onFailure { error ->
        println("revokeAndSubmit failed: ${error.message}")
    }
}

Because the revoke is not confirmed when this call returns, the delegation may still be active for a short time afterwards. Poll getStatus if you need to show the user that it is gone.

Example (transfer as a delegate)

Same TransferFromRequest as EVM Transfer From below. Your wallet must already be an approved delegate for fromAddress.

import io.portalhq.android.api.data.delegations.TransferFromRequest

lifecycleScope.launch {
    val request = TransferFromRequest(
        chain = "eip155:11155111",
        token = "USDC",
        fromAddress = "0x06ccd61bc37775140b0b039b392aa823c7cbeedd", // Token owner
        toAddress = "0x5bd098a9368d142126e8b53a058b5c563714bc76",   // Recipient
        amount = "0.01"
    )

    portal.delegations.transferAndSubmit(request).onSuccess { result ->
        println("Transfer submitted: ${result.hashes}")
    }.onFailure { error ->
        println("transferAndSubmit failed: ${error.message}")
    }
}

Example (custom signer)

Replace the default signer when you need to do something it does not, such as attaching a signatureApprovalMemo to every delegation transaction. A when over the sealed class is exhaustive and returns the hash directly:

import io.portalhq.android.delegations.DelegationTransaction
import io.portalhq.android.provider.data.PortalRequestMethod
import io.portalhq.android.provider.data.RequestOptions

portal.delegations.setSignAndSendTransaction { transaction, chainId ->
    val (method, param) = when (transaction) {
        is DelegationTransaction.Evm ->
            PortalRequestMethod.eth_sendTransaction to transaction.transaction
        is DelegationTransaction.Solana ->
            PortalRequestMethod.sol_signAndSendTransaction to transaction.encodedTransaction
    }

    val response = portal.request(
        chainId = chainId,
        method = method,
        params = listOf(param),
        options = RequestOptions(signatureApprovalMemo = "Delegation transaction")
    )

    // Returning a blank hash makes the submit method fail with
    // DelegationsError.InvalidTransactionHash, tagged with the right index.
    response.result as? String ?: ""
}

To use a different signer for a single call, pass it in the options instead — it takes priority over the instance signer:

import io.portalhq.android.api.data.delegations.ApproveDelegationRequest
import io.portalhq.android.delegations.DelegationSubmitOptions
import io.portalhq.android.delegations.DelegationTransaction
import io.portalhq.android.provider.data.PortalRequestMethod
import io.portalhq.android.provider.data.RequestOptions

lifecycleScope.launch {
    val request = ApproveDelegationRequest(
        chain = "eip155:11155111",
        token = "USDC",
        delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee",
        amount = "0.01"
    )

    portal.delegations.approveAndSubmit(
        request = request,
        options = DelegationSubmitOptions(
            signAndSendTransaction = { transaction, chainId ->
                val (method, param) = when (transaction) {
                    is DelegationTransaction.Evm ->
                        PortalRequestMethod.eth_sendTransaction to transaction.transaction
                    is DelegationTransaction.Solana ->
                        PortalRequestMethod.sol_signAndSendTransaction to transaction.encodedTransaction
                }

                portal.request(
                    chainId = chainId,
                    method = method,
                    params = listOf(param),
                    options = RequestOptions(signatureApprovalMemo = "One-off delegation approval")
                ).result as? String ?: ""
            }
        )
    ).onSuccess { result ->
        println("Submitted hashes: ${result.hashes}")
    }.onFailure { error ->
        println("approveAndSubmit failed: ${error.message}")
    }
}

Errors

DelegationsError is a sealed class of Exception subclasses. They arrive inside a failed Result, so match them in onFailure:

Case	When
`NoSignerConfigured`	No signer was available. This cannot happen on `portal.delegations`, which `Portal` wires for you — only when you construct `Delegations` yourself.
`NoTransactions`	The delegation response contained no transactions to submit.
`InvalidTransactionHash`	The signer returned a value that is not a usable hash for that chain. The message names which transaction in the sequence it was.

import io.portalhq.android.api.data.delegations.ApproveDelegationRequest
import io.portalhq.android.delegations.DelegationsError

lifecycleScope.launch {
    val request = ApproveDelegationRequest(
        chain = "eip155:11155111",
        token = "USDC",
        delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee",
        amount = "0.01"
    )

    portal.delegations.approveAndSubmit(request).onSuccess { result ->
        println("Submitted hashes: ${result.hashes}")
    }.onFailure { error ->
        when (error) {
            is DelegationsError.NoTransactions ->
                println("The approval response contained no transactions to submit.")
            is DelegationsError.InvalidTransactionHash ->
                println("The signer returned an unusable hash: ${error.message}")
            is DelegationsError.NoSignerConfigured ->
                println("No signer configured on this Delegations instance.")
            else ->
                println("approveAndSubmit failed: ${error.message}")
        }
    }
}

The submit methods can also fail with the network and decoding errors the low-level methods return. Coroutine cancellation is never captured in the Result — it is rethrown, so structured concurrency still works when the calling scope is torn down.

Low-Level Methods

The sections below are the manual path: approve, revoke, transferFrom, and getStatus return unsigned transactions and leave signing and broadcasting to you. Use them when you need to inspect, modify, batch, or route the transactions yourself. Otherwise prefer the high-level methods above.

Approving Delegations

Use approve to grant another address permission to spend tokens on your behalf. This method works for both EVM and Solana chains.

EVM Approval

lifecycleScope.launch {
    try {
        val request = ApproveDelegationRequest(
            chain = "eip155:11155111", // Sepolia testnet
            token = "USDC",
            delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee",
            amount = "0.01"
        )

        val result = portal.delegations.approve(request)

        result.onSuccess { response ->
            // Sign and send EVM transactions sequentially
            response.transactions?.let { transactions ->
                for ((index, tx) in transactions.withIndex()) {
                    val txDict = mutableMapOf<String, String>(
                        "from" to tx.from,
                        "to" to tx.to
                    )
                    tx.data?.let { txDict["data"] = it }
                    tx.value?.let { txDict["value"] = it }

                    val txResponse = portal.request(
                        chainId = "eip155:11155111",
                        method = PortalRequestMethod.eth_sendTransaction,
                        params = listOf(txDict),
                        options = RequestOptions(signatureApprovalMemo = "Approve delegation")
                    )
                    println("Tx ${index + 1} hash: ${txResponse.result as? String}")
                }
            }
        }.onFailure { error ->
            println("Approve (EVM) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error approving EVM delegation: ${e.message}")
    }
}

Solana Approval

lifecycleScope.launch {
    try {
        val request = ApproveDelegationRequest(
            chain = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1", // Solana Devnet
            token = "USDC",
            delegateAddress = "8uzXpjP9zXRHqo6KGZaE6XrxnjarBsKTufVya7jHtyt5",
            amount = "0.01"
        )

        val result = portal.delegations.approve(request)

        result.onSuccess { response ->
            // Sign and send Solana transactions sequentially
            response.encodedTransactions?.let { encodedTxs ->
                for ((index, encodedTx) in encodedTxs.withIndex()) {
                    val txResponse = portal.request(
                        chainId = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
                        method = PortalRequestMethod.sol_signAndSendTransaction,
                        params = listOf(encodedTx),
                        options = RequestOptions(signatureApprovalMemo = "Approve delegation")
                    )
                    println("Tx ${index + 1} hash: ${txResponse.result as? String}")
                }
            }
        }.onFailure { error ->
            println("Approve (SOL) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error approving Solana delegation: ${e.message}")
    }
}

Checking Delegation Status

Use getStatus to check current delegations and token balances for a specific delegate address.

EVM Status Check

lifecycleScope.launch {
    try {
        val request = GetDelegationStatusRequest(
            chain = "eip155:11155111",
            token = "USDC",
            delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee"
        )

        val result = portal.delegations.getStatus(request)

        result.onSuccess { response ->
            println("Chain ID: ${response.chainId}")
            println("Token: ${response.token}")
            println("Token Address: ${response.tokenAddress}")
            response.balance?.let { println("Balance: $it") }
            println("Delegations: ${response.delegations.size}")

            response.delegations.forEach { delegation ->
                println("  - Address: ${delegation.address}, Amount: ${delegation.delegateAmount}")
            }
        }.onFailure { error ->
            println("Get Status (EVM) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error getting EVM delegation status: ${e.message}")
    }
}

Solana Status Check

lifecycleScope.launch {
    try {
        val request = GetDelegationStatusRequest(
            chain = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token = "USDC",
            delegateAddress = "8uzXpjP9zXRHqo6KGZaE6XrxnjarBsKTufVya7jHtyt5"
        )

        val result = portal.delegations.getStatus(request)

        result.onSuccess { response ->
            println("Chain ID: ${response.chainId}")
            println("Token: ${response.token}")
            println("Delegations: ${response.delegations.size}")

            response.delegations.forEach { delegation ->
                println("  - Address: ${delegation.address}, Amount: ${delegation.delegateAmount}")
            }
        }.onFailure { error ->
            println("Get Status (SOL) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error getting Solana delegation status: ${e.message}")
    }
}

Revoking Delegations

Use revoke to remove spending permissions from a delegate address.

EVM Revoke

lifecycleScope.launch {
    try {
        val request = RevokeDelegationRequest(
            chain = "eip155:11155111",
            token = "USDC",
            delegateAddress = "0x1a3eda7eb7d13e60e638711c580490c19e164fee"
        )

        val result = portal.delegations.revoke(request)

        result.onSuccess { response ->
            // Sign and send EVM transactions sequentially
            response.transactions?.let { transactions ->
                for ((index, tx) in transactions.withIndex()) {
                    val txDict = mutableMapOf<String, String>(
                        "from" to tx.from,
                        "to" to tx.to
                    )
                    tx.data?.let { txDict["data"] = it }
                    tx.value?.let { txDict["value"] = it }

                    val txResponse = portal.request(
                        chainId = "eip155:11155111",
                        method = PortalRequestMethod.eth_sendTransaction,
                        params = listOf(txDict),
                        options = RequestOptions(signatureApprovalMemo = "Revoke delegation")
                    )
                    println("Tx ${index + 1} hash: ${txResponse.result as? String}")
                }
            }
        }.onFailure { error ->
            println("Revoke (EVM) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error revoking EVM delegation: ${e.message}")
    }
}

Solana Revoke

lifecycleScope.launch {
    try {
        val request = RevokeDelegationRequest(
            chain = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token = "USDC",
            delegateAddress = "8uzXpjP9zXRHqo6KGZaE6XrxnjarBsKTufVya7jHtyt5"
        )

        val result = portal.delegations.revoke(request)

        result.onSuccess { response ->
            // Sign and send Solana transactions sequentially
            response.encodedTransactions?.let { encodedTxs ->
                for ((index, encodedTx) in encodedTxs.withIndex()) {
                    val txResponse = portal.request(
                        chainId = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
                        method = PortalRequestMethod.sol_signAndSendTransaction,
                        params = listOf(encodedTx),
                        options = RequestOptions(signatureApprovalMemo = "Revoke delegation")
                    )
                    println("Tx ${index + 1} hash: ${txResponse.result as? String}")
                }
            }
        }.onFailure { error ->
            println("Revoke (SOL) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error revoking Solana delegation: ${e.message}")
    }
}

Always revoke unused delegations after completing operations to minimize security risks.

Transferring as a Delegate

Use transferFrom to transfer tokens from another address that has delegated spending permission to you.

EVM Transfer From

lifecycleScope.launch {
    try {
        val request = TransferFromRequest(
            chain = "eip155:11155111",
            token = "USDC",
            fromAddress = "0x06ccd61bc37775140b0b039b392aa823c7cbeedd", // Token owner
            toAddress = "0x5bd098a9368d142126e8b53a058b5c563714bc76",   // Recipient
            amount = "0.01"
        )

        val result = portal.delegations.transferFrom(request)

        result.onSuccess { response ->
            // Sign and send EVM transactions sequentially
            response.transactions?.let { transactions ->
                for ((index, tx) in transactions.withIndex()) {
                    val txDict = mutableMapOf<String, String>(
                        "from" to tx.from,
                        "to" to tx.to
                    )
                    tx.data?.let { txDict["data"] = it }
                    tx.value?.let { txDict["value"] = it }

                    val txResponse = portal.request(
                        chainId = "eip155:11155111",
                        method = PortalRequestMethod.eth_sendTransaction,
                        params = listOf(txDict),
                        options = RequestOptions(signatureApprovalMemo = "Transfer delegated tokens")
                    )
                    println("Tx ${index + 1} hash: ${txResponse.result as? String}")
                }
            }
        }.onFailure { error ->
            println("TransferFrom (EVM) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error transferring EVM delegation: ${e.message}")
    }
}

Solana Transfer From

lifecycleScope.launch {
    try {
        val request = TransferFromRequest(
            chain = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token = "USDC",
            fromAddress = "5qf7h6aJ47nfYkmtDW52LtCgBKEppf8CU1CmNXUJvPDD", // Token owner
            toAddress = "CaeuusKjRDw2NctShW2gMhEcMxFYfHLUUGHh3Hui3Mae",     // Recipient
            amount = "0.01"
        )

        val result = portal.delegations.transferFrom(request)

        result.onSuccess { response ->
            // Sign and send Solana transactions sequentially
            response.encodedTransactions?.let { encodedTxs ->
                for ((index, encodedTx) in encodedTxs.withIndex()) {
                    val txResponse = portal.request(
                        chainId = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
                        method = PortalRequestMethod.sol_signAndSendTransaction,
                        params = listOf(encodedTx),
                        options = RequestOptions(signatureApprovalMemo = "Transfer delegated tokens")
                    )
                    println("Tx ${index + 1} hash: ${txResponse.result as? String}")
                }
            }
        }.onFailure { error ->
            println("TransferFrom (SOL) failed: ${error.message}")
        }
    } catch (e: Exception) {
        println("Error transferring Solana delegation: ${e.message}")
    }
}

Delegation Roles: fromAddress is the token owner who approved the delegation. Your wallet (the delegate) signs the transaction to transfer tokens from the owner to the toAddress recipient.

Supported Networks

Delegations work on all Portal-supported EVM and Solana chains:

EVM: Ethereum, Polygon, Base, Arbitrum, Optimism, Monad, and all other EVM-compatible chains
Solana: Solana Mainnet and Devnet

For a complete list, see Blockchain Support.

Next Steps

Submit delegations in one call with the high-level methods
Learn about signing transactions
Explore Portal API methods
Review delegation concepts
Check out wallet lifecycle management

Getting Started

SDKs

APIs

Integrations

Resources

Manage Token Delegations

Overview

Prerequisites

High-Level Methods

Signatures

Configuring the signer

Options and progress

Return value

Example (approve and submit)

Example (revoke and submit)

Example (transfer as a delegate)

Example (custom signer)

Errors

Low-Level Methods

Approving Delegations

EVM Approval

Solana Approval

Checking Delegation Status

EVM Status Check

Solana Status Check

Revoking Delegations

EVM Revoke

Solana Revoke

Transferring as a Delegate

EVM Transfer From

Solana Transfer From

Supported Networks

Next Steps

​Overview

​Prerequisites

​High-Level Methods

​Signatures

​Configuring the signer

​Options and progress

​Return value

​Example (approve and submit)

​Example (revoke and submit)

​Example (transfer as a delegate)

​Example (custom signer)

​Errors

​Low-Level Methods

​Approving Delegations

​EVM Approval

​Solana Approval

​Checking Delegation Status

​EVM Status Check

​Solana Status Check

​Revoking Delegations

​EVM Revoke

​Solana Revoke

​Transferring as a Delegate

​EVM Transfer From

​Solana Transfer From

​Supported Networks

​Next Steps

Overview

Prerequisites

High-Level Methods

Signatures

Configuring the signer

Options and progress

Return value

Example (approve and submit)

Example (revoke and submit)

Example (transfer as a delegate)

Example (custom signer)

Errors

Low-Level Methods

Approving Delegations

EVM Approval

Solana Approval

Checking Delegation Status

EVM Status Check

Solana Status Check

Revoking Delegations

EVM Revoke

Solana Revoke

Transferring as a Delegate

EVM Transfer From

Solana Transfer From

Supported Networks

Next Steps