Smarta blockkedjekontrakt med Solidity · Lektion

ERC-1155-standarden för flera token-typer

Lär er ERC-1155-standarden för flera token-typer, som låter ett enda kontrakt hantera fungibla, semi-fungibla och icke-fungibla token tillsammans för gaseffektiva batchoperationer.

Lektion 4 av 413 steg

ERC-1155-standarden för flera token-typer är en gratis lektion i Smarta blockkedjekontrakt med Solidity på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Smarta blockkedjekontrakt med Solidity, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Varför ERC-1155 finns

ERC-20 hanterar en fungibel token, medan ERC-721 hanterar unika NFT:er. Men ett spel kan behöva tusentals objekttyper som kombinerar båda. Att distribuera ett separat kontrakt per typ är ineffektivt.

ERC-1155 är ett enda kontrakt som kan hantera många token-ID:n samtidigt, där varje ID kan vara fungibelt eller icke-fungibelt.

Token-ID:n som kategorier

I ERC-1155 identifieras varje token av ett numeriskt id. Samma id kan ha ett saldo som är större än ett (fungibel) eller en tillgång på exakt ett (icke-fungibel).

id = 1 med saldo 500 = ett fungibelt guldmynt
id = 2 med saldo 1 = ett unikt svärd som NFT

Den centrala saldomappningen

Kärnan i ett ERC-1155-kontrakt är en nästlad mappning från id till owner till balance.

mapping(uint256 => mapping(address => uint256)) private _balances;

function balanceOf(address account, uint256 id) public view returns (uint256) {
    return _balances[id][account];
}

Batchfrågor om saldon

En viktig funktion är balanceOfBatch, som returnerar många saldon i ett enda anrop och sparar extra rundturer.

function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
    public view returns (uint256[] memory)
{
    require(accounts.length == ids.length, 'length mismatch');
    uint256[] memory batch = new uint256[](accounts.length);
    for (uint256 i = 0; i < accounts.length; i++) {
        batch[i] = _balances[ids[i]][accounts[i]];
    }
    return batch;
}

Batchöverföringar

ERC-1155 låter er flytta flera tokentyper i en enda transaktion med safeBatchTransferFrom. Det är mycket billigare än många separata ERC-20-/ERC-721-överföringar.

function safeBatchTransferFrom(
    address from,
    address to,
    uint256[] memory ids,
    uint256[] memory amounts,
    bytes memory data
) public {
    require(ids.length == amounts.length, 'length mismatch');
    for (uint256 i = 0; i < ids.length; i++) {
        _balances[ids[i]][from] -= amounts[i];
        _balances[ids[i]][to] += amounts[i];
    }
}

Godkännande för alla

I stället för godkännanden per token använder ERC-1155 ett enda operatörsgodkännande: setApprovalForAll ger en adress rätt att flytta alla tokens som ni äger.

mapping(address => mapping(address => bool)) private _operatorApprovals;

function setApprovalForAll(address operator, bool approved) public {
    _operatorApprovals[msg.sender][operator] = approved;
}

function isApprovedForAll(address owner, address operator) public view returns (bool) {
    return _operatorApprovals[owner][operator];
}

Den gemensamma URI:n för metadata

ERC-1155 använder en URI-mall för alla tokens. Platshållaren {id} ersätts av klienter med token-ID:t i hexadecimal form.

Exempel: https://game.example/api/{id}.json

string private _uri = 'https://game.example/api/{id}.json';

function uri(uint256) public view returns (string memory) {
    return _uri;
}

Skapa tokens

Att skapa tokens ökar saldot för ett id. Samma interna logik fungerar både för fungibla tokens (amount > 1) och icke-fungibla tokens (amount = 1).

function _mint(address to, uint256 id, uint256 amount) internal {
    require(to != address(0), 'mint to zero');
    _balances[id][to] += amount;
    emit TransferSingle(msg.sender, address(0), to, id, amount);
}

event TransferSingle(address operator, address from, address to, uint256 id, uint256 value);

Kontroll av mottagare vid säkra överföringar

Precis som ERC-721 skyddar ERC-1155 mot att tokens låses in i kontrakt. Ett mottagande kontrakt måste implementera onERC1155Received och returnera sitt magic value, annars återställs överföringen.

interface IERC1155Receiver {
    function onERC1155Received(
        address operator, address from,
        uint256 id, uint256 value, bytes calldata data
    ) external returns (bytes4);
}

Använda OpenZeppelin

I praktiken ärver ni den granskade OpenZeppelin-implementationen i stället för att skriva den från grunden.

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

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

contract GameItems is ERC1155 {
    uint256 public constant GOLD = 0;
    uint256 public constant SWORD = 1;

    constructor() ERC1155('https://game.example/api/{id}.json') {
        _mint(msg.sender, GOLD, 1000, '');
        _mint(msg.sender, SWORD, 1, '');
    }
}

När ska ni välja ERC-1155?

Välj ERC-1155 när ni har många tokentyper, behöver batchoperationer eller kombinerar fungibla och icke-fungibla tillgångar. Använd ERC-20/721 för en enda enkel tillgång när den extra komplexiteten inte är motiverad.

Snabb kontroll

Testa er förståelse av ERC-1155.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att ERC-1155 är en multitoken-standard som hanterar många ID:n i ett enda kontrakt. Viktiga punkter:

Nästlad mappning med id => owner => balance
Batchfrågor och överföringar sparar gas
Ett enda operatörsgodkännande och en gemensam URI med {id}
Kontroller av mottagare vid säkra överföringar skyddar mot låsta tokens

Det är standarden att välja för spel och marknadsplatser med många tillgångstyper.

Gratis att börja

Lär dig Smarta blockkedjekontrakt med Solidity med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”ERC-1155-standarden för flera token-typer” gratis?

Ja – hela texten till ”ERC-1155-standarden för flera token-typer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Smarta blockkedjekontrakt med Solidity, kan Ni uppgradera till CoddyKit PRO. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Vad lär jag mig i ”ERC-1155-standarden för flera token-typer”?

Lär er ERC-1155-standarden för flera token-typer, som låter ett enda kontrakt hantera fungibla, semi-fungibla och icke-fungibla token tillsammans för gaseffektiva batchoperationer. Ni övar på Smarta blockkedjekontrakt med Solidity med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Smarta blockkedjekontrakt med Solidity?

Du behöver inga förkunskaper. Utbildningen i Smarta blockkedjekontrakt med Solidity på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”ERC-1155-standarden för flera token-typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Smarta blockkedjekontrakt med Solidity-lektionen?

Ja. Varje Smarta blockkedjekontrakt med Solidity-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Standarden ERC-20 för fungibla token
Implementera en ERC-20-token
Icke-fungibla token (NFT:er) enligt ERC-721
ERC-1155-standarden för flera token-typer

← Tillbaka till Smarta blockkedjekontrakt med Solidity