Particle Network Docs - Chain Abstraction & Universal Accounts

Universal Accounts take a fundamentally different approach to chain agnostic UX. Instead of requiring developers to manage intents, quotes, or execution steps, everything is abstracted at the account level—one account, one balance, automatic routing. This page compares Universal Accounts with three popular alternatives: Relay, OneBalance, and Avail Nexus.

At a Glance

Universal Accounts

Account-level abstractionOne account and one balance across chain. Cross-chain transactions, multi-token gas payments, and routing are always on by default.

Avail Nexus

Intent-based interoperabilityCoordinates cross-chain execution from user-defined intents.

Relay

Execution-level abstractionOrchestrate cross-chain execution via quotes, steps, signatures, and status tracking.

OneBalance

Account abstraction + aggregationManage smart contract accounts with unified balances, requiring explicit quote requests.

Feature Comparison

vs Relay
vs OneBalance
vs Avail Nexus

Feature	Universal Accounts	Relay
Abstraction layer	Account	Execution / bridging
Unified balance	✅ Aggregated Assets	✅ Aggregated Assets
One address across chains	✅ EVM + Solana	⚠️ EVM - Solana supported but with additional account configuration
Cross-chain txs	✅ Same API as single-chain	⚠️ Quote + steps
Gas abstraction	✅ Automatic	⚠️ Via quote / sponsorship
Pay gas in any token	✅ Automatic	✅ Automatic
Liquidity routing	✅ Fully automatic	⚠️ Explicit via quote
Bridging logic	✅ Hidden	⚠️ Needs configuration
7702 Delegation	✅ Server-side and WaaS	⚠️ For specific use cases
Setup required	Low	High configuration workload

Feature	Universal Accounts	OneBalance
Abstraction layer	Account	Account
Unified balance	✅ Aggregated assets	✅ Aggregated assets
One address across chains	✅ EVM + Solana	⚠️ Based on account type
Cross-chain txs	✅ Same API as single-chain	⚠️ Quote + sign + execute
Gas abstraction	✅ Automatic	✅ Automatic
Pay gas in any token	✅ Default	✅ Default
Liquidity routing	✅ Automatic	✅ Automatic
Bridging logic	✅ Hidden	⚠️ Exposed via operations
7702 Delegation	✅ Server-side and WaaS	⚠️ With multi-input limitation
Setup required	Low	Moderate

Feature	Universal Accounts	Avail Nexus
Abstraction layer	Account	Intent
Unified balance	✅ Aggregated assets	✅ Aggregated assets
One address across chains	✅ EVM + Solana	⚠️ Provider-based, no Solana
Cross-chain txs	✅ Same API as single-chain	⚠️ Intent creation + submission
Gas abstraction	✅ Automatic	✅ Automatic
Pay gas in any token	✅ Default	✅ Default but fewer assets available
Liquidity routing	✅ Fully automatic	✅ Via solvers
Bridging logic	✅ Hidden	⚠️ Explicit via configuration
Environment support	✅ Browser + server	⚠️ Browser only
7702 Delegation	✅ Server-side and WaaS	Not needed
Setup required	Low	Moderate

Speed Comparison

Real-world latency measurements across common cross-chain routes:

Route	Universal Accounts	Relay	OneBalance	Avail Nexus
Base → Arbitrum	~1,605 ms	~2,528 ms	~2,982 ms	~11899 ms
Base → Solana	~578 ms	~3,360 ms	~2,803 ms	N/A
Solana → Base	~1,348 ms	~9,820 ms	~2,803 ms	N/A

Universal Accounts achieve faster execution through a single abstracted flow, while alternatives require multiple API calls (quote → sign → execute → poll).

Integration Effort

Compare the integration complexity across all providers:

import { CHAIN_ID, SUPPORTED_TOKEN_TYPE, UniversalAccount } from '@particle-network/universal-account-sdk';
import { getBytes, Wallet } from 'ethers';

