Bridge & Swap with Li.Fi

Portal’s iOS SDK provides comprehensive cross-chain bridging and swapping capabilities through the portal.trading.lifi API. This guide covers getting quotes, finding routes, executing swaps and bridges, and tracking transaction status.

Overview

The Li.Fi functionality allows you to:

Get quotes for bridging or swapping tokens across chains
Find routes to discover the best paths for your cross-chain transfers
Execute swaps and bridges by signing and submitting transactions
Track transaction status for cross-chain transfers

Prerequisites

Before using Li.Fi operations, ensure you have:

A properly initialized Portal client
An active wallet with the required token(s) on the source network (see Create a wallet)
Li.Fi integration enabled in your Portal Dashboard (see Li.Fi Integration)

High-Level Methods

tradeAsset runs the entire bridge or swap in one call. pollStatus exposes the same Li.Fi status poller tradeAsset uses internally, for manual flows where you already have a transaction hash. If you only need to move tokens, use tradeAsset. Reach for the low-level methods when you need to inspect routes before committing, run your own signing, or drive a custom UI.

tradeAsset

Runs the end-to-end Li.Fi flow:

Discover routes (getRoutes)
Select a route (routeIndex, default 0)
Build each step (getRouteStep)
Sign and broadcast that step’s transaction
Wait for on-chain confirmation of that step
Poll Li.Fi status until the step reaches a terminal state
Continue to the next step

Steps execute sequentially, never in parallel. Signing and confirmation for each step happen on that step’s own chain, which the SDK resolves from the step itself — so a multi-chain route signs on each chain in turn without you managing it. Confirmation is strict. Every step must confirm on-chain before the next begins. There is no optimistic fallback: a revert or a confirmation timeout aborts the whole trade and throws.

Signature

func tradeAsset(params: LifiTradeAssetParams) async throws -> LifiTradeAssetResult

Essential parameters

Parameter	Type	Required	Description
`fromChain`	`String`	Yes	Source chain. Use CAIP-2 (`"eip155:8453"`), as everywhere else in this guide.
`toChain`	`String`	Yes	Destination chain, same format.
`fromToken`	`String`	Yes	Source token contract address or symbol.
`toToken`	`String`	Yes	Destination token contract address or symbol.
`amount`	`String`	Yes	Amount in the token’s base units, as an integer string (for example wei for an 18-decimal token).
`fromAddress`	`String?`	No, but pass it	Sending wallet address. See the note below.
`toAddress`	`String?`	No	Receiving wallet address. Falls back to `fromAddress` when omitted.
`routeIndex`	`Int?`	No	Which discovered route to execute. Default `0`.
`onProgress`	`LifiProgressHandler?`	No	Fired at each stage. See Progress lifecycle.

fromAddress is optional in the type system but the SDK does not fill it in for you — it is forwarded to Li.Fi exactly as given. Omitting it means routes are quoted without a sender, while the transaction is still signed by your Portal wallet, so the quote may not match what actually executes. Pass try await portal.getAddress("eip155:8453") explicitly.

Configuring the signer and confirmation Unlike the React Native and Web SDKs, tradeAsset takes no second options argument. The signing and confirmation hooks are injected once, when the Lifi instance is constructed:

public init(
  api: PortalLifiTradingApiProtocol,
  signAndSendTransaction: LifiSignAndSendTransaction? = nil,
  waitForConfirmation: LifiWaitForConfirmation? = nil,
  stepPollOptions: LifiPollStatusOptions = LifiPollStatusOptions(everyMs: 10_000, initialDelayMs: 0, timeoutMs: 600_000)
)

Portal wires both automatically, so portal.trading.lifi.tradeAsset(params:) works with no setup. The default confirmation poller retries 30 times at 2-second intervals. Overriding the defaults. portal.trading is built lazily by Portal with its own closures already supplied, so the instance at portal.trading.lifi cannot be reconfigured after the fact, and there is no per-call override. Trading has an internal initializer, so you cannot construct one yourself either — build a Lifi directly and call tradeAsset on it:

