ERC-5006 — Rental NFT, NFT User Extension

Back to Token Standards

ERC-5006: Rental for ERC-1155 Multi-Tokens

ERC-5006 is the ERC-4907 shape ported to ERC-1155: every (tokenId, user) pairing has a separate rental record with its own amount and expiry. Where ERC-4907 grants a single user the user-role of a single ERC-721, ERC-5006 lets a tokenId be split across multiple renters with different expiries. Used by:

• Game guilds lending out fractions of a multi-asset NFT (e.g. 100 weapons of type X across 50 scholars).
• Mass NFT rentals (concert tickets, conference badges issued as ERC-1155 batches).
• Gaming-asset DEXs that rent fractional ownership of high-value multi-tokens.

Required Interface

interface IERC5006 {
    struct UserRecord {
        uint256 tokenId;
        address owner;
        uint64  amount;
        address user;
        uint64  expiry;
    }

    event CreateUserRecord(uint256 recordId, uint256 tokenId, uint64 amount,
                           address owner, address user, uint64 expiry);
    event DeleteUserRecord(uint256 recordId);

    function usableBalanceOf(address user, uint256 tokenId) external view returns (uint256);
    function frozenBalanceOf(address owner, uint256 tokenId) external view returns (uint256);
    function userRecordOf(uint256 recordId) external view returns (UserRecord memory);

    function createUserRecord(address owner, address user, uint256 tokenId, uint64 amount, uint64 expiry)
        external returns (uint256 recordId);
    function deleteUserRecord(uint256 recordId) external;
}

Multiple UserRecords per (owner, tokenId, user) are allowed — each records a separate rental tranche. The owner's balance is frozen while rented (can't transfer the rented portion); the user's usable balance is the sum across non-expired records.

Neo Equivalent: NEP-11 (Divisible) + Per-record Storage

NEP-11 divisible tokens have multi-balance semantics that map to the ERC-1155 shape; ERC-5006 adds rental records on top. The Neo port stores records keyed by an auto-incrementing recordId, plus indices for fast lookup by (user, tokenId) and (owner, tokenId).

public static BigInteger UsableBalanceOf(UInt160 user, ByteString tokenId)
{
    var iter = Storage.Find(Storage.CurrentContext, RecordsByUserPrefix(user, tokenId), FindOptions.RemovePrefix);
    BigInteger sum = 0;
    while (iter.Next())
    {
        var rec = (Map<string, object>)StdLib.Deserialize((ByteString)iter.Value);
        if ((BigInteger)rec["expiry"] >= Runtime.Time)
            sum += (BigInteger)rec["amount"];
    }
    return sum;
}

ERC-5006 (Ethereum)	Neo Equivalent	Notes
createUserRecord(owner, user, tokenId, amount, expiry)	CreateUserRecord(...) returning new recordId	Witness-checked against owner
deleteUserRecord(recordId)	DeleteUserRecord(recordId)	Owner or user can delete (per spec)
usableBalanceOf(user, tokenId)	UsableBalanceOf(user, tokenId) summing non-expired records	Iterator over the user index
frozenBalanceOf(owner, tokenId)	FrozenBalanceOf(owner, tokenId) summing owner-side rentals
userRecordOf(recordId)	UserRecordOf(recordId) returning the stored record	Direct read

Pairs With

• ERC-4907 — single-user ERC-721 rentals. ERC-5006 extends to multi-token / multi-user.
• ERC-6551 — token-bound accounts. A renter could control the tokenId's TBA during the rental window (delegate authorization to the user via the rental record).
• ERC-2981 — NFT royalties. Royalty splits during rentals: configurable split between owner and renter.
• ERC-6982 — default lockable. Locking the owner's rented portion is the natural enforcement mechanism.

Migration Notes

The Neo port is straightforward:

1. Inherit Nep11Token divisible base.
2. Add the records storage (auto-incrementing recordId + records map).
3. Add user/owner indices for fast lookup.
4. Override the divisible Transfer to honour the frozen-balance constraint.

For game-guild operators porting Solidity ERC-5006 contracts, the record / index pattern is identical; the only Neo-specific idiom is using Runtime.CheckWitness for the owner-on-create and owner-or-user-on-delete authorization.

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

contract ERC5006 {
    struct UserRecord {
        uint256 tokenId;
        address owner;
        uint64  amount;
        address user;
        uint64  expiry;
    }

    uint256 private _nextId = 1;
    mapping(uint256 => UserRecord) public userRecord;

    event CreateUserRecord(uint256 recordId, uint256 tokenId, uint64 amount,
                           address owner, address user, uint64 expiry);
    event DeleteUserRecord(uint256 recordId);

    function createUserRecord(address owner, address user, uint256 tokenId, uint64 amount, uint64 expiry)
        external returns (uint256 recordId)
    {
        require(msg.sender == owner, "owner only");
        require(expiry > block.timestamp, "expiry in past");
        recordId = _nextId++;
        userRecord[recordId] = UserRecord(tokenId, owner, amount, user, expiry);
        emit CreateUserRecord(recordId, tokenId, amount, owner, user, expiry);
    }

    function deleteUserRecord(uint256 recordId) external {
        UserRecord memory r = userRecord[recordId];
        require(msg.sender == r.owner || msg.sender == r.user, "no auth");
        delete userRecord[recordId];
        emit DeleteUserRecord(recordId);
    }

    function usableBalanceOf(address user, uint256 tokenId) external view returns (uint256) {
        // Linear scan over records — production code uses indexed storage.
        return 0;  // simplified
    }
}

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("Rental5006")]
[ContractPermission("*", "*")]
public class Rental5006 : SmartContract
{
    private const byte Prefix_NextId       = 0x01;
    private const byte Prefix_Record       = 0x10;
    private const byte Prefix_RecordByUser = 0x11;  // (user, tokenId, recordId) -> 1
    private const byte Prefix_FrozenByOwn  = 0x12;  // (owner, tokenId, recordId) -> 1

