Manage Token Delegations

Portal’s iOS 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

func setSignAndSendTransaction(_ fn: @escaping DelegationSignAndSend)

func approveAndSubmit(
    request: ApproveDelegationRequest,
    options: DelegationSubmitOptions
) async throws -> DelegationSubmitResult

func revokeAndSubmit(
    request: RevokeDelegationRequest,
    options: DelegationSubmitOptions
) async throws -> DelegationSubmitResult

func transferAndSubmit(
    request: TransferFromRequest,
    options: DelegationSubmitOptions
) async throws -> DelegationSubmitResult

Each submit method also has a no-options convenience overload, which is what most callers want since Portal has already installed a signer:

func approveAndSubmit(request: ApproveDelegationRequest) async throws -> DelegationSubmitResult
func revokeAndSubmit(request: RevokeDelegationRequest) async throws -> DelegationSubmitResult
func transferAndSubmit(request: TransferFromRequest) async throws -> DelegationSubmitResult

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:

public typealias DelegationSignAndSend = (
    _ transaction: DelegationTransaction,
    _ chainId: String
) async throws -> String

DelegationTransaction covers both ecosystems:

public enum DelegationTransaction: Equatable {
    case evm(ConstructedEipTransaction)
    case solana(String) // base64-encoded

    public var evmTransaction: ConstructedEipTransaction? { get }
    public var solanaTransaction: String? { get }
}

Portal installs a default signer that routes .evm transactions to eth_sendTransaction and .solana transactions to sol_signAndSendTransaction, so this works with zero setup:

let result = try await portal.delegations.approveAndSubmit(request: request)

Use setSignAndSendTransaction(_:) 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(_:)`.
`onProgress`	`((DelegationSubmitProgress) -> Void)?`	No	Called as each transaction is signed and submitted.

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?`	`nil` on `.signing`, and the broadcast transaction hash on `.submitted`.

DelegationSubmitStep has exactly two cases — signing and submitted. There is no confirming or confirmed step, because nothing is awaited on-chain.

Return value

DelegationSubmitResult carries only the hashes:

Field	Type	Description
`hashes`	`[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 PortalSwift

Task {
    do {
        let request = ApproveDelegationRequest(
            chain: "eip155:11155111",
            token: "USDC",
            delegateAddress: "0xa944e86eb36f039becd1843132347eb5b8501562",
            amount: "0.01"
        )

        let result = try await portal.delegations.approveAndSubmit(
            request: request,
            options: DelegationSubmitOptions(
                onProgress: { progress in
                    switch progress.step {
                    case .signing:
                        print("Signing \(progress.index + 1)/\(progress.total)")
                    case .submitted:
                        print("Submitted: \(progress.hash ?? "")")
                    }
                }
            )
        )

        // These are broadcast, not confirmed.
        print("Submitted hashes: \(result.hashes)")
    } catch DelegationsError.noTransactions {
        print("The approval response contained no transactions to submit.")
    } catch DelegationsError.invalidTransactionHash(let index, let chainId) {
        print("Signer returned an unusable hash for transaction \(index) on \(chainId)")
    } catch {
        print("Error approving and submitting delegation: \(error)")
    }
}

The switch over progress.step is exhaustive with no default: — there really are only two steps.

Example (revoke and submit)

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

import PortalSwift

Task {
    do {
        let request = RevokeDelegationRequest(
            chain: "eip155:11155111",
            token: "USDC",
            delegateAddress: "0xa944e86eb36f039becd1843132347eb5b8501562"
        )

        let result = try await portal.delegations.revokeAndSubmit(request: request)

        print("Revoke submitted: \(result.hashes)")
    } catch DelegationsError.noTransactions {
        print("The revoke response contained no transactions to submit.")
    } catch {
        print("Error revoking delegation: \(error)")
    }
}

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 PortalSwift

Task {
    do {
        let request = TransferFromRequest(
            chain: "eip155:11155111",
            token: "USDC",
            fromAddress: "0x099699ed181517d4ce0ba4487bea671d31bb1db5", // Token owner
            toAddress: "0xdFd8302f44727A6348F702fF7B594f127dE3A902", // Recipient
            amount: "0.01"
        )

        let result = try await portal.delegations.transferAndSubmit(request: request)

        print("Transfer submitted: \(result.hashes)")
    } catch DelegationsError.noTransactions {
        print("The transfer response contained no transactions to submit.")
    } catch {
        print("Error transferring delegated tokens: \(error)")
    }
}

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. evmTransaction and solanaTransaction each return nil for the other case, so you can branch without a full switch:

import PortalSwift

enum MyAppError: Error {
    case missingTransactionHash
    case unsupportedTransaction
}

func sendEvmDelegationTransaction(
    _ transaction: ConstructedEipTransaction,
    chainId: String
) async throws -> String {
    // `ConstructedEipTransaction` is `Codable`, so you can also encode it here for logging
    // or to hand it off to another process before signing.
    var params: [String: String] = [
        "from": transaction.from,
        "to": transaction.to
    ]
    if let data = transaction.data { params["data"] = data }
    if let value = transaction.value { params["value"] = value }

    let response = try await portal.request(
        chainId: chainId,
        method: .eth_sendTransaction,
        params: [params],
        options: RequestOptions(signatureApprovalMemo: "Delegation transaction")
    )
    guard let hash = response.result as? String else {
        throw MyAppError.missingTransactionHash
    }
    return hash
}

func sendSolanaDelegationTransaction(
    _ encodedTransaction: String,
    chainId: String
) async throws -> String {
    let response = try await portal.request(
        chainId: chainId,
        method: .sol_signAndSendTransaction,
        params: [encodedTransaction],
        options: RequestOptions(signatureApprovalMemo: "Delegation transaction")
    )
    guard let hash = response.result as? String else {
        throw MyAppError.missingTransactionHash
    }
    return hash
}

// Branch with the accessors
portal.delegations.setSignAndSendTransaction { transaction, chainId in
    if let evmTransaction = transaction.evmTransaction {
        return try await sendEvmDelegationTransaction(evmTransaction, chainId: chainId)
    }
    if let encodedTransaction = transaction.solanaTransaction {
        return try await sendSolanaDelegationTransaction(encodedTransaction, chainId: chainId)
    }
    throw MyAppError.unsupportedTransaction
}

// Or match the enum, when you want the compiler to make you handle both cases
portal.delegations.setSignAndSendTransaction { transaction, chainId in
    switch transaction {
    case let .evm(evmTransaction):
        return try await sendEvmDelegationTransaction(evmTransaction, chainId: chainId)
    case let .solana(encodedTransaction):
        return try await sendSolanaDelegationTransaction(encodedTransaction, chainId: chainId)
    }
}

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

let result = try await portal.delegations.approveAndSubmit(
    request: request,
    options: DelegationSubmitOptions(
        signAndSendTransaction: { transaction, chainId in
            guard let evmTransaction = transaction.evmTransaction else {
                throw MyAppError.unsupportedTransaction
            }
            return try await sendEvmDelegationTransaction(evmTransaction, chainId: chainId)
        }
    )
)

Errors

The submit methods throw DelegationsError in addition to the network and decoding errors the low-level methods can throw.

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(index:chainId:)`	The signer returned a value that is not a usable hash for that chain. `index` identifies which transaction in the sequence it was.

DelegationsProtocol gained setSignAndSendTransaction, approveAndSubmit, revokeAndSubmit, and transferAndSubmit in 7.3.0. Calling code is unaffected, but anything that implements the protocol — a hand-rolled test mock, for example — needs all four before it will compile.

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