let lifi = Lifi(
    api: portal.api.lifi,
    signAndSendTransaction: { transaction, chainId in
        try await mySigner.signAndSend(transaction, chainId: chainId)
    },
    waitForConfirmation: { txHash, chainId -> LifiConfirmationResult in
        let receipt = try await myConfirmer.waitForReceipt(txHash: txHash, chainId: chainId)
        return receipt.succeeded ? .confirmed : .reverted
    },
    stepPollOptions: LifiPollStatusOptions(everyMs: 5_000, initialDelayMs: 0, timeoutMs: 300_000)
)

let result = try await lifi.tradeAsset(params: params)

stepPollOptions controls the per-step Li.Fi polling inside tradeAsset and is only reachable this way. waitForConfirmation returns a three-state enum rather than a boolean, so a revert and a timeout stay distinguishable:

`LifiConfirmationResult`	Meaning	Effect on `tradeAsset`
`.confirmed`	Mined with a success status.	Proceeds to the next step.
`.reverted`	Mined but the receipt status was not `0x1`.	Throws `LifiTradeAssetError.transactionConfirmationFailed(txHash)`.
`.timedOut`	Still pending, or the node was unreachable. Not a definitive revert.	Throws `LifiTradeAssetError.transactionConfirmationTimedOut(txHash)`.

Return value

Field	Type	Description
`hashes`	`[String]`	One transaction hash per executed step, in execution order.
`steps`	`[LifiStep]`	The enriched steps that were executed, with `transactionRequest` populated.
`route`	`LifiRoute`	The route that was selected and executed.

Example (progress reporting)

import PortalSwift

do {
    let fromAddress = try await portal.getAddress("eip155:8453")

    let result = try await portal.trading.lifi.tradeAsset(
        params: LifiTradeAssetParams(
            fromChain: "eip155:8453",
            toChain: "eip155:42161",
            fromToken: "ETH",
            toToken: "USDC",
            amount: "1000000000000",
            fromAddress: fromAddress,
            onProgress: { status, data in
                switch status {
                case .signing:
                    print("Signing step \((data.stepIndex ?? 0) + 1) of \(data.totalSteps ?? 0)")
                case .submitted:
                    print("Submitted: \(data.txHash ?? "")")
                case .complete:
                    print("Trade complete")
                case .failed:
                    print("Failed: \(data.errorMessage ?? "unknown")")
                default:
                    break
                }
            }
        )
    )

    print("Hashes: \(result.hashes)")
    print("Executed steps: \(result.steps.count)")
} catch LifiTradeAssetError.noRoutesFound {
    print("No route available for this pair")
} catch let LifiTradeAssetError.transactionConfirmationFailed(txHash) {
    print("Transaction reverted on-chain: \(txHash)")
} catch {
    print("tradeAsset failed: \(error)")
}

Example (minimal)

let fromAddress = try await portal.getAddress("eip155:8453")

let result = try await portal.trading.lifi.tradeAsset(
    params: LifiTradeAssetParams(
        fromChain: "eip155:8453",
        toChain: "eip155:42161",
        fromToken: "ETH",
        toToken: "USDC",
        amount: "1000000000000",
        fromAddress: fromAddress
    )
)

Errors

tradeAsset and pollStatus throw LifiTradeAssetError:

