> For the complete documentation index, see [llms.txt](https://docs.carv.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.carv.io/carv-ecosystem/verifier-nodes/how-do-verifier-nodes-work/carv-vecarv-token.md). # CARV/veCARV Token ## **CARV Token** 1. Implements the standard ERC20 (decimals: 18). 2. Mints 1 billion tokens to a specified address upon deployment; no further minting is possible afterward. ## **veCARV Token** 1. A non-transferable ERC20 token (decimals: 18), where standard addresses cannot invoke transfer or *transferFrom* methods. 2. Only the Vault contract can call transfer, used for distributing user verification rewards. 3. Locks the CARV Token address upon deployment, which cannot be modified thereafter. 4. No explicit minting method; veCARV can only be minted through 1:1 staking of CARV and is burned upon redemption. 5. Future governance of the CARV protocol will be enabled by associating the veCARV Token address with the governance contract. ### Function Definitions & Explanations Reference: ```Solidity interface IveCarv { /** * @notice This struct represents information about a Withdraw by the user. * * `withdrawer`: address of who initiates this Withdraw. * `canceledOrClaimed`: Has this Withdraw been canceled or claimed? * `amount`: The amount of Withdraw initiated by the user. * `timestamp`: The time this Withdraw was initiated. */ struct WithdrawInfo { address withdrawer; bool canceledOrClaimed; uint256 amount; uint256 timestamp; } event Deposit(address depositer, uint256 amount); event Withdraw(uint64 indexed id, address withdrawer, uint256 amount); event CancelWithdraw(uint64 indexed id); event Claim(uint64 id, uint256 amount); event ClaimBatch(uint64[] ids, uint256 amount); /** * @notice convert CARV to veCARV by locking CARV in this contract and minting veCARV to msg.sender. * @notice CARV can be converted to veCARV with 1:1 ratio through deposit. * @notice veCARV stands for voting-escrow CARV, is a non-transferable token. veCARV is mainly used for: * @notice 1. CARV Protocol governance. * @notice 2. Incentive to bootstrap incentive layer, e.g., data owners, providers, consumers. * @notice 3. Used for governance voting in P2E system 'Infinite Play'. * @notice 4. Used in P2E systems to delegate voting rights to escrow pool owners and receive pool rewards. * @notice 5. Incentivizes node operators who secure and support the network. * * @dev Emits `Deposit`. * * @param amount: amount of CARV to be deposited */ function deposit(uint256 amount) external; /** * @notice convert veCARV to CARV, veCARV conversion to CARV requires an unlocking period. * @notice The withdraw rate varies for different unlocking periods, * @notice with longer unlocking periods resulting in higher withdraw rates, reaching up to 100%. * @notice Users are required to pay a network channel fee of 1 CARV each time they initiate a Withdraw. * * @dev Emits `Withdraw`. * * @param amount: amount of veCARV to be withdrawn */ function withdraw(uint256 amount) external; /** * @notice Cancel the Withdraw by withdrawID. * @notice It can be canceled before the user claims. * @notice After the operation, the locking veCARV is returned to msg.sender. * * @dev Emits `CancelWithdraw`. * * @param withdrawID: The withdrawID that the user needs to cancel */ function cancelWithdraw(uint64 withdrawID) external; /** * @notice Return the CARV corresponding to the specified withdrawID to the user. * @notice The relationship between the user’s Locking Duration and claimable ratio is as follows: * ---------------------------------------------------- * | Locking Duration (Days) | Claims (CARV) | * | 15 | 25% | * | 90 | 60% | * | 150 | 100% | * ---------------------------------------------------- * @notice after that, Burn the locking veCARV corresponding to the specified withdrawID * @notice If the Locking Duration is less than 150 days, the remaining CARV will be: * @notice 1. 50% enter the CARV foundation to maintain network operation. * @notice 2. 50% will be burned, which makes CARV deflationary. * * @dev Emits `Claim`. * * @param withdrawID: The withdrawID that the user needs to claim CARV */ function claim(uint64 withdrawID) external; /** * @notice To claim CARV by withdrawIDs (Batch). * * @dev Emits `ClaimBatch`. * * @param withdrawIDs: The withdrawIDs that the user needs to claim CARV */ function claimBatch(uint64[] calldata withdrawIDs) external; } ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.carv.io/carv-ecosystem/verifier-nodes/how-do-verifier-nodes-work/carv-vecarv-token.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.