ERC-5725 — Transferable Vesting NFT

Back to Token Standards

ERC-5725: Transferable Vesting NFT

ERC-5725 represents a vesting schedule as an NFT. Each token owns a schedule of underlying-token releases (linear, cliff, custom curves); the NFT holder calls claim(tokenId) to withdraw vested tokens to themselves. The NFT is transferable — selling the vesting NFT transfers the future-claim rights to the buyer. Used for:

• Employee compensation — RSU-style vesting with secondary-sale liquidity.
• VC token vesting — investor allocations as tradeable NFTs.
• DAO contributor grants — vesting grants tradeable in treasury / market.
• Fundraising mechanics — bonding-curve vesting NFTs released over time.

The standard is token-agnostic — the underlying token can be any ERC-20 (or NEP-17 on Neo). Each NFT specifies its own asset, schedule, and start/end times.

Required Interface

interface IERC5725 {
    event PayoutClaimed(uint256 indexed tokenId, address indexed recipient, uint256 claimAmount);

    function claim(uint256 tokenId) external;

    function vestedPayout(uint256 tokenId)        external view returns (uint256);
    function vestedPayoutAtTime(uint256 tokenId, uint256 timestamp) external view returns (uint256);
    function vestingPayout(uint256 tokenId)       external view returns (uint256);  // remaining to vest
    function claimablePayout(uint256 tokenId)     external view returns (uint256);  // vested - claimed
    function payoutClaimed(uint256 tokenId)       external view returns (uint256);

    function vestingPeriod(uint256 tokenId) external view returns (uint256 startTime, uint256 endTime);
    function payoutToken(uint256 tokenId)   external view returns (address);
}

