ERC-3525 — Semi-Fungible Token

Back to Token Standards

ERC-3525: Semi-Fungible Token

ERC-3525 introduces tokens that have both an NFT-like unique tokenId and an ERC-20-like value quantity within each unit. Use cases: bonds (each tokenId is an issuance with units), structured products, ticketing (each tokenId is an event seat range), in-game stackable items.

Required Interface (Highlights)

function balanceOf(uint256 tokenId) external view returns (uint256);
function ownerOf(uint256 tokenId)   external view returns (address);
function slotOf(uint256 tokenId)    external view returns (uint256);   // category bucket
function transferFrom(uint256 fromTokenId, uint256 toTokenId, uint256 value) external;
function transferFrom(uint256 fromTokenId, address to, uint256 value)
    external returns (uint256 newTokenId);

Neo Equivalent: Direct Port

No dedicated NEP, but the standard is straightforward to port. The Neo C# version below combines NEP-11 (token identity) with per-token value tracking — wallets that read NEP-11 still see the token list, while applications that care about value introspect via the SFT-specific methods.

Live on Neo TestNet

Both implementations deployed on Neo N3 TestNet.

Implementation	TestNet Address	Contract Hash	Deploy Tx
Solidity (neo-solc)	NdzbQnww1HMVDUgZtZzrfN5TvxFTBoBTW6	0xd0fd56dad510d54ca7877bab2c578d63b82a52c6	0x16953f75…22a2e
Neo C# (nccs)	NVpt23PJU2ZbEHXmDkzEqCfoE9NQfEopNZ	0xfcfde62a4764cbcd9b35615084e0075c4bddba6c	0x9b8dc510…1cefba

Verified: symbol, mint(slot=1, value=1000), balanceOfToken, slotOf, valueDecimals. Both implementations agree that token #1 has value 1000 in slot 1. docs/standards-mirror/deployments/erc-3525/.

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

interface IERC3525 {
    function valueDecimals() external view returns (uint8);
    function balanceOf(uint256 tokenId) external view returns (uint256);
    function ownerOf(uint256 tokenId) external view returns (address);
    function slotOf(uint256 tokenId) external view returns (uint256);

    function transferFrom(uint256 fromTokenId, uint256 toTokenId, uint256 value) external;
    function transferFrom(uint256 fromTokenId, address to, uint256 value)
        external returns (uint256);

    event TransferValue(uint256 indexed from, uint256 indexed to, uint256 value);
    event SlotChanged(uint256 indexed tokenId, uint256 oldSlot, uint256 newSlot);
}

contract Bond is IERC3525 {
    struct Token { address owner; uint256 slot; uint256 value; }

    mapping(uint256 => Token) public tokens;
    uint256 private _next = 1;

    function valueDecimals() external pure returns (uint8) { return 18; }

    function balanceOf(uint256 tokenId) external view returns (uint256) {
        return tokens[tokenId].value;
    }
    function ownerOf(uint256 tokenId) external view returns (address) {
        return tokens[tokenId].owner;
    }
    function slotOf(uint256 tokenId) external view returns (uint256) {
        return tokens[tokenId].slot;
    }

    function mint(address to, uint256 slot, uint256 value)
        external returns (uint256 id)
    {
        id = _next++;
        tokens[id] = Token(to, slot, value);
        emit TransferValue(0, id, value);
    }

    function transferFrom(uint256 fromTokenId, uint256 toTokenId, uint256 value)
        external
    {
        Token storage src = tokens[fromTokenId];
        Token storage dst = tokens[toTokenId];
        require(msg.sender == src.owner,    "not owner");
        require(src.slot == dst.slot,        "slot mismatch");
        require(src.value >= value,          "insufficient");
        src.value -= value;
        dst.value += value;
        emit TransferValue(fromTokenId, toTokenId, value);
    }

    function transferFrom(uint256 fromTokenId, address to, uint256 value)
        external returns (uint256 newTokenId)
    {
        Token storage src = tokens[fromTokenId];
        require(msg.sender == src.owner, "not owner");
        require(src.value >= value,      "insufficient");
        src.value -= value;
        newTokenId = _next++;
        tokens[newTokenId] = Token(to, src.slot, value);
        emit TransferValue(fromTokenId, newTokenId, value);
    }
}

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("Bond")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]      // also exposes ERC-3525 semantics via dedicated methods
public class Bond : SmartContract
{
    private const byte Prefix_Owner = 0x01;   // tokenId -> UInt160
    private const byte Prefix_Slot  = 0x02;   // tokenId -> BigInteger
    private const byte Prefix_Value = 0x03;   // tokenId -> BigInteger
    private static readonly byte[] NextIdKey = { 0xFE };

