setSignAndSendTransaction

Function Signature

public func setSignAndSendTransaction(
    _ fn: @escaping DelegationSignAndSend
)

Where:

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

Description Replaces the signer that approveAndSubmit, revokeAndSubmit, and transferAndSubmit use when no per-call DelegationSubmitOptions.signAndSendTransaction is provided. The signer receives one transaction and the CAIP-2 chain ID, signs and broadcasts it, and returns the transaction hash. Portal already installs a signer on portal.delegations that routes .evm transactions to eth_sendTransaction and .solana transactions to sol_signAndSendTransaction, so you only need this method to change that behavior — for example to attach a signatureApprovalMemo, add your own logging, or route signing through a different key. Signer precedence is per-call DelegationSubmitOptions.signAndSendTransaction → the signer set here → the Portal default. Parameters

Parameter	Type	Required	Description
`fn`	`DelegationSignAndSend`	Yes	Signs and broadcasts a single `DelegationTransaction` and returns its hash. Returning an empty hash causes the submit method to throw `DelegationsError.invalidTransactionHash`.

The transaction argument is a DelegationTransaction:

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

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

Each accessor returns nil for the other case, so you can branch with if let instead of writing a full switch. ConstructedEipTransaction is Codable, so you can encode it for logging or to hand it off to another process.

Field	Type	Description
`from`	`String`	The sender address.
`to`	`String`	The contract or recipient address.
`data`	`String?`	The calldata, when present.
`value`	`String?`	The native value, when present.

Returns Nothing. The signer is stored on the instance and used by subsequent submit calls. Throws Nothing. Errors from the signer itself surface from whichever submit method invoked it. Notes

The stored signer is not access-synchronized. Set it once — during app setup, before any submit call — rather than changing it while a submit is in flight. To vary the signer per call, pass DelegationSubmitOptions.signAndSendTransaction instead.

Example Usage

import PortalSwift

enum MyAppError: Error {
    case missingTransactionHash
    case unsupportedTransaction
}

func sendEvmDelegationTransaction(
    _ transaction: ConstructedEipTransaction,
    chainId: String
) async throws -> String {
    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)
    }
}

// Every submit call now goes through your signer
Task {
    do {
        let request = ApproveDelegationRequest(
            chain: "eip155:11155111",
            token: "USDC",
            delegateAddress: "0xa944e86eb36f039becd1843132347eb5b8501562",
            amount: "0.01"
        )

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

        print("Submitted hashes: \(result.hashes)")
    } 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)")
    }
}

Related Documentation

Getting Started

SDKs

APIs

Integrations

Resources

setSignAndSendTransaction