Case	When
`missingSigner`	No signing closure on the `Lifi` instance. Cannot happen on `portal.trading.lifi`.
`missingConfirmation`	No confirmation closure on the `Lifi` instance. Cannot happen on `portal.trading.lifi`.
`noRoutesFound`	Li.Fi returned no routes for the requested trade.
`routeIndexOutOfBounds`	`routeIndex` is negative or beyond the number of discovered routes.
`routeHasNoSteps`	The selected route contains no steps.
`missingTransactionRequest`	A step came back without a transaction request to sign.
`invalidTransactionRequest`	A step’s transaction request was malformed — missing fields, wrong shape, or an invalid value such as a negative amount.
`transactionConfirmationFailed(String)`	The step’s transaction reverted on-chain. Carries the transaction hash.
`transactionConfirmationTimedOut(String)`	Confirmation could not be determined before timing out. Carries the transaction hash. The transaction may still be pending.
`lifiTransferFailed(String)`	Li.Fi reported a `FAILED` terminal state for the transfer.
`pollTimeout`	Status polling exceeded the configured timeout.

All cases conform to LocalizedError, so error.localizedDescription gives a readable message.

If the surrounding Task is cancelled, tradeAsset throws CancellationError and does not emit a .failed progress event. A UI that only dismisses its progress state on .failed or .complete will hang on cancellation — handle CancellationError separately.

Progress lifecycle

onProgress receives a LifiTradeAssetProgressStatus and a LifiTradeAssetProgressData. Every field on the data struct is optional; which ones are populated depends on the stage:

Status	Raw value	Populated data
`.fetchingRoutes`	`fetching_routes`	—
`.routeSelected`	`route_selected`	`routeIndex`, `route`, `totalSteps`
`.preparingStep`	`preparing_step`	`routeIndex`, `stepIndex`, `totalSteps`, `route`
`.signing`	`signing`	above, plus `step`
`.submitted`	`submitted`	above, plus `txHash`
`.confirming`	`confirming`	above, plus `txHash`
`.lifiPending`	`lifi_pending`	above, plus `lifiStatus` on later emissions
`.stepDone`	`step_done`	above
`.complete`	`complete`	`route`, `totalSteps`
`.failed`	`failed`	`errorMessage`

txHash is nil until .submitted. errorMessage is only ever set on .failed.

pollStatus

Polls Li.Fi for the status of a transfer until it reaches a terminal state. Use it when you have submitted a transaction yourself and want the same polling behavior tradeAsset uses internally. The protocol requirement takes three arguments, and three convenience overloads cover the common cases:

// Protocol requirement
func pollStatus(
    request: LifiStatusRequest,
    onUpdate: ((LifiStatusRawResponse) -> Bool)?,
    options: LifiPollStatusOptions
) async throws -> LifiStatusRawResponse

// Convenience overloads
func pollStatus(request: LifiStatusRequest) async throws -> LifiStatusRawResponse
func pollStatus(request: LifiStatusRequest, options: LifiPollStatusOptions) async throws -> LifiStatusRawResponse
func pollStatus(request: LifiStatusRequest, onUpdate: @escaping (LifiStatusRawResponse) -> Bool) async throws -> LifiStatusRawResponse

Returning false from onUpdate stops polling early and returns the last status received — it is not an error. Returning true continues.

let txHash = "0xYOUR_TRANSACTION_HASH"

let final = try await portal.trading.lifi.pollStatus(
    request: LifiStatusRequest(
        txHash: txHash,
        fromChain: "eip155:8453",
        toChain: "eip155:42161"
    ),
    onUpdate: { update in
        print("Status: \(update.status.rawValue)")
        return true  // return false to stop polling early
    }
)

print("Final status: \(final.status.rawValue)")

pollStatus options

Option	Type	Default	Description
`everyMs`	`Int`	`10000`	Interval between polls, in milliseconds. Values below `100` are raised to `100` to prevent busy-waiting.
`initialDelayMs`	`Int`	`0`	Delay before the first poll, in milliseconds.
`timeoutMs`	`Int`	`600000`	Overall polling timeout, in milliseconds. Exceeding it throws `LifiTradeAssetError.pollTimeout`.

let txHash = "0xYOUR_TRANSACTION_HASH"

