Skip to content

Latest commit

 

History

History
104 lines (85 loc) · 4.21 KB

nep-26.mediawiki

File metadata and controls

104 lines (85 loc) · 4.21 KB
Raw

  NEP: 26
  Title: Smart contract transfer callback for non-fungible tokens
  Author: Erik Zhang <[email protected]>, Roman Khimov <[email protected]>, Jaime Kindelan <[email protected]>, Jimmy Liao <[email protected]>
  Type: Informational
  Status: Final
  Created: 2024-03-03
  Requires: 11

Table of Contents

Abstract

This proposal describes the callback method used by Neo smart contracts to process transfers of non-fungible NEP-11 tokens to their addresses.

Motivation

While the original NEP-11 already defines this method, it lacks some details relevant specifically to the receiver contract and it doesn't allow for easy reference. This standard can be used in supportedstandards section of NEP-15 manifest or in any other situation to refer to contracts able to receive NEP-11 tokens (but not necessarily being NEP-11 themselves). Typical use cases for this functionality are: depositing/staking (with contract locking and managing tokens according to some rules) or exchange/minting (contract accepting transfer to itself, but returning some different token to the sender).

Specification

Smart contracts that need to receive and own NEP-11 tokens MUST implement onNEP11Payment method with the following signature: 

{
  "name": "onNEP11Payment",
  "parameters": [
    {
      "name": "from",
      "type": "Hash160"
    },
    {
      "name": "amount",
      "type": "Integer"
    },
    {
      "name": "tokenId",
      "type": "ByteString"
    },
    {
      "name": "data",
      "type": "Any"
    }
  ],
  "returntype": "Void"
}

A contract that doesn't implement this method will not be able to receive NEP-11 tokens (standard requires this method to be called unconditionally which will fail at the system call level if it's not implemented which then leads to a complete transaction failure). This method is called by NEP-11 contracts which tokens are being transferred. A particular token can be obtained via the System.Runtime.GetCallingScriptHash system call. Notice that technically this method MAY be called by entry scripts or non-NEP-11 contracts as well, so contracts SHOULD check for caller script hash to match their expectations like allowed/accepted tokens. Processing this call means that contract trusts the caller to implement NEP-11 correctly.

from parameter specifies the sender of tokens and can be null for minted tokens.

amount is the amount of tokens transferred to the contract. It's always 1 for non-divisible NEP-11 tokens.

tokenId is the transferred token ID.

data is the same dataparameter that was given to the NEP-11 transfer call. Contract can interpret it in any application-specific way including imposing any restrictions on accepted data contents.

If the contract implementing this NEP can't accept the transfer (for reasons like unexpected token, wrong amount, forbidden sender, wrong data parameter or any other) it MUST call ABORT or ABORTMSG VM opcode to fail the transaction. This is the only way to ensure contract won't own transferred tokens, because the method doesn't return any value and exceptions can be handled by calling contract. Contact MAY also check for various conditions with ASSERT or ASSERTMSG opcodes.

Rationale

This NEP just follows and explains NEP-11 semantics, no design decisions made here.

Backwards Compatibility

This NEP is completely compatible with NEP-11, there are just two extensions to it:

  • addition of ABORTMSG opcode that didn't exist at the time of NEP-11 creation, but it's the same thing as ABORT semantically.
  • explicit ASSERT and ASSERTMSG opcode allowance that was not a part of NEP-11, but also has the same function as ABORT for failed conditions.

Implementation