Skip to main content

ERC1155

This interface is currently support by the Edition and Edition Drop contracts. You can access all of its functions through an Edition or Edition Drop contract instance.

type ERC1155 struct {
    ClaimConditions *EditionDropClaimConditions
}

func (*ERC1155) Balance​

func (erc1155 *ERC1155) Balance(ctx context.Context, tokenId int) (int, error)

Get NFT balance​

@extension: ERC1155

tokenId: the token ID of a specific token to check the balance of

returns: the number of NFTs of the specified token ID owned by the connected wallet

func (*ERC1155) BalanceOf​

func (erc1155 *ERC1155) BalanceOf(ctx context.Context, address string, tokenId int) (int, error)

Get NFT balance of a specific wallet​

@extension: ERC1155

address: the address of the wallet to get the NFT balance of

returns: the number of NFTs of the specified token ID owned by the specified wallet

Example​

address := "{{wallet_address}}"
tokenId := 0
balance, err := contract.BalanceOf(context.Background(), address, tokenId)

func (*ERC1155) Burn​

func (erc1155 *ERC1155) Burn(ctx context.Context, tokenId int, amount int) (*types.Transaction, error)

Burn NFTs​

@extension: ERC1155Burnable

tokenId: tokenID of the token to burn

amount: number of NFTs of the token ID to burn

returns: the transaction receipt of the burn

Example​

tokenId := 0
amount := 1
tx, err := contract.Burn(context.Background(), tokenId, amount)

func (*ERC1155) Claim​

func (erc1155 *ERC1155) Claim(ctx context.Context, tokenId int, quantity int) (*types.Transaction, error)

Claim an NFT​

@extension: ERC1155ClaimCustom | ERC1155ClaimPhasesV2 | ERC1155ClaimConditionsV2

tokenId: the token ID of the NFT to claim

quantity: the number of NFTs to claim

returns: the transaction receipt of the claim

Example​

tokenId = 0
quantity = 1
tx, err := contract.ClaimTo(context.Background(), tokenId, quantity)

func (*ERC1155) ClaimTo​

func (erc1155 *ERC1155) ClaimTo(ctx context.Context, destinationAddress string, tokenId int, quantity int) (*types.Transaction, error)

Claim an NFT to a specific wallet​

@extension: ERC1155ClaimCustom | ERC1155ClaimPhasesV2 | ERC1155ClaimConditionsV2

tokenId: the token ID of the NFT to claim

destinationAddress: the address of the wallet to claim the NFTs to

quantity: the number of NFTs to claim

returns: the transaction receipt of the claim

Example​

address = "{{wallet_address}}"
tokenId = 0
quantity = 1

tx, err := contract.ClaimTo(context.Background(), address, tokenId, quantity)

func (*ERC1155) CreateBatch​

func (erc1155 *ERC1155) CreateBatch(ctx context.Context, metadatas []*NFTMetadataInput) (*types.Transaction, error)

Lazy mint NFTs​

@extension: ERC1155LazyMintableV2

metadatas: a list of the metadatas of the NFTs to create

returns: the transaction receipt of the batch creation

Example​

image0, err := os.Open("path/to/image/0.jpg")
defer image0.Close()

image1, err := os.Open("path/to/image/1.jpg")
defer image1.Close()

metadatasWithSupply := []*thirdweb.EditionMetadataInput{
    &thirdweb.EditionMetadataInput{
        Metadata: &thirdweb.NFTMetadataInput{
            Name: "Cool NFT",
            Description: "This is a cool NFT",
            Image: image0,
        },
        Supply: 100,
    },
    &thirdweb.EditionMetadataInput{
        Metadata: &thirdweb.NFTMetadataInput{
            Name: "Cool NFT",
            Description: "This is a cool NFT",
            Image: image1,
        },
        Supply: 100,
    },
}

tx, err := contract.CreateBatch(context.Background(), metadatasWithSupply)

func (*ERC1155) Get​

func (erc1155 *ERC1155) Get(ctx context.Context, tokenId int) (*EditionMetadata, error)

Get an NFT​

@extension: ERC1155