let final = try await portal.trading.lifi.pollStatus(
    request: LifiStatusRequest(txHash: txHash, fromChain: "eip155:8453", toChain: "eip155:42161"),
    options: LifiPollStatusOptions(everyMs: 5_000, initialDelayMs: 10_000, timeoutMs: 300_000)
)

Low-level methods

The rest of this guide covers the individual Li.Fi methods. Use them when you need control over route selection, signing, or status tracking that tradeAsset does not expose.

Getting a Quote

Use the getQuote method to get a quote for bridging or swapping tokens across chains.

do {
    let userAddress = try await portal.getAddress("eip155:1")

    let request = LifiQuoteRequest(
        fromChain: "eip155:1",
        toChain: "eip155:137",
        fromToken: "ETH",
        toToken: "USDC",
        fromAddress: userAddress,
        fromAmount: "1000000000000" // 0.000001 ETH in wei
    )

    let response = try await portal.trading.lifi.getQuote(request: request)
    if let rawResponse = response.data?.rawResponse {
        // Process quote response
        if let estimate = rawResponse.estimate {
            print("From amount: \(estimate.fromAmount)")
            print("To amount: \(estimate.toAmount)")
            print("Execution duration: \(estimate.executionDuration)s")
        }

        // Sign and submit the transaction if transactionRequest is available
        if let transactionRequest = rawResponse.transactionRequest {
            try await executeTransaction(transactionRequest, chainId: request.fromChain)
        }
    }
} catch {
    print("Error getting quote: \(error)")
}

The response includes a transactionRequest object with the transaction details you’ll need to sign and submit.

Finding Routes

Use the getRoutes method to discover available routes for your cross-chain transfer.

do {
    let userAddress = try await portal.getAddress("eip155:1")

    let request = LifiRoutesRequest(
        fromChainId: "eip155:1",
        fromAmount: "1000000000000", // 0.000001 ETH in wei
        fromTokenAddress: "ETH",
        toChainId: "eip155:137",
        toTokenAddress: "USDC",
        fromAddress: userAddress
    )

    let response = try await portal.trading.lifi.getRoutes(request: request)
    if let rawResponse = response.data?.rawResponse {
        let routes = rawResponse.routes

        // Find recommended route
        let recommendedRoute = routes.first { route in
            route.tags?.contains("RECOMMENDED") ?? false
        } ?? routes.first

        if let route = recommendedRoute {
            print("Selected route: \(route.id)")
            print("Steps: \(route.steps.count)")
            print("From: \(route.fromAmountUSD) USD")
            print("To: \(route.toAmountUSD) USD")

            // Process route steps
            try await processRouteSteps(route.steps, fromChainId: request.fromChainId)
        }
    }
} catch {
    print("Error getting routes: \(error)")
}

The response includes an array of routes with estimates, fees, and gas costs. Routes may be tagged as RECOMMENDED, CHEAPEST, or FASTEST.

Getting Route Step Details

Use the getRouteStep method to get detailed transaction information for a specific route step, including an unsigned transaction that you can then sign and submit to an RPC provider (the transactionRequest field).

func getStepTransactionDetails(step: LifiStep) async throws -> LifiStep? {
    let stepRequest = step as LifiStepTransactionRequest

    let response = try await portal.trading.lifi.getRouteStep(request: stepRequest)

    if let rawResponse = response.data?.rawResponse {
        return rawResponse
    }

    return nil
}

The response includes a transactionRequest object with the unsigned transaction that you can sign and submit.

Executing Swaps and Bridges

After getting a quote or route step details, extract the transaction details from the transactionRequest object and sign the transaction. Extract the from, to, value, and data fields to sign and submit the transaction.

Approving ERC-20 Tokens

If your fromToken is an ERC-20, the Li.Fi router cannot move it on your behalf until you grant an on-chain allowance. Skip this step when the fromToken is the chain’s native asset (its address is 0x0000000000000000000000000000000000000000). Build the approval transaction with the portal.delegations.approve(request:) method, then sign each transaction it returns with the same eth_sendTransaction flow used to sign the swap. Call this helper after obtaining a quote and before calling executeTransaction:

