What is ERC721 on Solana?

If you're coming from the EVM ecosystem, one thing you know well is ERC721. NFTs (non-fungible tokens) are at the heart of many blockchain applications, and ERC721 is one of the first standards developers learn when deploying NFT collections. On Solana, what is the ERC721 equivalent and how does it differ?

ERC721 sets a standard for Non-Fungible Tokens (NFTs), meaning each token is unique (in type and value) compared to another token. The ERC721 standard is utilized to represent individual tokens with distinct identifiers. Unlike ERC20 tokens, ERC721 tokens can possess unique characteristics and functions.

Το Token Program (Συν Μεταδεδομένα)

Στη Solana, δεν υπάρχει νέο έξυπνο συμβόλαιο για κάθε συλλογή NFT. Αντίθετα, τα NFTs δημιουργούνται υπό ένα ενιαίο onchain Token Program, το ίδιο που χρησιμοποιείται για εναλλάξιμα tokens - απλώς εκδίδονται με προσφορά 1. Για να αποθηκεύσουν επιπλέον λεπτομέρειες NFT (όπως όνομα, σύμβολο, URI εικόνας κ.λπ.), οι προγραμματιστές χρησιμοποιούν το Metaplex Token Metadata Program.

Το Metaplex Metadata είναι ένα πρωτόκολλο και πλατφόρμα ανοιχτού κώδικα για NFTs (Non-Fungible Tokens) και ψηφιακά περιουσιακά στοιχεία. Χτισμένο στο blockchain της Solana, το Metaplex διευκολύνει την προσθήκη πρόσθετων μεταδεδομένων σε tokens στη Solana.

Αυτό διαφέρει από το Ethereum, όπου συνήθως αναπτύσσετε ένα ολοκαίνουργιο συμβόλαιο ERC721 για κάθε συλλογή. Γιατί υπάρχει ένα ενιαίο κύριο πρόγραμμα για NFTs στη Solana; Οφείλεται στο μοντέλο λογαριασμών της Solana, το οποίο διαχωρίζει την κατάσταση (τα δεδομένα) από τη λογική εκτέλεσης (το πρόγραμμα). Επειδή η Solana επαναχρησιμοποιεί το Token Program για όλα τα tokens, δεν χρειάζεται να γράψετε και να αναπτύξετε ένα νέο συμβόλαιο NFT - απλώς ένα νέο mint account με προσφορά = 1.

NFTs Don't Have Contract Addresses, Only Mint Addresses

On Ethereum, each NFT collection is identified by its Contract Address, and each token has a unique tokenId within that contract. On Solana, each NFT is identified by a Mint Address. The difference is that you don't deploy a separate "NFT contract" - you just instruct the universal Token Program to create a new mint.

Because Solana's Token Program is universal, there's no concept of a unique "NFT contract address." Instead, each NFT is a special SPL token (supply of 1) with its own Mint Address.

If you want a "collection," you group multiple mint addresses together via a Collection Address in Metaplex, but each minted NFT is still just an SPL token with a unique Mint Address.

No Approval Flow Needed

On Ethereum, ERC721 often relies on approve or setApprovalForAll for external marketplaces or dApps to transfer your NFTs. On Solana, each NFT is stored in a user's ATA(Associated token account), and a single transaction can include any necessary steps. There's no separate approval flow - one atomic transaction can handle all instructions (e.g. transfer ownership, update metadata, etc.).

What Does A Solana Token Program Look Like?

A very rough translation of the Solana Token Program would look like this:

solidity

// SPDX-License-Identifier: MIT license
pragma solidity =0.8.28;

struct Mint {
    uint8 decimals;
    uint256 supply;
    address mintAuthority;
    address freezeAuthority;
    address mintAddress;
}

struct TokenAccount {
    address mintAddress;
    address owner;
    uint256 balance;
    bool isFrozen;
}

struct Metadata {
    string name;
    string symbol;
    string tokenURI;
}