const wallet = new Wallet(process.env.PRIVATE_KEY || '');
const universalAccount = new UniversalAccount({
    projectId: process.env.PROJECT_ID || '',
    projectClientKey: process.env.PROJECT_CLIENT_KEY || '',
    projectAppUuid: process.env.PROJECT_APP_UUID || '',
    ownerAddress: wallet.address,
});

// Create and send a cross-chain transaction
const transaction = await universalAccount.createConvertTransaction({
    expectToken: { type: SUPPORTED_TOKEN_TYPE.USDC, amount: '1' },
    chainId: CHAIN_ID.ARBITRUM_MAINNET_ONE,
});

const result = await universalAccount.sendTransaction(
    transaction,
    wallet.signMessageSync(getBytes(transaction.rootHash))
);

import { config } from 'dotenv';
import { Wallet, ethers } from 'ethers';
import { createClient, getClient, MAINNET_RELAY_API } from '@relayprotocol/relay-sdk';

config();

(async () => {
    const privateKey = process.env.PRIVATE_KEY_BASE || '';
    const walletAddress = process.env.WALLET_ADDRESS || '';

    // Create Relay SDK client
    createClient({
        baseApiUrl: MAINNET_RELAY_API,
        source: "universal-account-benchmark"
    });

    // Create ethers wallet
    const provider = new ethers.JsonRpcProvider('https://mainnet.base.org');
    const ethersWallet = new Wallet(privateKey, provider);

    const quote = await getClient()?.actions.getQuote({
        chainId: 8453, // Base
        toChainId: 42161, // Arbitrum
        currency: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
        toCurrency: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831', // USDC on Arbitrum
        amount: '100000', // $0.1 USDC (6 decimals)
        user: walletAddress,
        recipient: walletAddress,
        tradeType: 'EXACT_INPUT'
    });

    if (!quote) {
        console.error('Failed to get quote');
        return;
    }

    for (const step of quote.steps || []) {
        const item = step.items?.[0];
        if (step.kind === 'transaction' && item?.data) {
            const tx = await ethersWallet.sendTransaction({
                to: item.data.to,
                data: item.data.data,
                value: BigInt(item.data.value || '0')
            });
            
            await tx.wait();
            
            if (step.requestId) {
                console.log('explorer url', `https://relay.link/bridge/${step.requestId}`);
            }
        }
    }
})();

import { config } from 'dotenv';
import { privateKeyToAccount } from 'viem/accounts';
import { parseUnits } from 'viem';
import { entryPoint07Address, getUserOperationHash } from 'viem/account-abstraction';

config();