let nativeTokenAddress = "0x0000000000000000000000000000000000000000"

func approveErc20IfNeeded(
    quote: LifiQuoteResponse,
    fromAmount: String,
    fromChainId: String
) async throws {
    guard let action = quote.data?.rawResponse?.action,
          let estimate = quote.data?.rawResponse?.estimate,
          let fromToken = action.fromToken,
          fromToken.address != nativeTokenAddress
    else {
        // Native asset — no approval needed.
        return
    }

    // Convert the raw fromAmount into the token's primary denomination
    // (e.g. raw "10000" with 6 decimals → "0.01"). Use a Decimal-aware
    // conversion to preserve precision for large values.
    let amount = formatUnits(fromAmount, decimals: fromToken.decimals)

    let request = ApproveDelegationRequest(
        chain: fromChainId,
        token: fromToken.address,
        delegateAddress: estimate.approvalAddress,
        amount: amount
    )

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

    guard let transactions = response.transactions else { return }

    for tx in transactions {
        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: fromChainId,
            method: .eth_sendTransaction,
            params: [txDict],
            options: RequestOptions(signatureApprovalMemo: "Approve token for Li.Fi")
        )

        if let txHash = txResponse.result as? String {
            _ = await waitForConfirmation(txHash: txHash, chainId: fromChainId)
        }
    }
}

This step only applies when the fromToken is an ERC-20. Native-asset swaps (ETH, MATIC, etc.) skip it. For more on the delegations API, see the Manage Token Delegations guide.

Signing and Submitting Transactions