contract Spl721 {
    mapping(address => Mint) public mints;
    mapping(address => TokenAccount) public tokenAccounts;
    mapping(address => Metadata) public nftMetadata;
    mapping(address => bool) public mintAddresses;
    mapping(address => bool) public tokenAddresses;

    function initializeMint(
        uint8 decimals,
        address mintAuthority,
        address freezeAuthority,
        address mintAddress
    )
        public
        returns (Mint memory)
    {
        require(!mintAddresses[mintAddress], "Mint already exists");
        mints[mintAddress] = Mint(decimals, 0, mintAuthority, freezeAuthority, mintAddress);
        mintAddresses[mintAddress] = true;
        return mints[mintAddress];
    }

    function setMetadata(
        address mintAddress,
        string memory name,
        string memory symbol,
        string memory tokenURI
    )
        public
    {
        require(mintAddresses[mintAddress], "Mint does not exist");
        nftMetadata[mintAddress] = Metadata(name, symbol, tokenURI);
    }

    function mintNFT(address toMintTokens, address mintAddress) public {
        require(mintAddresses[mintAddress], "NFT mint does not exist");
        require(mints[mintAddress].mintAuthority == msg.sender, "Only the mint authority can mint");
        require(mints[mintAddress].supply == 0, "NFT already minted");
        mints[mintAddress].supply = 1;
        address tokenAddress = address(uint160(uint256(keccak256(abi.encodePacked(toMintTokens, mintAddress)))));
        if (!tokenAddresses[tokenAddress]) {
            tokenAccounts[tokenAddress] = TokenAccount(mintAddress, toMintTokens, 0, false);
            tokenAddresses[tokenAddress] = true;
        }
        tokenAccounts[tokenAddress].balance = 1;
        tokenAccounts[tokenAddress].owner = toMintTokens;
    }

    function transfer(address to, address mintAddress, uint256 amount) public {
        address toTokenAddress = address(uint160(uint256(keccak256(abi.encodePacked(to, mintAddress)))));
        address fromTokenAddress = address(uint160(uint256(keccak256(abi.encodePacked(msg.sender, mintAddress)))));
        require(tokenAccounts[fromTokenAddress].balance >= amount, "Insufficient balance");
        require(amount == 1, "Only transferring 1 NFT at a time");
        require(tokenAccounts[fromTokenAddress].owner == msg.sender, "Not the NFT owner");
        require(!tokenAccounts[fromTokenAddress].isFrozen, "Sender token account is frozen");
        if (tokenAddresses[toTokenAddress]) {
            require(!tokenAccounts[toTokenAddress].isFrozen, "Receiver token account is frozen");
        }
        if (!tokenAddresses[toTokenAddress]) {
            tokenAccounts[toTokenAddress] = TokenAccount(mintAddress, to, 0, false);
            tokenAddresses[toTokenAddress] = true;
        }
        tokenAccounts[fromTokenAddress].balance -= amount;
        tokenAccounts[toTokenAddress].balance += amount;
        tokenAccounts[toTokenAddress].owner = to;
    }

    function freezeAccount(address owner, address mintAddress) public {
        require(mintAddresses[mintAddress], "Mint does not exist");
        require(mints[mintAddress].freezeAuthority == msg.sender, "Only the freeze authority can freeze");
        address tokenAddress = address(uint160(uint256(keccak256(abi.encodePacked(owner, mintAddress)))));
        require(tokenAddresses[tokenAddress], "Token account not found");
        tokenAccounts[tokenAddress].isFrozen = true;
    }

    function getMint(address token) public view returns (Mint memory) {
        return mints[token];
    }

    function getTokenAccount(address owner, address token) public view returns (TokenAccount memory) {
        return tokenAccounts[address(uint160(uint256(keccak256(abi.encodePacked(owner, token)))))];
    }

    function getMetadata(address mintAddress) public view returns (Metadata memory) {
        return nftMetadata[mintAddress];
    }
}