(async () => {
    const API_KEY = process.env.ONEBALANCE_API_KEY!;
    const privateKey = process.env.PRIVATE_KEY_BASE as `0x${string}`;
    const signer = privateKeyToAccount(privateKey);

    // Predict account address
    const predictResponse = await fetch('<https://be.onebalance.io/api/account/predict-address>', {
        method: 'POST',
        headers: { 'x-api-key': API_KEY, 'Content-Type': 'application/json' },
        body: JSON.stringify({
            type: 'kernel-v3.1-ecdsa',
            signerAddress: signer.address,
        })
    });
    const { predictedAddress } = await predictResponse.json() as { predictedAddress: string };

    // Get quote for USDC → ETH swap
    const quoteResponse = await fetch('<https://be.onebalance.io/api/v3/quote>', {
        method: 'POST',
        headers: { 'x-api-key': API_KEY, 'Content-Type': 'application/json' },
        body: JSON.stringify({
            from: {
                accounts: [{
                    type: 'kernel-v3.1-ecdsa',
                    signerAddress: signer.address,
                    accountAddress: predictedAddress,
                }],
                asset: { assetId: 'ob:usdc' },
                amount: parseUnits('0.5', 6).toString(),
            },
            to: {
                asset: { assetId: 'ob:eth' },
            },
        })
    });
    const quote = await quoteResponse.json() as any;

    // Sign operation (Kernel v3.1 requires signing UserOp hash)
    const operation = quote.originChainsOperations[0];
    const userOp = {
        sender: operation.userOp.sender,
        nonce: BigInt(operation.userOp.nonce),
        factory: operation.userOp.factory,
        factoryData: operation.userOp.factoryData,
        callData: operation.userOp.callData,
        callGasLimit: BigInt(operation.userOp.callGasLimit),
        verificationGasLimit: BigInt(operation.userOp.verificationGasLimit),
        preVerificationGas: BigInt(operation.userOp.preVerificationGas),
        maxFeePerGas: BigInt(operation.userOp.maxFeePerGas),
        maxPriorityFeePerGas: BigInt(operation.userOp.maxPriorityFeePerGas),
        paymaster: operation.userOp.paymaster,
        paymasterVerificationGasLimit: operation.userOp.paymasterVerificationGasLimit
            ? BigInt(operation.userOp.paymasterVerificationGasLimit) : undefined,
        paymasterPostOpGasLimit: operation.userOp.paymasterPostOpGasLimit
            ? BigInt(operation.userOp.paymasterPostOpGasLimit) : undefined,
        paymasterData: operation.userOp.paymasterData,
        signature: operation.userOp.signature,
    };
    const userOpHash = getUserOperationHash({
        userOperation: userOp,
        entryPointAddress: entryPoint07Address,
        entryPointVersion: '0.7',
        chainId: Number(operation.typedDataToSign.domain.chainId),
    });
    const signature = await signer.signMessage({ message: { raw: userOpHash } });
    quote.originChainsOperations[0].userOp.signature = signature;

    // Execute swap
    const executeResponse = await fetch('<https://be.onebalance.io/api/v3/quote/execute-quote>', {
        method: 'POST',
        headers: { 'x-api-key': API_KEY, 'Content-Type': 'application/json' },
        body: JSON.stringify(quote)
    });
    const result = await executeResponse.json() as any;
})();

import { NexusSDK, NEXUS_EVENTS } from '@avail-project/nexus-core';

// Initialize SDK
const sdk = new NexusSDK({ network: 'mainnet' });
await sdk.initialize(provider); // Your EVM-compatible wallet provider

// ---------------------------
// 1️⃣ Get unified balances
// ---------------------------
const balances = await sdk.getUnifiedBalances(false); // false = CA balances only
console.log('Balances:', balances);

// ---------------------------
// 2️⃣ Bridge tokens
// ---------------------------
const bridgeResult = await sdk.bridge(
  {
    token: 'USDC',
    amount: 1_500_000n,
    recipient: '0x...' // Optional
    toChainId: 137, // Polygon
  },
  {
    onEvent: (event) => {
      if (event.name === NEXUS_EVENTS.STEPS_LIST) console.log('Bridge steps:', event.args);
      if (event.name === NEXUS_EVENTS.STEP_COMPLETE) console.log('Step completed:', event.args);
    },
  },
);

Summary

Choose Universal Accounts if you want...

Zero configuration for chain agnostic UX
Fastest execution times
EVM + Solana support
Server-side compatibility
Simplest integration (2 API calls)

Consider alternatives if you need...

Relay: Fine-grained control over bridging steps
OneBalance: Bridging driven by resource locks
Avail Nexus: Intent-based transaction construction & execution

Ready to integrate?

Get started with Universal Accounts in minutes →

OVERVIEW

SDK Reference

Comparison with Alternatives

At a Glance

Universal Accounts

Avail Nexus

Relay

OneBalance

Feature Comparison

Speed Comparison

Integration Effort

Summary

Choose Universal Accounts if you want...

Consider alternatives if you need...

Ready to integrate?

​At a Glance

Universal Accounts

Avail Nexus

Relay

OneBalance

​Feature Comparison

​Speed Comparison

​Integration Effort

​Summary

Choose Universal Accounts if you want...

Consider alternatives if you need...

Ready to integrate?

At a Glance

Feature Comparison

Speed Comparison

Integration Effort

Summary