Ethereum (Base) — 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
}

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
}

// 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();

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();

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

// 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);

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
  }
}