As you can see in the contract, instead of an approval flow, there is only a transfer function to move tokens. On Solana, a single transaction can call multiple smart contract functions atomically, removing the need for the approval flow. Another difference is that everything is stored in a token account on Solana, keeping the details of the owner's tokens separate from the other state.

Where's the NFT Metadata?

On Ethereum, ERC721 contracts often store a metadata URI or embed logic for fetching token metadata. On Solana, the Token Metadata Program (by Metaplex) handles NFT metadata in a separate account. You can include fields like name, symbol, description, image URI, and more--all without changing the underlying Token Program. This does mean there's a separate instruction in your minting transaction to attach metadata. Since Solana can handle multiple program calls atomically in one transaction, you can easily create the mint and set up metadata in a single go.

Tradeoffs of Each Approach

Now that you have a general idea of how the token program and metadata program on Solana works, let's go through some of the tradeoffs of each NFT standard.

ERC721

Highly customizable contracts
New contract deployment for each collection
Hard to index across many contracts
Metadata often defined in contract or via URIs
Requires individual audits

Solana NFT (SPL + Metaplex)

Single program for all NFTs
New NFTs created by transactions, not by new contracts
Easier to index since there's one main program
Metadata stored in a separate program
Reuses existing audited code

High-Level Comparison

Below is a table comparing the basic steps of deploying an ERC-721 token on Ethereum vs. creating an NFT (SPL token with metadata) on Solana. (On Solana, you can freely mint SPL tokens by using the spl-token command in the command-line tool.)

Βήμα	Ethereum (ERC-721)	Solana (SPL + Metaplex)
1. Προετοιμασία Κώδικα Token	Συνήθως χρησιμοποιούνται οι βιβλιοθήκες ERC721 της OpenZeppelin. Δημιουργείτε ένα αρχείο Solidity (π.χ. MyNFT.sol).	Δεν απαιτείται προσαρμοσμένο συμβόλαιο για βασική λειτουργικότητα NFT. Το Token Program είναι ήδη αναπτυγμένο. Απλά δημιουργείτε ένα mint account (προσφορά = 1).
2. Μεταγλώττιση & Ανάπτυξη	Μεταγλωττίζετε και αναπτύσσετε χρησιμοποιώντας Hardhat/Truffle (π.χ. `npx hardhat run deploy.js --network ...`).	Χρησιμοποιείτε ένα CLI (π.χ. `spl-token create-token --decimals 0`) ή ένα εργαλείο SDK (όπως το Candy Machine του Metaplex). Δεν απαιτείται ξεχωριστή ανάπτυξη συμβολαίου.
3. Δημιουργία NFT	Καλείτε τη συνάρτηση `mint()` του συμβολαίου, η οποία αναθέτει το NFT σε μια διεύθυνση και συνήθως ορίζει URIs μεταδεδομένων token. Τα τέλη gas μπορεί να ποικίλλουν.	Εκτελείτε `spl-token mint <MINT_ADDRESS> 1` ή χρησιμοποιείτε οδηγίες mint του Metaplex για να δημιουργήσετε ακριβώς 1 προσφορά. Τα τέλη συναλλαγών στο Solana είναι συνήθως πολύ χαμηλά.
4. Δημιουργία Αποδέκτη	Συνήθως απλά μια κανονική διεύθυνση Ethereum. Οι χρήστες πρέπει να προσθέσουν τη διεύθυνση του συμβολαίου NFT σε πολλά πορτοφόλια για να το δουν.	Κάθε χρήστης έχει ένα Associated Token Account (ATA). Πορτοφόλια όπως το Phantom αναγνωρίζουν αυτόματα τα ATA για NFT. Δεν χρειάζεται επιπλέον βήμα για να "προσθέσετε" το token, αν και μπορεί να εμφανιστεί στην καρτέλα "Συλλεκτικά" μόλις αναγνωριστεί.
5. Έλεγχος Αποτελεσμάτων	Προβολή στο Etherscan ή χρήση μιας αγοράς NFT όπως το OpenSea. Συχνά, οι χρήστες πρέπει να προσθέσουν χειροκίνητα τη διεύθυνση του συμβολαίου για να δουν τα tokens σε ορισμένα πορτοφόλια.	Χρησιμοποιήστε `solana balance <ADDRESS>` ή `spl-token accounts` για να δείτε τα token που κατέχετε. Μπορείτε επίσης να χρησιμοποιήσετε έναν Solana Explorer ή μια αγορά NFT (Magic Eden, OpenSea Solana κ.λπ.) για να επιβεβαιώσετε την παρουσία του NFT.
6. Μοναδικά Αναγνωριστικά	Διεύθυνση Συμβολαίου + `tokenId`.	Διεύθυνση Mint. Κάθε NFT είναι απλά ένα SPL token με `supply=1`.
7. Συλλογές	Όλα τα tokens σε ένα συμβόλαιο συνήθως αντιπροσωπεύουν μια ενιαία συλλογή.	Οι συλλογές ανατίθενται μέσω μιας "διεύθυνσης συλλογής" στο Metaplex. Δεν αναπτύσσετε αποκλειστικό συμβόλαιο.
8. Ενημερώσεις Κώδικα	Για μεγάλες αναβαθμίσεις, μπορεί να χρησιμοποιήσετε ένα μοτίβο proxy ή να επαναναπτύξετε το συμβόλαιο. Μόνο προχωρημένοι προγραμματιστές το κάνουν συνήθως αυτό.	Το Token Program είναι σταθερό. Αν χρειάζεστε προηγμένες δυνατότητες (δικαιώματα, δυναμικά μεταδεδομένα κ.λπ.), μπορείτε να χρησιμοποιήσετε ή να δημιουργήσετε ξεχωριστά onchain προγράμματα. Το Metaplex υποστηρίζει επίσης επεκτάσεις όπως προγραμματιζόμενα NFT.
9. Απαιτήσεις Ελέγχου	Κάθε συμβόλαιο συνήθως απαιτεί έλεγχο, ειδικά αν προσθέσετε προσαρμοσμένη λογική minting, μια αγορά κ.λπ.	Το κύριο Token Program και το Metaplex Metadata Program έχουν ελεγχθεί πολλές φορές. Για ένα τυπικό mint ενός NFT, δεν είναι συνήθως απαραίτητος πρόσθετος έλεγχος συμβολαίου.

