Oneliq Documentation

The engineering reference for the unified stablecoin terminal on Arc. Oneliq puts Circle's stablecoin stack - Gateway, CCTP V2, Programmable Wallets, USDC, EURC - behind a single non-custodial UI on the Arc Layer 1. This guide covers every live product surface, the on-chain contract registry, the proxy API, and the security baseline.

Introduction

Oneliq is a unified stablecoin platform that simplifies how people use USDC across chains. Built on Circle's infrastructure and designed for the Arc Layer 1, Oneliq brings trading, cross-chain balance management, automation, and onboarding into one seamless experience. Six surfaces, one balance, zero custody:

Who is this for?

• Stablecoin holders tired of fragmenting USDC into seven balances across seven chains.
• Multi-chain treasurers who want one place to see, move, and automate USDC across the Circle ecosystem.
• Arc-native traders swapping USDC ⇄ EURC inside the L1 with sub-second finality and predictable USD-denominated gas.
• Agent operators who want sign-once / run-forever USDC plumbing - auto top-ups, scheduled payouts - across any of 8 Circle-supported chains.
• Builders using Oneliq as a reference implementation for Circle Gateway, CCTP V2, App Kit Swap, and Programmable Wallets integrations.

Design principles

• Custody never leaves you. Oneliq holds no funds and has no admin path that can pause your access. Every state-changing call is signed by your wallet against a third-party contract.
• No build pipeline. The frontend is plain HTML/CSS/vanilla JS plus ethers.js v6 - every served byte is reviewable, every CDN script is SRI-pinned.
• Strict CSP, locked CDNs. Every page ships with a Content-Security-Policy. The only third-party origins reachable are the RPCs, the Circle endpoints we explicitly trust, and Cloudflare's own cookieless analytics beacon.
• Reads through proxies. Reads to Circle's Gateway and IRIS APIs route through Cloudflare Pages Functions to keep the browser's connect-src tight and to dodge CORS quirks.

Architecture

Oneliq is a thin frontend over Circle's stablecoin stack and the Arc Layer 1. We deploy exactly two small contracts on Arc - OneliqRouter (the swap fee router) and OneliqCheckIn (the daily check-in contract) - and neither can hold your balance. Everything that moves value is Circle's. What lives on our origin is static HTML, a few KB of shared JavaScript, a handful of stateless proxy routes, and two Cloudflare Workers.

# Oneliq layered architecture
┌─ UI Layer ────────────────────────────────────────────────────────────┐
│  index · trade · explore · balance · history · dashboard · docs       │
│   plain HTML + CSS + vanilla JS, no framework, no build step          │
└────────────────────────────────────────────────────────────────────────┘
                                  ↓
┌─ Shared JS modules (assets/) ─────────────────────────────────────────┐
│  arc-core-v2.js    → chain registry, token registry, ABIs, RPC      │
│  arc-gateway.js    → Circle Gateway client (deposit, transfer, mint)│
│  arc-appkit.js     → Circle App Kit wallet picker (EIP-6963)        │
│  arc-ui.js / .css  → shared UI atoms (modal, toast, skeleton, nav)  │
└────────────────────────────────────────────────────────────────────────┘
                                  ↓