tokenId: token ID of the token to get the metadata for

returns: the metadata for the NFT and its supply

Example​

nft, err := contract.Get(context.Background(), 0)
supply := nft.Supply
name := nft.Metadata.Name

func (*ERC1155) GetAll​

func (erc1155 *ERC1155) GetAll(ctx context.Context) ([]*EditionMetadata, error)

Get all NFTs​

@extension: ERC1155

returns: the metadatas and supplies of all the NFTs on this contract

Example​

nfts, err := contract.GetAll(context.Background())
supplyOne := nfts[0].Supply
nameOne := nfts[0].Metadata.Name

func (*ERC1155) GetOwned​

func (erc1155 *ERC1155) GetOwned(ctx context.Context, address string) ([]*EditionMetadataOwner, error)

Get owned NFTs​

@extension: ERC1155Enumerable

address: the address of the owner of the NFTs

returns: the metadatas and supplies of all the NFTs owned by the address

Example​

owner := "{{wallet_address}}"
nfts, err := contract.GetOwned(context.Background(), owner)
name := nfts[0].Metadata.Name

func (*ERC1155) GetTotalCount​

func (erc1155 *ERC1155) GetTotalCount(ctx context.Context) (int, error)

Get the total number of NFTs​

@extension: ERC1155Enumerable

returns: the total number of NFTs on this contract

Example​

totalCount, err := contract.GetTotalCount(context.Background())

func (*ERC1155) IsApproved​

func (erc1155 *ERC1155) IsApproved(ctx context.Context, owner string, operator string) (bool, error)

Check NFT approval​

@extension: ERC1155

address: the address whose assets are to be checked

operator: the address of the operator to check

returns: true if the operator is approved for all operations of the assets, otherwise false

Example​

owner := "{{wallet_address}}"
operator := "0x..."

isApproved, err := contract.IsApproved(context.Background, owner, operator)

func (*ERC1155) Mint​

func (erc1155 *ERC1155) Mint(ctx context.Context, metadataWithSupply *EditionMetadataInput) (*types.Transaction, error)

Mint an NFT​

@extension: ERC1155Mintable

metadataWithSupply: nft metadata with supply of the NFT to mint

returns: the transaction receipt of the mint

Example​

image, err := os.Open("path/to/image.jpg")
defer image.Close()

metadataWithSupply := &thirdweb.EditionMetadataInput{
    Metadata: &thirdweb.NFTMetadataInput{
        Name: "Cool NFT",
        Description: "This is a cool NFT",
        Image: image,
    },
    Supply: 100,
}

tx, err := contract.Mint(context.Background(), metadataWithSupply)

func (*ERC1155) MintAdditionalSupply​

func (erc1155 *ERC1155) MintAdditionalSupply(ctx context.Context, tokenId int, additionalSupply int) (*types.Transaction, error)

Mint additionally supply of an NFT​

@extension: ERC1155Mintable

tokenId: token ID to mint additional supply of

additionalSupply: additional supply to mint

returns: the transaction receipt of the mint

Example​

tokenId := 0
additionalSupply := 100

tx, err := contract.MintAdditionalSupply(context.Background(), tokenId, additionalSupply)

func (*ERC1155) MintAdditionalSupplyTo​

func (erc1155 *ERC1155) MintAdditionalSupplyTo(ctx context.Context, to string, tokenId int, additionalSupply int) (*types.Transaction, error)

Mint additional supply of an NFT to a specific wallet​

@extension: ERC1155Mintable

to: address of the wallet to mint NFTs to

tokenId: token Id to mint additional supply of

additionalySupply: additional supply to mint

returns: the transaction receipt of the mint

Example​

to := "{{wallet_address}}"
tokenId := 0
additionalSupply := 100

tx, err := contract.MintAdditionalSupplyTo(context.Background(), to, tokenId, additionalSupply)

func (*ERC1155) MintBatch​

func (erc1155 *ERC1155) MintBatch(ctx context.Context, metadatasWithSupply []*EditionMetadataInput) (*types.Transaction, error)

Mint many NFTs​

@extension: ERC1155BatchMintable

