How Arcfolio works

Arcfolio lets anyone on Arc buy and hold listed US stocks as tokens, with USDC. You send USDC to the ArcfolioHub, the hub records an order, and within seconds you receive NVDA.afol (or any other listed STOCK.afol) in the same wallet, on the same chain.

Each STOCK.afol is matched one to one by tokenized stock held in the ReserveVault on Arc. You never bridge, never open a brokerage account and never switch networks: the cross-chain work happens underneath, and both sides of the match are public state you can read.

• Listed today: NVDA.afol, TSLA.afol, AAPL.afol, AMZN.afol, META.afol, GOOGL.afol, SPY.afol, QQQ.afol.
• Quote asset: USDC, the native gas asset on Arc (18 decimals as msg.value).
• Fees: 0.25% on buys, 0.25% on sells, accrued in the hub.
• Exit: sell back to the hub any time, or trade STOCK.afol on FolioSwap.

Stablecoin chains made dollars programmable. Equities are the next asset people want in the same wallet, but tokenized stocks today live on the chain where they were issued. Arcfolio is the equity layer for Arc: one hub that makes every listed stock a native Arc token.

Once a stock is an Arc token it composes with everything else on Arc. That is why the protocol ships with a stock layer from day one: a constant-product AMM, a lending market that accepts STOCK.afol as collateral, fully collateralised index baskets, and a launch pool that prices a token in shares instead of dollars.

The aim is boring infrastructure: predictable fills, a reserve anyone can audit in two calls, and a sell path that cannot be switched off.

Five components, one chain. Everything, from your order to the stock that backs it, lives on Arc.

1. 1WalletUSDC on Arc
2. 2ArcfolioHuborder logged · Arc
3. 3Operatorwatches the hub
4. 4Venuebuys the stock · Arc
5. 5ReserveVaultholds and counts · Arc
6. 6STOCK.afolminted to wallet · Arc

On Arc

• ArcfolioHub takes orders, escrows funds, mints and burns STOCK.afol on fill, and accounts fees.
• STOCK.afol tokens are standard ERC-20s (18 decimals). Only the hub can mint or burn.
• ArcfolioOracle publishes the venue price per underlying; used for quotes, FolioLend and min-out checks.

Custody and execution

• ReserveVault holds the tokenized stock and records the entitlement: how much STOCK.afol is allowed to circulate.
• Execution venue is where the operator buys and sells the stock token for each order.

Operator

An off-chain service that watches OrderRequested, buys or sells the tokenized stock at the venue, updates the vault, then settles the order in the hub. It can only settle at or better than the order’s minimum.

1. Call requestBuy(underlying, minSharesOut) with USDC as msg.value. No approval is needed because USDC is native.
2. The hub takes the fee, escrows the rest and emits OrderRequested.
3. The operator buys the tokenized stock at the execution venue and deposits it in the ReserveVault, raising the entitlement.
4. The operator calls fill on Arc. The hub checks amountOut ≥ minSharesOut, mints STOCK.afol to you and emits OrderFilled.

Typical fill time is a few seconds. If an order is not filled within 30 minutes, you can cancel it and receive your full USDC back, fee included.

hub.requestBuy{ value: 1000e18 }(NVDA, 4.5e18); // 1,000 USDC, at least 4.5 NVDA.afol

requestSell(underlying, sharesIn, minUsdcOut) moves your STOCK.afol into escrow (approve the hub first). The operator sells the same amount of stock token from the vault, the entitlement drops, the hub burns the escrowed STOCK.afol and sends you USDC.

• Never pausable. There is no admin switch on requestSell or cancel.
• Cancel after 30 minutes. cancel(id) returns escrowed USDC or STOCK.afol to the order owner. Only the owner can call it.
• Min out is enforced on-chain. A fill below your minimum reverts.

The invariant is simple: for every stock, reserve ≥ entitlement = totalSupply(STOCK.afol). Reserve is the stock token balance of the vault; entitlement is what the vault has recorded as circulating on Arc; supply is read from the token on Arc.

The reserves page and GET /api/v1/reserves read all three every few seconds. You can do the same with any RPC client:

cast call $VAULT "backingOf(address)(uint256,uint256)" $NVDA --rpc-url https://rpc.mainnet.arc.io
cast call $NVDA_AFOL "totalSupply()(uint256)" --rpc-url https://rpc.mainnet.arc.io

If the numbers ever disagree beyond in-flight orders, the site shows the row in red and the backing figure drops below 100%.

Orders fill at the execution venue price at the moment the operator trades, minus the fee. The ArcfolioOracle on Arc publishes the venue price per underlying (priceOf(address), 18-decimal USDC per share). Quotes use it to estimate output, and FolioLend uses it to value collateral.

Your protection is the minimum you set, not the oracle. The app and the API default to 0.5% slippage; you can choose 1% or 2%, or pass any slippageBps to the quote endpoint.

Tokenized stocks can trade outside US market hours. Prices outside the session can move more, and fills may take longer when venue liquidity is thin.

A constant-product (x·y = k) pool per listed stock, pairing STOCK.afol with native USDC. Pools are created by FolioSwapFactory and found with poolOf(stockToken).

• swapExactUsdcForStock(minOut) payable, and swapExactStockForUsdc(amountIn, minOut).
• Pool fee is read from feeBps() and stays in the pool for liquidity providers.
• Swaps are instant and do not wait for the operator; the hub is the path that changes supply.