┌─ Cloudflare Pages Functions (proxies, history, metrics) ──────────────┐
│  /api/circle-proxy/*   → CCTP V2 IRIS attestation API                 │
│  /api/gateway-proxy/*  → Circle Gateway public REST API               │
│  /api/history/*        → per-wallet Trade / Balance receipts          │
│  /api/recipients/*     → saved payees for Batch Pay                   │
│  /api/metrics/*        → aggregated read-only telemetry rollup        │
│  /auth/*               → Discord linking + wallet profile             │
└────────────────────────────────────────────────────────────────────────┘
                                  ↓
┌─ Cloudflare Workers (scheduled) ──────────────────────────────────────┐
│  kv-backup        → nightly KV snapshot of profiles and history        │
└────────────────────────────────────────────────────────────────────────┘
                                  ↓
┌─ External protocols (we don't operate any of these) ──────────────────┐
│  Arc L1                  → EVM execution + USDC native gas               │
│  Circle Gateway          → GatewayWallet / GatewayMinter + REST API      │
│  Circle CCTP V2          → TokenMessenger / MessageTransmitter + IRIS    │
│  Circle App Kit Swap     → same-chain USDC ⇄ EURC routing on Arc         │
└────────────────────────────────────────────────────────────────────────┘

What "non-custodial" means in practice

• Every state-changing user action is a transaction signed by your wallet - against Circle's Gateway or CCTP, against a Uniswap pool on Arc, or against one of our two published contracts.
• Oneliq has no privileged role on any Circle or Arc contract: no owner, no admin, no upgrade path.
• Of our own two, OneliqCheckIn is fully immutable - no owner, no admin, and it moves no funds. OneliqRouter does have an owner, deliberately limited to two things: changing the swap fee (hard-capped at 1% in the bytecode, currently 0.30%) and withdrawing the fees the router has collected. It cannot touch a user balance, because it only holds the USDC in flight inside the swap transaction itself. Read the verified source on the Arc explorer.
• The proxy routes (/api/*) only reformulate read requests to Circle's public APIs. They cannot move funds, sign messages, or hold custody.

Quick start

From a fresh browser to your first cross-chain USDC spend in five steps.

1. Install a wallet. MetaMask, Rabby, Coinbase Wallet, Frame, or any EIP-6963-compliant browser wallet. See Supported wallets.
2. Add Arc Mainnet. Open oneliq.xyz/trade, click Connect, and approve the network prompt. Manual params are in the Network info table below.
3. Get USDC onto Arc. Arc uses USDC as native gas, so the same balance pays fees and funds whatever you do with it. There is no faucet on mainnet - bring USDC in from a chain you already hold it on. See Get USDC on Arc.
4. Open Balance. Deposit USDC from any supported chain (Ethereum, Base, Avalanche, Arbitrum, OP, Polygon, Unichain) into the Gateway. Your unified balance updates in seconds.
5. Spend from Balance. Pick a destination chain and recipient. Multi-source unified spend pulls from N chains in one signature and mints native USDC on the destination. Trade is the surface for swapping and bridging instead.

Wallet setup

Oneliq uses EIP-6963 for wallet discovery - the multi-injector standard that replaced the old window.ethereum singleton. Any wallet that announces itself via eip6963:announceProvider appears in our wallet picker, ranked by RDNS so the choice is deterministic when multiple wallets are installed.

Once connected, the session is held entirely in browser memory. There is no auth cookie, no JWT, no session token issued by Oneliq.

Adding Arc Mainnet manually

If your wallet doesn't auto-prompt or you prefer to add the network by hand:

Get USDC on Arc

Arc uses USDC as the native gas token, so a single balance pays transaction fees and funds everything else - deposits, swaps, agent funding. Mainnet has no faucet: USDC has to come from a chain you already hold it on. Three routes, in the order most people want them:

1. Unified Balance (recommended). Open Balance, deposit USDC from any supported chain into Circle Gateway, then spend to Arc. The spend mints native USDC on Arc, which is exactly the balance that pays gas. This is the path that works even with an empty Arc wallet, because Gateway's forwarder can mint for you without you holding Arc gas first.
2. Trade (CCTP V2). Open Trade, pick a source chain and Arc as the destination. Burns on the source, attests, mints on Arc.
3. Circle's own bridge. bridge.usdc.com lists Arc as a destination if you would rather not use Oneliq for the first hop.

Trade

The /trade page is the spend surface. It unifies same-chain swap (any Arc pair via OneliqRouter into Uniswap) and cross-chain bridging (USDC anywhere via CCTP V2) into a single panel. Source picker shows your wallet balances plus your Circle Gateway pre-deposits, ranked so the path with the lowest friction floats to the top.

Same-chain swap (Arc internal)

Swaps that stay on Arc route through our own OneliqRouter contract, which forwards the trade into Uniswap - v4 through the Universal Router and Permit2, or v3 through SwapRouter02 - and takes a transparent 0.30% on-chain protocol fee, hard-capped at 1%. The quote comes from the Uniswap quoter for whichever version holds the deeper pool, and is debounced at 150 ms on the source-amount input. Explore lists every Arc pool the router can reach.

Cross-chain spend (CCTP V2)

1. Choose source chain and destination chain (any pair from the 8 supported).
2. Enter USDC amount and recipient address (defaults to your own).
3. Pick a finality mode - Fast (~20 s, small Circle fee) or Standard (13–19 min, zero fee).
4. Burn on source - calls TokenMessengerV2.depositForBurn(amount, destDomain, recipient, burnToken, ...).
5. Wait for Circle's IRIS attestation, then mint on destination - calls MessageTransmitterV2.receiveMessage(message, attestation). Oneliq submits the receive automatically when the attestation arrives.

Trade panel features

• Source picker. One dropdown - wallet on any chain or Circle Gateway pre-deposits - ranked by available balance.
• Slippage. Default 0.5%. Presets 0.1% / 0.5% / 1% / custom (hard cap 5%).
• Route box. Shows rate, price impact, network fee, min received, ETA.
• Resumability. A burn tx hash is the only thing needed to mint on the destination later. Close the tab mid-flight, return to /trade with the same wallet - the pending mint appears automatically.
• Park the output. When the swap or bridge lands plain USDC in your own wallet, the route offers an extra step that deposits it straight into your Unified Balance. It costs one more transaction and Circle needs finality before the funds count as spendable, so it saves a context switch rather than gas. Offered only when you are the recipient - deposit() credits the sender, so parking a third-party payment would credit the wrong person.
• Activity rail. Live tx ledger on the right - last 10 actions deep-linked to per-chain explorer.

Unified Balance

The /balance page is the centerpiece of Oneliq. It uses Circle Gateway V1 to give you a single USDC balance that's spendable on every supported chain - no bridge clicks, no chain switching, no wrapped tokens.

How it works

Each Gateway-supported chain has a GatewayWallet contract at the same deterministic address (CREATE2 with the same salt). You deposit USDC into the wallet on whichever chain you currently hold it. Circle's Gateway service issues attestations that authorize a fresh mint of native USDC on the destination chain - the USDC you spend is always native USDC, not a wrapped derivative.

Deposit flow

1. Select a source chain with a USDC balance (Ethereum, Base, Arbitrum, OP, Polygon, Avalanche, Unichain).
2. Approve the GatewayWallet to pull USDC (one-time per chain per token).
3. Deposit - your USDC moves from your wallet into the GatewayWallet contract on that chain.
4. Done. Your unified balance updates once the source chain finalises - quickest on Avalanche, slowest on Ethereum, which waits two beacon-chain epochs. Spendable everywhere Gateway is supported.

Spend flow (mint on Arc)

1. Submit an EIP-712 signed burn intent to Circle's Gateway service via POST /v1/transfer.
2. Gateway validates available balance across all your deposits, signs an attestation.
3. Your wallet calls GatewayMinter.gatewayMint(attestation, signature) on the destination chain.
4. Native USDC appears on the destination, ready to spend or hold.

Spend: three modes

The ↗ Spend modal lets you choose how the source funds are allocated. You enter a recipient, an amount, and a destination chain; the mode decides where the USDC comes from.

In every mode, a partial-liquidity route that spans several chains is still a single EIP-712 signature: one BurnIntentSet → one attestation → one mint on the destination. No popup-per-chain.

Estimate before you sign

Before the wallet popup, Oneliq shows the route, the per-intent fee, and the recipient outcome via ARC.gateway.estimateSpend(). Cost is visible up front. When a spend can't be fully covered, the UI names why - insufficient balance, no viable route, or needs aggregation across sources - instead of a generic error.

⇉ Batch Pay

Batch Pay sends USDC to many recipients from one Unified Balance. Each recipient has its own address, amount, and destination chain. Oneliq runs a non-overlapping allocation across your balances so no chain's funds are double-spent, then groups recipients by destination chain: one signature per destination. Recipients that all land on the same chain settle in a single signature; a payout spanning K destination chains becomes K signatures, one click each. Built for payroll, contributor payouts, or fanning funds out to a set of wallets.

Rows can be typed one at a time or pasted in bulk - address, amount, chain per line, with the chain column optional. Everyone you successfully pay is remembered in a recipient book stored against your wallet address, so the list follows you to another browser or device instead of living in one browser's storage.

⤵ Consolidate

Consolidate is the mirror of Batch Pay. It sweeps your entire spendable balance from every chain except a chosen destination onto that one chain, in a single signature, minting back to your own wallet. It reuses the Auto-spend engine with the recipient set to you. Chains whose balance is too small to clear their per-intent fee floor are skipped automatically (and listed in the preview) rather than failing the whole sweep. Use it to tidy dust across chains or stage liquidity where you need it next.

If you close the tab mid-transfer

A forwarded spend is recorded locally the moment it is submitted, together with the attestation needed to finish it. Reconnect the same wallet and Oneliq re-checks the transfer with Gateway: already minted, it just clears the record; still pending, it waits for the forwarder and falls back to a self-mint if that fails. Terminal outcomes (failed or expired) are cleared rather than retried forever.

Withdrawals

Withdrawals are two-step. You initiate a withdrawal on the source chain, which queues it through Gateway's safety delay. Then you finalize to receive USDC back in your wallet. The pending list shows everything in flight with countdown timers.

Direct deposits on Arc

Arc's USDC is the native gas token, which lives in the L1 ledger rather than in an ERC-20 wrapper. GatewayWallet.deposit relies on standard approve/transferFrom, which can only move ERC-20 balances, so direct deposits from Arc are disabled. To fund Arc, deposit from any other supported chain and let Gateway mint native USDC on Arc.

History

The /history page is your personal stablecoin operations explorer. Every transfer, swap and bridge renders as a clean receipt - title, source → destination chain tags, status pill, relative time, amount, tx hash linkable to the right chain explorer.

Tabs

• All - every event across both surfaces, newest first.
• Trade - same-chain swaps and bridge originations.
• Balance - deposits, withdrawals, multi-source unified spends.

Data sources

Trade and Balance events are recorded local-first in your browser's activity log (arc.trade.activity.v1) and also mirrored to /api/history/*, keyed by your wallet address, so the feed follows your wallet across browsers and devices. Agent events come from the backend endpoints which only return rows where you're the rule owner (server-side auth).

Dashboard

The /dashboard page is your portfolio home - a read-only aggregator over everything a connected wallet holds. It shows your profile (deterministic avatar + address), total portfolio value with 24h change, a Holdings table (USDC / EURC on Arc Mainnet, with live price and value), an allocation donut, your unified USDC balance across Gateway chains, and a recent-activity feed mirrored from History.

It's a pure aggregator - no Gateway writes happen on this page. Prices come from CoinGecko (USDC pinned to $1) and every card deep-links to Balance, Trade, or History.

Arc L1

Arc is a purpose-built Layer 1 blockchain optimized for stablecoin-denominated finance. Three defining design choices set it apart from a generic EVM chain:

• USDC-denominated gas. Transaction fees are paid in USDC, so costs are predictable in USD terms regardless of any token's price action.
• Sub-second deterministic finality. No reorgs, no probabilistic finality. Once a transaction is finalized, it cannot revert.
• Opt-in privacy. Confidential transfers and selective disclosure for regulated counterparties (not yet integrated by Oneliq).

Arc is fully EVM-compatible: existing Solidity contracts, Hardhat / Foundry / Viem / ethers tooling all work without modification. Reference docs at docs.arc.network.

Circle Gateway

Circle Gateway is the protocol that powers Unified Balance. It replaces "I bridged my USDC to chain X and now I have to bridge it back" with "my USDC is already everywhere I need it."

The two on-chain contracts

• GatewayWallet at 0x0077777d7EBA4688BDeF3E311b846F25870A19B9 on every Gateway chain. You deposit USDC into this contract; balances are held per-chain but indexed globally by the Gateway service.
• GatewayMinter at 0x0022222ABE238Cc2C7Bb1f21003F0a260052475B on every Gateway chain. Anyone with a valid Circle-signed attestation can call gatewayMint to materialize USDC on the destination chain.

Both addresses are deterministic across chains (CREATE2 deploy with the same salt), which is why Unified Balance can address every chain uniformly without a per-chain registry.

Gateway vs. CCTP - when to use which

CCTP V2

Cross-Chain Transfer Protocol V2 is Circle's official bridge for native USDC. Unlike lock-and-mint bridges (which create wrapped tokens backed by frozen liquidity), CCTP burns native USDC on the source chain and mints native USDC on the destination - every USDC stays "real USDC" all the way through.

Why this matters

• No wrapped USDC variants. No USDC.e, no axlUSDC, no synthetic IOU.
• No bridge TVL to drain - there's no pool of locked tokens for an attacker to target.
• Issuer-attested. Only Circle's signed attestation can authorize the destination mint.

Finality modes

• Fast (V2-only) - Circle's enhanced attestation pipeline issues the attestation ahead of full source-chain finality for supported pairs. Small Circle fee. Typical end-to-end: ~20 seconds.
• Standard - Circle waits for source-chain finality (two beacon epochs on Ethereum, instant on Arc). Zero fee. Typical: 13–19 minutes when Sepolia is the source.

USDC as native gas

Most chains use a volatile native token for gas (ETH, MATIC, AVAX). Arc uses USDC. The practical impact:

• Gas costs are predictable in USD terms - a transfer that costs $0.001 today costs $0.001 tomorrow, regardless of any token's price action.
• You don't need to maintain a "gas reserve" in a separate token. The same USDC you spend with pays for the transaction.
• Internally, native USDC has 18 decimals (to match standard EVM gas math), distinct from the canonical 6-decimal Circle USDC. The frontend handles the conversion at the burn/mint boundary using a cctpDecimals hint on the token registry.

Implementation note

Arc's USDC lives at 0x3600000000000000000000000000000000000000 as a precompile-style ledger token, not a deployed ERC-20. Standard balanceOf/transfer/ approve all work, but the token cannot be deposited via transferFrom to any contract that wasn't designed for native gas - which is why Gateway deposits originate from other chains.

Network info - Arc Mainnet

Arc Testnet (chain ID 5042002, rpc.testnet.arc.network, CCTP domain 26) is still reachable for rehearsal, with USDC from faucet.circle.com. Mainnet is the default everywhere in the app.

Supported chains

Oneliq surfaces eight mainnets - Arc as the home chain plus seven external chains for Unified Balance and CCTP bridging.

Contract addresses

All contracts Oneliq interacts with on Arc Mainnet (chain ID 5042). Every address below is readable on explorer.arc.io.

Tokens

USDC appears twice on purpose. The balance that pays gas is the L1 native ledger with 18 decimals; 0x3600…0000 is its ERC-20 face, and CCTP moves it in 6-decimal units. Oneliq converts between the two at every boundary rather than assuming one of them.

Circle Gateway V1

Same deterministic addresses on every Gateway-supported mainnet.

Circle CCTP V2

Same addresses on every CCTP V2 mainnet.

OneliqRouter (Oneliq swap router → Uniswap on Arc)

Used by Trade, Explore and the Agent for swaps that stay on Arc. It wraps Uniswap and takes a transparent 0.30% on-chain protocol fee, hard-capped at 1% in the bytecode. Verified at deploy: feeBps() reads 30 and paused() reads false on chain.

The live router carries two paths: swap() goes to Uniswap v4 through the Universal Router and Permit2, and swapV3() goes to Uniswap v3 through SwapRouter02 directly - Arc's Universal Router v3 handler reverts with SliceOutOfBounds on every input shape, so v3 pairs are routed around it. It measures the pool's actual output by balance delta instead of trusting the number the pool reports, keeps a fee ledger a withdrawal can never exceed, and carries a deadline, a reentrancy guard, a pause switch and two-step ownership. The earlier v4-only deployment stays on chain so its swaps remain verifiable, but nothing routes to it.

Uniswap on Arc

Uniswap's official Arc deployment. Oneliq quotes against these and routes through them; it operates none of them.

OneliqCheckIn (check-in contract)

Immutable, no owner and no upgrade path. Counts days in UTC, which is why the streak logic in the app does the same.

Arc-native

Oneliq deploys exactly two contracts - OneliqRouter and OneliqCheckIn - and both are published and verified. Neither can hold your balance: the router forwards a swap within a single transaction, and the check-in contract moves no funds at all. Every other contract above is operated by Circle or the Arc Foundation.

API endpoints

Oneliq exposes a handful of Cloudflare Pages Functions. Two are read-only proxies to Circle's public APIs; the others are the minimal backend the app needs (rule storage, cron triggers, execution log). None hold private keys, none custody funds.

/api/circle-proxy/*

Proxies Circle's IRIS attestation API for CCTP. Used by the Trade module to poll for attestations after a burn transaction.

# Fetch attestation by burn message hash
GET /api/circle-proxy/v2/messages/{sourceDomain}?transactionHash={txHash}
   ↓ proxies to https://iris-api-sandbox.circle.com https://iris-api.circle.com/v2/messages/...

/api/gateway-proxy/*

Proxies Circle's Gateway public REST API. Used by Unified Balance to fetch balances and submit signed transfer intents.

# Read multi-chain balance
POST /api/gateway-proxy/v1/balances
     # body: { token, sources: [{ domain, depositor }] }

# Submit a signed burn-intent for cross-chain spend
POST /api/gateway-proxy/v1/transfer
     # body: signed EIP-712 BurnIntent

/api/history/* and /api/recipients/*

Per-wallet storage, keyed by address and capped in size: the receipt feed behind History, and the recipient book behind Batch Pay. Both exist so the data follows your wallet across browsers instead of being trapped in one browser's local storage. Neither can move funds.

/auth/*

Discord account linking for the wallet profile - the Connect Discord option in the Profile menu and the profile record it writes. Identity only: it holds no funds and has no signing authority.

/api/metrics/*

Read-only telemetry rollup used by status.oneliq.xyz. Compute-on-write so a single /summary call doesn't trigger 273× KV reads. Headline counters are re-derived from Arc itself - router swaps and check-in totals read straight off-chain - rather than trusted from our own store.

Supported wallets

Any browser wallet announcing itself via EIP-6963 appears in the picker. Tested with:

• MetaMask - most common, widest compat.
• Rabby - recommended for active DeFi users (better tx simulation, native multi-chain UX).
• Coinbase Wallet - extension or injected.
• Frame - desktop-native, hardware-wallet friendly.
• Ledger / Trezor - through MetaMask, Rabby, or Frame.
• Brave Wallet - works via the standard injected provider.

Mobile wallets via WalletConnect / Reown AppKit are on the near-term roadmap (see Changelog).

Tech stack

Deliberately minimal. Every choice was made to maximize auditability and minimize attack surface.

Why no framework?

• Auditability. Every line shipped to your browser is in the repo as written, not generated by a bundler. You can diff the served HTML against the GitHub source byte-for-byte.
• SRI integrity. The only third-party script (ethers.js) is pinned by SHA-384. Any tamper at the CDN fails to load instead of executing.
• Performance. No runtime, no hydration. The Balance page is interactive in < 200 ms after first byte.
• Footprint. No node_modules, no supply-chain blast radius from npm install, no dependency CVEs.

Security

Oneliq takes a defense-in-depth approach. Highlights:

• Non-custodial. No user funds ever flow through Oneliq-controlled addresses. Permits you explicitly signed.
• Open source. The entire frontend is published. Verify the served build matches the committed source.
• Strict CSP. A Content-Security-Policy header constrains script, style, image, font, and connect origins per page. There is no 'unsafe-eval'.
• SRI on every CDN script. ethers.js (and any other CDN asset) carries a SHA-384 integrity hash; CDN tampering fails closed.
• Host security headers. HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy - all set via Cloudflare Pages _headers.
• Cookieless analytics, nothing else. We run Cloudflare Web Analytics, which sets no cookie, writes nothing to your browser's storage, and builds no cross-site profile. It reports aggregate page views, referrer, country, and load timing. There are no marketing pixels, no ad networks, and no fingerprinting scripts. Apart from that beacon, every third-party origin reachable from a page is a chain RPC or a Circle API explicitly allowlisted in the CSP.
• Pre-flight checks. Every deploy runs scripts/preflight-check.sh - six gates covering CSP, SRI, link hygiene (rel=noopener), hardcoded secrets, .env leakage, and host headers.
• Internal surfaces are gated. The operator console sits behind credentials that fail closed - if the secret is unset the page returns an error rather than opening. Source, config, and internal files are 404'd at the edge even if a deploy uploads them by accident.

Found a vulnerability? Report it via SECURITY.md. There is no funded bug-bounty program today; a valid report gets triage and a fix, credit in the Hall of Fame, and a discretionary thank-you in proportion to impact. Coordinated disclosure expected.

FAQ

When should I use Unified Balance vs. Trade (CCTP)?

Use Unified Balance when you want USDC ready to spend on multiple chains over time. Deposit once, spend many times - latency at spend is in the seconds. Use the Trade cross-chain mode (CCTP V2) for a one-shot move from chain A to chain B where you don't need to pre-fund.

Why is my CCTP bridge taking 13 minutes?

You're on Standard finality. Circle waits for source-chain finality before issuing the attestation - sub-second on Arc, but ~13 min on Ethereum (two beacon-chain epochs). Switch to Fast finality for supported pairs to bring this down to ~20s for a small fee.

Does Oneliq have its own token?

No. Oneliq is a frontend, not a protocol. There is no ASWP token, no airdrop campaign, no governance token sale. Anyone telling you otherwise is running a scam.

When mainnet?

Arc mainnet is governed by the Arc Foundation; Oneliq deploys on mainnet shortly after Arc launches. See the homepage roadmap for current milestones.

Why don't you use a bigger frontend framework?

We optimized for auditability and minimum supply-chain risk. See Tech stack.

Changelog

v0.11.x - Live on Arc Mainnet

• 2026-10-03 - These docs move to mainnet. Network info, the supported-chain table and the whole contract registry now carry Arc Mainnet values; the faucet walkthrough is replaced by the three real ways to get USDC onto Arc. The swap section is rewritten for Uniswap: the mainnet OneliqRouter wraps v4 through the Universal Router and v3 through SwapRouter02, not the Curve pool the testnet build used.
• 2026-10-02 - Explore joins the sidebar above Trade, listing every Arc pool with live price, 1H/1D change, FDV and volume, and a per-token detail page with an on-chain chart and inline swap.
• 2026-09-20 - OneliqRouter redeployed on Arc Mainnet with a dedicated v3 path, so v3-only pairs collect the same 0.30% fee as v4 pairs. The v4-only deployment stays on chain and unused.
• 2026-09-16 - Arc Mainnet. Chain ID 5042 becomes the default network across the app; OneliqCheckIn deployed for Portal.
• 2026-08-10 - Surfaces that talk to each other. Trade can park a swap output straight into the Unified Balance; Batch Pay gains bulk paste and a per-wallet recipient book, and splits past Circle's 16-intent cap instead of refusing; the agent now reads your unified balance in its pre-flight.
• 2026-08-10 - Light theme across every page with a sun/moon switch, plus a new Oneliq wordmark for both themes.
• 2026-08-09 - Balance power-ups. ⇉ Batch Pay (pay N recipients, grouped by destination, one signature per chain) and ⤵ Consolidate (sweep every chain onto one in a single signature). Spend gains a Manual mode alongside Auto and Single, plus estimate-before-sign and three explicit partial-liquidity states.
• 2026-08-09 - Oneliq AI. The agent grows a chat layer: describe a rule in plain language, the assistant prefills the config, you sign. Powered by Cloudflare Workers AI.
• 2026-08-04 - Dashboard live - read-only portfolio view of everything your wallet holds on Arc, priced from CoinGecko.
• 2026-06-18 - Gasless mint default-on. Cross-chain spends route the destination mint through Circle's Forwarding Service, so recipients receive USDC without holding gas first.
• 2026-05-20 - Docs rewrite. Dropped Vault / Pools / Points sections (no longer being built). Added Trade, Agent, History, Create Token, Dashboard reference pages. Updated contract registry - USYC removed, App Kit fallback noted on the Uniswap V2 entry.
• 2026-05-18 - Trade declutter - removed App Kit ready pill, Gateway hint pill, Liquidity card. Quote latency cut via 150ms debounce + SDK prefetch.
• 2026-05-15 - Balance polish - circular chain logos, Unichain added to the chain registry, CCTP-domain subtext dropped.
• 2026-05-12 - History page launched. Receipt-feed aesthetic across Trade / Balance / Agent activity, segmented tabs, deep-link to chain explorer.
• 2026-05-08 - Agent v0.9 - auto-pause after 5 consecutive failures; admin diagnostic endpoint for failure log; Cloudflare cron rollout.
• 2026-05-04 - Real Unified Balance with multi-source spend; wallet picker (EIP-6963 + RDNS-based ranking).
• 2026-04-25 - Security baseline: CSP, SRI, host headers, vulnerability disclosure policy, pre-flight check script.
• 2026-04-20 - Initial homepage launch.

Upcoming

• Balance / Trade / Explore - UX deepening - continued polish across the live surfaces. Intent / approval / revoke flows, quote & route polish.
• WalletConnect / Reown AppKit - mobile wallet support.
• Circle Wallets onboarding - non-crypto-native users land directly on a Programmable Wallet.
• StableFX - RFQ-driven USDC ⇄ EURC ⇄ USDP PvP settlement via the Arc FxEscrow contract.
• Mainnet - shipping shortly after Arc Foundation launches Arc L1 mainnet.