Introduction

As decentralized applications (dApps) evolve, interoperability between different blockchain networks becomes crucial. This is especially true for NFTs, which are often tied to specific blockchain ecosystems. The ERC-6551 standard introduces a novel way to manage NFTs by associating them with smart contracts, enabling more advanced and programmable functionalities. This article explores the Cross-Chain ERC-6551 implementation, which extends ERC-6551 across multiple chains.

This implementation is based on the code developed by the Bounty Program winner, Maniveer Singh, whose project can be found on GitHub. We would like to express our gratitude to Maniveer for his contribution and sharing his solution, pushing the boundaries of cross-chain NFT functionality.

ERC-6551 Explained

ERC-6551 allows NFTs to be linked with a unique smart contract account. This account can perform actions, hold assets, and interact with other smart contracts, providing the NFT with its own digital identity. The standard enhances NFTs' functionality, transforming them from static digital assets into dynamic entities capable of executing complex transactions and holding other tokens.

Why Cross-Chain ERC-6551 Matters

While ERC-6551 improves the utility of NFTs within a single blockchain, their potential remains limited if they can’t interact with other blockchains. Cross-chain ERC-6551 aims to solve this problem by enabling NFTs to operate across multiple chains, opening new possibilities in decentralized finance (DeFi), gaming, and other dApp ecosystems where cross-chain is vital.

Implementation

The Cross-Chain ERC-6551 implementation relies on several smart contracts, each playing a specific role in providing interaction across multiple blockchains.

Contracts

The Cross-Chain ERC-6551 implementation relies on several smart contracts, each playing a specific role in facilitating interaction across multiple blockchains:

1. `ERC6551_Reactive.sol`: Reacts to events like account creation and ownership transfers on origin chains and triggers actions on destination chains.

2. `ERC6551_Origin.sol`: Manages the creation of ERC-6551 accounts on origin chains, ensuring that only the NFT owner can create accounts and limiting creation to supported chains. 

3. `ERC6551_Registry.sol`: Handles the deployment and management of ERC-6551 accounts on destination chains, including account creation, ownership changes, and event handling.

4. `ERC6551_Account.sol`: Represents the smart contract account tied to an NFT, managing its identity, transactions, and signature validation.

Key Functionalities

Let’s take a closer look at the key functionalities of our contracts.

Account Creation and Subscription

The `ERC6551_Reactive` contract subscribes to the `CreateAccount` event emitted by the `ERC6551_Origin` contract. When this event is detected, the `react()` function in `ERC6551_Reactive` is triggered to create an ERC-6551 account on the destination chain through the `ERC6551_Registry` contract. A `Callback` event is emitted to propagate this action to the destination chain.

if(topic_0 == CreateAccount_Topic0){
    address owner = abi.decode(data, (address));
    bytes memory payload = abi.encodeWithSignature(
        "createAccount(address,address,uint256,address,uint256,uint256)",
        address(0),
        owner,
        SEPOLIA_CHAIN_ID,
        address(uint160(topic_2)),
        topic_3,
        7000  // salt
    );

    emit Callback(topic_1, _callback, GAS_LIMIT, payload);

    bytes memory subscribepayload = abi.encodeWithSignature(
        "subscribe(address,address,uint256,uint256,uint256,uint256)",
        address(0),
        address(uint160(topic_2)),
        Transfer_Topic0,
        REACTIVE_IGNORE,
        REACTIVE_IGNORE,
        topic_3
    );

    emit Callback(REACTIVE_CHAIN_ID, address(this), GAS_LIMIT, subscribepayload);
}

Cross-Chain Ownership Transfer

When an NFT is transferred on the origin chain, the `Transfer` event is emitted. The `ERC6551_Reactive` contract reacts by invoking the `changeOwnerofAccount()` function in the `ERC6551_Registry` contract on all destination chains. The ownership of the ERC-6551 account is updated across all connected chains through a `Callback` event.

else if (topic_0 == Transfer_Topic0){
    for(uint i = 0; i < DestinationChainIds.length; i++){
        bytes memory payload = abi.encodeWithSignature(
            "changeOwnerofAccount(address,address,uint256,address,uint256,uint256)", 
            address(0),
            address(uint160(topic_2)),
            SEPOLIA_CHAIN_ID,
            _contract,
            topic_3,
            7000
        );
        emit Callback(DestinationChainIds[i], _callback, GAS_LIMIT, payload);
    }
}

Handling Multiple Chains

The implementation supports multiple destination chains by maintaining a list of `DestinationChainIds`. The `ERC6551_Reactive` contract iterates through this list when reacting to events, ensuring that actions are propagated to all relevant chains via `Callback` events.

uint[] DestinationChainIds;

for(uint i = 0; i < DestinationChainIds.length; i++){
    // Trigger actions on each destination chain
}

Callbacks

Callbacks are emitted by the `ERC6551_Reactive` contract to trigger actions on destination chains. They include all necessary information (such as the function signature, parameters, and gas limit) to execute operations like account creation or ownership updates. These callbacks are essential for propagating events across chains.

Conclusion

Cross-Chain ERC-6551 significantly improves the utility of NFTs by enabling them to function across multiple blockchains. This capability opens up new possibilities for NFTs in various dApp ecosystems, particularly in areas like DeFi, gaming, and digital identity. By utilizing Reactive Smart Contracts, developers can create more dynamic and interoperable NFT solutions that transcend the limitations of individual blockchains.

Join our Hackathon and bounty program today to start building with Reactive Smart Contracts and bring your innovative ideas to life on the Reactive Network!

About Reactive Network

The Reactive Network, pioneered by PARSIQ, ushers in a new wave of blockchain innovation through its Reactive Smart Contracts (RSCs). These advanced contracts can autonomously execute based on specific on-chain events, eliminating the need for off-chain computation and heralding a seamless cross-chain ecosystem vital for Web3’s growth. 

Central to this breakthrough is the Inversion of Control (IoC) framework, which redefines smart contracts and decentralized applications (DApps) by imbuing them with unparalleled autonomy, efficiency, and interactivity. By marrying RSCs with IoC, Reactive Network is setting the stage for a transformative blockchain era, characterized by enhanced interoperability and the robust, user-friendly foundation Web3 demands.

Website | Blog | Twitter | Telegram | Discord