Your First API Call

Before you can execute chain-abstracted operations with OneBalance, you need to set up a smart contract account (SCA). This smart contract account will hold your assets and enable gas abstraction across chains.

​

Predicting Your Account Address

Now that we’ve set up our project with proper CORS handling, let’s use the OneBalance API to predict a smart contract account (SCA) address based on Privy’s embedded wallet addresses:

First, create a component that will handle the account setup:

// src/components/AccountSetup.tsx
'use client';

// Example usage in a component
import { useEffect, useState } from 'react';
import { useWallets } from '@privy-io/react-auth';
import { predictAccountAddress } from '@/lib/onebalance';

export function AccountSetup() {
  const { wallets } = useWallets();
  const [accountAddress, setAccountAddress] = useState<string | null>(null);

  // Find the Privy-managed embedded wallet
  const embeddedWallet = wallets.find(wallet => wallet.walletClientType === 'privy');

  useEffect(() => {
    async function setupAccount() {
      if (embeddedWallet && embeddedWallet.address) {
        try {
          // Using the same address as both session and admin for simplicity
          const predictedAddress = await predictAccountAddress(
            embeddedWallet.address,
            embeddedWallet.address
          );
          setAccountAddress(predictedAddress);
          console.log(`Smart Contract Account Address: ${predictedAddress}`);
        } catch (err) {
          console.error('Error setting up account:', err);
        }
      }
    }

    setupAccount();
  }, [embeddedWallet]);

  return (
    <div>
      {accountAddress ? (
        <p>Your OneBalance Smart Account: {accountAddress}</p>
      ) : (
        <p>Loading account address...</p>
      )}
    </div>
  );
}

Next, create a dashboard page that will use this component:

// src/app/dashboard/page.tsx
import { AccountSetup } from '@/components/AccountSetup';

export default function Dashboard() {
  return (
    <main className="flex min-h-screen flex-col items-center justify-center p-24">
      <div className="max-w-md w-full bg-white p-8 rounded-xl shadow-md text-black">
        <h1 className="text-2xl font-bold mb-6">OneBalance Dashboard</h1>
        <AccountSetup />
      </div>
    </main>
  );
}

When a user logs in with Privy on the homepage, they’ll be redirected to this dashboard page where their predicted smart contract account address will be displayed. This is your first successful API call to OneBalance!

The predictAccountAddress function makes an API call to OneBalance’s /account/predict-address endpoint with the Privy wallet address as both the session and admin address. This deterministically calculates the smart contract account address that will be used for all your OneBalance operations.

​

Understanding Smart Contract Accounts (SCAs)

OneBalance uses smart contract accounts to enable key features like:

1. Gas Abstraction: Pay for transactions using any token in your balance, not just the chain’s native gas token
2. Resource Locks: Secure validation of transaction intents without requiring on-chain confirmations for every step
3. Fast Path: Near-instant transactions without waiting for block confirmations

Smart contract accounts are counterfactual, meaning they don’t need to be deployed until they’re actually used in a transaction. This saves gas costs and simplifies the user experience.

​

Checking Account Balances

Before performing operations, you’ll want to check if your account has sufficient funds. The OneBalance API allows you to fetch aggregated balances across all chains:

// Example of checking for USDC and ETH balances
import { getAggregatedBalance } from '@/lib/onebalance';
import { formatUnits } from 'viem';

async function checkBalances(accountAddress: string) {
  try {
    const balanceData = await getAggregatedBalance(accountAddress);

    // Find USDC in the balance data
    const usdcAsset = balanceData.balanceByAggregatedAsset.find(
      (asset: any) => asset.aggregatedAssetId === 'ds:usdc'
    );

    // Find ETH in the balance data
    const ethAsset = balanceData.balanceByAggregatedAsset.find(
      (asset: any) => asset.aggregatedAssetId === 'ds:eth'
    );

    if (usdcAsset) {
      // Format the balance (USDC has 6 decimals)
      const formattedBalance = parseFloat(formatUnits(BigInt(usdcAsset.balance), 6)).toFixed(2);
      console.log(`USDC Balance: ${formattedBalance} USDC`);
    }

    if (ethAsset) {
      // Format the balance (ETH has 18 decimals)
      const formattedBalance = parseFloat(formatUnits(BigInt(ethAsset.balance), 18)).toFixed(6);
      console.log(`ETH Balance: ${formattedBalance} ETH`);
    }
  } catch (err) {
    console.error('Error fetching balances:', err);
  }
}

This function fetches the aggregated balance for an account and formats the values correctly:

• USDC has 6 decimals, so we divide by 10^6
• ETH has 18 decimals, so we divide by 10^18

The balances shown represent the total amount available across all supported chains, providing users with a unified view of their assets.

Your dashboard will show aggregated balances across multiple chains as a single, unified total. For example, if you have 10 USDC on Ethereum, 5 USDC on Polygon, and 5 USDC on Arbitrum, your dashboard will display a total of 20 USDC. This multichain aggregation is a key benefit of using OneBalance, as it eliminates the need to track assets separately across different networks.

​

Funding Your Account

Before you can perform any operations with your smart contract account, you’ll need to fund it. Send tokens to the predictedAddress returned from the API. This is your SCA’s deposit address.

​

Next Steps

Now that you’ve learned how to set up a smart contract account and check balances, you’re ready to execute chain-abstracted operations. In the next section, we’ll use the predicted account address to create a quote for swapping tokens across chains, with no bridging required.