> For the complete documentation index, see [llms.txt](https://www.ankitavirani.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.ankitavirani.com/experience/protocols/ercs-and-eips/erc-223.md).

# ERC-223

## ERC-223: An Enhanced Token Standard

### Introduction

ERC-223 is a token standard for Ethereum, proposed as an improvement to the widely used ERC-20 standard. It introduces mechanisms to address critical shortcomings of ERC-20, such as accidental token losses and inefficient gas usage. By defining a new communication model for token transfers, ERC-223 provides a more robust and user-friendly framework for token interactions.

***

### What is ERC-223?

ERC-223 is similar to ERC-20 but extends its functionality by:

* Handling token transfers on the recipient's side.
* Preventing the loss of tokens sent to incompatible contracts.
* Supporting metadata in token transfers for additional transaction context.

***

### Key Features and Differences

#### Improvements Over ERC-20

1. **Recipient Awareness**
   * ERC-223 tokens can only be transferred to contracts that implement the `tokenReceived` function.
   * Prevents tokens from being permanently lost if sent to non-compatible contracts.
2. **Efficient Transactions**
   * Uses a single `transfer` method instead of separate `approve` and `transferFrom`.
   * Reduces gas consumption by eliminating unnecessary calls.
3. **Metadata Support**
   * Allows metadata to be included with transfers, enabling context-specific actions.

***

### Workflow Diagram

<figure><img src="/files/n2gkjTOjmtdk0ZEs2H0I" alt=""><figcaption></figcaption></figure>

***

### ERC-223 Implementation

An ERC-223 token must define specific methods and events, as described in [EIP-223](https://eips.ethereum.org/EIPS/eip-223).

#### Required Methods

```solidity
function name() public view returns (string);
function symbol() public view returns (string);
function decimals() public view returns (uint8);
function totalSupply() public view returns (uint256);
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transfer(address _to, uint256 _value, bytes calldata _data) public returns (bool success);
```

#### Events

```solidity
event Transfer(address indexed _from, address indexed _to, uint256 _value, bytes calldata _data);
```

#### Recipient Contract Requirements

Contracts receiving ERC-223 tokens must implement:

```solidity
function tokenReceived(address _from, uint _value, bytes calldata _data);
```

If the recipient contract does not implement this function, the transaction fails, and tokens remain with the sender.

***

### Example Implementation

#### ERC-223 Token Contract

```solidity
pragma solidity ^0.8.19;

abstract contract IERC223Recipient {
    function tokenReceived(address _from, uint _value, bytes memory _data) public virtual;
}

contract ERC223Token {
    event Transfer(address indexed from, address indexed to, uint value, bytes data);
    mapping(address => uint256) private balances;

    function transfer(address _to, uint _value, bytes calldata _data) public returns (bool success) {
        balances[msg.sender] -= _value;
        balances[_to] += _value;
        if (isContract(_to)) {
            IERC223Recipient(_to).tokenReceived(msg.sender, _value, _data);
        }
        emit Transfer(msg.sender, _to, _value, _data);
        return true;
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}
```

#### Recipient Contract

```solidity
pragma solidity ^0.8.19;

contract RecipientContract is IERC223Recipient {
    event Deposit(address indexed sender, uint value);
    uint256 public deposits;

    function tokenReceived(address _from, uint _value, bytes memory _data) public override {
        deposits += _value;
        emit Deposit(_from, _value);
    }
}
```

***

### Advantages of ERC-223

* **Safety**: Tokens cannot be accidentally lost by sending them to incompatible contracts.
* **Efficiency**: Reduces gas costs by requiring fewer transactions.
* **Extensibility**: Supports metadata for enhanced functionality.

***

### Limitations

* **Adoption**: ERC-223 is not yet widely adopted, limiting compatibility.
* **Backward Compatibility**: Existing ERC-20 tools and contracts require modifications to support ERC-223.
* **Gas Costs**: The additional recipient checks may increase transaction costs in some scenarios.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://www.ankitavirani.com/experience/protocols/ercs-and-eips/erc-223.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.