ERC-4494 — Permit for ERC-721

Back to Token Standards

ERC-4494: NFT Permit (Gasless NFT Approval)

ERC-4494 brings ERC-2612-style gasless approvals to NFTs. The owner signs an EIP-712 typed message authorising a single-use permit; a marketplace submits the permit on-chain to set the approval, then immediately calls transferFrom. One transaction, no separate approve.

Required Interface

function permit(
    address spender, uint256 tokenId, uint256 deadline,
    bytes memory sig
) external;
function nonces(uint256 tokenId)  external view returns (uint256);
function DOMAIN_SEPARATOR()       external view returns (bytes32);

Neo Equivalent: Witness Scopes

Just like ERC-2612, the Ethereum signature-parsing mechanism is unnecessary on Neo. The user signs a single transaction with WitnessScope.CustomContracts allowing the marketplace contract to call Transfer on the NFT. No EIP-712 domain separator or signature recovery is needed. The mirror keeps a small permit/nonce method only to demonstrate replay protection side-by-side.

Live on Neo TestNet

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

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0xe683fa29d01521d99abfe15cb7e4b1f69ed47b66	(reused — see 0xe683fa29d01521d99abfe15cb7e4b1f69ed47b66)
Neo C# (nccs)	0xc705641088ed11e564c946bf8a9a1569a9cc9257	(reused — see 0xc705641088ed11e564c946bf8a9a1569a9cc9257)

Checked-in snapshot matches on initial nextId; the manifest now also exercises mint plus per-token permit nonce. Source pairs under docs/standards-mirror/deployments/erc-4494/.

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

contract ERC721Permit {
    bytes32 private constant _PERMIT_TYPEHASH = keccak256(
      "Permit(address spender,uint256 tokenId,uint256 nonce,uint256 deadline)"
    );
    mapping(uint256 => uint256) public nonces;
    bytes32 public immutable DOMAIN_SEPARATOR;

    constructor() {
        DOMAIN_SEPARATOR = keccak256(abi.encode(
            keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"),
            keccak256("MyNFT"), block.chainid, address(this)
        ));
    }

    function permit(address spender, uint256 tokenId, uint256 deadline, bytes memory sig)
        external
    {
        require(block.timestamp <= deadline, "expired");
        bytes32 structHash = keccak256(abi.encode(
            _PERMIT_TYPEHASH, spender, tokenId, nonces[tokenId]++, deadline
        ));
        bytes32 hash = keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, structHash));

        address signer = _recoverSigner(hash, sig);
        require(signer == _ownerOf(tokenId), "unauth");
        _approve(spender, tokenId);
    }

    function _ownerOf(uint256) internal view returns (address) { /* ... */ return address(0); }
    function _approve(address, uint256) internal { /* ... */ }
    function _recoverSigner(bytes32, bytes memory) internal pure returns (address) { /* ECDSA */ return address(0); }
}

// Standard NEP-11 already covers this — no permit method needed.
//
// User-side flow on Neo (TypeScript example showing what the dApp builds):
//
//   const tx = new TransactionBuilder()
//     .invoke(marketplace, "buy", [listingId])
//     .signers([{
//       account: userAddress,
//       scopes: WitnessScope.CustomContracts,
//       allowedContracts: [nftContract, marketplace]   // scope-limited authorization
//     }])
//     .build();
//   const signed = await wallet.signTransaction(tx);
//   await rpc.sendRawTransaction(signed);
//
// Inside marketplace.buy(...) the marketplace calls:
//   Contract.Call(nftContract, "transfer", CallFlags.All, ...)
// which invokes the NFT's Transfer with the user's witness available.
// The NFT's CheckWitness(owner) succeeds because the user signed with
// CustomContracts scope including the NFT contract.

using System;
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;

/// <summary>
/// Marketplace using the buyer's witness for atomic NFT settlement.
/// No permit, no signatures to parse — single-tx UX is built in.
/// </summary>
[DisplayName("Marketplace")]
[ContractPermission("*", "*")]
public class Marketplace : SmartContract
{
    public static void Buy(UInt160 buyer, UInt160 nft, ByteString tokenId,
                           BigInteger price, UInt160 paymentToken)
    {
        if (!Runtime.CheckWitness(buyer)) throw new Exception("buyer must sign");

        var seller = (UInt160)Contract.Call(nft, "ownerOf", CallFlags.ReadOnly,
                                            new object[] { tokenId });

        // Pay the seller
        Contract.Call(paymentToken, "transfer", CallFlags.All,
                      new object[] { buyer, seller, price, "purchase" });
        // Receive the NFT — works because buyer's witness scope includes nft contract
        Contract.Call(nft, "transfer", CallFlags.All,
                      new object[] { buyer, tokenId, "purchase" });
    }
}