func executeTransaction(_ transactionRequest: AnyCodable, chainId: String) async throws {
    // Extract transaction parameters
    guard let txParams = transactionRequest.value as? [String: Any],
          let from = txParams["from"] as? String,
          let to = txParams["to"] as? String
    else {
        throw NSError(domain: "LiFi", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid transaction parameters"])
    }

    // Extract value (default to 0x0 if not present)
    var value = "0x0"
    if let valueString = txParams["value"] as? String {
        value = valueString
    }

    // Extract data
    let data = txParams["data"] as? String ?? "0x"

    // Create transaction
    let ethTransaction = ETHTransactionParam(
        from: from,
        to: to,
        value: value,
        data: data
    )

    // Sign and send
    let sendResponse = try await portal.request(
        chainId: chainId,
        method: .eth_sendTransaction,
        params: [ethTransaction],
        options: RequestOptions(signatureApprovalMemo: "Bridge & swap via Li.Fi")
    )

    if let txHash = sendResponse.result as? String {
        print("Transaction submitted: \(txHash)")

        // Wait for on-chain confirmation
        let confirmed = await waitForConfirmation(txHash: txHash, chainId: chainId)
        if confirmed {
            print("Transaction confirmed")
        }
    }
}

The transactionRequest from Li.Fi may include gasPrice and gasLimit fields. You can remove these if you want Portal to estimate the gas for you, or include them if you want to use Li.Fi’s estimates.

Processing Multiple Route Steps

For routes with multiple steps, process them sequentially:

func processRouteSteps(_ steps: [LifiStep], fromChainId: String) async throws {
    for (index, step) in steps.enumerated() {
        print("Processing step \(index + 1)/\(steps.count): \(step.tool)")

        // 1. Get transaction details for this step
        guard let stepWithTx = try await getStepTransactionDetails(step: step),
              let transactionRequest = stepWithTx.transactionRequest
        else {
            throw NSError(domain: "LiFi", code: -1, userInfo: [NSLocalizedDescriptionKey: "Failed to get transaction details"])
        }

        // 2. Sign and submit the transaction
        try await executeTransaction(transactionRequest, chainId: fromChainId)

        print("Step \(index + 1) completed")
    }
}

Waiting for Transaction Confirmation

func waitForConfirmation(
    txHash: String,
    chainId: String,
    maxAttempts: Int = 30,
    delaySeconds: UInt64 = 2
) async -> Bool {
    for _ in 0..<maxAttempts {
        try? await Task.sleep(nanoseconds: delaySeconds * 1_000_000_000)

        do {
            let response = try await portal.request(
                chainId: chainId,
                method: .eth_getTransactionReceipt,
                params: [txHash]
            )

            if let receipt = response.result as? [String: Any],
               let status = receipt["status"] as? String {
                if status == "0x1" {
                    return true  // Transaction succeeded
                } else if status == "0x0" {
                    return false // Transaction reverted
                }
            }
        } catch {
            continue
        }
    }

    return false // Timeout
}

Tracking Transaction Status

Use the getStatus method to track the status of your cross-chain transfer.

func trackLiFiStatus(txHash: String, fromChain: String) async throws {
    let request = LifiStatusRequest(
        txHash: txHash,
        fromChain: fromChain
    )

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

    if let rawResponse = response.data?.rawResponse {
        print("Status: \(rawResponse.status.rawValue)")

        if let txId = rawResponse.transactionId {
            print("Transaction ID: \(txId)")
        }

        if let explorerLink = rawResponse.lifiExplorerLink {
            print("Explorer: \(explorerLink)")
        }

        // Check if complete
        if rawResponse.status == .done {
            print("Transfer completed successfully!")
        } else if rawResponse.status == .failed {
            print("Transfer failed")
        }
    }
}

Polling for Cross-Chain Completion

For cross-chain transfers, poll the status endpoint until the transfer completes:

func pollForCompletion(
    txHash: String,
    fromChain: String,
    maxAttempts: Int = 300,
    pollIntervalSeconds: UInt64 = 2
) async -> Bool {
    for attempt in 0..<maxAttempts {
        do {
            let request = LifiStatusRequest(
                txHash: txHash,
                fromChain: fromChain
            )

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

            if let rawResponse = response.data?.rawResponse {
                print("Polling (\(attempt + 1)/\(maxAttempts)): \(rawResponse.status.rawValue)")

                if rawResponse.status == .done {
                    return true
                } else if rawResponse.status == .failed {
                    return false
                }
            }
        } catch {
            // Continue polling on error
        }

        try? await Task.sleep(nanoseconds: pollIntervalSeconds * 1_000_000_000)
    }

    return false // Timeout
}

Example Flow

Here’s a complete example of executing a cross-chain bridge:

do {
    // 1. Get user address
    let userAddress = try await portal.getAddress("eip155:1")

    // 2. Get a quote
    let quoteRequest = LifiQuoteRequest(
        fromChain: "eip155:1",
        toChain: "eip155:137",
        fromToken: "ETH",
        toToken: "USDC",
        fromAddress: userAddress,
        fromAmount: "1000000000000" // 0.000001 ETH in wei
    )

    let quoteResponse = try await portal.trading.lifi.getQuote(request: quoteRequest)

    guard let quote = quoteResponse.data?.rawResponse,
          let transactionRequest = quote.transactionRequest
    else {
        print("No quote available")
        return
    }

    // 3. Approve the fromToken if it's an ERC-20 (no-op for native assets)
    try await approveErc20IfNeeded(
        quote: quoteResponse,
        fromAmount: quoteRequest.fromAmount,
        fromChainId: quoteRequest.fromChain
    )

    // 4. Extract transaction parameters
    guard let txParams = transactionRequest.value as? [String: Any],
          let from = txParams["from"] as? String,
          let to = txParams["to"] as? String
    else {
        print("Invalid transaction parameters")
        return
    }

    let value = txParams["value"] as? String ?? "0x0"
    let data = txParams["data"] as? String ?? "0x"

    // 5. Sign and submit the transaction
    let ethTransaction = ETHTransactionParam(
        from: from,
        to: to,
        value: value,
        data: data
    )

    let sendResponse = try await portal.request(
        chainId: quoteRequest.fromChain,
        method: .eth_sendTransaction,
        params: [ethTransaction],
        options: RequestOptions(signatureApprovalMemo: "Bridge & swap via Li.Fi")
    )

    guard let txHash = sendResponse.result as? String else {
        print("Failed to submit transaction")
        return
    }

    print("Transaction submitted: \(txHash)")

    // 6. Track status for cross-chain completion
    let completed = await pollForCompletion(
        txHash: txHash,
        fromChain: quoteRequest.fromChain
    )

    if completed {
        print("Bridge completed successfully!")
    } else {
        print("Bridge failed or timed out")
    }
} catch {
    print("Error: \(error)")
}

Best Practices

Compare quotes/routes before signing and submitting the transaction(s) to find the best option for your use case
Process steps sequentially for multi-step routes, ensuring each step completes before starting the next
Handle network errors gracefully and provide user feedback
Monitor transaction status for cross-chain transfers, as they may take longer than single-chain transactions
Validate user balances before initiating swaps or bridges

Supported Networks

Portal’s Li.Fi integration supports the following mainnet networks:

Monad (eip155:143)
Ethereum (eip155:1)
Optimism (eip155:10)
BSC (eip155:56)
Gnosis (eip155:100)
Unichain (eip155:130)
Polygon (eip155:137)
Sonic (eip155:146)
Mantle (eip155:5000)
Base (eip155:8453)
Arbitrum (eip155:42161)
Celo (eip155:42220)
Avalanche (eip155:43114)
Linea (eip155:59144)
Berachain (eip155:80094)
Katana (eip155:747474)
Solana (solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp)
Bitcoin (bip122:000000000019d6689c085ae165831e93-p2wpkh)

For the complete list of networks Li.Fi supports across its ecosystem, refer to the Li.Fi documentation. If you need a chain that isn’t listed above, contact Portal support.

Testnets are not supported.

Getting Started

SDKs

APIs

Integrations

Resources

Bridge & Swap with Li.Fi

Overview

Prerequisites

High-Level Methods

tradeAsset

Signature

Example (progress reporting)

Example (minimal)

Errors

Progress lifecycle

pollStatus

pollStatus options

Low-level methods

Getting a Quote

Finding Routes

Getting Route Step Details

Executing Swaps and Bridges

Approving ERC-20 Tokens

Signing and Submitting Transactions

Processing Multiple Route Steps

Waiting for Transaction Confirmation

Tracking Transaction Status

Polling for Cross-Chain Completion

Example Flow

Best Practices

Supported Networks

Next Steps

​Overview

​Prerequisites

​High-Level Methods

​tradeAsset

​Signature

​Example (progress reporting)

​Example (minimal)

​Errors

​Progress lifecycle

​pollStatus

​pollStatus options

​Low-level methods

​Getting a Quote

​Finding Routes

​Getting Route Step Details

​Executing Swaps and Bridges

​Approving ERC-20 Tokens

​Signing and Submitting Transactions

​Processing Multiple Route Steps

​Waiting for Transaction Confirmation

​Tracking Transaction Status

​Polling for Cross-Chain Completion

​Example Flow

​Best Practices

​Supported Networks

​Next Steps

Overview

Prerequisites

High-Level Methods

tradeAsset

Signature

Example (progress reporting)

Example (minimal)

Errors

Progress lifecycle

pollStatus

pollStatus options

Low-level methods

Getting a Quote

Finding Routes

Getting Route Step Details

Executing Swaps and Bridges

Approving ERC-20 Tokens

Signing and Submitting Transactions

Processing Multiple Route Steps

Waiting for Transaction Confirmation

Tracking Transaction Status

Polling for Cross-Chain Completion

Example Flow

Best Practices

Supported Networks

Next Steps