From Basics to Deployment: ERC-721 and ERC-1155 for DeFi Enthusiasts

Introduction to Token Standards in DeFi

Digital assets on Ethereum are built on a set of rules called token standards. These standards define how tokens behave, how they are stored, and how they interact with smart contracts. For developers and enthusiasts who want to explore the intersection of non‑fungible tokens (NFTs) and decentralized finance (DeFi), the most important standards to understand are ERC‑721 and ERC‑1155.

In this guide we start from the very basics, explain why NFTs matter in DeFi, compare the two standards side by side, and walk through a practical deployment example. By the end you will have a solid foundation to experiment with NFTs in your own DeFi projects.

What Makes a Token Standard?

A token standard is simply a specification that describes a set of functions and events. It guarantees that any contract that follows the standard will behave predictably. Think of it as a contract template that all applications can trust.

• ERC‑20 is the standard for fungible tokens (e.g., USDC, DAI).
• ERC‑721 is the standard for unique, indivisible tokens (the classic NFT).
• ERC‑1155 is a newer standard that allows a single contract to hold both fungible and non‑fungible tokens.

The advantage of using a standard is that wallets, exchanges, and other contracts can interact with any token that implements the same interface without needing custom code.

NFTs in DeFi: Why They Matter

Non‑fungible tokens are usually associated with digital art, collectibles, or virtual real estate. However, DeFi ecosystems have begun to leverage the unique properties of NFTs in creative ways:

1. Collateralization – NFTs can serve as collateral for loans on platforms like NFTfi or Aave’s NFT vaults.
2. Tokenization of Physical Assets – Real‑world items can be represented as NFTs, enabling fractional ownership.
3. Governance – Rare NFTs can confer voting power or exclusive rights within DAO structures.
4. Yield Farming – Some protocols allow users to stake NFTs to earn fungible tokens.

Because NFTs are non‑fungible, they require specialized handling compared to fungible tokens. That’s where ERC‑721 and ERC‑1155 come into play.

ERC‑721: The Classic NFT Standard

Core Characteristics

• Uniqueness – Every token has a distinct ID that cannot be replicated.
• Indivisibility – A token cannot be split into smaller units.
• Metadata URI – Each token can point to external metadata (images, attributes, etc.).
• Ownership Transfer – Secure transfer via transferFrom or safeTransferFrom.

Typical Use Cases

• Digital art platforms like OpenSea.
• Collectible card games (e.g., CryptoKitties).
• In‑game items that are truly unique.

Key Functions

Pros and Cons

ERC‑1155: Multi‑Token Flexibility

Core Characteristics

• Batch Operations – Mint, transfer, and burn multiple token types in a single transaction.
• Mixed Token Types – A single contract can contain fungible, semi‑fungible, and non‑fungible tokens.
• Single Address for All Tokens – Easier to manage permissions and royalties.

Typical Use Cases

• Game assets where some items are common (e.g., gold coins) and others rare (e.g., legendary weapons).
• Decentralized exchanges that support token swaps for multiple token types simultaneously.
• Protocols that want to offer NFT collateral and fungible rewards from the same contract.

Key Functions

Pros and Cons

Choosing Between ERC‑721 and ERC‑1155

A pragmatic strategy is to start with ERC‑1155 if you foresee scaling or mixed token types, and then create a wrapper or bridge if you later need to expose specific assets to purely ERC‑721 marketplaces.

Step‑by‑Step Deployment: From Concept to Live Contract

Below is a concise guide to deploying an ERC‑1155 contract that can be used for both fungible and non‑fungible assets. We assume you are familiar with Solidity and the Hardhat development environment.

1. Project Setup

mkdir nft-defi-demo
cd nft-defi-demo
npm init -y
npm install --save-dev hardhat @nomiclabs/hardhat-ethers ethers
npx hardhat

Choose “Create an empty hardhat.config.js” when prompted.

2. Install OpenZeppelin Contracts

OpenZeppelin provides battle‑tested implementations for ERC‑1155.

npm install @openzeppelin/contracts

3. Write the Contract