    [DisplayName("Transfer")]
    public static event Action<UInt160, UInt160, BigInteger, ByteString> OnTransfer;
    [DisplayName("TransferValue")]
    public static event Action<ByteString, ByteString, BigInteger> OnTransferValue;

    public static byte ValueDecimals() => 8;

    public static UInt160    OwnerOf(ByteString tokenId)
        => (UInt160)Storage.Get(Storage.CurrentContext,
                                new byte[] { Prefix_Owner }.Concat(tokenId));

    public static BigInteger SlotOf(ByteString tokenId)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
                                    new byte[] { Prefix_Slot }.Concat(tokenId))
                        ?? ByteString.Empty);

    /// <summary>NEP-11 balanceOf for divisible NFTs returns the value of this token.</summary>
    public static BigInteger BalanceOf(ByteString tokenId)
        => (BigInteger)(Storage.Get(Storage.CurrentContext,
                                    new byte[] { Prefix_Value }.Concat(tokenId))
                        ?? ByteString.Empty);

    public static ByteString Mint(UInt160 to, BigInteger slot, BigInteger value)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        var id = NextId();
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Owner }.Concat(id), to);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Slot  }.Concat(id), slot);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Value }.Concat(id), value);
        OnTransfer(UInt160.Zero, to, value, id);
        OnTransferValue(null, id, value);
        return id;
    }

    /// <summary>Move `value` from one tokenId to another within the same slot.</summary>
    public static void TransferValueToToken(ByteString fromId, ByteString toId, BigInteger value)
    {
        var fromOwner = OwnerOf(fromId);
        if (!Runtime.CheckWitness(fromOwner)) throw new Exception("not owner");
        if (!SlotOf(fromId).Equals(SlotOf(toId))) throw new Exception("slot mismatch");

        var fromVal = BalanceOf(fromId);
        if (fromVal < value) throw new Exception("insufficient");
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Value }.Concat(fromId),
                    fromVal - value);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Value }.Concat(toId),
                    BalanceOf(toId) + value);
        OnTransferValue(fromId, toId, value);
    }

    /// <summary>Split: move `value` to a new token owned by `to`.</summary>
    public static ByteString TransferValueToAddress(ByteString fromId, UInt160 to, BigInteger value)
    {
        var fromOwner = OwnerOf(fromId);
        if (!Runtime.CheckWitness(fromOwner)) throw new Exception("not owner");
        var fromVal = BalanceOf(fromId);
        if (fromVal < value) throw new Exception("insufficient");

        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Value }.Concat(fromId),
                    fromVal - value);
        var newId = NextId();
        var slot  = SlotOf(fromId);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Owner }.Concat(newId), to);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Slot  }.Concat(newId), slot);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Value }.Concat(newId), value);
        OnTransfer(UInt160.Zero, to, value, newId);
        OnTransferValue(fromId, newId, value);
        return newId;
    }

    private static ByteString NextId()
    {
        var n = (BigInteger)(Storage.Get(Storage.CurrentContext, NextIdKey) ?? ByteString.Empty) + 1;
        Storage.Put(Storage.CurrentContext, NextIdKey, n);
        return (ByteString)n.ToByteArray();
    }

    private static UInt160 GetAdmin() => (UInt160)"0x0000000000000000000000000000000000000000";
}

Why It Works on Neo Without a NEP

A semi-fungible token is just an NFT with a per-token value field. The properties map of NEP-11 already supports per-token data; the bond contract above just promotes "value" to a first-class field for explicit access. Wallets that only know NEP-11 still see "this address owns N tokens"; bond-aware applications use the SFT methods to introspect value.