Task {
    do {
        let request = ApproveDelegationRequest(
            chain: "eip155:11155111",
            token: "USDC",
            delegateAddress: "0xa944e86eb36f039becd1843132347eb5b8501562",
            amount: "0.01"
        )

        let response = try await portal.delegations.approve(request: request)

        // Sign and send EVM transactions sequentially
        if let transactions = response.transactions {
            for (index, tx) in transactions.enumerated() {
                var txDict: [String: String] = [
                    "from": tx.from,
                    "to": tx.to
                ]
                if let data = tx.data { txDict["data"] = data }
                if let value = tx.value { txDict["value"] = value }

                let txResponse = try await portal.request(
                    chainId: "eip155:11155111",
                    method: .eth_sendTransaction,
                    params: [txDict],
                    options: RequestOptions(signatureApprovalMemo: "Approve delegation")
                )
                print("Tx \(index + 1) hash: \(txResponse.result as? String ?? "Unknown")")
            }
        }
    } catch {
        print("Error approving EVM delegation: \(error)")
    }
}

Solana Approval

Task {
    do {
        let request = ApproveDelegationRequest(
            chain: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token: "USDC",
            delegateAddress: "7smgSuU5mjP7QY5yWGdaTfgKn8hUWwvQgfvgcZB3HmJi",
            amount: "0.01"
        )

        let response = try await portal.delegations.approve(request: request)

        // Sign and send Solana transactions sequentially
        if let encodedTransactions = response.encodedTransactions {
            for (index, encodedTx) in encodedTransactions.enumerated() {
                let txResponse = try await portal.request(
                    chainId: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
                    method: .sol_signAndSendTransaction,
                    params: [encodedTx],
                    options: RequestOptions(signatureApprovalMemo: "Approve delegation")
                )
                print("Tx \(index + 1) hash: \(txResponse.result as? String ?? "Unknown")")
            }
        }
    } catch {
        print("Error approving Solana delegation: \(error)")
    }
}

Checking Delegation Status

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

EVM Status Check

Task {
    do {
        let request = GetDelegationStatusRequest(
            chain: "eip155:11155111",
            token: "USDC",
            delegateAddress: "0xa944e86eb36f039becd1843132347eb5b8501562"
        )

        let response = try await portal.delegations.getStatus(request: request)

        print("Chain ID: \(response.chainId)")
        print("Token: \(response.token)")
        print("Token Address: \(response.tokenAddress)")
        if let balance = response.balance { print("Balance: \(balance)") }
        print("Delegations: \(response.delegations.count)")

        for delegation in response.delegations {
            print("  - Address: \(delegation.address), Amount: \(delegation.delegateAmount)")
        }
    } catch {
        print("Error getting EVM delegation status: \(error)")
    }
}

Solana Status Check

Task {
    do {
        let request = GetDelegationStatusRequest(
            chain: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token: "USDC",
            delegateAddress: "7smgSuU5mjP7QY5yWGdaTfgKn8hUWwvQgfvgcZB3HmJi"
        )

        let response = try await portal.delegations.getStatus(request: request)

        print("Chain ID: \(response.chainId)")
        print("Token: \(response.token)")
        print("Delegations: \(response.delegations.count)")

        for delegation in response.delegations {
            print("  - Address: \(delegation.address), Amount: \(delegation.delegateAmount)")
        }
    } catch {
        print("Error getting Solana delegation status: \(error)")
    }
}

Revoking Delegations

Use revoke to remove spending permissions from a delegate address.

EVM Revoke

