Zum Inhalt springen
MetaMask herunterladen
MetaMask herunterladen

Ein einfacher Leitfaden zu ERC-1155-Tokens auf Ethereum

Entdecke die Vielseitigkeit von Ethereums ERC-1155-Token-Standard, erfahre, wie er das digitale Asset-Management vereinfacht, und folge einer Schritt-für-Schritt-Anleitung zur Erstellung...

4 Min. Lesezeit
Ein einfacher Leitfaden zu ERC-1155-Tokens auf Ethereum

Die Blockchain von Ethereum hat die Erstellung und Verwaltung digitaler Assets grundlegend verändert. Zu diesen Fortschritten zählt der ERC-1155-Standard als besonders bemerkenswerte Innovation. Vom Team bei Enjin eingeführt, wurde ERC-1155 entwickelt, um die Effizienz digitaler Assets auf der Blockchain zu optimieren und zu steigern – durch die Möglichkeit, fungible, non-fungible und semi-fungible Token innerhalb eines einzigen Smart Contracts zu erstellen.

ERC-1155 wurde entwickelt, um Ineffizienzen früherer Token-Standards wie ERC-20 und ERC-721 zu beheben. Während ERC-20 für fungible Token geeignet ist (bei denen jeder Token identisch und austauschbar ist) und ERC-721 für non-fungible Token (bei denen jeder Token einzigartig ist), stoßen diese Standards beim Umgang mit mehreren Token-Typen an ihre Grenzen in Bezug auf Umfang und Effizienz.

Einige der wichtigsten Vorteile von ERC-1155 sind:

  • Batch Transfers: ERC-1155 unterstützt Batch Transfers und ermöglicht es, mehrere Token-Typen in einer einzigen Transaktion zu übertragen. Dies senkt die Gaskosten erheblich und erhöht die Transaktionsgeschwindigkeit.

  • Ein einziger Contract für mehrere Token: Dieser Standard ermöglicht es einem einzigen Contract, sowohl fungible als auch non-fungible Token zu verwalten, was die Bereitstellung vereinfacht und Kosten reduziert.

  • Safe Transfer Checks: ERC-1155 stellt sicher, dass Token an kompatible Adressen gesendet werden, was die Transaktionssicherheit erhöht und Verluste durch Fehler verhindert.

Hier sind einige praktische Anwendungen von ERC-1155:

  • Gaming: Ermöglicht die Verwaltung einer vollständigen In-Game-Wirtschaft – von Verbrauchsgegenständen bis hin zu seltener Ausrüstung – innerhalb eines einzigen Contracts.

  • Digitale Kunst: Ermöglicht Künstlern, sowohl limitierte als auch offene Editionen nahtlos herauszugeben.

  • Tokenisierte Assets: Reale Vermögenswerte können mithilfe von ERC-1155 tokenisiert und verwaltet werden.

Einen ERC-1155-Token schreiben und deployen

In diesem Tutorial erstellen wir einen einfachen ERC-1155-Token namens RAD Token. Dieses Beispiel zeigt, wie verschiedene Assets innerhalb eines einzigen Contract-Frameworks verwaltet werden können.

  1. Richte deine Entwicklungsumgebung ein: Stelle vor dem Start sicher, dass Node.js und npm installiert sind. Richte dann dein Hardhat-Projekt ein:

mkdir rad-token
cd rad-token
npm init -y
Kopieren

  1. Installiere Hardhat und OpenZeppelin Contracts

npm install --save-dev hardhat 
npm install @openzeppelin/contracts
Kopieren

  1. Initialisiere Hardhat

npx hardhat

Wähle „Create an empty hardhat.config.js", wenn du dazu aufgefordert wirst.

  1. Schreibe den RADToken-Contract: Erstelle eine neue Datei contracts/RADToken.sol und füge den folgenden Contract-Code ein.


// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

import "@openzeppelin/contracts/utils/Strings.sol";

contract RADToken is ERC1155, Ownable {

    constructor(address initialOwner, string memory baseURI) ERC1155(baseURI) Ownable(initialOwner) {

        // Initialize contract with metadata URI

 }

    function mint(address account, uint256 id, uint256 amount, bytes memory data)

        public

        onlyOwner

 {

        _mint(account, id, amount, data);

 }

    function mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data)

        public

        onlyOwner

 {

        _mintBatch(to, ids, amounts, data);

 }

    function setURI(string memory newuri) public onlyOwner {

        _setURI(newuri);

 }

    function uri(uint256 tokenId) public view override returns (string memory) {

        return string(abi.encodePacked(super.uri(tokenId), Strings.toString(tokenId), ".json"));

 }

    function burn(address account, uint256 id, uint256 amount) public onlyOwner {

        _burn(account, id, amount);

 }

    function burnBatch(address account, uint256[] memory ids, uint256[] memory amounts)

        public

        onlyOwner

 {

        _burnBatch(account, ids, amounts);

 }

}