The vesting curve is implementation-specific (the spec doesn't mandate linear); typical implementations expose a constructor / mint function that sets the curve parameters per token.

Neo Equivalent: NEP-11 + Per-Token Vesting Schedule + Claim Flow

public static void Claim(ByteString tokenId)
{
    var owner = OwnerOf(tokenId);
    if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");

    var claimable = ClaimablePayout(tokenId);
    if (claimable == 0) return;

    var token = PayoutToken(tokenId);
    var newClaimed = PayoutClaimed(tokenId) + claimable;
    Storage.Put(Storage.CurrentContext, ClaimedKey(tokenId), newClaimed);

    // Push underlying tokens to holder.
    Contract.Call(token, "transfer", CallFlags.All,
        new object[] { Runtime.ExecutingScriptHash, owner, claimable, null });
    OnPayoutClaimed(tokenId, owner, claimable);
}

public static BigInteger VestedPayoutAtTime(ByteString tokenId, BigInteger timestamp)
{
    var (start, end) = VestingPeriod(tokenId);
    var totalAllocation = TotalAllocation(tokenId);

    if (timestamp <= start) return 0;
    if (timestamp >= end)   return totalAllocation;

    // Linear vesting; replace with cliff / custom curve as needed.
    return (totalAllocation * (timestamp - start)) / (end - start);
}

public static BigInteger ClaimablePayout(ByteString tokenId)
    => VestedPayoutAtTime(tokenId, Runtime.Time) - PayoutClaimed(tokenId);

ERC-5725 (Ethereum)	Neo Equivalent	Notes
claim(tokenId)	Claim(tokenId) owner-witness-checked	Pulls vested tokens to holder
vestedPayoutAtTime(tokenId, t)	VestedPayoutAtTime(tokenId, timestamp)	Curve-specific
claimablePayout(tokenId)	ClaimablePayout(tokenId) = VestedPayoutAtTime(now) - PayoutClaimed	Direct port
vestingPeriod(tokenId)	VestingPeriod(tokenId) returning (start, end)
payoutToken(tokenId)	PayoutToken(tokenId) returning NEP-17 contract hash
Per-token underlying-asset support	(tokenId → token, totalAllocation, start, end, claimed)	Storage layout

Composition

• ERC-7540 — async vault. Vesting NFTs feed vested tokens into staking / vault flows.
• ERC-7066 — lockable. Lock the NFT during a governance / dispute period.
• ERC-2981 — royalties. Secondary-market sales of vesting NFTs may pay royalty to the original issuer.
• ERC-3475 + ERC-7092 — bonds. Vesting NFTs are often bond-like; reuse the bond mirror patterns for issuer-side accounting.

Migration Notes

For Solidity vesting protocols porting:

1. Storage layout: per-tokenId (token, allocation, start, end, claimed) tuple stored serialised.
2. Vesting curve: linear is the default; cliff = 0 vesting before cliffEnd then linear; custom curves via per-token parameters.
3. Claim flow: pulls underlying tokens from the vesting contract's balance to the NFT holder.
4. Pre-deposit the underlying tokens to the vesting contract before minting NFTs; otherwise claims revert.

The Neo port has the advantage that NEP-17 transfers inside the claim function are atomic with the storage update — no risk of state inconsistency between the claim record and the underlying-token movement.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract ERC5725 {
    struct Vest {
        address token;
        uint256 totalAllocation;
        uint256 start;
        uint256 end;
        uint256 claimed;
    }
    mapping(uint256 => Vest) public vests;

    event PayoutClaimed(uint256 indexed tokenId, address indexed recipient, uint256 claimAmount);

    function claim(uint256 tokenId) external {
        // ... owner check ...
        Vest storage v = vests[tokenId];
        uint256 claimable = vestedPayoutAtTime(tokenId, block.timestamp) - v.claimed;
        if (claimable == 0) return;
        v.claimed += claimable;
        IERC20(v.token).transfer(msg.sender, claimable);
        emit PayoutClaimed(tokenId, msg.sender, claimable);
    }

    function vestedPayoutAtTime(uint256 tokenId, uint256 timestamp) public view returns (uint256) {
        Vest memory v = vests[tokenId];
        if (timestamp <= v.start) return 0;
        if (timestamp >= v.end)   return v.totalAllocation;
        return (v.totalAllocation * (timestamp - v.start)) / (v.end - v.start);
    }

    function claimablePayout(uint256 tokenId) external view returns (uint256) {
        return vestedPayoutAtTime(tokenId, block.timestamp) - vests[tokenId].claimed;
    }
}

interface IERC20 { function transfer(address to, uint256 amount) external returns (bool); }

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

[DisplayName("VestingNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class VestingNFT : Nep11Token<TokenState>
{
    public override string Symbol => "VEST";

    private const byte Prefix_Vest    = 0xA0;
    private const byte Prefix_Claimed = 0xA1;

    [DisplayName("PayoutClaimed")]
    public static event Action<ByteString, UInt160, BigInteger> OnPayoutClaimed;

    public static void MintVesting(UInt160 to, ByteString tokenId, UInt160 token,
                                   BigInteger totalAllocation, BigInteger start, BigInteger end)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("NEP11:NotAdmin");
        var vest = new Map<string, object>
        {
            ["token"]           = token,
            ["totalAllocation"] = totalAllocation,
            ["start"]           = start,
            ["end"]             = end,
        };
        Storage.Put(Storage.CurrentContext, VestKey(tokenId), StdLib.Serialize(vest));
        Mint(tokenId, new TokenState { Owner = to });  // NEP-11 base: Mint(tokenId, TokenState)
    }

    public static void Claim(ByteString tokenId)
    {
        var owner = OwnerOf(tokenId);
        if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NotOwner");

        var claimable = ClaimablePayout(tokenId);
        if (claimable == 0) return;

        var newClaimed = PayoutClaimed(tokenId) + claimable;
        Storage.Put(Storage.CurrentContext, ClaimedKey(tokenId), newClaimed);

        var token = PayoutToken(tokenId);
        Contract.Call(token, "transfer", CallFlags.All,
            new object[] { Runtime.ExecutingScriptHash, owner, claimable, null });
        OnPayoutClaimed(tokenId, owner, claimable);
    }

    public static BigInteger VestedPayoutAtTime(ByteString tokenId, BigInteger timestamp)
    {
        var vest = LoadVest(tokenId);
        var start = (BigInteger)vest["start"];
        var end   = (BigInteger)vest["end"];
        var alloc = (BigInteger)vest["totalAllocation"];

        if (timestamp <= start) return 0;
        if (timestamp >= end)   return alloc;
        return (alloc * (timestamp - start)) / (end - start);
    }

    public static BigInteger ClaimablePayout(ByteString tokenId)
        => VestedPayoutAtTime(tokenId, Runtime.Time) - PayoutClaimed(tokenId);

    public static BigInteger PayoutClaimed(ByteString tokenId)
        => (BigInteger)(Storage.Get(Storage.CurrentContext, ClaimedKey(tokenId)) ?? ByteString.Empty);

    public static UInt160 PayoutToken(ByteString tokenId)
        => (UInt160)LoadVest(tokenId)["token"];

    public static (BigInteger, BigInteger) VestingPeriod(ByteString tokenId)
    {
        var vest = LoadVest(tokenId);
        return ((BigInteger)vest["start"], (BigInteger)vest["end"]);
    }

    private static Map<string, object> LoadVest(ByteString tokenId)
        => (Map<string, object>)StdLib.Deserialize((ByteString)Storage.Get(Storage.CurrentContext, VestKey(tokenId)));

    public static BigInteger TotalAllocation(ByteString tokenId)
        => (BigInteger)LoadVest(tokenId)["totalAllocation"];

    private static byte[] VestKey(ByteString tokenId)    => new byte[] { Prefix_Vest    }.Concat(tokenId);
    private static byte[] ClaimedKey(ByteString tokenId) => new byte[] { Prefix_Claimed }.Concat(tokenId);
    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}

Liquidity Note

The transferability is the key feature: an employee with vesting can sell to a secondary buyer who'll claim the remaining tokens. Without ERC-5725, vesting is illiquid (tied to the original wallet); with it, the vesting becomes a tradeable asset whose discount-to-face reflects the time-value-of-money + counterparty trust.