An vToken is issued whenever assets are supplied into a Vaultera market and is burnt again when those assets are withdrawn. Each vToken records how much of a crypto asset a user has placed with the protocol together with the yield that position has accrued. Because an vToken stays pegged to its matching supplied asset at a 1:1 ratio, it can be held, moved, or traded with confidence. Every bit of yield gathered by the vTokens' reserves flows straight to vToken holders, whose wallet balances rise continuously over time.

This contract is the implementation of the interest bearing token for the Vaultera Protocol. It inherits the ScaledBalanceTokenBase and EIP712Base token contracts.

Every standard EIP20 method is available on vTokens, including balanceOf , transfer , transferFrom , approve , totalSupply and so on.

balanceOf always reports the freshest balance held by a user, folding together both their principal balance and the yield that principal balance has produced.

The complete source code lives on the repo.

function initialize(    IPool initializingPool,    address treasury,    address underlyingAsset,    IVaulteraIncentivesController incentivesController,    uint8 aTokenDecimals,    string calldata aTokenName,    string calldata aTokenSymbol,    bytes calldata params) public virtual

Runs when a new vToken instance is initialized.

function mint(    address caller,    address onBehalfOf,    uint256 amount,    uint256 index) external virtual override onlyPool returns (bool)

Issues amount vTokens to user .

function burn(    address from,    address receiverOfUnderlying,    uint256 amount,    uint256 index) external virtual override onlyPool

Burns vTokens from user and transfers the matching amount of underlying to receiverOfUnderlying .

In certain cases, the mint event may fire during a burn transaction when the amount to burn is smaller than the interest the user has accrued.

function mintToTreasury(uint256 amount, uint256 index) external override onlyPool

Issues vTokens into the reserve treasury.

function transferOnLiquidation(    address from,    address to,    uint256 value) virtual override onlyPool

Moves vTokens whenever a borrow position is liquidated, provided the liquidator opts to claim the vToken.

function transferUnderlyingTo(address target, uint256 amount) external virtual override onlyPool

Sends the underlying asset across to target .

Run by the Pool to shift funds through borrow(), withdraw() and flashLoan().

function handleRepayment(address user, address onBehalfOf, uint256 amount) external virtual override onlyPool

Deals with the underlying that lands in the vToken once the transfer step has fully settled.

By default this hook does nothing, since for ordinary ERC20 tokens no follow-up work is required once the transfer wraps up. Down the line, though, certain vTokens might let holders stake the underlying to collect LM rewards. In a design like that, handleRepayment() would carry out the staking of the underlying asset on the holder's behalf.

function permit(    address owner,    address spender,    uint256 value,    uint256 deadline,    uint8 v,    bytes32 r,    bytes32 s) external override

Lets a holder authorize another account (or contract) to spend their funds by handing over a signed message. This unlocks gas-less flows and folds approval and transfer into a single call. Pass along a signed message to grant spending rights.

Implements permit in accordance with EIP-2612.

A sample flow for signing and calling permit:

import { signTypedData_v4 } from "eth-sig-util";import { fromRpcSig } from "ethereumjs-util";// ... other importsimport aTokenAbi from "./aTokenAbi.json";// ... setup your web3 providerconst aTokenAddress = "ATOKEN_ADDRESS";const aTokenContract = new web3.eth.Contract(aTokenAbi, aTokenAddress);const privateKey = "YOUR_PRIVATE_KEY_WITHOUT_0x";const chainId = 1;const owner = "OWNER_ADDRESS";const spender = "SPENDER_ADDRESS";const value = 100; // Amount the spender is permittedconst nonce = 1; // The next valid nonce, use `_nonces()`const deadline = 1600093162;const permitParams = {  types: {    EIP712Domain: [      { name: "name", type: "string" },      { name: "version", type: "string" },      { name: "chainId", type: "uint256" },      { name: "verifyingContract", type: "address" },    ],    Permit: [      { name: "owner", type: "address" },      { name: "spender", type: "address" },      { name: "value", type: "uint256" },      { name: "nonce", type: "uint256" },      { name: "deadline", type: "uint256" },    ],  },  primaryType: "Permit",  domain: {    name: "aTOKEN_NAME",    version: "1",    chainId: chainId,    verifyingContract: aTokenAddress,  },  message: {    owner,    spender,    value,    nonce,    deadline,  },};const signature = signTypedData_v4(Buffer.from(privateKey, "hex"), {  data: permitParams,});// The signature can now be used to execute the transactionconst { v, r, s } = fromRpcSig(signature);await aTokenContract.methods  .permit({    owner,    spender,    value,    deadline,    v,    r,    s,  })  .send()  .catch((e) => {    throw Error(`Error permitting: ${e.message}`);  });

