ERC-1363 — Payable Token

Back to Token Standards

ERC-1363: Payable Token / Token Transfer with Callback

ERC-1363 layers a callback hook on top of ERC-20 so that a token transfer can trigger logic in the receiver in the same transaction — without requiring the receiver to do a separate approve + transferFrom dance. It's the "transferAndCall" ergonomic improvement that ERC-20 originally lacked.

Required Interface

function transferAndCall(address to, uint256 amount) external returns (bool);
function transferAndCall(address to, uint256 amount, bytes calldata data) external returns (bool);
function transferFromAndCall(address from, address to, uint256 amount) external returns (bool);
function transferFromAndCall(address from, address to, uint256 amount, bytes calldata data)
    external returns (bool);
function approveAndCall(address spender, uint256 amount) external returns (bool);
function approveAndCall(address spender, uint256 amount, bytes calldata data) external returns (bool);

The receiver implements IERC1363Receiver.onTransferReceived(...) and must return the magic selector 0x88a7ca5c to accept the transfer; the spender target implements IERC1363Spender.onApprovalReceived(...) returning 0x7b04a2d0. ERC-1363 is the design ancestor of NEP-17's payment callback.

Neo Equivalent: NEP-17 callback (built in)

NEP-17's required transfer(from, to, amount, data) already invokes onNEP17Payment(from, amount, data) on the recipient when the recipient is a contract. No separate "payable token" extension is needed — every NEP-17 token is "payable" by spec.

ERC-1363 (Ethereum)	NEP-17 (Neo)	Notes
transferAndCall(to, amount, data)	transfer(from, to, amount, data)	Built into the core NEP-17 spec
IERC1363Receiver.onTransferReceived(...) returning magic value	onNEP17Payment(from, amount, data)	Recipient revert / not-implementing aborts the transfer
transferFromAndCall(from, to, ...)	transfer(from, to, ...) with witness for from	Authorization via witness instead of allowance
approveAndCall(spender, amount, data)	—	Neo has no allowance; spender pattern unnecessary
Magic selector handshake (0x88a7ca5c)	onNEP17Payment presence + revert semantics	Neo enforces by missing-method semantics, not by selector match

Why It's Built In on Neo

ERC-1363 exists because ERC-20 was designed without callback hooks; protocols that wanted "transfer + immediate logic" had to choose between trusting users to call two functions or shipping a wrapper. NEP-17 made the callback a mandatory part of every transfer to a contract, which is why NEP-17 receivers are guaranteed to know about every payment.

Migration Notes

Solidity contracts targeting Neo via neo-solc can drop ERC-1363 entirely: declare function onNEP17Payment(address from, uint256 amount, bytes calldata data) external on the receiver and the compiler routes Neo-side onNEP17Payment invocations to that function. The four-parameter transfer signature is the only correct shape on Neo.

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

interface IERC1363Receiver {
    function onTransferReceived(
        address operator,
        address from,
        uint256 amount,
        bytes calldata data
    ) external returns (bytes4);
}

contract ERC1363 {
    string public name = "Payable Token";
    string public symbol = "PAY";
    uint8  public decimals = 18;
    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    function transfer(address to, uint256 amount) public returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to]         += amount;
        emit Transfer(msg.sender, to, amount);
        return true;
    }

    function transferAndCall(address to, uint256 amount, bytes calldata data) public returns (bool) {
        require(transfer(to, amount), "transfer failed");
        if (_isContract(to)) {
            bytes4 ret = IERC1363Receiver(to).onTransferReceived(
                msg.sender, msg.sender, amount, data
            );
            require(ret == IERC1363Receiver.onTransferReceived.selector,
                "ERC1363: receiver returned wrong magic value");
        }
        return true;
    }

    function _isContract(address a) internal view returns (bool) {
        return a.code.length > 0;
    }
}

When compiled with neo-solc, replace transferAndCall with NEP-17's mandatory transfer(from, to, amount, data) shape and let the runtime route the onNEP17Payment callback automatically.

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("PayableToken")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep17)]
public class PayableToken : Nep17Token
{
    public override string Symbol => "PAY";
    public override byte Decimals => 8;

    // Transfer is inherited from Nep17Token. Recipients that implement
    // OnNEP17Payment(from, amount, data) get notified automatically — that
    // IS the ERC-1363 "transferAndCall" contract.
    //
    // Recipients that do NOT implement OnNEP17Payment cause the transfer to
    // revert (matching ERC-1363's "magic value" reject semantics).

    public static void Mint(UInt160 to, BigInteger amount)
    {
        if (!Runtime.CheckWitness(GetAdmin())) throw new Exception("admin only");
        Mint(to, amount);
    }

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

// Recipient contract — receives PAY tokens with attached calldata.
[DisplayName("PayableTokenReceiver")]
public class PayableTokenReceiver : SmartContract
{
    [DisplayName("OnNEP17Payment")]
    public static void OnNEP17Payment(UInt160 from, BigInteger amount, object data)
    {
        // ERC-1363's `onTransferReceived(operator, from, amount, data)` ↔
        // NEP-17's `OnNEP17Payment(from, amount, data)`.
        // No magic-value handshake required — being callable is the contract.
        Runtime.Notify("Received", new object[] { from, amount, data });
    }
}