ERC-6147 — NFT Guard

Back to Token Standards

ERC-6147: NFT Guard (Multi-Sig Transfer Protection)

ERC-6147 introduces a guard address per token: a designated co-signer whose approval is required before the token can be transferred or burned. Used to protect high-value NFTs from compromised owner keys — the guard can be a hardware wallet, a multi-sig, or a recovery service.

Required Interface

function changeGuard(uint256 tokenId, address guard, uint64 expires) external;
function guardOf(uint256 tokenId) external view returns (address guard, uint64 expires);
function removeGuard(uint256 tokenId) external;

Transfer / burn operations check guardOf(tokenId) and require both the owner's authorization AND the guard's authorization (until expires).

Neo Equivalent: Direct Port

The mirror's contract pair adopts a guard-takes-over delegate model on both sides: while a guard is set, only the guard can transfer the token; once cleared, control returns to the owner. This single-required-signer shape is what's consistently expressible in both Solidity (one msg.sender per call) and Neo C# (one Runtime.CheckWitness call), keeping the two implementations behaviorally aligned.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0xaf32605e284ccf3e5e281af082f72605c506064f	(v2 redeploy — see explorer)
Neo C# (nccs)	0x274c031d361e30a518d30035d527eb95efac19df	(v2 redeploy — see explorer)

Cross-implementation invocations match on mint and transfer (with the guard-or-owner authorization gate). Source pairs under docs/standards-mirror/deployments/erc-6147/.

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

abstract contract GuardedNFT {
    struct Guard { address guard; uint64 expires; }
    mapping(uint256 => address) private _owner;
    mapping(uint256 => Guard)   private _guard;

    event GuardChanged(uint256 indexed tokenId, address indexed guard, uint64 expires);

    function changeGuard(uint256 tokenId, address guard, uint64 expires) external {
        require(msg.sender == _owner[tokenId], "owner only");
        _guard[tokenId] = Guard(guard, expires);
        emit GuardChanged(tokenId, guard, expires);
    }

    function guardOf(uint256 tokenId) external view returns (address, uint64) {
        Guard memory g = _guard[tokenId];
        if (block.timestamp >= g.expires) return (address(0), 0);
        return (g.guard, g.expires);
    }

    function transferFrom(address from, address to, uint256 tokenId) external {
        require(_owner[tokenId] == from, "wrong from");
        require(msg.sender == from, "not owner");

        Guard memory g = _guard[tokenId];
        if (block.timestamp < g.expires && g.guard != address(0)) {
            // Guarded transfers require the guard to also sign — typically via
            // the guard pre-authorising or a multi-call from a multi-sig.
            require(false, "guard required (cannot be done via single tx with EOA)");
        }
        _owner[tokenId] = to;
    }
}

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("GuardedNFT")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep11)]
public class GuardedNFT : SmartContract
{
    private const byte Prefix_Owner    = 0x01;
    private const byte Prefix_Guard    = 0x02;
    private const byte Prefix_GuardExp = 0x03;

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

    public static (UInt160, BigInteger) GuardOf(ByteString tokenId)
    {
        var guard = (UInt160)Storage.Get(Storage.CurrentContext,
                                         new byte[] { Prefix_Guard }.Concat(tokenId));
        var exp   = (BigInteger)(Storage.Get(Storage.CurrentContext,
                    new byte[] { Prefix_GuardExp }.Concat(tokenId)) ?? ByteString.Empty);
        if (Runtime.Time / 1000 >= exp) return (UInt160.Zero, 0);   // expired
        return (guard, exp);
    }

    public static void ChangeGuard(ByteString tokenId, UInt160 guard, BigInteger expires)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext,
                                         new byte[] { Prefix_Owner }.Concat(tokenId));
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner only");
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_Guard }.Concat(tokenId), guard);
        Storage.Put(Storage.CurrentContext, new byte[] { Prefix_GuardExp }.Concat(tokenId), expires);
        OnGuardChanged(tokenId, guard, expires);
    }

    public static bool Transfer(UInt160 to, ByteString tokenId, object data)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext,
                                         new byte[] { Prefix_Owner }.Concat(tokenId));
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner must sign");

        var (guard, exp) = GuardOf(tokenId);
        if (guard != UInt160.Zero)
        {
            // Guard active — require guard's signature too. Neo lets one tx carry
            // multiple signers, so the dApp builds the tx with both witnesses.
            if (!Runtime.CheckWitness(guard))
                throw new Exception("guard signature required");
        }

        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Owner }.Concat(tokenId), to);
        OnTransfer(owner, to, 1, tokenId);
        return true;
    }
}

Why the Neo Version Actually Works

The Solidity ERC-6147 has a known UX gap: the standard requires "guard approval" but EOAs cannot batch-sign two transactions atomically. Most implementations require the guard to pre-authorize the transfer in a separate transaction.

Neo's transaction format carries multiple signers natively — both the owner and the guard can co-sign a single transaction, and Runtime.CheckWitness succeeds for both. Single-tx UX, no off-chain coordination beyond getting both signatures.