Want to mint your own NFT on Solana? Check out this guide!

How to do ERC721 on Solana

Let's explore how to interact with the Token Program using solana/web3.js based on Ethereum's ERC721 interface structure.

As mentioned above, since NFT Collections on Solana are not tied to a specific contract, the concept of a tokenId does not exist. Therefore, to find the specific data of a token, you should use Mint Address or Collection Address.

How to do `name()`

solidity

function name() external view returns (string); // Returns the token collection name

You can use @metaplex-foundation/umi-bundle-defaults and @metaplex-foundation/mpl-token-metadata to fetch and parse an NFT's off-chain metadata from its mint address.

jsx

import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
import { fetchDigitalAsset, mplTokenMetadata } from "@metaplex-foundation/mpl-token-metadata";
import { PublicKey } from "@metaplex-foundation/js";
const mintAddress = new PublicKey("Token Address");

async function name() {
  try {
    const umi = createUmi("https://api.devnet.solana.com");
    umi.use(mplTokenMetadata());
    const digitalAsset = await fetchDigitalAsset(umi, mintAddress);
    return digitalAsset.metadata.name;
  } catch (error) {
    console.error("Error fetching NFT name:", error);
    return null;
  }
}

name().then(nftName => {
    console.log("NFT Name:", nftName);
  })
  .catch(error => {
    console.error("Error:", error);
  });

How to do `symbol()`

solidity

function symbol() external view returns (string); // Returns the token collection symbol

You can also retrieve the symbol in the same way as name(), using @metaplex-foundation/umi-bundle-defaults and @metaplex-foundation/mpl-token-metadata.

jsx

