Comparison with Alternatives

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);
    },
  },
);