Ethereum (Base) — Trading

The Market and token functions you call to quote, buy, sell, and claim payouts on Base.

Everything you need to trade lives on two contracts: Market (quotes + buy/sell) and the RWA token itself (ERC-20 balance/approve + payouts). The functions below are the trader-facing subset — admin/governance functions are intentionally omitted.

​

Market — quotes & trading

interface IMarket {
    struct AssetConfig {
        address token;          // ERC20 RWA token
        address vault;          // Vault holding payment tokens
        uint256 price;          // Price in cents per 1 token (PRICE_PRECISION = 100)
        uint256 feeBps;         // Fee in basis points (100 = 1%)
        bool    isActive;       // Whether trading is enabled
        uint256 lastUpdated;    // Timestamp of last price update
        uint8   tokenDecimals;  // Cached token decimals
    }

    // ---- Discover & read ----
    function getRegisteredTokens() external view returns (address[] memory);
    function isAssetTradeable(address token) external view returns (bool);   // registered && active
    function getAsset(address token) external view returns (AssetConfig memory);

    // ---- Quote (call before trading) ----
    function calculateBuyCost(address token, uint256 amount)
        external view returns (uint256 baseCost, uint256 fee, uint256 totalCost);
    function calculateSellPayout(address token, uint256 amount)
        external view returns (uint256 grossPayout, uint256 fee, uint256 netPayout);

    // ---- Trade ----
    function buy(address token, uint256 amount, uint256 maxCost) external;    // maxCost = slippage guard
    function sell(address token, uint256 amount, uint256 minPayout) external; // minPayout = slippage guard
}

​

RWA token — balances, approvals & terms

The token is a standard ERC-20 (18 decimals) plus a few reads for the asset terms.

There are no coupon payments. Yield accrues into the Market price instead — see How yield accrues. hasPeriodicPayouts() still exists on the contract and returns payoutFrequency != NONE, but no payment happens on any schedule; treat it as a descriptive label, not as behaviour. The former calculatePayout() and claimPayout() functions have been removed.

interface IRWAToken {
    // ---- ERC-20 ----
    function decimals() external view returns (uint8);            // 18
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);

    // ---- Asset info ----
    function payoutToken() external view returns (address);       // settlement currency
    function hasMaturity() external view returns (bool);
    function maturityDate() external view returns (uint256);      // 0 if none
    function paused() external view returns (bool);               // trading/transfers paused?

    // ---- Yield ----
    // Yield is carried by the Market price, not by this token. There is nothing to claim.
    function interestRateBps() external view returns (uint256);   // declared rate; restated on a reset
                                                                  // (the Market's rate is what accrues)
    function redeemPrincipal() external returns (uint256);        // after maturity, self-service
}

payoutToken() also tells you which ERC-20 you’ll spend when buying and receive when selling — it’s the asset’s settlement currency.

​

Buying

1. Quote the cost with calculateBuyCost(token, amount).
2. Approve the payment token to the Market for at least totalCost.
3. Buy with a maxCost guard.

// ethers v6 — amount is in token base units (18 decimals)
const amount = 100n * 10n ** 18n; // 100 tokens

const [ , , totalCost] = await market.calculateBuyCost(token, amount);
const maxCost = totalCost + totalCost / 100n; // allow 1% slippage

const payToken = await rwaToken.payoutToken();
const pay = new ethers.Contract(payToken, erc20Abi, signer);
await (await pay.approve(marketAddress, maxCost)).wait();

await (await market.buy(token, amount, maxCost)).wait();

​

Selling

1. Quote the proceeds with calculateSellPayout(token, amount).
2. Approve the RWA token to the Market for amount.
3. Sell with a minPayout guard.

const amount = 100n * 10n ** 18n;

const [ , , netPayout] = await market.calculateSellPayout(token, amount);
const minPayout = netPayout - netPayout / 100n; // allow 1% slippage

await (await rwaToken.approve(marketAddress, amount)).wait();

await (await market.sell(token, amount, minPayout)).wait();

​

How yield accrues

Your balance never changes, and nothing is ever pushed to you. Interest is carried by the asset’s price on the Market, which rises every second at the contractual rate:

price(t) = checkpointPrice x (1 + rateBps / 10000 x elapsed / 365 days)

So a holding is worth balance x price, and that figure grows continuously without any transaction. Accrual stops at maturity — a matured note does not keep earning.

Read the value with the Market, not the token:

// What the asset is worth per whole token, in hundredths of its payoutToken.
const price = await market.currentPrice(token);

// What you would ACTUALLY receive for `amount`, net of fees. Prefer this for display:
// it is exact, whereas currentPrice() is rounded to whole hundredths.
const [gross, fee, net] = await market.calculateSellPayout(token, amount);

currentPrice() is rounded down to whole hundredths of the payout token. On a low-priced asset that figure can sit unchanged for weeks while the value genuinely accrues — a 1.00 note at 16.5% takes about 22 days to move by one hundredth. The underlying accrual is carried at far finer precision and is paid in full; only this display value is rounded. Use calculateSellPayout when the number matters.

There are two ways to realise the accrued value:

1. Sell on the Market at any time, at the accreted price less the asset’s fee.
2. Redeem at maturity, if the asset has one.

​

Redemption at maturity

Redemption is self-service — you must call it yourself. Nothing is pushed to you automatically. It pays principal plus all accrued interest in one transfer, gross, with no fee charged at maturity:

if (await rwaToken.hasMaturity()) {
  const maturity = await rwaToken.maturityDate();       // unix seconds
  if (BigInt(Math.floor(Date.now() / 1000)) > maturity) {
    await (await rwaToken.redeemPrincipal()).wait();     // burns your balance, pays out
  }
}

redeemPrincipal() returns 0 and does nothing if the asset has no maturity — funds and equity are perpetual, so for those, selling on the Market is the only exit.

Separately, the issuer may wind an asset down before maturity. That path burns every holder and pays out at a single snapshot price; you do not need to call anything for it, and trading is halted when it begins.