Kopieren

  1. Schreibe das Deployment-Skript: Erstelle eine neue Datei ignition/modules/RadToken.js für das Hardhat Ignition Deployment-Modul und füge den folgenden Code hinzu.

const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
module.exports = buildModule("RADTokenModule", (m) => {
  const deployer = m.getAccount(0);
  const baseURI = m.getParameter(
    "baseURI",
"<https://gateway.pinata.cloud/ipfs/Qmar8RRAZ5QoVPTzvrRk9PcFSm9YKbkanxmd951nXk2bgM/>"
);
  const radToken = m.contract("RADToken", [deployer, baseURI]);
  return { radToken };
});
Kopieren

  1. Schreibe Test-Skripte: Erstelle eine neue Datei test/RadToken.js zum Testen des Contracts und füge den folgenden Code hinzu:

const { expect } = require("chai");
const { ethers } = require("hardhat");
const {
  loadFixture,
} = require("@nomicfoundation/hardhat-toolbox/network-helpers");

describe("RADToken", function () {
  async function deployRADTokenFixture() {
    const [owner, addr1, addr2, ...addrs] = await ethers.getSigners();
    const RADToken = await ethers.getContractFactory("RADToken");
    const baseURI =
      "https://gateway.pinata.cloud/ipfs/Qmar8RRAZ5QoVPTzvrRk9PcFSm9YKbkanxmd951nXk2bgM/";
    const radToken = await RADToken.deploy(owner.address, baseURI);

    return { radToken, owner, addr1, addr2, addrs };
 }

  describe("Minting", function () {
    it("Should mint a token", async function () {
      const { radToken, addr1 } = await loadFixture(deployRADTokenFixture);
      await radToken.mint(addr1.address, 1, 100, "0x");
      expect(await radToken.balanceOf(addr1.address, 1)).to.equal(100);
 });

    it("Should mint multiple tokens in batch", async function () {
      const { radToken, addr1 } = await loadFixture(deployRADTokenFixture);
      await radToken.mintBatch(addr1.address, [1, 2], [100, 200], "0x");
      expect(await radToken.balanceOf(addr1.address, 1)).to.equal(100);
      expect(await radToken.balanceOf(addr1.address, 2)).to.equal(200);
 });
 });

  describe("URI Management", function () {
    it("Should return correct token URI", async function () {
      const { radToken } = await loadFixture(deployRADTokenFixture);
      expect(await radToken.uri(1)).to.equal(
        "https://gateway.pinata.cloud/ipfs/Qmar8RRAZ5QoVPTzvrRk9PcFSm9YKbkanxmd951nXk2bgM/1.json"
 );
 });

    it("Should set new URI and return correct token URI", async function () {
      const { radToken } = await loadFixture(deployRADTokenFixture);
      const newBaseURI = "https://newbase.uri/";
      await radToken.setURI(newBaseURI);
      expect(await radToken.uri(1)).to.equal("https://newbase.uri/1.json");
 });
 });
});
Kopieren

  1. Teste den Contract-Code: Führe die Tests mit dem folgenden Befehl aus:

npx hardhat test

  1. Deploye den RADToken-Contract: Kompiliere und deploye den Contract mit den folgenden Befehlen:

npx hardhat compile 
npx hardhat ignition --network localhost --show-logs ignition/modules/RadToken.js
Kopieren

Wie geht es weiter?

ERC-1155 stellt einen bedeutenden Fortschritt bei den Token-Standards von Ethereum dar und bietet im Vergleich zu seinen Vorgängern mehr Flexibilität, Effizienz und Nutzen. Das RAD-Token-Beispiel zeigt, wie einfach mehrere Token-Typen unter einem einzigen Contract verwaltet werden können – und öffnet damit die Tür für eine neue Generation dezentraler Anwendungen.

Nützliche Ressourcen

KI-übersetzt. Kann Fehler enthalten. Bitte überprüfen Sie die Informationen stets.

Bewerten Sie die Übersetzung

Dieser Artikel wurde verfasst von:

Neueste Artikel

Alle Nachrichten