Create contracts/DeFiNFT.sol:

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract DeFiNFT is ERC1155, Ownable {
    // Mapping from token ID to its supply (for fungible tokens)
    mapping(uint256 => uint256) private _supply;

    constructor(string memory uri_) ERC1155(uri_) {}

    // Mint new tokens
    function mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) external onlyOwner {
        _mint(to, id, amount, data);
        _supply[id] += amount;
    }

    // Mint batch
    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) external onlyOwner {
        _mintBatch(to, ids, amounts, data);
        for (uint i = 0; i < ids.length; i++) {
            _supply[ids[i]] += amounts[i];
        }
    }

    // Burn tokens
    function burn(
        address from,
        uint256 id,
        uint256 amount
    ) external {
        require(msg.sender == from || isApprovedForAll(from, msg.sender), "Not approved");
        _burn(from, id, amount);
        _supply[id] -= amount;
    }

    // Get total supply for a token ID
    function totalSupply(uint256 id) external view returns (uint256) {
        return _supply[id];
    }
}

4. Configure Hardhat

Edit hardhat.config.js:

require("@nomiclabs/hardhat-ethers");

module.exports = {
  solidity: "0.8.20",
  networks: {
    goerli: {
      url: "https://goerli.infura.io/v3/<YOUR_INFURA_KEY>",
      accounts: [`0x${process.env.PRIVATE_KEY}`]
    }
  }
};

Add your Infura key and private key to .env and load it using dotenv.

5. Compile

npx hardhat compile

6. Write a Deployment Script

Create scripts/deploy.js:

async function main() {
  const [deployer] = await ethers.getSigners();
  console.log("Deploying contracts with account:", deployer.address);

  const DeFiNFT = await ethers.getContractFactory("DeFiNFT");
  const nft = await DeFiNFT.deploy("https://api.example.com/metadata/{id}.json");

  await nft.deployed();
  console.log("DeFiNFT deployed at:", nft.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

7. Deploy to Goerli

npx hardhat run scripts/deploy.js --network goerli

The script will output the contract address. Verify on Etherscan and test minting.

8. Interacting with the Contract

Use Hardhat console or a front‑end framework to call mint, mintBatch, or burn. For example:

const tx = await nft.mint(deployer.address, 1, 100, "0x");
await tx.wait();

This mints 100 units of fungible token ID 1 to the deployer. For a non‑fungible token, call mint with amount = 1.

9. Integrating with DeFi Protocols

• Collateralization – Wrap the NFT contract into a vault contract that accepts any ERC‑1155 token as collateral.
• Yield Farming – Allow users to stake specific token IDs to earn rewards.
• Cross‑chain Bridges – Use ChainBridge or similar to transfer ERC‑1155 tokens between networks.

Security Considerations

OpenZeppelin’s libraries already include many of these safeguards. Always audit your contract or use a reputable third‑party auditor before deploying to mainnet.

Tooling and Ecosystem Support

• Hardhat & Truffle – Local development and testing.
• OpenZeppelin Defender – Deploys, monitors, and secures contracts.
• Chainlink Keepers – Automate periodic actions (e.g., auto‑bidding on NFTs).
• The Graph – Index ERC‑1155 events for off‑chain analytics.
• Third‑web – Front‑end SDK that simplifies wallet interactions.

Community Resources

• OpenZeppelin Blog – Guides on token standards.
• Ethereum Stack Exchange – Question‑answering for Solidity nuances.
• DeFi Pulse & Nansen – Analytics on NFT collateralization trends.
• Discord Communities – @defifarm, @nftcatalyst, and others share real‑world use cases.

Conclusion

ERC‑721 and ERC‑1155 each bring unique strengths to the DeFi landscape. ERC‑721 remains the gold standard for truly unique digital assets, while ERC‑1155 offers a powerful, gas‑efficient approach for handling multiple token types within a single contract. Understanding these standards is crucial for building robust, interoperable DeFi solutions that leverage the full potential of digital ownership.

By following the deployment steps outlined above, you can prototype an ERC‑1155 contract that fits both fungible and non‑fungible use cases. From there, the path opens to innovative collateralization mechanisms, yield farming strategies, and cross‑chain integrations that bring NFT utility to the broader DeFi ecosystem.

Happy hacking, and may your smart contracts stay secure and your yields stay high!