    [DisplayName("CreateUserRecord")]
    public static event Action<BigInteger, ByteString, BigInteger, UInt160, UInt160, BigInteger> OnCreate;
    [DisplayName("DeleteUserRecord")]
    public static event Action<BigInteger> OnDelete;

    public static BigInteger CreateUserRecord(
        UInt160 owner, UInt160 user, ByteString tokenId,
        BigInteger amount, BigInteger expiry)
    {
        if (!Runtime.CheckWitness(owner)) throw new Exception("NEP11:NoAuth");
        if (expiry <= Runtime.Time)       throw new Exception("NEP11:ExpiryInPast");

        var ctx = Storage.CurrentContext;
        var nextKey = new byte[] { Prefix_NextId };
        var recordId = (BigInteger)(Storage.Get(ctx, nextKey) ?? ByteString.Empty) + 1;
        Storage.Put(ctx, nextKey, recordId);

        var rec = new Map<string, object>
        {
            ["tokenId"] = tokenId,
            ["owner"]   = owner,
            ["amount"]  = amount,
            ["user"]    = user,
            ["expiry"]  = expiry,
        };
        Storage.Put(ctx, RecordKey(recordId), StdLib.Serialize(rec));
        Storage.Put(ctx, UserIndexKey(user, tokenId, recordId),  1);
        Storage.Put(ctx, OwnerIndexKey(owner, tokenId, recordId), 1);
        OnCreate(recordId, tokenId, amount, owner, user, expiry);
        return recordId;
    }

    public static void DeleteUserRecord(BigInteger recordId)
    {
        var ctx = Storage.CurrentContext;
        var rec = (Map<string, object>)StdLib.Deserialize((ByteString)Storage.Get(ctx, RecordKey(recordId)));
        if (rec is null) throw new Exception("NEP11:NoRecord");

        var owner = (UInt160)rec["owner"];
        var user  = (UInt160)rec["user"];
        if (!Runtime.CheckWitness(owner) && !Runtime.CheckWitness(user))
            throw new Exception("NEP11:NoAuth");

        Storage.Delete(ctx, RecordKey(recordId));
        Storage.Delete(ctx, UserIndexKey(user,   (ByteString)rec["tokenId"], recordId));
        Storage.Delete(ctx, OwnerIndexKey(owner, (ByteString)rec["tokenId"], recordId));
        OnDelete(recordId);
    }

    public static BigInteger UsableBalanceOf(UInt160 user, ByteString tokenId)
    {
        var ctx = Storage.CurrentContext;
        var iter = Storage.Find(ctx, UserIndexPrefix(user, tokenId), FindOptions.KeysOnly | FindOptions.RemovePrefix);
        BigInteger sum = 0;
        while (iter.Next())
        {
            var recordId = (BigInteger)(byte[])iter.Value;
            var raw = Storage.Get(ctx, RecordKey(recordId));
            if (raw is null) continue;
            var rec = (Map<string, object>)StdLib.Deserialize((ByteString)raw);
            if ((BigInteger)rec["expiry"] >= Runtime.Time)
                sum += (BigInteger)rec["amount"];
        }
        return sum;
    }

    public static BigInteger FrozenBalanceOf(UInt160 owner, ByteString tokenId)
    {
        var ctx = Storage.CurrentContext;
        var iter = Storage.Find(ctx, OwnerIndexPrefix(owner, tokenId), FindOptions.KeysOnly | FindOptions.RemovePrefix);
        BigInteger sum = 0;
        while (iter.Next())
        {
            var recordId = (BigInteger)(byte[])iter.Value;
            var raw = Storage.Get(ctx, RecordKey(recordId));
            if (raw is null) continue;
            var rec = (Map<string, object>)StdLib.Deserialize((ByteString)raw);
            if ((BigInteger)rec["expiry"] >= Runtime.Time)
                sum += (BigInteger)rec["amount"];
        }
        return sum;
    }

    private static byte[] RecordKey(BigInteger recordId)
        => new byte[] { Prefix_Record }.Concat((ByteString)(byte[])recordId.ToByteArray());
    private static byte[] UserIndexKey(UInt160 user, ByteString tokenId, BigInteger recordId)
        => new byte[] { Prefix_RecordByUser }.Concat(user).Concat(tokenId).Concat((ByteString)(byte[])recordId.ToByteArray());
    private static byte[] OwnerIndexKey(UInt160 owner, ByteString tokenId, BigInteger recordId)
        => new byte[] { Prefix_FrozenByOwn }.Concat(owner).Concat(tokenId).Concat((ByteString)(byte[])recordId.ToByteArray());
    private static byte[] UserIndexPrefix(UInt160 user, ByteString tokenId)
        => new byte[] { Prefix_RecordByUser }.Concat(user).Concat(tokenId);
    private static byte[] OwnerIndexPrefix(UInt160 owner, ByteString tokenId)
        => new byte[] { Prefix_FrozenByOwn }.Concat(owner).Concat(tokenId);
}

Storage-cost Note

Each rental record holds owner, user, tokenId, amount, expiry (~80 bytes serialised). For collections with thousands of active rentals, the index storage dominates — consider sharding by tokenId class or paginating the iterator results in off-chain indexers. The on-chain footprint per transfer of an unrented portion stays constant; only the rental operations touch the records storage.