An isolated market that lends USDC against STOCK.afol collateral, valued at the oracle price.

• Suppliers call supply() with USDC and earn the borrow rate (aprBps()).
• Borrowers deposit collateral with depositCollateral(token, amount), then borrow(amount) up to ltvBps() of collateral value.
• Liquidation opens when debt reaches liquidationBps() of collateral value. The app shows LTV used against that line.
• repay() is payable; withdrawAllCollateral(token) works once debt is zero.

Fully collateralised baskets of STOCK.afol. Each index token is backed by fixed units of its components, readable with components().

• Arcfolio AI Index (AFAI): NVDA.afol, META.afol, GOOGL.afol.
• Arcfolio Nasdaq Basket (AF50): QQQ.afol, AAPL.afol, AMZN.afol.

mint(amount) pulls the component units from your wallet (approve each first); redeemAll() burns your index tokens and returns the components. Redemption is always available.

A launch pool pairs a new token with NVDA.afol instead of a stablecoin, so the token is priced in NVIDIA shares. Buy with buyWithStock(stockIn, minTokenOut) after approving NVDA.afol; sell with sellForStock(tokenIn, minStockOut). $AFOL is the first token launched this way.

$AFOL is the Arcfolio token on Arc mainnet. The contract address is published through the chip at the top of every page; it updates live on open tabs within a second of being set, and that chip is the only official source.

$AFOL does not back STOCK.afol and is not needed to buy, sell or redeem. Treat any address that does not match the chip as unofficial.

• Protocol fee: 0.25% on buys (taken from USDC in) and 0.25% on sells (taken from USDC out).
• Integrator fee: registered integrators add their tier on top, read with integratorFeeBps(address). The total is capped at 1.00%.
• Preview: previewBuyFee(usdcIn, caller) returns the exact fee a deposit will pay.
• API keys are metered the same way. Nothing is billed during the MVP.

The read side is a JSON API at https://jellybelly.fun/api/v1 (OpenAPI at /api/v1/openapi.json): chains, stocks, prices, reserves, quote, orders, layer and keys. Anonymous calls get 60 requests a minute; an API key raises that to 600.

Every quote carries the raw hub call (contract, function, args, value), so any language can place the order. @arcfolio/sdk wraps both surfaces with viem. See the developers page for examples.

Your STOCK.afol is in your own wallet on Arc. The underlying tokenized stock is held by the ReserveVault contract on Arc, not by a person. The vault can only release stock tokens to the execution venue against a sell order and must reduce the entitlement by the same amount.

The tokenized stocks themselves are issued by their issuer and carry its terms and custody arrangements; Arcfolio inherits those. Arcfolio is not a broker and does not hold your USDC outside of escrow for an open order.

• Signatures: every user action is a standard secp256k1 transaction signed by your wallet. The site never sees keys.
• Operator authority: fills and vault updates are signed by the operator key; hub parameters can only be changed by the admin address listed in the reference below.
• Checksums: contract addresses are EIP-55 checksummed. The CA chip copies the full checksummed address, never a shortened one.
• Transport: the site, API and live CA stream are served over HTTPS; the CA is only accepted from the configured admin account.

Read this before putting money in. None of it is investment advice.

• Market risk. STOCK.afol moves with the stock. You can lose money.
• Smart-contract risk. Bugs in the hub, vault, tokens or stock layer could lose funds.
• Operator risk. If the operator stops, new orders do not fill. Cancel after 30 minutes returns your funds; existing STOCK.afol stays backed by the vault.
• Issuer and venue risk. Tokenized stocks depend on their issuer and the execution venue operating normally.
• Liquidation risk. Borrowing on FolioLend can be liquidated if the stock falls.
• Regulatory risk. Tokenized equities are not available everywhere. You are responsible for whether you may use them where you live.

Live addresses. Rows show “pending” until a contract is published. The product token row follows the live CA.

Chain

• Arc: chain id 5042, RPC https://rpc.mainnet.arc.io, explorer https://explorer.arc.io.

Interfaces

interface IArcfolioHub {
  event OrderRequested(uint256 indexed id, address indexed user, address indexed underlying, uint8 side, uint256 amountIn);
  event OrderFilled(uint256 indexed id, uint256 amountOut, uint256 fee);
  event OrderCancelled(uint256 indexed id);
  function requestBuy(address underlying, uint256 minSharesOut) external payable returns (uint256 id);
  function requestSell(address underlying, uint256 sharesIn, uint256 minUsdcOut) external returns (uint256 id);
  function cancel(uint256 id) external;              // after 30 minutes, order owner only
  function getOrder(uint256 id) external view returns (Order memory);
  function ordersOf(address user) external view returns (uint256[] memory);
  function pendingOrders() external view returns (uint256[] memory);
  function orderCount() external view returns (uint256);
  function supplyOf(address underlying) external view returns (uint256);
  function volumeOf(address underlying) external view returns (uint256);
  function allListings() external view returns (address[] memory underlyings, address[] memory tokens);
  function previewBuyFee(uint256 usdcIn, address caller) external view returns (uint256);
  function integratorFeeBps(address integrator) external view returns (uint16);
}
interface IReserveVault {
  function backingOf(address underlying) external view returns (uint256 reserve, uint256 entitlement);
}

Hub deployed: pending · Vault deployed: pending