import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
import { fetchDigitalAsset, mplTokenMetadata } from "@metaplex-foundation/mpl-token-metadata";
import { PublicKey } from "@metaplex-foundation/js";
const mintAddress = new PublicKey("Token Address");

async function symbol() {
  try {
    const umi = createUmi("https://api.devnet.solana.com");
    umi.use(mplTokenMetadata());
    const digitalAsset = await fetchDigitalAsset(umi, mintAddress);
    return digitalAsset.metadata.symbol;
  } catch (error) {
    console.error("Error fetching NFT symbol:", error);
    return null;
  }
}

symbol().then(nftSymbol => {
  console.log("NFT Symbol:", nftSymbol);
}).catch(error => {
  console.error("Error:", error);
});

How to do `tokenURI()`

bash

function tokenURI(uint256 _tokenId) external view returns (string); // Returns the tokenURI of the token

You can also retrieve the symbol in the same way as name(), using @metaplex-foundation/umi-bundle-defaults and @metaplex-foundation/mpl-token-metadata.

jsx

import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
import { fetchDigitalAsset, mplTokenMetadata } from "@metaplex-foundation/mpl-token-metadata";
import { PublicKey } from "@metaplex-foundation/js";
const mintAddress = new PublicKey("Token Address");

async function tokenURI( /* no tokenId */ ) {
  try {
    const umi = createUmi("https://api.devnet.solana.com");
    umi.use(mplTokenMetadata());
    const digitalAsset = await fetchDigitalAsset(umi, mintAddress);
    return digitalAsset.metadata.uri;
  } catch (error) {
    console.error("Error fetching token URI:", error);
    return null;
  }
}

tokenURI()
  .then(uri => {
    console.log("Token URI:", uri);
  })
  .catch(error => {
    console.error("Error:", error);
  });

How to do `ownerOf()`

bash

function ownerOf(uint256 _tokenId) public view returns (address) // Returns the owner of the tokenId token

We can check the owner of an NFT using the mint address instead of the tokenId.

jsx

import { Connection, PublicKey } from "@solana/web3.js";

const connection = new Connection("https://api.devnet.solana.com", "confirmed");
const mintAddress = new PublicKey("Token Address");

async function ownerOf( /*no tokenId*/ ){
  const largestAccounts = await connection.getTokenLargestAccounts(new PublicKey(mintAddress));
  const largestAccountInfo = await connection.getParsedAccountInfo(largestAccounts.value[0].address);
  return largestAccountInfo.value.data.parsed.info.owner;
}

ownerOf().then(owner => {
  console.log(owner);
}).catch(error => {
  console.error("Error:", error);
});

How to do `transferFrom()`

solidity

function transferFrom(address _from, address _to, uint256 _tokenId) external payable; // Transfers tokenId token from _from to _to

First, Let's look at this code for understanding logic:

On Solana, each token is identified by its unique Mint address, and users store their balances in an Associated Token Account (ATA). In a transaction, the ATA address is used as the sender or receiver for transferring tokens. Unlike on Ethereum, where you directly call an ERC-20 contract, Solana handles token transfer logic through its native system program.

We can make a transaction's transfer instruction through createTransferCheckedInstruction and send it through sendTransaction from @solana/spl-token.

jsx

import { Keypair, Transaction, Connection, PublicKey } from "@solana/web3.js";
import { createTransferCheckedInstruction } from "@solana/spl-token";

const connection = new Connection("https://api.devnet.solana.com", "confirmed");

// Replace with your real private key (as a Uint8Array)
const ownerSecretkey = [];
const ownerPrivatekeypair = Keypair.fromSecretKey(new Uint8Array(ownerSecretkey));

const fromPublicKey = ownerPrivatekeypair.publicKey; // The sender's public key
const toPublicKey = new PublicKey("Receiver's Wallet Address");

const mintAddress = new PublicKey("Token Address");

// Pre-existing ATA addresses (for `_from` and `_to`)
const ownerTokenAccount = new PublicKey("Associated Token Account of _from");
const receiverTokenAccount = new PublicKey("Associated Token Account of _to");