metadatasWithSupply: list of NFT metadatas with supplies to mint

returns: the transaction receipt of the mint

Example​

metadatasWithSupply := []*thirdweb.EditionMetadataInput{
    &thirdweb.EditionMetadataInput{
        Metadata: &thirdweb.NFTMetadataInput{
            Name: "Cool NFT",
            Description: "This is a cool NFT",
        },
        Supply: 100,
    },
    &thirdweb.EditionMetadataInput{
        Metadata: &thirdweb.NFTMetadataInput{
            Name: "Cool NFT",
            Description: "This is a cool NFT",
        },
        Supply: 100,
    },
}

tx, err := contract.MintBatch(context.Background(), metadatasWithSupply)

func (*ERC1155) MintBatchTo​

func (erc1155 *ERC1155) MintBatchTo(ctx context.Context, to string, metadatasWithSupply []*EditionMetadataInput) (*types.Transaction, error)

Mint many NFTs to a specific wallet​

@extension: ERC1155BatchMintable

to: address of the wallet to mint NFTs to

metadatasWithSupply: list of NFT metadatas with supplies to mint

returns: the transaction receipt of the mint

Example​

metadatasWithSupply := []*thirdweb.EditionMetadataInput{
    &thirdweb.EditionMetadataInput{
        Metadata: &thirdweb.NFTMetadataInput{
            Name: "Cool NFT",
            Description: "This is a cool NFT",
        },
        Supply: 100,
    },
    &thirdweb.EditionMetadataInput{
        Metadata: &thirdweb.NFTMetadataInput{
            Name: "Cool NFT",
            Description: "This is a cool NFT",
        },
        Supply: 100,
    },
}

tx, err := contract.MintBatchTo(context.Background(), "{{wallet_address}}", metadatasWithSupply)

func (*ERC1155) MintTo​

func (erc1155 *ERC1155) MintTo(ctx context.Context, address string, metadataWithSupply *EditionMetadataInput) (*types.Transaction, error)

Mint an NFT to a specific wallet​

@extension: ERC1155Mintable

address: the wallet address to mint the NFT to

metadataWithSupply: nft metadata with supply of the NFT to mint

returns: the transaction receipt of the mint

Example​

image, err := os.Open("path/to/image.jpg")
defer image.Close()

metadataWithSupply := &thirdweb.EditionMetadataInput{
    Metadata: &thirdweb.NFTMetadataInput{
        Name: "Cool NFT",
        Description: "This is a cool NFT",
        Image: image,
    },
    Supply: 100,
}

tx, err := contract.MintTo(context.Background(), "{{wallet_address}}", metadataWithSupply)

func (*ERC1155) SetApprovalForAll​

func (erc1155 *ERC1155) SetApprovalForAll(ctx context.Context, operator string, approved bool) (*types.Transaction, error)

Set approval for all NFTs​

@extension: ERC1155

address: the address whose assets are to be approved

operator: the address of the operator to set the approval for

approved: true if the operator is approved for all operations of the assets, otherwise false

returns: the transaction receipt of the approval

Example​

operator := "{{wallet_address}}"
approved := true

tx, err := contract.SetApprovalForAll(context.Background(), operator, approved)

func (*ERC1155) TotalSupply​

func (erc1155 *ERC1155) TotalSupply(ctx context.Context, tokenId int) (int, error)

Get the total supply of an NFT​

@extension: ERC1155

tokenId: the token ID to check the total supply of

returns: the supply of NFTs on the specified token ID

Example​

tokenId := 0

totalSupply, err := contract.TotalSupply(context.Background, tokenId)

func (*ERC1155) Transfer​

func (erc1155 *ERC1155) Transfer(ctx context.Context, to string, tokenId int, amount int) (*types.Transaction, error)

Transfer NFTs​

@extension: ERC1155

to: wallet address to transfer the tokens to

tokenId: the token ID of the NFT to transfer

amount: number of NFTs of the token ID to transfer

returns: the transaction of the NFT transfer

Example​

to := "0x..."
tokenId := 0
amount := 1

tx, err := contract.Transfer(context.Background(), to, tokenId, amount)