Task {
    do {
        let request = RevokeDelegationRequest(
            chain: "eip155:11155111",
            token: "USDC",
            delegateAddress: "0xa944e86eb36f039becd1843132347eb5b8501562"
        )

        let response = try await portal.delegations.revoke(request: request)

        // Sign and send EVM transactions sequentially
        if let transactions = response.transactions {
            for (index, tx) in transactions.enumerated() {
                var txDict: [String: String] = [
                    "from": tx.from,
                    "to": tx.to
                ]
                if let data = tx.data { txDict["data"] = data }
                if let value = tx.value { txDict["value"] = value }

                let txResponse = try await portal.request(
                    chainId: "eip155:11155111",
                    method: .eth_sendTransaction,
                    params: [txDict],
                    options: RequestOptions(signatureApprovalMemo: "Revoke delegation")
                )
                print("Tx \(index + 1) hash: \(txResponse.result as? String ?? "Unknown")")
            }
        }
    } catch {
        print("Error revoking EVM delegation: \(error)")
    }
}

Solana Revoke

Task {
    do {
        let request = RevokeDelegationRequest(
            chain: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token: "USDC",
            delegateAddress: "7smgSuU5mjP7QY5yWGdaTfgKn8hUWwvQgfvgcZB3HmJi"
        )

        let response = try await portal.delegations.revoke(request: request)

        // Sign and send Solana transactions sequentially
        if let encodedTransactions = response.encodedTransactions {
            for (index, encodedTx) in encodedTransactions.enumerated() {
                let txResponse = try await portal.request(
                    chainId: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
                    method: .sol_signAndSendTransaction,
                    params: [encodedTx],
                    options: RequestOptions(signatureApprovalMemo: "Revoke delegation")
                )
                print("Tx \(index + 1) hash: \(txResponse.result as? String ?? "Unknown")")
            }
        }
    } catch {
        print("Error revoking Solana delegation: \(error)")
    }
}

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

Task {
    do {
        let request = TransferFromRequest(
            chain: "eip155:11155111",
            token: "USDC",
            fromAddress: "0x099699ed181517d4ce0ba4487bea671d31bb1db5", // Token owner
            toAddress: "0xdFd8302f44727A6348F702fF7B594f127dE3A902",   // Recipient
            amount: "0.01"
        )

        let response = try await portal.delegations.transferFrom(request: request)

        // Sign and send EVM transactions sequentially
        if let transactions = response.transactions {
            for (index, tx) in transactions.enumerated() {
                var txDict: [String: String] = [
                    "from": tx.from,
                    "to": tx.to
                ]
                if let data = tx.data { txDict["data"] = data }
                if let value = tx.value { txDict["value"] = value }

                let txResponse = try await portal.request(
                    chainId: "eip155:11155111",
                    method: .eth_sendTransaction,
                    params: [txDict],
                    options: RequestOptions(signatureApprovalMemo: "Transfer delegated tokens")
                )
                print("Tx \(index + 1) hash: \(txResponse.result as? String ?? "Unknown")")
            }
        }
    } catch {
        print("Error transferring EVM delegation: \(error)")
    }
}

Solana Transfer From

Task {
    do {
        let request = TransferFromRequest(
            chain: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
            token: "USDC",
            fromAddress: "ARttPLesu9RiX6H111Pfdc9Y2DhGy1B8P8jyyrD8Cj5b", // Token owner
            toAddress: "GPsPXxoQA51aTJJkNHtFDFYui5hN5UxcFPnheJEHa5Du",   // Recipient
            amount: "0.01"
        )

        let response = try await portal.delegations.transferFrom(request: request)

        // Sign and send Solana transactions sequentially
        if let encodedTransactions = response.encodedTransactions {
            for (index, encodedTx) in encodedTransactions.enumerated() {
                let txResponse = try await portal.request(
                    chainId: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
                    method: .sol_signAndSendTransaction,
                    params: [encodedTx],
                    options: RequestOptions(signatureApprovalMemo: "Transfer delegated tokens")
                )
                print("Tx \(index + 1) hash: \(txResponse.result as? String ?? "Unknown")")
            }
        }
    } catch {
        print("Error transferring Solana delegation: \(error)")
    }
}

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

Read the reference pages for approveAndSubmit, revokeAndSubmit, transferAndSubmit, and setSignAndSendTransaction
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