// For an NFT, decimals = 0 and amount = 1
async function transferFrom(_from, _to) {
  try {
    const tx = new Transaction().add(
      createTransferCheckedInstruction(
        ownerTokenAccount,              // _from's ATA
        mintAddress,
        receiverTokenAccount,           // _to's ATA
        ownerPrivatekeypair.publicKey,  // Authority for `_from` (the private key must match this public key)
        1,                              // amount = 1 NFT
        0                               // decimals = 0 for NFT
      )
    );
    
    // Send transaction (simple version)
    await connection.sendTransaction(tx, [ownerPrivatekeypair]);
    return true;
  } catch (error) {
    console.error("Error in transferFrom:", error);
    return false;
  }
}

transferFrom(fromPublicKey, toPublicKey)
  .then(result => {
    console.log("transferFrom result:", result);
  })
  .catch(error => {
    console.error("Error:", error);
  });

How we can check receiverTokenAddress through receiverAddress? We can use getOrCreateAssociatedTokenAccount. It will retrieve the associated token account, or create it if it doesn't exist.

jsx

import { Keypair, Transaction, Connection, PublicKey } from "@solana/web3.js";
import { createTransferCheckedInstruction, getOrCreateAssociatedTokenAccount } from "@solana/spl-token";

const connection = new Connection("https://api.devnet.solana.com", "confirmed");

// Insert your private key as a Uint8Array
const ownerSecretkey = [];
const ownerPrivatekeypair = Keypair.fromSecretKey(new Uint8Array(ownerSecretkey));

const fromAddress = ownerPrivatekeypair.publicKey;  // The sender's public key
const toAddress = new PublicKey("Receiver's Wallet Address");

const mintAddress = new PublicKey("Token Address");

// For an NFT: decimals = 0, amount = 1
async function transferFrom(_from, _to) {
  try {
    // Retrieve (or create if missing) the sender's ATA
    const ownerTokenAccount = await getOrCreateAssociatedTokenAccount(
      connection,
      ownerPrivatekeypair,    // Fee payer
      mintAddress,
      _from
    );

    // Retrieve (or create if missing) the receiver's ATA
    const receiverTokenAccount = await getOrCreateAssociatedTokenAccount(
      connection,
      ownerPrivatekeypair,    // Fee payer (use the receiver if needed)
      mintAddress,
      _to
    );

    // Create transaction with a transfer of 1 NFT (decimals=0)
    const tx = new Transaction().add(
      createTransferCheckedInstruction(
        ownerTokenAccount.address,
        mintAddress,
        receiverTokenAccount.address,
        ownerPrivatekeypair.publicKey,
        1, // Always transfer exactly 1 (NFT)
        0  // decimals = 0 for an NFT
      )
    );

    // Send the transaction
    await connection.sendTransaction(tx, [ownerPrivatekeypair]);
    return true;
  } catch (error) {
    console.error("Error in transferFrom:", error);
    return false;
  }
}

transferFrom(fromAddress, toAddress)
  .then(result => {
    console.log("Transaction result:", result);
  })
  .catch(error => {
    console.error("Error:", error);
  });

Want to explore more features? Check out this guide!

EVM TO SVM

Home

Start building on Solana

What is ERC721 on Solana?

Το Token Program (Συν Μεταδεδομένα)

NFTs Don't Have Contract Addresses, Only Mint Addresses

No Approval Flow Needed

What Does A Solana Token Program Look Like?

Where's the NFT Metadata?

Tradeoffs of Each Approach

High-Level Comparison

How to do ERC721 on Solana

How to do name()

How to do symbol()

How to do tokenURI()

How to do ownerOf()

How to do transferFrom()

Start building on Solana

Intro to Solana Development

Intro to Solana Development

Solana Development Course

Solana Bootcamp

More Solana Developer Tools

How to do `name()`

How to do `symbol()`

How to do `tokenURI()`

How to do `ownerOf()`

How to do `transferFrom()`