function rescueTokens(    address token,    address to,    uint256 amount) external override onlyPoolAdmin

Recover and send out tokens that are stuck inside this contract. Only POOL_ADMIN.

function balanceOf(address user)    public    view    virtual    override(IncentivizedERC20, IERC20)    returns (uint256)

Gives the token balance held by user .

Overrides the parent method.

function totalSupply() public view virtual override(IncentivizedERC20, IERC20 returns (uint256)

Yields the current number of tokens minted.

Supersedes the base method.

function RESERVE_TREASURY_ADDRESS() external view override returns (address)

Provides the address of the Vaultera treasury, governed onchain, which collects the fees accrued by this vToken.

function UNDERLYING_ASSET_ADDRESS() external view override returns (address)

Provides the address of the underlying reserve asset backing this vToken (E.g. WETH for vWETH).

function DOMAIN_SEPARATOR() public view override(IAToken, EIP712Base) returns (bytes32)

Fetch the domain separator for this token on the active chain.

Returns the cached copy when chainId matches, otherwise recomputes the separator.

Supersedes the base method to fully satisfy IAToken.

function nonces(address owner) public view override(IAToken, EIP712Base) returns (uint256)

Provides the nonce value for the address passed as a parameter; this is the nonce consumed when calling permit() .

Supersedes the base method to completely implement IAToken.

Example:

const token = new Contract(aTokenAddress, vToken.abi, provider);await token.nonces(user);

function getRevision() internal pure virtual override returns (uint256)

Provides the revision number of the contract. Must be declared in the inheriting class as a constant.

Returns 0x1 .

RwaAToken is a purpose-built extension of the AToken contract tailored for Real-World Assets (RWAs). It tracks a user's supplied collateral within the Vaultera Horizon market. To satisfy regulatory obligations, RwaAToken instances remain non-transferable by default for end-users.

Core operations such as transfer , approve , and permit are switched off to block peer-to-peer movement of these tokens. The Vaultera Horizon market defines an ATOKEN_ADMIN_ROLE, which may be assigned to RWA issuers or their appointed managers to handle tasks such as wallet recovery or position migration. Any address holding this role can carry out authorized transfers on behalf of users, as described below.

function authorizedTransfer(address from, address to, uint256 amount) external returns (bool)

Moves a quantity of vTokens from one user to another. This function may only be invoked by the RWAaTokenManager address that holds the ATOKEN_ADMIN_ROLE to precisely oversee vToken-specific transfers. It is meant for administrative operations, such as relocating a user's position to a fresh wallet. Every transfer remains bound by the protocol's health factor checks.

function mint(    address caller,    address onBehalfOf,    uint256 amount,    uint256 index) public virtual returns (bool)

Mints amount vTokens to a user. This function overrides the standard mint so that the caller of the transaction must match the onBehalfOf address. In practice, this turns off the supplyOnBehalfOf functionality for RWAs.

function ATOKEN_ADMIN_ROLE() external pure returns (bytes32)

Provides the bytes32 identifier assigned to the ATOKEN_ADMIN_ROLE . This role lets an account call authorizedTransfer .

To preserve the non-transferable and compliant design of RWA collateral, the majority of standard ERC20 interactions are turned off for RwaAToken . Invoking any of the functions listed below will revert with an OPERATION_NOT_SUPPORTED error:

The StataTokenFactory serves as both a factory and a registry contract that oversees every deployed StataToken instance for a given Vaultera pool. It supports deploying fresh StataToken instances on demand and enforces that only a single StataToken instance exists per underlying asset. The contract keeps a mapping that links each underlying asset to its matching StataToken address.

StataTokens are ERC-4626 compliant wrappers around Vaultera's vTokens that deliver a non-rebasing mechanism for yield accrual.

You can access the source code on RepoHub.

function initialize() external initializer

Sets up the StataTokenFactory contract for use. This method follows the Initializable pattern and must be invoked to prepare the contract once it has been deployed onchain. In the present build, it intentionally executes no operations.

function createStataTokens(address[] memory underlyings) external returns (address[] memory)

Deploys fresh StataToken instances for the supplied underlying assets whenever they are not yet present. For every underlying asset passed in, the routine checks whether a matching StataToken already exists. When one is found, its existing StataToken address is returned. Otherwise, it deploys a new StataToken for that underlying asset, registers it, and returns the freshly created address.

function getStataTokens() external view returns (address[] memory)

Yields every StataToken instance deployed by this factory.

function getStataToken(address underlying) external view returns (address)

Provides the StataToken address for a specified underlying asset.

function POOL() external view returns (IPool)

Provides the onchain address of the Vaultera pool tied to this factory.

function PROXY_ADMIN() external view returns (address)

Provides the proxy admin address that governs the StataToken proxies.

function TRANSPARENT_PROXY_FACTORY() external view returns (ITransparentProxyFactory)

Exposes the transparent proxy factory address used to spin up new StataToken proxies.

function STATA_TOKEN_IMPL() external view returns (address)

Exposes the StataToken implementation address referenced whenever fresh StataToken instances are deployed.

Provides a variable debt token that records the borrowing positions held by users in variable rate mode.

Because variable debt tokens are non-transferable, the transfer and approve functionalities remain disabled.

Each vToken holds a 1:1 peg to the underlying borrowed asset and reflects the full amount currently owed to the protocol, namely principal debt + interest accrued.

The VariableDebtToken contract extends both the DebtTokenBase and ScaledBalanceTokenBase token contracts.

You can read the full source code our repo.

function initialize(    IPool initializingPool,    address underlyingAsset,    IVaulteraIncentivesController incentivesController,    uint8 debtTokenDecimals,    string memory debtTokenName,    string memory debtTokenSymbol,    bytes calldata params) external virtual

Runs when a variableDebtToken instance is initialised.

function mint(    address user,    address onBehalfOf,    uint256 amount,    uint256 index) external virtual override onlyPool returns (bool, uint256)

Issues the variable debt token to the onBehalfOf address.

function burn(    address from,    uint256 amount,    uint256 index) external virtual override onlyPool returns (uint256)

Removes user variable debt.

Occasionally a burn transaction emits a mint event whenever the amount to burn is smaller than the interest the user has accrued.

function UNDERLYING_ASSET_ADDRESS() external view override returns (address)

Provides the address of the underlying asset backing this variableDebtToken (e.g. WETH for variableDebtWETH)

function balanceOf(address account) public view virtual override returns (uint256)

Provides the number of tokens held by account - the fully up to date accrued debt (principal + interest) belonging to the user.

A standard ERC20 method.

function totalSupply() public view virtual override returns (uint256)

Reports how many tokens are currently outstanding — the freshest aggregate debt owed across every account in the protocol for that particular variable rate of debt token.

A standard ERC20 method.

function getRevision() internal pure virtual override returns (uint256)

Provides the revision identifier for this contract, which must be declared as a constant within the inheriting class.

Yields 0x1 .

Since it is not transferable by design, the variable debt token exposes none of the standard ERC20 functions for transfer and allowance .

Each of the methods listed here will revert with the error code 80, OPERATION_NOT_SUPPORTED : transfer , allowance , approve , transferFrom , increaseAllowance , decreaseAllowance .