thirdweb

package
v2.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 19, 2023 License: Apache-2.0 Imports: 42 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	MAINNET           ChainID = 1
	RINKEBY                   = 4
	GOERLI                    = 5
	POLYGON                   = 137
	FANTOM                    = 250
	FANTOM_TESTNET            = 4002
	AVALANCHE_TESTNET         = 43113
	AVALANCHE                 = 43114
	MUMBAI                    = 80001
	OPTIMISM                  = 10
	OPTIMISM_TESTNET          = 69
	ARBITRUM                  = 42161
	ARBITRUM_TESTNET          = 421611
)
View Source 
const (
	NotEnoughSupply     ClaimEligibility = "There is not enough supply to claim."
	AddressNotAllowed                    = "This address is not on the allowlist."
	InsufficientBalance                  = "There isn't enough of the required currency in the wallet to pay for the claim."
	NoActiveClaimPhase                   = "There is no active claim phase at the moment. Please check back in later."
	NoClaimConditionSet                  = "There is no claim condition set."
	ExceedsMaxClaimable                  = "The quantity of tokens to claim is above the remaining limit for this wallet."
	NoWallet                             = "No wallet connected."
	Unknown                              = "No claim conditions found."
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AuctionListing 

type AuctionListing struct {
	Id                                string
	AssetContractAddress              string
	TokenId                           int
	Asset                             *NFTMetadata
	StartTimeInEpochSeconds           int
	EndTimeInEpochSeconds             int
	Quantity                          int
	CurrencyContractAddress           string
	ReservePrice                      string
	BuyoutPrice                       string
	BuyoutCurrencyValuePerToken       *CurrencyValue
	ReservePriceCurrencyValuePerToken *CurrencyValue
	SellerAddress                     string
}

type ChainID 

type ChainID int

type ChainName 

type ChainName string

type ClaimArguments 

type ClaimArguments struct {
	TxValue        *big.Int
	Receiver       common.Address
	Quantity       *big.Int
	Currency       common.Address
	PricePerToken  *big.Int
	AllowlistProof abi.IDropAllowlistProof
	Data           []byte
}

type ClaimConditionInput 

type ClaimConditionInput struct {
	StartTime                   *time.Time
	CurrencyAddress             string
	Price                       float64
	MaxQuantity                 int
	QuantityLimitPerTransaction int
	WaitInSeconds               int
	MerkleRootHash              string
	Snapshot                    []*SnapshotInput
}

type ClaimConditionOutput 

type ClaimConditionOutput struct {
	StartTime             time.Time
	MaxClaimableSupply    *big.Int
	MaxClaimablePerWallet *big.Int
	CurrentMintSupply     *big.Int
	AvailableSupply       *big.Int
	WaitInSeconds         *big.Int
	Price                 *big.Int
	CurrencyAddress       string
	CurrencyMetadata      *CurrencyValue
	MerkleRootHash        [32]byte
}

type ClaimEligibility 

type ClaimEligibility string

type ClaimInfo 

type ClaimInfo struct {
	PricePerToken      *big.Int
	CurrencyAddress    common.Address
	RemainingClaimable *big.Int
}

type ClaimVerification 

type ClaimVerification struct {
	Value                  *big.Int
	Proofs                 [][32]byte
	MaxClaimable           *big.Int
	Price                  *big.Int
	CurrencyAddress        string
	PriceInProof           *big.Int
	CurrencyAddressInProof string
}

type ContractDeployer 

type ContractDeployer struct {
	*ProviderHandler
	// contains filtered or unexported fields
}

The contract deployer lets you deploy new contracts to the blockchain using just the thirdweb SDK. You can access the contract deployer interface as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

// Now you can deploy a contract
address, err := sdk.Deployer.DeployNFTCollection(
	&thirdweb.DeployNFTCollectionMetadata{
		Name: "Go NFT",
	}
})

func (*ContractDeployer) DeployEdition 

func (deployer *ContractDeployer) DeployEdition(ctx context.Context, metadata *DeployEditionMetadata) (string, error)

Deploy a new Edition contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployEdition(
     context.Background(),
		&thirdweb.DeployEditionMetadata{
			Name: "Go Edition",
		}
	})

func (*ContractDeployer) DeployEditionDrop 

func (deployer *ContractDeployer) DeployEditionDrop(ctx context.Context, metadata *DeployEditionDropMetadata) (string, error)

Deploy a new Edition Drop contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployEditionDrop(
     context.Background(),
		&thirdweb.DeployEditionDropMetadata{
			Name: "Go Edition Drop",
		}
	})

func (*ContractDeployer) DeployMarketplace 

func (deployer *ContractDeployer) DeployMarketplace(ctx context.Context, metadata *DeployMarketplaceMetadata) (string, error)

Deploy a new Marketplace contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployMarketplace(
     context.Background()
		&thirdweb.DeployMarketplaceMetadata{
			Name: "Go Marketplace",
		}
	})

func (*ContractDeployer) DeployMultiwrap 

func (deployer *ContractDeployer) DeployMultiwrap(ctx context.Context, metadata *DeployMultiwrapMetadata) (string, error)

Deploy a new Multiwrap contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployMultiwrap(
     context.Background()
		&thirdweb.DeployMultiwrapMetadata{
			Name: "Go Multiwrap",
		}
	})

func (*ContractDeployer) DeployNFTCollection 

func (deployer *ContractDeployer) DeployNFTCollection(ctx context.Context, metadata *DeployNFTCollectionMetadata) (string, error)

Deploy a new NFT Collection contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployNFTCollection(
     context.Background(),
		&thirdweb.DeployNFTCollectionMetadata{
			Name: "Go NFT",
		}
	})

func (*ContractDeployer) DeployNFTDrop 

func (deployer *ContractDeployer) DeployNFTDrop(ctx context.Context, metadata *DeployNFTDropMetadata) (string, error)

Deploy a new NFT Drop contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployNFTDrop(
     context.Background(),
		&thirdweb.DeployNFTDropMetadata{
			Name: "Go NFT Drop",
		}
	})

func (*ContractDeployer) DeployToken 

func (deployer *ContractDeployer) DeployToken(ctx context.Context, metadata *DeployTokenMetadata) (string, error)

Deploy a new Token contract.

metadata: the contract metadata

returns: the address of the deployed contract

Example 

	address, err := sdk.Deployer.DeployToken(
     context.Background(),
		&thirdweb.DeployTokenMetadata{
			Name: "Go Token",
		}
	})

type ContractEncoder 

type ContractEncoder struct {
	// contains filtered or unexported fields
}

This interface is currently supported by all contract encoder classes and provides a generic method to encode write function calls.

func (*ContractEncoder) Encode 

func (encoder *ContractEncoder) Encode(ctx context.Context, signerAddress string, method string, args ...interface{}) (*types.Transaction, error)

Get the unsigned transaction data for any contract call on a contract.

signerAddress: the address expected to sign this transaction

method: the name of the contract function to encode transaction data for

args: the arguments to pass to the contract function.

returns: the encoded transaction data for the transaction.

Example 

toAddress := "0x..."
amount := 1

// Now you can get the transaction data for the contract call.
tx, err := contract.Encoder.Encode(context.Background(), "transfer", toAddress, amount)
fmt.Println(tx.Data()) // Now you can access all transaction data, like the following fields
fmt.Println(tx.Nonce())
fmt.Println(tx.Value())

type ContractEvent 

type ContractEvent struct {
	EventName   string
	Data        map[string]interface{}
	Transaction types.Log
}

type ContractEvents 

type ContractEvents struct {
	// contains filtered or unexported fields
}

This interface provides a way to query past events or listen for future events on any contract. It's currently support on all pre-built and custom contracts!

Example 

// First get an instance of your contract
contract, _ := sdk.GetContract("0x...");

// Now, get all Transfer events from a specific block range
contract.Events.GetEvents("Transfer", thirdweb.EventQueryOptions{
  FromBlock: 100000000,
  ToBlock:   100000001,
})

// And setup a listener to listen for future Transfer events
contract.Events.AddEventListener("Transfer", func (event thirdweb.ContractEvent) {
  fmt.Printf("%#v\n", event)
})

func (*ContractEvents) AddEventListener 

func (events *ContractEvents) AddEventListener(ctx context.Context, eventName string, listener func(event ContractEvent)) EventSubscription

Add a listener to listen in the background for any future events of a specific type.

eventName: The name of the event to listen for

listener: The listener function that will be called whenever a new event is received

returns: An EventSubscription object that can be used to unsubscribe from the event or check for errors

Example 

// Define a listener function to be called whenever a new Transfer event is received
listener := func (event thirdweb.ContractEvent) {
  fmt.Printf("%#v\n", event)
}

// Add a new listener for the Transfer event
subscription := contract.Events.AddEventListener(context.Background(), "Transfer", listener)

// Unsubscribe from the Transfer event at some time in the future, closing the listener
subscription.Unsubscribe()

func (*ContractEvents) GetEvents 

func (events *ContractEvents) GetEvents(ctx context.Context, eventName string, options EventQueryOptions) ([]ContractEvent, error)

Query past events of a specific type on the contract.

eventName: The name of the event to query for

options: The options to use when querying for events, including block range specifications and filters

returns: a list of ContractEvent objects that match the query

Example 

// First we define a filter to only get Transfer events where the "from" address is "0x..."
// Note that you can only add filters for indexed parameters on events
filters := map[string]interface{} {
  "from": common.HexToAddress("0x...")
}

// Now we can define the query options, including the block range and the filter
queryOptions := thirdweb.EventQueryOptions{
  FromBlock: 100000000, // Defaults to block 0 if you don't specify this field
  ToBlock:   100000001, // Defaults to latest block if you don't specify this field
  Filters:   filters,
}

// Now we can query for the Transfer events
events, _ := contract.Events.GetEvents("Transfer", queryOptions)

type Currency 

type Currency struct {
	Name     string
	Symbol   string
	Decimals int
}

type CurrencyValue 

type CurrencyValue struct {
	Name         string
	Symbol       string
	Decimals     int
	Value        *big.Int
	DisplayValue float64
}

type DeployEditionDropMetadata 

type DeployEditionDropMetadata struct {
	Name                   string      `mapstructure:"name" json:"name"`
	Description            string      `mapstructure:"description" json:"description"`
	Image                  interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink           string      `mapstructure:"external_link,omitempty" json:"external_link"`
	SellerFeeBasisPoints   int         `mapstructure:"seller_fee_basis_points" json:"seller_fee_basis_points"`
	FeeRecipient           string      `mapstructure:"fee_recipient" json:"fee_recipient"`
	Merkle                 interface{} `mapstructure:"merkle" json:"merkle"`
	Symbol                 string      `mapstructure:"symbol" json:"symbol"`
	PrimarySaleRecipient   string      `mapstructure:"primary_sale_recipient" json:"primary_sale_recipient"`
	PlatformFeeBasisPoints int         `mapstructure:"platform_fee_basis_points" json:"platform_fee_basis_points"`
	PlatformFeeRecipient   string      `mapstructure:"platform_fee_recipient" json:"platform_fee_recipient"`
	TrustedForwarders      []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DeployEditionMetadata 

type DeployEditionMetadata struct {
	Name                   string      `mapstructure:"name" json:"name"`
	Description            string      `mapstructure:"description" json:"description"`
	Image                  interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink           string      `mapstructure:"external_link,omitempty" json:"external_link"`
	SellerFeeBasisPoints   int         `mapstructure:"seller_fee_basis_points" json:"seller_fee_basis_points"`
	FeeRecipient           string      `mapstructure:"fee_recipient" json:"fee_recipient"`
	Symbol                 string      `mapstructure:"symbol" json:"symbol"`
	PrimarySaleRecipient   string      `mapstructure:"primary_sale_recipient" json:"primary_sale_recipient"`
	PlatformFeeBasisPoints int         `mapstructure:"platform_fee_basis_points" json:"platform_fee_basis_points"`
	PlatformFeeRecipient   string      `mapstructure:"platform_fee_recipient" json:"platform_fee_recipient"`
	TrustedForwarders      []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DeployMarketplaceMetadata 

type DeployMarketplaceMetadata struct {
	Name                   string      `mapstructure:"name" json:"name"`
	Description            string      `mapstructure:"description" json:"description"`
	Image                  interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink           string      `mapstructure:"external_link,omitempty" json:"external_link"`
	PlatformFeeBasisPoints int         `mapstructure:"platform_fee_basis_points" json:"platform_fee_basis_points"`
	PlatformFeeRecipient   string      `mapstructure:"platform_fee_recipient" json:"platform_fee_recipient"`
	TrustedForwarders      []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DeployMultiwrapMetadata 

type DeployMultiwrapMetadata struct {
	Name                 string      `mapstructure:"name" json:"name"`
	Description          string      `mapstructure:"description" json:"description"`
	Image                interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink         string      `mapstructure:"external_link,omitempty" json:"external_link"`
	SellerFeeBasisPoints int         `mapstructure:"seller_fee_basis_points" json:"seller_fee_basis_points"`
	FeeRecipient         string      `mapstructure:"fee_recipient" json:"fee_recipient"`
	Symbol               string      `mapstructure:"symbol" json:"symbol"`
	TrustedForwarders    []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DeployNFTCollectionMetadata 

type DeployNFTCollectionMetadata struct {
	Name                   string      `mapstructure:"name" json:"name"`
	Description            string      `mapstructure:"description" json:"description"`
	Image                  interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink           string      `mapstructure:"external_link,omitempty" json:"external_link"`
	SellerFeeBasisPoints   int         `mapstructure:"seller_fee_basis_points" json:"seller_fee_basis_points"`
	FeeRecipient           string      `mapstructure:"fee_recipient" json:"fee_recipient"`
	Symbol                 string      `mapstructure:"symbol" json:"symbol"`
	PrimarySaleRecipient   string      `mapstructure:"primary_sale_recipient" json:"primary_sale_recipient"`
	PlatformFeeBasisPoints int         `mapstructure:"platform_fee_basis_points" json:"platform_fee_basis_points"`
	PlatformFeeRecipient   string      `mapstructure:"platform_fee_recipient" json:"platform_fee_recipient"`
	TrustedForwarders      []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DeployNFTDropMetadata 

type DeployNFTDropMetadata struct {
	Name                   string      `mapstructure:"name" json:"name"`
	Description            string      `mapstructure:"description" json:"description"`
	Image                  interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink           string      `mapstructure:"external_link,omitempty" json:"external_link"`
	SellerFeeBasisPoints   int         `mapstructure:"seller_fee_basis_points" json:"seller_fee_basis_points"`
	FeeRecipient           string      `mapstructure:"fee_recipient" json:"fee_recipient"`
	Merkle                 interface{} `mapstructure:"merkle" json:"merkle"`
	Symbol                 string      `mapstructure:"symbol" json:"symbol"`
	PrimarySaleRecipient   string      `mapstructure:"primary_sale_recipient" json:"primary_sale_recipient"`
	PlatformFeeBasisPoints int         `mapstructure:"platform_fee_basis_points" json:"platform_fee_basis_points"`
	PlatformFeeRecipient   string      `mapstructure:"platform_fee_recipient" json:"platform_fee_recipient"`
	TrustedForwarders      []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DeployTokenMetadata 

type DeployTokenMetadata struct {
	Name                   string      `mapstructure:"name" json:"name"`
	Description            string      `mapstructure:"description" json:"description"`
	Image                  interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalLink           string      `mapstructure:"external_link,omitempty" json:"external_link"`
	Symbol                 string      `mapstructure:"symbol" json:"symbol"`
	PrimarySaleRecipient   string      `mapstructure:"primary_sale_recipient" json:"primary_sale_recipient"`
	PlatformFeeBasisPoints int         `mapstructure:"platform_fee_basis_points" json:"platform_fee_basis_points"`
	PlatformFeeRecipient   string      `mapstructure:"platform_fee_recipient" json:"platform_fee_recipient"`
	TrustedForwarders      []string    `mapstructure:"trusted_forwarders" json:"trusted_forwarders"`
}

type DirectListing 

type DirectListing struct {
	Id                          string
	AssetContractAddress        string
	TokenId                     int
	Asset                       *NFTMetadata
	StartTimeInEpochSeconds     int
	EndTimeInEpochSeconds       int
	Quantity                    int
	CurrencyContractAddress     string
	BuyoutCurrencyValuePerToken *CurrencyValue
	BuyoutPrice                 string
	SellerAddress               string
}

type ERC1155 

type ERC1155 struct {
	ClaimConditions *EditionDropClaimConditions
	// contains filtered or unexported fields
}

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.

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 additionaly 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) PrepareClaim 

func (erc1155 *ERC1155) PrepareClaim(ctx context.Context, tokenId int, quantity int) (*ClaimVerification, error)

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)

type ERC1155SignatureMinting 

type ERC1155SignatureMinting struct {
	Helper *contractHelper
	// contains filtered or unexported fields
}

You can access this interface from the edition contract under the signature interface

func (*ERC1155SignatureMinting) Generate 

func (signature *ERC1155SignatureMinting) Generate(ctx context.Context, payloadToSign *Signature1155PayloadInput) (*SignedPayload1155, error)

Generate a payload to mint a new token ID

payloadToSign: the payload containing the data for the signature mint

returns: the payload signed by the minter's private key

Example 

payload := &thirdweb.Signature721PayloadInput{
	To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6", // address to mint to
	Price:                0,                                            // cost of minting
	CurrencyAddress:      "0x0000000000000000000000000000000000000000", // currency to pay in order to mint
	MintStartTime:        0,                                            // time where minting is allowed to start (epoch seconds)
	MintEndTime:          100000000000000,                              // time when this signature expires (epoch seconds)
	PrimarySaleRecipient: "0x0000000000000000000000000000000000000000", // address to receive the primary sales of this mint
	Metadata: &thirdweb.NFTMetadataInput{																// metadata of the NFT to mint
 		Name:  "ERC721 Sigmint!",
	},
	RoyaltyRecipient: "0x0000000000000000000000000000000000000000",     // address to receive royalties of this mint
	RoyaltyBps:       0,                                                // royalty cut of this mint in basis points
	Quantity:         1,   																					    // number of tokens to mint
}

signedPayload, err := contract.Signature.Generate(context.Background(), payload)

func (*ERC1155SignatureMinting) GenerateBatch 

func (signature *ERC1155SignatureMinting) GenerateBatch(ctx context.Context, payloadsToSign []*Signature1155PayloadInput) ([]*SignedPayload1155, error)

Generate a batch of payloads to mint multiple new token IDs

payloadToSign: the payloads containing the data for the signature mint

returns: the payloads signed by the minter's private key

Example 

payload := []*thirdweb.Signature1155PayloadInput{
	&thirdweb.Signature1155PayloadInput{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata: &thirdweb.NFTMetadataInput{
 			Name:  "ERC1155 Sigmint 1",
		},
		RoyaltyRecipient: "0x0000000000000000000000000000000000000000",
		RoyaltyBps:       0,
		Quantity:         1,
	},
	&thirdweb.Signature1155PayloadInput{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata: &thirdweb.NFTMetadataInput{
 			Name:  "ERC1155 Sigmint 2",
		},
		RoyaltyRecipient: "0x0000000000000000000000000000000000000000",
		RoyaltyBps:       0,
		Quantity:         1,
	},
}

signedPayload, err := contract.Signature.GenerateBatch(context.Background(), payload)

func (*ERC1155SignatureMinting) GenerateBatchFromTokenIds 

func (signature *ERC1155SignatureMinting) GenerateBatchFromTokenIds(ctx context.Context, payloadsToSign []*Signature1155PayloadInputWithTokenId) ([]*SignedPayload1155, error)

Generate a batch of payloads to mint multiple new token IDs

payloadToSign: the payloads containing the data for the signature mint

returns: the payloads signed by the minter's private key

Example 

payload := []*thirdweb.Signature1155PayloadInputWithTokenId{
	&thirdweb.Signature1155PayloadInputWithTokenId{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata: &thirdweb.NFTMetadataInput{
 			Name:  "ERC1155 Sigmint 1",
		},
		RoyaltyRecipient: "0x0000000000000000000000000000000000000000",
		RoyaltyBps:       0,
		Quantity:         1,
		TokenId:          0,
	},
	&thirdweb.Signature1155PayloadInputWithTokenId{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata: nil
		RoyaltyRecipient: "0x0000000000000000000000000000000000000000",
		RoyaltyBps:       0,
		Quantity:         1,
		TokenId:          1,
	},
}

signedPayload, err := contract.Signature.GenerateBatchFromTokenIds(context.Background(), payload)

func (*ERC1155SignatureMinting) GenerateFromTokenId 

func (signature *ERC1155SignatureMinting) GenerateFromTokenId(ctx context.Context, payloadToSign *Signature1155PayloadInputWithTokenId) (*SignedPayload1155, error)

Generate a new payload to mint additionaly supply to an existing token ID

payloadToSign: the payload containing the data for the signature mint

returns: the payload signed by the minter's private key

Example 

	payload := &thirdweb.Signature1155PayloadInputWithTokenId{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata:             nil,                                          // we don't need to pass NFT metadata since we are minting an existing token
		RoyaltyRecipient:     "0x0000000000000000000000000000000000000000",
		RoyaltyBps:           0,
		Quantity:             1,
 	TokenId:              0,                                            // now we need to specify the token ID to mint supply to
	}

	signedPayload, err := contract.Signature.GenerateFromTokenId(context.Background(), payload)

func (*ERC1155SignatureMinting) Mint 

func (signature *ERC1155SignatureMinting) Mint(ctx context.Context, signedPayload *SignedPayload1155) (*types.Transaction, error)

Mint a token with the data in given payload.

signedPayload: the payload signed by the minters private key being used to mint

returns: the transaction receipt of the mint

Example 

// Learn more about how to craft a payload in the Generate() function
signedPayload, err := contract.Signature.Generate(payload)
tx, err := contract.Signature.Mint(signedPayload)

func (*ERC1155SignatureMinting) MintBatch 

func (signature *ERC1155SignatureMinting) MintBatch(ctx context.Context, signedPayloads []*SignedPayload1155) (*types.Transaction, error)

Mint a batch of token with the data in given payload.

signedPayload: the list of payloads signed by the minters private key being used to mint

returns: the transaction receipt of the batch mint

Example 

// Learn more about how to craft multiple payloads in the GenerateBatch() function
signedPayloads, err := contract.Signature.GenerateBatch(payloads)
tx, err := contract.Signature.MintBatch(signedPayloads)

func (*ERC1155SignatureMinting) MintWithOpts 

func (signature *ERC1155SignatureMinting) MintWithOpts(ctx context.Context, signedPayload *SignedPayload1155, txOpts *bind.TransactOpts) (*types.Transaction, error)

func (*ERC1155SignatureMinting) Verify 

func (signature *ERC1155SignatureMinting) Verify(ctx context.Context, signedPayload *SignedPayload1155) (bool, error)

Verify that a signed payload is valid

signedPayload: the payload to verify

returns: true if the payload is valid, otherwise false.

Example 

// Learn more about how to craft a payload in the Generate() function
signedPayload, err := contract.Signature.Generate(payload)
isValid, err := contract.Signature.Verify(context.Background(), signedPayload)

type ERC1155Standard 

type ERC1155Standard struct {
	// contains filtered or unexported fields
}

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.

func (*ERC1155Standard) Balance 

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

Get the NFT balance of the connected wallet for a specific token ID.

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 (*ERC1155Standard) BalanceOf 

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

Get the NFT balance of a specific wallet.

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 (*ERC1155Standard) Burn 

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

Burn an amount of a specified NFT from the connected wallet.

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 (*ERC1155Standard) Get 

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

Get metadata for a token.

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 (*ERC1155Standard) GetAll 

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

Get the metadata of all the NFTs on this contract.

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 (*ERC1155Standard) GetOwned 

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

Get the metadatas of all the NFTs owned by a specific address.

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 (*ERC1155Standard) GetTotalCount 

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

Get the total number of NFTs on this contract.

returns: the total number of NFTs on this contract

func (*ERC1155Standard) IsApproved 

func (erc1155 *ERC1155Standard) IsApproved(ctx context.Context, address string, operator string) (bool, error)

Check whether an operator address is approved for all operations of a specifc addresses assets.

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

func (*ERC1155Standard) SetApprovalForAll 

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

Set the approval for all operations of a specific address's assets.

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

func (*ERC1155Standard) TotalSupply 

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

Get the total number of NFTs of a specific token ID.

tokenId: the token ID to check the total supply of

returns: the supply of NFTs on the specified token ID

func (*ERC1155Standard) Transfer 

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

Transfer a specific quantity of a token ID from the connected wallet to a specified address.

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)

type ERC20 

type ERC20 struct {
	// contains filtered or unexported fields
}

This interface is currently support by the Token contract. You can access all of its functions through a Token contract instance.

func (*ERC20) Allowance 

func (erc20 *ERC20) Allowance(ctx context.Context, spender string) (*CurrencyValue, error)

Get token allowance for a specific spender

@extension: ERC20

spender: wallet address to check the allowance of

returns: allowance of the spender for the connected wallets tokens

Example 

spender := "0x..."

allowance, err := contract.ERC20.Allowance(spender)
allowanceValue := allowance.DisplayValue

func (*ERC20) AllowanceOf 

func (erc20 *ERC20) AllowanceOf(ctx context.Context, owner string, spender string) (*CurrencyValue, error)

Get token allowance for a specific spender and owner

@extension: ERC20

owner: wallet address who owns the assets

spender: wallet address to check the allowance of

returns: allowance of the spender for the connected wallets tokens

Example 

address := "{{wallet_address}}"
spender := "0x..."

allowance, err := contract.ERC20.AllowanceOf(address, spender)
allowanceValue := allowance.DisplayValue

func (*ERC20) Balance 

func (erc20 *ERC20) Balance(ctx context.Context) (*CurrencyValue, error)

Get token balance

@extension: ERC20

returns: balance of the connected wallet

Example 

balance, err := contract.ERC20.Balance()
balanceValue := balance.DisplayValue

func (*ERC20) BalanceOf 

func (erc20 *ERC20) BalanceOf(ctx context.Context, address string) (*CurrencyValue, error)

Get token balance of a specific wallet

@extension: ERC20

address: wallet address to check the balance of

returns: balance of the specified wallet

Example 

address := "{{wallet_address}}"
balance, err := contract.ERC20.BalanceOf()
balanceValue := balance.DisplayValue

func (*ERC20) Burn 

func (erc20 *ERC20) Burn(ctx context.Context, amount float64) (*types.Transaction, error)

Burn tokens

@extension: ERC20Burnable

amount: amount of tokens to burn

returns: transaction receipt of the burn

Example 

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

func (*ERC20) BurnFrom 

func (erc20 *ERC20) BurnFrom(ctx context.Context, holder string, amount float64) (*types.Transaction, error)

Burn tokens from a specific wallet

@extension: ERC20Burnable

holder: wallet address to burn the tokens from

amount: amount of tokens to burn

returns: transaction receipt of the burn

Example 

holder := "0x..."
amount := 1

tx, err := contract.ERC20.BurnFrom(context.Background(), holder, amount)

func (*ERC20) Get 

func (erc20 *ERC20) Get(ctx context.Context) (*Currency, error)

Get token metadata

@extension: ERC20

returns: the metadata for the token

Example 

currency, err := contract.ERC20.Get()
symbol := currency.Symbol

func (*ERC20) Mint 

func (erc20 *ERC20) Mint(ctx context.Context, amount float64) (*types.Transaction, error)

Mint tokens

@extension: ERC20Mintable

amount: amount of tokens to mint

returns: transaction receipt of the mint

Example 

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

func (*ERC20) MintBatchTo 

func (erc20 *ERC20) MintBatchTo(ctx context.Context, args []*TokenAmount) (*types.Transaction, error)

Mint tokens to many wallets

@extension: ERC20BatchMintable

args: list of wallet addresses and amounts to mint

returns: transaction receipt of the mint

Example 

args = []*thirdweb.TokenAmount{
	&thirdweb.TokenAmount{
		ToAddress: "{{wallet_address}}",
		Amount:    1
	}
	&thirdweb.TokenAmount{
		ToAddress: "{{wallet_address}}",
		Amount:    2
	}
}

tx, err := contract.ERC20.MintBatchTo(context.Background(), args)

func (*ERC20) MintTo 

func (erc20 *ERC20) MintTo(ctx context.Context, to string, amount float64) (*types.Transaction, error)

Mint tokens to a specific wallet

@extension: ERC20Mintable

to: wallet address to mint tokens to

amount: amount of tokens to mint

returns: transaction receipt of the mint

Example 

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

func (*ERC20) SetAllowance 

func (erc20 *ERC20) SetAllowance(ctx context.Context, spender string, amount float64) (*types.Transaction, error)

Set token allowance

@extension: ERC20

spender: wallet address to set the allowance of

amount: amount of tokens to grant the spender allowance of

returns: transaction receipt of the allowance set

Example 

spender := "0x..."
amount := 1

tx, err := contract.ERC20.SetAllowance(context.Background(), spender, amount)

func (*ERC20) TotalSupply 

func (erc20 *ERC20) TotalSupply(ctx context.Context) (*CurrencyValue, error)

Get the total minted supply

@extension: ERC20

returns: total minted supply of the token

Example 

supply, err := contract.ERC20.TotalSupply(context.Background())

func (*ERC20) Transfer 

func (erc20 *ERC20) Transfer(ctx context.Context, to string, amount float64) (*types.Transaction, error)

Transfer tokens

@extension: ERC20

to: address to transfer the tokens to

amount: amount of tokens to transfer

returns: transaction receipt of the transfer

Example 

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

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

func (*ERC20) TransferBatch 

func (erc20 *ERC20) TransferBatch(ctx context.Context, args []*TokenAmount) (*types.Transaction, error)

Transfer many tokens

args: list of token amounts with amounts and addresses to transfer to

returns: transaction receipt of the transfers

Example 

args = []*thirdweb.TokenAmount{
	&thirdweb.TokenAmount{
		ToAddress: "0x...",
		Amount:    1
	}
	&thirdweb.TokenAmount{
		ToAddress: "0x...",
		Amount:    2
	}
}

tx, err := contract.ERC20.TransferBatch(context.Background(), args)

func (*ERC20) TransferFrom 

func (erc20 *ERC20) TransferFrom(ctx context.Context, from string, to string, amount float64) (*types.Transaction, error)

Transfer tokens from a specific wallet

@extension: ERC20

from: address to transfer the tokens from

to: address to transfer the tokens to

amount: amount of tokens to transfer

returns: transaction receipt of the transfer

Example 

from := "{{wallet_address}}"
to := "0x..."
amount := 1

tx, err := contract.ERC20.TransferFrom(context.Background(), from, to, amount)

type ERC20Standard 

type ERC20Standard struct {
	// contains filtered or unexported fields
}

This interface is currently support by the Token contract. You can access all of its functions through a Token contract instance.

func (*ERC20Standard) Allowance 

func (erc20 *ERC20Standard) Allowance(ctx context.Context, spender string) (*CurrencyValue, error)

Get a specified spenders allowance for the connected wallets tokens.

spender: wallet address to check the allowance of

returns: allowance of the spender for the connected wallets tokens

Example 

spender := "0x..."

allowance, err := contract.Allowance(spender)
allowanceValue := allowance.DisplayValue

func (*ERC20Standard) AllowanceOf 

func (erc20 *ERC20Standard) AllowanceOf(ctx context.Context, owner string, spender string) (*CurrencyValue, error)

Get a specified spenders allowance for the a specific wallets tokens.

owner: wallet address who owns the assets

spender: wallet address to check the allowance of

returns: allowance of the spender for the connected wallets tokens

Example 

address := "{{wallet_address}}"
spender := "0x..."

allowance, err := contract.AllowanceOf(address, spender)
allowanceValue := allowance.DisplayValue

func (*ERC20Standard) Balance 

func (erc20 *ERC20Standard) Balance(ctx context.Context) (*CurrencyValue, error)

Get the token balance of the connected wallet.

returns: balance of the connected wallet

Example 

	balance, err := contract.Balance()
 balanceValue := balance.DisplayValue

func (*ERC20Standard) BalanceOf 

func (erc20 *ERC20Standard) BalanceOf(ctx context.Context, address string) (*CurrencyValue, error)

Get the balance of the specified wallet.

address: wallet address to check the balance of

returns: balance of the specified wallet

Example 

	address := "{{wallet_address}}"
	balance, err := contract.BalanceOf()
 balanceValue := balance.DisplayValue

func (*ERC20Standard) Burn 

func (erc20 *ERC20Standard) Burn(ctx context.Context, amount float64) (*types.Transaction, error)

Burn a specified amount of tokens from the connected wallet.

amount: amount of tokens to burn

returns: transaction receipt of the burn

Example 

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

func (*ERC20Standard) BurnFrom 

func (erc20 *ERC20Standard) BurnFrom(ctx context.Context, holder string, amount float64) (*types.Transaction, error)

Burn a specified amount of tokens from a specific wallet.

holder: wallet address to burn the tokens from

amount: amount of tokens to burn

returns: transaction receipt of the burn

Example 

holder := "0x..."
amount := 1

tx, err := contract.BurnFrom(context.Background(), holder, amount)

func (*ERC20Standard) Get 

func (erc20 *ERC20Standard) Get(ctx context.Context) (*Currency, error)

Get token metadata including name, symbol, decimals, etc.

returns: the metadata for the token

Example 

currency, err := contract.Get()
symbol := currency.Symbol

func (*ERC20Standard) SetAllowance 

func (erc20 *ERC20Standard) SetAllowance(ctx context.Context, spender string, amount float64) (*types.Transaction, error)

Sets the allowance of a wallet to spend the connected wallets funds.

spender: wallet address to set the allowance of

amount: amount of tokens to grant the spender allowance of

returns: transaction receipt of the allowance set

Example 

spender := "0x..."
amount := 1

tx, err := contract.SetAllowance(context.Background(), spender, amount)

func (*ERC20Standard) TotalSupply 

func (erc20 *ERC20Standard) TotalSupply(ctx context.Context) (*CurrencyValue, error)

Get the total minted supply of the token.

returns: total minted supply of the token

func (*ERC20Standard) Transfer 

func (erc20 *ERC20Standard) Transfer(ctx context.Context, to string, amount float64) (*types.Transaction, error)

Transfer a specified amount of tokens from the connected wallet to a specified address.

to: address to transfer the tokens to

amount: amount of tokens to transfer

returns: transaction receipt of the transfer

Example 

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

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

func (*ERC20Standard) TransferBatch 

func (erc20 *ERC20Standard) TransferBatch(ctx context.Context, args []*TokenAmount) (*types.Transaction, error)

Transfer tokens from the connected wallet to many wallets.

args: list of token amounts with amounts and addresses to transfer to

returns: transaction receipt of the transfers

Example 

args = []*thirdweb.TokenAmount{
	&thirdweb.TokenAmount{
		ToAddress: "0x...",
		Amount:    1
	}
	&thirdweb.TokenAmount{
		ToAddress: "0x...",
		Amount:    2
	}
}

tx, err := contract.TransferBatch(context.Background(), args)

func (*ERC20Standard) TransferFrom 

func (erc20 *ERC20Standard) TransferFrom(ctx context.Context, from string, to string, amount float64) (*types.Transaction, error)

Transfer a specified amount of tokens from one specified address to another.

from: address to transfer the tokens from

to: address to transfer the tokens to

amount: amount of tokens to transfer

returns: transaction receipt of the transfer

Example 

from := "{{wallet_address}}"
to := "0x..."
amount := 1

tx, err := contract.TransferFrom(context.Background(), from, to, amount)

type ERC721 

type ERC721 struct {
	Token *abi.TokenERC721
	Drop  *abi.DropERC721

	ClaimConditions *NFTDropClaimConditions
	// contains filtered or unexported fields
}

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

func (*ERC721) Balance 

func (erc721 *ERC721) Balance(ctx context.Context) (int, error)

Get NFT balance

@extension: ERC721

returns: the number of NFTs on this contract owned by the connected wallet

Example 

balance, err := contract.ERC721.Balance(context.Background())

func (*ERC721) BalanceOf 

func (erc721 *ERC721) BalanceOf(ctx context.Context, address string) (int, error)

Get NFT balance of a specific wallet

@extension: ERC721

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

returns: the number of NFTs on this contract owned by the specified wallet

Example 

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

func (*ERC721) Burn 

func (erc721 *ERC721) Burn(ctx context.Context, tokenId int) (*types.Transaction, error)

Burna an NFT

@extension: ERC721Burnable

tokenId: tokenID of the token to burn

returns: the transaction receipt of the burn

Example 

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

func (*ERC721) Claim 

func (erc721 *ERC721) Claim(ctx context.Context, quantity int) (*types.Transaction, error)

Claim an NFT

@extension: ERC721ClaimCustom | ERC721ClaimPhasesV2 | ERC721ClaimConditionsV2

quantity: the number of NFTs to claim

returns: the transaction receipt of the claim

Example 

quantity = 1

tx, err := contract.ERC721.Claim(context.Background(), quantity)

func (*ERC721) ClaimTo 

func (erc721 *ERC721) ClaimTo(ctx context.Context, destinationAddress string, quantity int) (*types.Transaction, error)

Claim NFTs to a specific wallet

@extension: ERC721ClaimCustom | ERC721ClaimPhasesV2 | ERC721ClaimConditionsV2

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}}"
quantity = 1

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

func (*ERC721) CreateBatch 

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

Lazy mint NFTs

@extension: ERC721LazyMintable

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()

metadatas := []*thirdweb.NFTMetadataInput{
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT",
		Description: "This is a cool NFT",
		Image: image1
	}
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT 2",
		Description: "This is also a cool NFT",
		Image: image2
	}
}

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

func (*ERC721) Get 

func (erc721 *ERC721) Get(ctx context.Context, tokenId int) (*NFTMetadataOwner, error)

Get an NFT

@extension: ERC721

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

returns: the metadata for the NFT and its owner

Example 

nft, err := contract.ERC721.Get(context.Background(), 0)
owner := nft.Owner
name := nft.Metadata.Name

func (*ERC721) GetAll 

func (erc721 *ERC721) GetAll(ctx context.Context) ([]*NFTMetadataOwner, error)

Get all NFTs

@extension: ERC721Supply | ERC721Enumerable

returns: the metadata of all the NFTs on this contract

Example 

nfts, err := contract.ERC721.GetAll(context.Background())
ownerOne := nfts[0].Owner
nameOne := nfts[0].Metadata.Name

func (*ERC721) GetAllClaimed 

func (erc721 *ERC721) GetAllClaimed(ctx context.Context) ([]*NFTMetadataOwner, error)

Get all claimed NFTs

returns: a list of the metadatas of the claimed NFTs

Example 

claimedNfts, err := contract.ERC721.GetAllClaimed(context.Background())
firstOwner := claimedNfts[0].Owner

func (*ERC721) GetAllUnclaimed 

func (erc721 *ERC721) GetAllUnclaimed(ctx context.Context) ([]*NFTMetadata, error)

Get all unclaimed NFTs

returns: a list of the metadatas of the unclaimed NFTs

Example 

unclaimedNfts, err := contract.ERC721.GetAllUnclaimed(context.Background())
firstNftName := unclaimedNfts[0].Name

func (*ERC721) GetClaimArguments 

func (erc721 *ERC721) GetClaimArguments(
	ctx context.Context,
	destinationAddress string,
	quantity int,
) (
	*ClaimArguments,
	error,
)

func (*ERC721) GetClaimIneligibilityReasons 

func (erc721 *ERC721) GetClaimIneligibilityReasons(ctx context.Context, quantity int, addressToCheck string) ([]ClaimEligibility, error)

func (*ERC721) GetClaimInfo 

func (erc721 *ERC721) GetClaimInfo(ctx context.Context, address string) (*ClaimInfo, error)

func (*ERC721) GetTotalCount 

func (erc721 *ERC721) GetTotalCount(ctx context.Context) (int, error)

Get the total number of NFTs

@extension: ERC721ClaimCustom | ERC721ClaimPhasesV2 | ERC721ClaimConditionsV2

returns: the total number of NFTs on this contract

Example 

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

func (*ERC721) IsApproved 

func (erc721 *ERC721) IsApproved(ctx context.Context, owner string, operator string) (bool, error)

Check NFT approval

@extension: ERC721

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.ERC721.IsApproved(ctx, owner, operator)

func (*ERC721) Mint 

func (erc721 *ERC721) Mint(ctx context.Context, metadata *NFTMetadataInput) (*types.Transaction, error)

Mint an NFT

@extension: ERC721Mintable

metadata: metadata of the NFT to mint

returns: the transaction receipt of the mint

Example 

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

metadata := &thirdweb.NFTMetadataInput{
	Name: "Cool NFT",
	Description: "This is a cool NFT",
	Image: image,
}

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

func (*ERC721) MintBatch 

func (erc721 *ERC721) MintBatch(ctx context.Context, metadatas []*NFTMetadataInput) (*types.Transaction, error)

Mint many NFTs

@extension: ERC721BatchMintable

metadatas: list of metadata of the NFTs to mint

returns: the transaction receipt of the mint

Example 

metadatas := []*thirdweb.NFTMetadataInput{
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT",
		Description: "This is a cool NFT",
	}
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT 2",
		Description: "This is also a cool NFT",
	}
}

tx, err := contract.ERC721.MintBatchTo(context.Background(), metadatas)

func (*ERC721) MintBatchTo 

func (erc721 *ERC721) MintBatchTo(ctx context.Context, address string, metadatas []*NFTMetadataInput) (*types.Transaction, error)

Mint many NFTs to a specific wallet

@extension: ERC721BatchMintable

to: the wallet address to mint to

metadatas: list of metadata of the NFTs to mint

returns: the transaction receipt of the mint

Example 

metadatas := []*thirdweb.NFTMetadataInput{
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT",
		Description: "This is a cool NFT",
	}
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT 2",
		Description: "This is also a cool NFT",
	}
}

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

func (*ERC721) MintTo 

func (erc721 *ERC721) MintTo(ctx context.Context, address string, metadata *NFTMetadataInput) (*types.Transaction, error)

Mint an NFT to a specific wallet

@extension: ERC721Mintable

address: the wallet address to mint to

metadata: metadata of the NFT to mint

returns: the transaction receipt of the mint

Example 

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

metadata := &thirdweb.NFTMetadataInput{
	Name: "Cool NFT",
	Description: "This is a cool NFT",
	Image: image,
}

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

func (*ERC721) OwnerOf 

func (erc721 *ERC721) OwnerOf(ctx context.Context, tokenId int) (string, error)

Get the owner of an NFT

@extension: ERC721

tokenId: the token ID of the NFT to get the owner of

returns: the owner of the NFT

Example 

tokenId := 0
owner, err := contract.ERC721.OwnerOf(context.Background(), tokenId)

func (*ERC721) PrepareClaimTo 

func (erc721 *ERC721) PrepareClaimTo(ctx context.Context, destinationAddress string, quantity int) (*PreparedClaimTo, error)

func (*ERC721) SetApprovalForAll 

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

Set approval for all NFTs

@extension: ERC721

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.ERC721.SetApprovalForAll(context.Background(), operator, approved)

func (*ERC721) SetApprovalForToken 

func (erc721 *ERC721) SetApprovalForToken(ctx context.Context, operator string, tokenId int) (*types.Transaction, error)

Set approval for a specific NFT

@extension: ERC721

operator: the address of the operator to approve

tokenId: the token ID of the NFT to approve

returns: the transaction receipt of the approval

Example 

operator := "{{wallet_address}}"
approved := "0x..."
tokenId := 0

tx, err := contract.ERC721.SetApprovalForToken(context.Background(), operator, approved, tokenId)

func (*ERC721) TotalClaimedSupply 

func (erc721 *ERC721) TotalClaimedSupply(ctx context.Context) (int, error)

Get the number of claimed NFTs

@extension: ERC721ClaimCustom | ERC721ClaimPhasesV2 | ERC721ClaimConditionsV2

Example 

totalClaimed, err := contract.ERC721.TotalClaimedSupply(context.Background())

func (*ERC721) TotalSupply 

func (erc721 *ERC721) TotalSupply(ctx context.Context) (int, error)

Get the total number of NFTs

@extension: ERC721

returns: the supply of NFTs on this contract

Example 

supply, err := contract.ERC721.TotalSupply(context.Background)

func (*ERC721) TotalUnclaimedSupply 

func (erc721 *ERC721) TotalUnclaimedSupply(ctx context.Context) (int, error)

Get the number of unclaimed NFTs

@extension: ERC721ClaimCustom | ERC721ClaimPhasesV2 | ERC721ClaimConditionsV2

Example 

totalUnclaimed, err := contract.ERC721.TotalUnclaimedSupply(context.Background())

func (*ERC721) Transfer 

func (erc721 *ERC721) Transfer(ctx context.Context, to string, tokenId int) (*types.Transaction, error)

Transfer an NFT

@extension: ERC721

to: wallet address to transfer the tokens to

tokenId: the token ID of the NFT to transfer

returns: the transaction of the NFT transfer

Example 

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

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

type ERC721SignatureMinting 

type ERC721SignatureMinting struct {
	Helper *contractHelper
	// contains filtered or unexported fields
}

You can access this interface from the NFT Collection contract under the signature interface.

func (*ERC721SignatureMinting) Generate 

func (signature *ERC721SignatureMinting) Generate(ctx context.Context, payloadToSign *Signature721PayloadInput) (*SignedPayload721, error)

Generate a new payload from the given data

payloadToSign: the payload containing the data for the signature mint

returns: the payload signed by the minter's private key

Example 

payload := &thirdweb.Signature721PayloadInput{
	To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6", // address to mint to
	Price:                0,                                            // cost of minting
	CurrencyAddress:      "0x0000000000000000000000000000000000000000", // currency to pay in order to mint
	MintStartTime:        0,                                            // time where minting is allowed to start (epoch seconds)
	MintEndTime:          100000000000000,                              // time when this signature expires (epoch seconds)
	PrimarySaleRecipient: "0x0000000000000000000000000000000000000000", // address to receive the primary sales of this mint
	Metadata: &thirdweb.NFTMetadataInput{																// metadata of the NFT to mint
 		Name:  "ERC721 Sigmint!",
	},
	RoyaltyRecipient: "0x0000000000000000000000000000000000000000",     // address to receive royalties of this mint
	RoyaltyBps:       0,                                                // royalty cut of this mint in basis points
}

signedPayload, err := contract.Signature.Generate(payload)

func (*ERC721SignatureMinting) GenerateBatch 

func (signature *ERC721SignatureMinting) GenerateBatch(ctx context.Context, payloadsToSign []*Signature721PayloadInput) ([]*SignedPayload721, error)

Generate a batch of new payload from the given data

payloadToSign: the payloads containing the data for the signature mint

returns: the payloads signed by the minter's private key

Example 

payload := []*thirdweb.Signature721PayloadInput{
	&thirdweb.Signature721PayloadInput{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata: &thirdweb.NFTMetadataInput{
 			Name:  "ERC721 Sigmint!",
 			Image: imageFile,
		},
		RoyaltyRecipient: "0x0000000000000000000000000000000000000000",
		RoyaltyBps:       0,
	},
	&thirdweb.Signature721PayloadInput{
		To:                   "0x9e1b8A86fFEE4a7175DAE4bDB1cC12d111Dcb3D6",
		Price:                0,
		CurrencyAddress:      "0x0000000000000000000000000000000000000000",
		MintStartTime:        0,
		MintEndTime:          100000000000000,
		PrimarySaleRecipient: "0x0000000000000000000000000000000000000000",
		Metadata: &thirdweb.NFTMetadataInput{
 			Name:  "ERC721 Sigmint!",
 			Image: imageFile,
		},
		RoyaltyRecipient: "0x0000000000000000000000000000000000000000",
		RoyaltyBps:       0,
	},
}

signedPayload, err := contract.Signature.GenerateBatch(context.Background(), payload)

func (*ERC721SignatureMinting) GenerateBatchWithUris 

func (signature *ERC721SignatureMinting) GenerateBatchWithUris(ctx context.Context, payloadsToSign []*Signature721PayloadInputWithUri) ([]*SignedPayload721, error)

func (*ERC721SignatureMinting) Mint deprecated 

func (signature *ERC721SignatureMinting) Mint(ctx context.Context, signedPayload *SignedPayload721) (*types.Transaction, error)

Deprecated: use MintAndAwait

func (*ERC721SignatureMinting) MintAndAwait 

func (signature *ERC721SignatureMinting) MintAndAwait(ctx context.Context, signedPayload *SignedPayload721) (*types.Transaction, error)

func (*ERC721SignatureMinting) MintBatch 

func (signature *ERC721SignatureMinting) MintBatch(ctx context.Context, signedPayloads []*SignedPayload721) (*types.Transaction, error)

Mint a batch of token with the data in given payload.

signedPayload: the list of payloads signed by the minters private key being used to mint

returns: the transaction receipt of the batch mint

Example 

// Learn more about how to craft multiple payloads in the GenerateBatch() function
signedPayloads, err := contract.Signature.GenerateBatch(payloads)
tx, err := contract.Signature.MintBatch(context.Background(), signedPayloads)

func (*ERC721SignatureMinting) MintWithOpts 

func (signature *ERC721SignatureMinting) MintWithOpts(ctx context.Context, signedPayload *SignedPayload721, txOpts *bind.TransactOpts) (*types.Transaction, error)

func (*ERC721SignatureMinting) Verify 

func (signature *ERC721SignatureMinting) Verify(ctx context.Context, signedPayload *SignedPayload721) (bool, error)

Verify that a signed payload is valid

signedPayload: the payload to verify

returns: true if the payload is valid, otherwise false.

Example 

// Learn more about how to craft a payload in the Generate() function
signedPayload, err := contract.Signature.Generate(payload)
isValid, err := contract.Signature.Verify(signedPayload)

type ERC721Standard 

type ERC721Standard struct {
	// contains filtered or unexported fields
}

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

func (*ERC721Standard) Balance 

func (erc721 *ERC721Standard) Balance(ctx context.Context) (int, error)

Get the NFT balance of the connected wallet.

returns: the number of NFTs on this contract owned by the connected wallet

func (*ERC721Standard) BalanceOf 

func (erc721 *ERC721Standard) BalanceOf(ctx context.Context, address string) (int, error)

Get the NFT balance of a specific wallet.

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

returns: the number of NFTs on this contract owned by the specified wallet

Example 

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

func (*ERC721Standard) Burn 

func (erc721 *ERC721Standard) Burn(ctx context.Context, tokenId int) (*types.Transaction, error)

Burn a specified NFT from the connected wallet.

tokenId: tokenID of the token to burn

returns: the transaction receipt of the burn

Example 

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

func (*ERC721Standard) Get 

func (erc721 *ERC721Standard) Get(ctx context.Context, tokenId int) (*NFTMetadataOwner, error)

Get metadata for a token.

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

returns: the metadata for the NFT and its owner

Example 

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

func (*ERC721Standard) GetAll 

func (erc721 *ERC721Standard) GetAll(ctx context.Context) ([]*NFTMetadataOwner, error)

Get the metadata of all the NFTs on this contract.

returns: the metadata of all the NFTs on this contract

Example 

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

func (*ERC721Standard) GetTotalCount 

func (erc721 *ERC721Standard) GetTotalCount(ctx context.Context) (int, error)

Get the total number of NFTs on this contract.

returns: the total number of NFTs on this contract

func (*ERC721Standard) IsApproved 

func (erc721 *ERC721Standard) IsApproved(ctx context.Context, address string, operator string) (bool, error)

Check whether an operator address is approved for all operations of a specifc addresses assets.

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

func (*ERC721Standard) OwnerOf 

func (erc721 *ERC721Standard) OwnerOf(ctx context.Context, tokenId int) (string, error)

Get the owner of an NFT.

tokenId: the token ID of the NFT to get the owner of

returns: the owner of the NFT

func (*ERC721Standard) SetApprovalForAll 

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

Set the approval for all operations of a specific address's assets.

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

func (*ERC721Standard) SetApprovalForToken 

func (erc721 *ERC721Standard) SetApprovalForToken(ctx context.Context, operator string, tokenId int) (*types.Transaction, error)

Approve an operator for the NFT owner, which allows the operator to call transferFrom or safeTransferFrom for the specified token.

operator: the address of the operator to approve

tokenId: the token ID of the NFT to approve

returns: the transaction receipt of the approval

func (*ERC721Standard) TotalSupply 

func (erc721 *ERC721Standard) TotalSupply(ctx context.Context) (int, error)

Get the total number of NFTs on this contract.

returns: the supply of NFTs on this contract

func (*ERC721Standard) Transfer 

func (erc721 *ERC721Standard) Transfer(ctx context.Context, to string, tokenId int) (*types.Transaction, error)

Transfer a specified token from the connected wallet to a specified address.

to: wallet address to transfer the tokens to

tokenId: the token ID of the NFT to transfer

returns: the transaction of the NFT transfer

Example 

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

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

type Edition 

type Edition struct {
	*ERC1155Standard

	Helper    *contractHelper
	Signature *ERC1155SignatureMinting
	Encoder   *ContractEncoder
	Events    *ContractEvents
	// contains filtered or unexported fields
}

You can access the Edition interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetEdition("{{contract_address}}")

func (*Edition) Mint 

func (edition *Edition) Mint(ctx context.Context, metadataWithSupply *EditionMetadataInput) (*types.Transaction, error)

Mint an NFT to the connected wallet.

metadataWithSupply: nft metadata with supply of the NFT to mint

returns: the transaction receipt of the mint

func (*Edition) MintAdditionalSupply 

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

Mint additionaly supply of a token to the connected wallet.

tokenId: token ID to mint additional supply of

additionalSupply: additional supply to mint

returns: the transaction receipt of the mint

func (*Edition) MintAdditionalSupplyTo 

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

Mint additional supply of a token to the specified wallet.

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

func (*Edition) MintBatch 

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

Mint a batch of NFTs to the connected wallet.

metadatasWithSupply: list of NFT metadatas with supplies to mint

returns: the transaction receipt of the mint

func (*Edition) MintBatchTo 

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

Mint a batch of NFTs to a specific wallet.

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 (*Edition) MintTo 

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

Mint a new NFT to the specified wallet.

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{
        context.Background(),
		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)

type EditionDrop 

type EditionDrop struct {
	*ERC1155Standard

	Helper          *contractHelper
	ClaimConditions *EditionDropClaimConditions
	Encoder         *ContractEncoder
	Events          *ContractEvents
	// contains filtered or unexported fields
}

You can access the Edition Drop interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetEditionDrop("{{contract_address}}")

func (*EditionDrop) Claim 

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

Claim NFTs from this contract to the connect wallet.

tokenId: the token ID of the NFT to claim

quantity: the number of NFTs to claim

returns: the transaction receipt of the claim

func (*EditionDrop) ClaimTo 

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

Claim NFTs from this contract to the connect wallet.

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 (*EditionDrop) CreateBatch 

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

Create a batch of NFTs on this contract.

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.MintBatchTo(context.Background(), "{{wallet_address}}", metadatasWithSupply)

type EditionDropClaimConditions 

type EditionDropClaimConditions struct {
	// contains filtered or unexported fields
}

This interface is currently accessible from the Edition Drop contract contract type via the ClaimConditions property.

func (*EditionDropClaimConditions) GetActive 

func (claim *EditionDropClaimConditions) GetActive(ctx context.Context, tokenId int) (*ClaimConditionOutput, error)

Get the currently active claim condition for a given token

tokenId: the token ID of the token to get the active claim condition for

returns: the currently active claim condition metadata

Example 

tokenId := 0
condition, err := contract.ClaimConditions.GetActive(context.Background(), tokenId)

// Now you have access to all the claim condition metadata
fmt.Println("Start Time:", condition.StartTime)
fmt.Println("Available:", condition.AvailableSupply)
fmt.Println("Quantity:", condition.MaxQuantity)
fmt.Println("Quantity Limit:", condition.QuantityLimitPerTransaction)
fmt.Println("Price:", condition.Price)
fmt.Println("Wait In Seconds", condition.WaitInSeconds)

func (*EditionDropClaimConditions) GetAll 

func (claim *EditionDropClaimConditions) GetAll(ctx context.Context, tokenId int) ([]*ClaimConditionOutput, error)

Get all claim conditions on this contract for a given token

tokenId: the token ID of the token to get the claim conditions for

returns: the metadata for all the claim conditions on this contract

Example 

tokenId := 0
conditions, err := contract.ClaimConditions.GetAll(context.Background(), tokenId)

// Now you have access to all the claim condition metadata
condition := conditions[0]
fmt.Println("Start Time:", condition.StartTime)
fmt.Println("Available:", condition.AvailableSupply)
fmt.Println("Quantity:", condition.MaxQuantity)
fmt.Println("Quantity Limit:", condition.QuantityLimitPerTransaction)
fmt.Println("Price:", condition.Price)
fmt.Println("Wait In Seconds", condition.WaitInSeconds)

func (*EditionDropClaimConditions) GetMerkleMetadata 

func (claim *EditionDropClaimConditions) GetMerkleMetadata(ctx context.Context) (*map[string]string, error)

type EditionMetadata 

type EditionMetadata struct {
	Metadata *NFTMetadata
	Supply   int
}

type EditionMetadataInput 

type EditionMetadataInput struct {
	Metadata *NFTMetadataInput
	Supply   int
}

type EditionMetadataOwner 

type EditionMetadataOwner struct {
	Metadata      *NFTMetadata
	Supply        int
	Owner         string
	QuantityOwned int
}

type EditionResult 

type EditionResult struct {
	// contains filtered or unexported fields
}

type EventQueryOptions 

type EventQueryOptions struct {
	FromBlock uint64
	ToBlock   *uint64
	Filters   map[string]interface{}
}

type EventSubscription 

type EventSubscription struct {
	Err         func() <-chan error
	Unsubscribe func()
}

type IpfsStorage 

type IpfsStorage struct {
	// contains filtered or unexported fields
}

func (*IpfsStorage) Get 

func (ipfs *IpfsStorage) Get(ctx context.Context, uri string) ([]byte, error)

Get

Get IPFS data at a given hash and return it as byte data

uri: the IPFS URI to fetch data from

returns: byte data of the IPFS data at the URI

func (*IpfsStorage) Upload 

func (ipfs *IpfsStorage) Upload(ctx context.Context, data map[string]interface{}, contractAddress string, signerAddress string) (string, error)

Upload

Upload method can be used to upload a generic payload to IPFS.

data: the individual data to upload to IPFS

contractAddress: the optional contractAddress upload is being called from

signerAddress: the optional signerAddress upload is being called from

returns: the URI of the IPFS upload

func (*IpfsStorage) UploadBatch 

func (ipfs *IpfsStorage) UploadBatch(ctx context.Context, data []map[string]interface{}, fileStartNumber int, contractAddress string, signerAddress string) (*baseUriWithUris, error)

UploadBatch

UploadBatch method can be used to upload a batch of generic payloads to IPFS.

data: the array of data to upload to IPFS

contractAddress: the optional contractAddress upload is being called from

signerAddress: the optional signerAddress upload is being called from

returns: the base URI of the IPFS upload folder with the URIs of each subfile

type Marketplace 

type Marketplace struct {
	Abi     *abi.Marketplace
	Helper  *contractHelper
	Encoder *MarketplaceEncoder
	Events  *ContractEvents
	// contains filtered or unexported fields
}

You can access the Marketplace interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetMarketplace("{{contract_address}}")

func (*Marketplace) BuyoutListing 

func (marketplace *Marketplace) BuyoutListing(ctx context.Context, listingId int, quantityDesired int) (*types.Transaction, error)

Buy a specific listing from the marketplace.

listingId: listing ID of the asset you want to buy

quantityDesired: the quantity of the asset to buy from the listing

returns: transaction receipt of the purchase

func (*Marketplace) BuyoutListingTo 

func (marketplace *Marketplace) BuyoutListingTo(ctx context.Context, listingId int, quantityDesired int, receiver string) (*types.Transaction, error)

Buy a specific listing from the marketplace to a specific address.

listingId: listing ID of the asset you want to buy

quantityDesired: the quantity of the asset to buy from the listing

receiver: specific address to receive the assets from the listing

returns: transaction receipt of the purchase

Example 

listingId := 0
quantityDesired := 1
receiver := "0x..."
receipt, err := marketplace.BuyoutListingTo(context.Background(), listingId, quantityDesired, receiver)

func (*Marketplace) CancelListing 

func (marketplace *Marketplace) CancelListing(ctx context.Context, listingId int) (*types.Transaction, error)

Cancel a listing on the marketplace.

listingId: listing ID to cancel

returns: transaction receipt of the cancellation

Example 

listingId := 0
receipt, err := marketplace.CancelListing(context.Background(), listingId)

func (*Marketplace) CreateListing 

func (marketplace *Marketplace) CreateListing(ctx context.Context, listing *NewDirectListing) (int, error)

Create a new listing on the marketplace where people can buy an asset directly.

listing: the data for the listing to create

returns: the ID of the listing that was created

Example 

listing := &NewDirectListing{
	AssetContractAddress: "0x...", // Address of the asset contract
	TokenId: 0, // Token ID of the asset to list
	StartTimeInEpochSeconds: int(time.Now().Unix()), // Defaults to current time
	ListingDurationInSeconds: int(time.Now().Unix() + 3600), // Defaults to current time + 1 hour
	Quantity: 1, // Quantity of the asset to list
	CurrencyContractAddress: "0x...", // Contract address of currency to sell for, defaults to native token
	BuyoutPricePerToken: 1, // Price per token of the asset to list
}

listingId, err := marketplace.CreateListing(context.Background(), listing)

func (*Marketplace) GetActiveListings 

func (marketplace *Marketplace) GetActiveListings(ctx context.Context, filter *MarketplaceFilter) ([]*DirectListing, error)

Get all active listings from the marketplace.

filter: optional filter parameters

returns: all active listings in the marketplace

Example 

listings, err := marketplace.GetActiveListings(context.Background(), nil)
// Price per token of the first listing
listings[0].BuyoutCurrencyValuePerToken.DisplayValue

func (*Marketplace) GetAllListings 

func (marketplace *Marketplace) GetAllListings(ctx context.Context, filter *MarketplaceFilter) ([]*DirectListing, error)

Get all the listings from the marketplace.

filter: optional filter parameters

returns: all listings in the marketplace

Example 

listings, err := marketplace.GetAllListings(context.Background(), nil)
// Price per token of the first listing
listings[0].BuyoutCurrencyValuePerToken.DisplayValue

func (*Marketplace) GetListing 

func (marketplace *Marketplace) GetListing(ctx context.Context, listingId int) (*DirectListing, error)

Get a single listing from the marketplace.

listingId: listing ID to get

returns: listing at the given listing ID

Example 

listingId := 0
listing, err := marketplace.GetListing(context.Background(), listingId)

func (*Marketplace) GetTotalCount 

func (marketplace *Marketplace) GetTotalCount(ctx context.Context) (int, error)

Get the total number of listings in the marketplace.

returns: total number of listings in the marketplace

type MarketplaceEncoder 

type MarketplaceEncoder struct {
	*ContractEncoder
	// contains filtered or unexported fields
}

The marketplace encoder class is used to get the unsigned transaction data for marketplace contract contract calls that can be signed at a later time after generation.

It can be accessed from the SDK through the `Encoder` namespace of the marketplace contract:

You can access the Marketplace interface from the SDK as follows: 

	import (
		"github.com/sontungpytn/go-sdk/v2/thirdweb"
	)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

	marketplace, err := sdk.GetMarketplace("{{contract_address}}")

	// Now the encoder can be accessed from the contract
 marketplace.Encoder.CreateListing(...)

func (*MarketplaceEncoder) ApproveBuyoutListing 

func (encoder *MarketplaceEncoder) ApproveBuyoutListing(
	ctx context.Context,
	signerAddress string,
	listingId int,
	quantityDesired int,
	receiver string,
) (*types.Transaction, error)

Get the transaction data to approve the tokens needed for a buyout listing transaction. If the transaction wouldn't require any additional token approvals, this method will return nil.

signerAddress: the address intended to sign the transaction

listingId: the ID of the listing to buyout

quantityDesired: the quantity of the listed tokens to purchase

receiver: the address to receive the purchased tokens

returns: the transaction data for the token approval if an approval is needed, or nil

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."
// ID of the listing to buyout
listingId := 1
// Quantity of the listed tokens to purchase
quantityDesired := 1
// receiver address to receive the purchased tokens
receiver := "0x..."

// Transaction data required for this request
tx, err := marketplace.Encoder.ApproveBuyoutListing(context.Background(), signerAddress, listingId, quantityDesired, receiver)

// Now you can get transaction all the standard data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

func (*MarketplaceEncoder) ApproveCreateListing 

func (encoder *MarketplaceEncoder) ApproveCreateListing(ctx context.Context, signerAddress string, listing *NewDirectListing) (*types.Transaction, error)

Get the transaction data to approve the tokens needed for a create liting transaction. If the transaction wouldn't require any additional token approvals, this method will return nil.

signerAddress: the address intended to sign the transaction

listing: the parameters for the new direct listing to create

returns: the transaction data for the create listing transaction

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."

listing := &NewDirectListing{
	AssetContractAddress: "0x...", // Address of the asset contract
	TokenId: 0, // Token ID of the asset to list
	StartTimeInEpochSeconds: int(time.Now().Unix()), // Defaults to current time
	ListingDurationInSeconds: int(time.Now().Unix() + 3600), // Defaults to current time + 1 hour
	Quantity: 1, // Quantity of the asset to list
	CurrencyContractAddress: "0x...", // Contract address of currency to sell for, defaults to native token
	BuyoutPricePerToken: 1, // Price per token of the asset to list
}

// Transaction data required for this request
tx, err := marketplace.Encoder.ApproveCreateListing(context.Background(), signerAddress, listing)

// Now you can get transaction data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

func (*MarketplaceEncoder) BuyoutListing 

func (encoder *MarketplaceEncoder) BuyoutListing(
	ctx context.Context,
	signerAddress string,
	listingId int,
	quantityDesired int,
	receiver string,
) (*types.Transaction, error)

Get the transaction data for the buyout listing transaction. This method will throw an error if the listing requires payment in ERC20 tokens and the ERC20 tokens haven't yet been approved by the spender. You can get the transaction data of this required approval transaction from the `ApproveBuyoutListing` method.

signerAddress: the address intended to sign the transaction

listingId: the ID of the listing to buyout

quantityDesired: the quantity of the listed tokens to purchase

receiver: the address to receive the purchased tokens

returns: the transaction data for this purchase

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."
// ID of the listing to buyout
listingId := 1
// Quantity of the listed tokens to purchase
quantityDesired := 1
// receiver address to receive the purchased tokens
receiver := "0x..."

// Transaction data required for this request
tx, err := marketplace.Encoder.BuyoutListing(context.Background(), signerAddress, listingId, quantityDesired, receiver)

// Now you can get transaction all the standard data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

func (*MarketplaceEncoder) CancelListing 

func (encoder *MarketplaceEncoder) CancelListing(ctx context.Context, signerAddress string, listingId int) (*types.Transaction, error)

Get the data for the transaction required to cancel a listing on the marketplace

signerAddress: the address intended to sign the transaction

listingId: the ID of the listing to cancel

returns: the transaction data for the cancellation

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."
// ID of the listing to cancel
listingId := 1

// Transaction data required for this request
tx, err := marketplace.Encoder.CancelListing(context.Background(), signerAddress, listingId)

// Now you can get transaction all the standard data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

func (*MarketplaceEncoder) CreateListing 

func (encoder *MarketplaceEncoder) CreateListing(ctx context.Context, signerAddress string, listing *NewDirectListing) (*types.Transaction, error)

Get the data for the transaction required to create a direct listing. This method will throw an error if the tokens needed for the listing have not yet been approved by the asset owner for the marketplace to spend. You can get the transaction data of this required approval transaction from the `ApproveCreateListing` method.

signerAddress: the address intended to sign the transaction

listing: the parameters for the new direct listing to create

returns: the transaction data for the create listing transaction

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."

listing := &NewDirectListing{
	AssetContractAddress: "0x...", // Address of the asset contract
	TokenId: 0, // Token ID of the asset to list
	StartTimeInEpochSeconds: int(time.Now().Unix()), // Defaults to current time
	ListingDurationInSeconds: int(time.Now().Unix() + 3600), // Defaults to current time + 1 hour
	Quantity: 1, // Quantity of the asset to list
	CurrencyContractAddress: "0x...", // Contract address of currency to sell for, defaults to native token
	BuyoutPricePerToken: 1, // Price per token of the asset to list
}

// Transaction data required for this request
tx, err := marketplace.Encoder.CreateListing(context.Background(), signerAddress, listing)

// Now you can get transaction data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

type MarketplaceFilter 

type MarketplaceFilter struct {
	Start         int
	Count         int
	Seller        string
	TokenContract string
}

type MerkleContent 

type MerkleContent struct {
	// contains filtered or unexported fields
}

func (MerkleContent) CalculateHash 

func (t MerkleContent) CalculateHash() ([]byte, error)

func (MerkleContent) Equals 

func (t MerkleContent) Equals(other merkletree.Content) (bool, error)

type MerkleNode 

type MerkleNode struct {
	// contains filtered or unexported fields
}

func (*MerkleNode) Serialize 

func (t *MerkleNode) Serialize() ([]byte, error)

type Metadata 

type Metadata struct {
	MetadataUri    string
	MetadataObject interface{}
}

type Multiwrap 

type Multiwrap struct {
	*ERC721Standard

	Helper  *contractHelper
	Encoder *ContractEncoder
	// contains filtered or unexported fields
}

You can access the Multiwrap interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetMultiwrap("{{contract_address}}")

func (*Multiwrap) GetWrappedContents 

func (multiwrap *Multiwrap) GetWrappedContents(wrappedTokenId int) (*MultiwrapBundle, error)

Get the contents of a wrapped token bundle.

wrappedTokenId: the ID of the wrapped token bundle

returns: the contents of the wrapped token bundle

Example 

tokenId := 0
contents, err := contract.GetWrappedContents(tokenId)
erc20Tokens := contents.Erc20Tokens
erc721Tokens := contents.Erc721Tokens
erc1155Tokens := contents.Erc1155Tokens

func (*Multiwrap) Unwrap 

func (multiwrap *Multiwrap) Unwrap(ctx context.Context, wrappedTokenId int, recipientAddress string) (*types.Transaction, error)

Unwrap a wrapped token bundle into its contents

wrappedTokenId: the ID of the wrapped token bundle

recipientAddress: the optional address to send the wrapped token to

returns: the contents of the wrapped token bundle

Example 

tokenId := 0
tx, err := contract.Unwrap(context.Background(), tokenId, "")

func (*Multiwrap) Wrap 

func (multiwrap *Multiwrap) Wrap(ctx context.Context, contents *MultiwrapBundle, wrappedTokenMetadata interface{}, recipientAddress string) (*types.Transaction, error)

Wrap any number of ERC20, ERC721, or ERC1155 tokens into a single wrapped token

contents: the tokens to wrap into a single wrapped token

wrappedTokenMetadata: the NFT Metadata or URI to as the metadata for the wrapped token

recipientAddress: the optional address to send the wrapped token to

returns: the transaction receipt of the wrapping

Example 

contents := &thirdweb.MultiwrapBundle{
	ERC20Tokens: []*thirdweb.MultiwrapERC20{
		&thirdweb.MultiwrapERC20{
			ContractAddress: "0x...",
			Quantity:        1,
		},
	},
	ERC721Tokens: []*thirdweb.MultiwrapERC721{
		&thirdweb.MultiwrapERC721{
			ContractAddress: "0x...",
			TokenId:         1,
		},
	},
	ERC1155Tokens: []*thirdweb.MultiwrapERC1155{
		&thirdweb.MultiwrapERC1155{
			ContractAddress: "0x...",
			TokenId:         1,
			Quantity:        1,
		},
	},
}

wrappedTokenMetadata := &thirdweb.NFTMetadataInput{
	Name: "Wrapped Token"
}

// This will mint the wrapped token to the connected wallet
tx, err := contract.Wrap(context.Background(), contents, wrappedTokenMetadata, "")

type MultiwrapBundle 

type MultiwrapBundle struct {
	ERC20Tokens   []*MultiwrapERC20
	ERC721Tokens  []*MultiwrapERC721
	ERC1155Tokens []*MultiwrapERC1155
}

type MultiwrapERC1155 

type MultiwrapERC1155 struct {
	ContractAddress string
	TokenId         int
	Quantity        int
}

type MultiwrapERC20 

type MultiwrapERC20 struct {
	ContractAddress string
	Quantity        float64
}

type MultiwrapERC721 

type MultiwrapERC721 struct {
	ContractAddress string
	TokenId         int
}

type NFTCollection 

type NFTCollection struct {
	*ERC721Standard

	Helper    *contractHelper
	Signature *ERC721SignatureMinting
	Encoder   *ContractEncoder
	Events    *ContractEvents
	// contains filtered or unexported fields
}

You can access the NFT Collection interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetNFTCollection("{{contract_address}}")

func (*NFTCollection) GetOwned 

func (nft *NFTCollection) GetOwned(ctx context.Context, address string) ([]*NFTMetadataOwner, error)

Get the metadatas of all the NFTs owned by a specific address.

address: the address of the owner of the NFTs

returns: the metadata 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 (*NFTCollection) GetOwnedTokenIDs 

func (nft *NFTCollection) GetOwnedTokenIDs(ctx context.Context, address string) ([]*big.Int, error)

Get the tokenIds of all the NFTs owned by a specific address.

address: the address of the owner of the NFTs

returns: the tokenIds of all the NFTs owned by the address

func (*NFTCollection) Mint 

func (nft *NFTCollection) Mint(ctx context.Context, metadata *NFTMetadataInput) (*types.Transaction, error)

Mint a new NFT to the connected wallet.

metadata: metadata of the NFT to mint

returns: the transaction receipt of the mint

func (*NFTCollection) MintBatch 

func (nft *NFTCollection) MintBatch(ctx context.Context, metadatas []*NFTMetadataInput) (*types.Transaction, error)

Mint a batch of new NFTs to the connected wallet.

metadatas: list of metadata of the NFTs to mint

returns: the transaction receipt of the mint

func (*NFTCollection) MintBatchTo 

func (nft *NFTCollection) MintBatchTo(ctx context.Context, address string, metadatas []*NFTMetadataInput) (*types.Transaction, error)

Mint a batch of new NFTs to the specified wallet.

to: the wallet address to mint to

metadatas: list of metadata of the NFTs to mint

returns: the transaction receipt of the mint

Example 

metadatas := []*thirdweb.NFTMetadataInput{
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT",
		Description: "This is a cool NFT",
	}
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT 2",
		Description: "This is also a cool NFT",
	}
}

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

func (*NFTCollection) MintTo 

func (nft *NFTCollection) MintTo(ctx context.Context, address string, metadata *NFTMetadataInput) (*types.Transaction, error)

Mint a new NFT to the specified wallet.

address: the wallet address to mint to

metadata: metadata of the NFT to mint

returns: the transaction receipt of the mint

Example 

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

metadata := &thirdweb.NFTMetadataInput{
	Name: "Cool NFT",
	Description: "This is a cool NFT",
	Image: image,
}

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

type NFTDrop 

type NFTDrop struct {
	*ERC721Standard
	Abi             *abi.DropERC721
	Helper          *contractHelper
	ClaimConditions *NFTDropClaimConditions
	Encoder         *NFTDropEncoder
	Events          *ContractEvents
}

You can access the NFT Drop interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetNFTDrop("{{contract_address}}")

func (*NFTDrop) Claim 

func (drop *NFTDrop) Claim(ctx context.Context, quantity int) (*types.Transaction, error)

Claim NFTs from this contract to the connect wallet.

quantity: the number of NFTs to claim

returns: the transaction receipt of the claim

func (*NFTDrop) ClaimTo 

func (drop *NFTDrop) ClaimTo(ctx context.Context, destinationAddress string, quantity int) (*types.Transaction, error)

Claim NFTs from this contract to the connect wallet.

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}}"
quantity = 1

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

func (*NFTDrop) CreateBatch 

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

Create a batch of NFTs on this contract.

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()

metadatas := []*thirdweb.NFTMetadataInput{
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT",
		Description: "This is a cool NFT",
		Image: image1
	}
	&thirdweb.NFTMetadataInput{
		Name: "Cool NFT 2",
		Description: "This is also a cool NFT",
		Image: image2
	}
}

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

func (*NFTDrop) GetAllClaimed 

func (drop *NFTDrop) GetAllClaimed(ctx context.Context) ([]*NFTMetadataOwner, error)

Get a list of all the NFTs that have been claimed from this contract.

returns: a list of the metadatas of the claimed NFTs

Example 

claimedNfts, err := contract.GetAllClaimed(context.Background())
firstOwner := claimedNfts[0].Owner

func (*NFTDrop) GetAllUnclaimed 

func (drop *NFTDrop) GetAllUnclaimed(ctx context.Context) ([]*NFTMetadata, error)

Get a list of all the NFTs on this contract that have not yet been claimed.

returns: a list of the metadatas of the unclaimed NFTs

Example 

unclaimedNfts, err := contract.GetAllUnclaimed(context.Background())
firstNftName := unclaimedNfts[0].Name

func (*NFTDrop) GetClaimArguments 

func (drop *NFTDrop) GetClaimArguments(
	ctx context.Context,
	destinationAddress string,
	quantity int,
) (
	*ClaimArguments,
	error,
)

func (*NFTDrop) GetClaimIneligibilityReasons 

func (drop *NFTDrop) GetClaimIneligibilityReasons(ctx context.Context, quantity int, addressToCheck string) ([]ClaimEligibility, error)

func (*NFTDrop) GetClaimInfo 

func (drop *NFTDrop) GetClaimInfo(ctx context.Context, address string) (*ClaimInfo, error)

func (*NFTDrop) GetOwned 

func (nft *NFTDrop) GetOwned(ctx context.Context, address string) ([]*NFTMetadataOwner, error)

Get the metadatas of all the NFTs owned by a specific address.

address: the address of the owner of the NFTs

returns: the metadata 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 (*NFTDrop) GetOwnedTokenIDs 

func (nft *NFTDrop) GetOwnedTokenIDs(ctx context.Context, address string) ([]*big.Int, error)

Get the tokenIds of all the NFTs owned by a specific address.

address: the address of the owner of the NFTs

returns: the tokenIds of all the NFTs owned by the address

func (*NFTDrop) GetTotalClaimed 

func (drop *NFTDrop) GetTotalClaimed(ctx context.Context, address string) (*big.Int, error)

func (*NFTDrop) TotalClaimedSupply 

func (drop *NFTDrop) TotalClaimedSupply(ctx context.Context) (int, error)

Get the total number of NFTs that have been claimed.

func (*NFTDrop) TotalUnclaimedSupply 

func (drop *NFTDrop) TotalUnclaimedSupply(ctx context.Context) (int, error)

Get the total number of NFTs that have not yet been claimed.

type NFTDropClaimConditions 

type NFTDropClaimConditions struct {
	// contains filtered or unexported fields
}

This interface is currently accessible from the NFT Drop contract contract type via the ClaimConditions property.

func (*NFTDropClaimConditions) Get 

func (claim *NFTDropClaimConditions) Get(ctx context.Context, claimConditionId int) (*ClaimConditionOutput, error)

func (*NFTDropClaimConditions) GetActive 

func (claim *NFTDropClaimConditions) GetActive(ctx context.Context) (*ClaimConditionOutput, error)

Get the currently active claim condition

returns: the currently active claim condition metadata

Example 

condition, err := contract.ClaimConditions.GetActive()

// Now you have access to all the claim condition metadata
fmt.Println("Start Time:", condition.StartTime)
fmt.Println("Available:", condition.AvailableSupply)
fmt.Println("Quantity:", condition.MaxQuantity)
fmt.Println("Quantity Limit:", condition.QuantityLimitPerTransaction)
fmt.Println("Price:", condition.Price)
fmt.Println("Wait In Seconds", condition.WaitInSeconds)

func (*NFTDropClaimConditions) GetAll 

func (claim *NFTDropClaimConditions) GetAll(ctx context.Context) ([]*ClaimConditionOutput, error)

Get all claim conditions on this contract

returns: the metadata for all the claim conditions on this contract

Example 

conditions, err := contract.ClaimConditions.GetAll()

// Now you have access to all the claim condition metadata
condition := conditions[0]
fmt.Println("Start Time:", condition.StartTime)
fmt.Println("Available:", condition.AvailableSupply)
fmt.Println("Quantity:", condition.MaxQuantity)
fmt.Println("Quantity Limit:", condition.QuantityLimitPerTransaction)
fmt.Println("Price:", condition.Price)
fmt.Println("Wait In Seconds", condition.WaitInSeconds)

func (*NFTDropClaimConditions) GetClaimerProofs 

func (claim *NFTDropClaimConditions) GetClaimerProofs(
	ctx context.Context,
	claimerAddress string,
) (*SnapshotEntryWithProof, error)

type NFTDropEncoder 

type NFTDropEncoder struct {
	*ContractEncoder
	// contains filtered or unexported fields
}

The nft drop encoder class is used to get the unsigned transaction data for nft drop contract contract calls that can be signed at a later time after generation.

It can be accessed from the SDK through the `Encoder` namespace of the nft drop contract:

You can access the NFTDrop interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetNFTDrop("{{contract_address}}")

// Now the encoder can be accessed from the contract
contract.Encoder.ClaimTo(...)

func (*NFTDropEncoder) ApproveClaimTo 

func (encoder *NFTDropEncoder) ApproveClaimTo(ctx context.Context, signerAddress string, quantity int) (*types.Transaction, error)

Get the data for the transaction data required to approve the ERC20 token transfers necessary to claim NFTs from this contract.

signerAddress: the address intended to sign the transaction

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

quantity: the number of NFTs to claim

returns: the transaction data of the token approval for the claim

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."
// Number of NFTs to claim
quantity = 1

tx, err := contract.Encoder.ApproveClaimTo(context.Background(), signerAddress, quantity)

// Now you can get all the standard transaction data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

func (*NFTDropEncoder) ClaimTo 

func (encoder *NFTDropEncoder) ClaimTo(ctx context.Context, signerAddress string, destinationAddress string, quantity int) (*types.Transaction, error)

Get the data for the transaction required to claim NFTs from this contract.

signerAddress: the address intended to sign the transaction

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

quantity: the number of NFTs to claim

returns: the transaction data of the claim

Example 

// Address of the wallet we expect to sign this message
signerAddress := "0x..."
// Address of the wallet we want to claim the NFTs to
destinationAddress := "{{wallet_address}}"
// Number of NFTs to claim
quantity = 1

tx, err := contract.Encoder.ClaimTo(context.Background(), signerAddress, destinationAddress, quantity)

// Now you can get all the standard transaction data as needed
fmt.Println(tx.Data()) // Ex: get the data field or the nonce field (others are available)
fmt.Println(tx.Nonce())

type NFTMetadata 

type NFTMetadata struct {
	Id              *big.Int    `json:"id"`
	Uri             string      `json:"uri"`
	Name            string      `json:"name"`
	Description     string      `json:"description"`
	Image           interface{} `json:"image"`
	ExternalUrl     string      `json:"external_url"`
	AnimationUrl    string      `json:"animation_url"`
	BackgroundColor string      `json:"background_color"`
	Properties      interface{} `json:"properties,omitempty"`
	Attributes      interface{} `json:"attributes,omitempty"`
}

type NFTMetadataInput 

type NFTMetadataInput struct {
	Name            string      `mapstructure:"name" json:"name"`
	Description     string      `mapstructure:"description,omitempty" json:"description"`
	Image           interface{} `mapstructure:"image,omitempty" json:"image"`
	ExternalUrl     string      `mapstructure:"external_url,omitempty" json:"external_url"`
	AnimationUrl    string      `mapstructure:"animation_url,omitempty" json:"animation_url"`
	BackgroundColor string      `mapstructure:"background_color,omitempty" json:"background_color"`
	Properties      interface{} `mapstructure:"properties,omitempty" json:"properties,omitempty"`
	Attributes      interface{} `mapstructure:"attributes,omitempty" json:"attributes,omitempty"`
}

type NFTMetadataOwner 

type NFTMetadataOwner struct {
	Metadata *NFTMetadata
	Owner    string
}

type NFTResult 

type NFTResult struct {
	// contains filtered or unexported fields
}

type NativeToken 

type NativeToken struct {
	// contains filtered or unexported fields
}

type NewDirectListing 

type NewDirectListing struct {
	AssetContractAddress     string
	TokenId                  int
	StartTimeInEpochSeconds  int
	ListingDurationInSeconds int
	Quantity                 int
	CurrencyContractAddress  string
	BuyoutPricePerToken      float64
}

type PreparedClaimTo 

type PreparedClaimTo struct {
	Receiver       common.Address
	Quantity       *big.Int
	Currency       common.Address
	PricePerToken  *big.Int
	AllowlistProof abi.IDropAllowlistProof
	Data           []byte
	Value          *big.Int
}

type ProviderHandler 

type ProviderHandler struct {
	// contains filtered or unexported fields
}

func NewProviderHandler 

func NewProviderHandler(provider *ethclient.Client, privateKey string) (*ProviderHandler, error)

func (*ProviderHandler) GetChainID 

func (handler *ProviderHandler) GetChainID(ctx context.Context) (*big.Int, error)

func (*ProviderHandler) GetPrivateKey 

func (handler *ProviderHandler) GetPrivateKey() *ecdsa.PrivateKey

func (*ProviderHandler) GetProvider 

func (handler *ProviderHandler) GetProvider() *ethclient.Client

func (*ProviderHandler) GetRawPrivateKey 

func (handler *ProviderHandler) GetRawPrivateKey() string

func (*ProviderHandler) GetSignerAddress 

func (handler *ProviderHandler) GetSignerAddress() common.Address

func (*ProviderHandler) UpdatePrivateKey 

func (handler *ProviderHandler) UpdatePrivateKey(privateKey string) error

func (*ProviderHandler) UpdateProvider 

func (handler *ProviderHandler) UpdateProvider(provider *ethclient.Client)

type SDKOptions 

type SDKOptions struct {
	SecretKey  string
	PrivateKey string
	GatewayUrl string
	HttpClient *http.Client
}

type ShardData 

type ShardData struct {
	Proofs  []string        `json:"proofs"`
	Entries []SnapshotEntry `json:"entries"`
}

type ShardedMerkleTree 

type ShardedMerkleTree struct {
	// contains filtered or unexported fields
}

func (*ShardedMerkleTree) FetchAndCacheDecimals 

func (tree *ShardedMerkleTree) FetchAndCacheDecimals(
	ctx context.Context,
	cache map[string]int,
	provider *ethclient.Client,
	currencyAddress string,
) (int, error)

func (*ShardedMerkleTree) GetProof 

func (tree *ShardedMerkleTree) GetProof(
	ctx context.Context,
	address string,
	provider *ethclient.Client,
) (*SnapshotEntryWithProof, error)

func (*ShardedMerkleTree) HashEntry 

func (tree *ShardedMerkleTree) HashEntry(
	entry *SnapshotEntry,
	tokenDecimals int,
	currencyDecimals int,
) (string, error)

type ShardedMerkleTreeInfo 

type ShardedMerkleTreeInfo struct {
	MerkleRoot         string `json:"merkleRoot"`
	BaseUri            string `json:"baseUri"`
	OriginalEntriesUri string `json:"originalEntriesUri"`
	ShardNybbles       int    `json:"shardNybbles"`
	TokenDecimals      int    `json:"tokenDecimals"`
}

type Signature1155PayloadInput 

type Signature1155PayloadInput struct {
	To                   string
	Price                float64
	CurrencyAddress      string
	MintStartTime        int
	MintEndTime          int
	PrimarySaleRecipient string
	Metadata             *NFTMetadataInput
	RoyaltyRecipient     string
	RoyaltyBps           int
	Quantity             int
}

type Signature1155PayloadInputWithTokenId 

type Signature1155PayloadInputWithTokenId struct {
	To                   string
	Price                float64
	CurrencyAddress      string
	MintStartTime        int
	MintEndTime          int
	PrimarySaleRecipient string
	Metadata             *NFTMetadataInput
	TokenId              *big.Int
	RoyaltyRecipient     string
	RoyaltyBps           int
	Quantity             int
}

type Signature1155PayloadOutput 

type Signature1155PayloadOutput struct {
	To                   string            `json:"to"`
	Price                string            `json:"price"`
	CurrencyAddress      string            `json:"currencyAddress"`
	MintStartTime        int               `json:"mintStartTime"`
	MintEndTime          int               `json:"mintEndTime"`
	PrimarySaleRecipient string            `json:"primarySaleRecipient"`
	Metadata             *NFTMetadataInput `json:"metadata"`
	RoyaltyRecipient     string            `json:"royaltyRecipient"`
	RoyaltyBps           int               `json:"royaltyBps"`
	TokenId              *big.Int          `json:"tokenId"`
	Quantity             int               `json:"quantity"`
	Uri                  string            `json:"uri"`
	Uid                  [32]byte          `json:"uid"`
}

type Signature721PayloadInput 

type Signature721PayloadInput struct {
	To                   string
	Price                float64
	CurrencyAddress      string
	MintStartTime        int
	MintEndTime          int
	PrimarySaleRecipient string
	Metadata             *NFTMetadataInput
	RoyaltyRecipient     string
	RoyaltyBps           int
}

type Signature721PayloadInputWithUri 

type Signature721PayloadInputWithUri struct {
	To                   string
	Price                float64
	CurrencyAddress      string
	MintStartTime        int
	MintEndTime          int
	PrimarySaleRecipient string
	MetadataUri          string
	RoyaltyRecipient     string
	RoyaltyBps           int
}

type Signature721PayloadOutput 

type Signature721PayloadOutput struct {
	To                   string   `json:"to"`
	Price                string   `json:"price"`
	CurrencyAddress      string   `json:"currencyAddress"`
	MintStartTime        int      `json:"mintStartTime"`
	MintEndTime          int      `json:"mintEndTime"`
	PrimarySaleRecipient string   `json:"primarySaleRecipient"`
	RoyaltyRecipient     string   `json:"royaltyRecipient"`
	RoyaltyBps           int      `json:"royaltyBps"`
	Uri                  string   `json:"uri"`
	Uid                  [32]byte `json:"uid"`
}

type SignedPayload1155 

type SignedPayload1155 struct {
	Payload   *Signature1155PayloadOutput `json:"payload"`
	Signature string                      `json:"signature"`
}

type SignedPayload721 

type SignedPayload721 struct {
	Payload   *Signature721PayloadOutput `json:"payload"`
	Signature string                     `json:"signature"`
}

type SmartContract 

type SmartContract struct {
	Helper  *contractHelper
	Encoder *ContractEncoder
	Events  *ContractEvents
	ERC20   *ERC20
	ERC721  *ERC721
	ERC1155 *ERC1155
	// contains filtered or unexported fields
}

Custom Contracts

With the thirdweb SDK, you can get a contract instance for any contract. Additionally, if you deployed your contract using thirdweb deploy, you can get a more explicit and intuitive interface to interact with your contracts.

Getting a Custom Contract Instance

Let's take a look at how you can get a custom contract instance for one of your contracts deployed using the thirdweb deploy flow: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

// You can replace your own contract address here
contractAddress := "{{contract_address}}"

// Now you have a contract instance ready to go
contract, err := sdk.GetContract(contractAddress)

Alternatively, if you didn't deploy your contract with thirdweb deploy, you can still get a contract instance for any contract using your contracts ABI: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey = "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
})

// You can replace your own contract address here
contractAddress := "{{contract_address}}"

// Add your contract ABI here
abi := "[...]"

// Now you have a contract instance ready to go
contract, err := sdk.GetContractFromAbi(contractAddress, abi)

Calling Contract Functions

Now that you have an SDK instance for your contract, you can easily call any function on your contract with the contract "call" method as follows: 

// The first parameter to the call function is the method name
// All other parameters to the call function get passed as arguments to your contract
balance, err := contract.Call("balanceOf", "{{wallet_address}}")

// You can also make a transaction to your contract with the call method
tx, err := contract.Call("mintTo", "{{wallet_address}}", "ipfs://...")

func (*SmartContract) Call 

func (c *SmartContract) Call(ctx context.Context, method string, args ...interface{}) (interface{}, error)

Call any function on your contract.

method: the name of the method on your contract you want to call

args: the arguments to pass to the method

Example 

// The first parameter to the call function is the method name
// All other parameters to the call function get passed as arguments to your contract
balance, err := contract.Call("balanceOf", "{{wallet_address}}")

// You can also make a transaction to your contract with the call method
tx, err := contract.Call(context.Background(), "mintTo", "{{wallet_address}}", "ipfs://...")

type SnapshotClaim 

type SnapshotClaim struct {
	Address      string   `json:"address"`
	MaxClaimable int      `json:"maxClaimable"`
	Proof        []string `json:"proof"`
}

type SnapshotEntry 

type SnapshotEntry struct {
	Address         string `json:"address"`
	MaxClaimable    string `json:"maxClaimable"`
	Price           string `json:"price"`
	CurrencyAddress string `json:"currencyAddress"`
}

type SnapshotEntryWithProof 

type SnapshotEntryWithProof struct {
	Address         string
	MaxClaimable    string
	Price           string
	CurrencyAddress string
	Proof           [][32]byte
}

type SnapshotInfo 

type SnapshotInfo struct {
	MerkleRoot string          `json:"merkleRoot"`
	Claims     []SnapshotClaim `json:"claims"`
}

type SnapshotInfos 

type SnapshotInfos struct {
	Snapshot    SnapshotInfo
	MerkleRoot  string
	SnapshotUri string
}

type SnapshotInput 

type SnapshotInput struct {
	Address      string
	MaxClaimable int
}

type ThirdwebSDK 

type ThirdwebSDK struct {
	*ProviderHandler
	Deployer *ContractDeployer
	Storage  IpfsStorage
	Auth     WalletAuthenticator
}

func NewThirdwebSDK 

func NewThirdwebSDK(rpcUrlOrChainName string, options *SDKOptions) (*ThirdwebSDK, error)

NewThirdwebSDK

Create a new instance of the Thirdweb SDK

rpcUrlOrName: the name of the chain to connection to (e.g. "rinkeby", "mumbai", "polygon", "mainnet", "fantom", "avalanche") or the RPC URL to connect to

options: an SDKOptions instance to specify a private key and/or an IPFS gateway URL

func NewThirdwebSDKFromProvider 

func NewThirdwebSDKFromProvider(provider *ethclient.Client, options *SDKOptions) (*ThirdwebSDK, error)

func (*ThirdwebSDK) GetContract 

func (sdk *ThirdwebSDK) GetContract(ctx context.Context, address string) (*SmartContract, error)

GetContract

Get an instance of a custom contract deployed with thirdweb deploy

address: the address of the contract

func (*ThirdwebSDK) GetContractFromAbi 

func (sdk *ThirdwebSDK) GetContractFromAbi(address string, abi string) (*SmartContract, error)

GetContractFromABI

Get an instance of ant custom contract from its ABI

address: the address of the contract

abi: the ABI of the contract

func (*ThirdwebSDK) GetEdition 

func (sdk *ThirdwebSDK) GetEdition(address string) (*Edition, error)

GetEdition

Get an Edition contract SDK instance

address: the address of the Edition contract

func (*ThirdwebSDK) GetEditionDrop 

func (sdk *ThirdwebSDK) GetEditionDrop(address string) (*EditionDrop, error)

GetEditionDrop

Get an Edition Drop contract SDK instance

address: the address of the Edition Drop contract

func (*ThirdwebSDK) GetMarketplace 

func (sdk *ThirdwebSDK) GetMarketplace(address string) (*Marketplace, error)

GetMarketplace

Get a Marketplace contract SDK instance

address: the address of the Marketplace contract

func (*ThirdwebSDK) GetMultiwrap 

func (sdk *ThirdwebSDK) GetMultiwrap(address string) (*Multiwrap, error)

GetMultiwrap

Get a Multiwrap contract SDK instance

address: the address of the Multiwrap contract

func (*ThirdwebSDK) GetNFTCollection 

func (sdk *ThirdwebSDK) GetNFTCollection(address string) (*NFTCollection, error)

GetNFTCollection

Get an NFT Collection contract SDK instance

address: the address of the NFT Collection contract

func (*ThirdwebSDK) GetNFTDrop 

func (sdk *ThirdwebSDK) GetNFTDrop(address string) (*NFTDrop, error)

GetNFTDrop

Get an NFT Drop contract SDK instance

address: the address of the NFT Drop contract

func (*ThirdwebSDK) GetToken 

func (sdk *ThirdwebSDK) GetToken(address string) (*Token, error)

GetToken

Returns a Token contract SDK instance

address: address of the token contract

Returns a Token contract SDK instance

type Token 

type Token struct {
	*ERC20Standard

	Helper  *contractHelper
	Encoder *ContractEncoder
	Events  *ContractEvents
	// contains filtered or unexported fields
}

You can access the Token interface from the SDK as follows: 

import (
	"github.com/sontungpytn/go-sdk/v2/thirdweb"
)

privateKey := "..."
secretKey := "..."

sdk, err := thirdweb.NewThirdwebSDK("mumbai", &thirdweb.SDKOptions{
	PrivateKey: privateKey,
	SecretKey: secretKey
})

contract, err := sdk.GetToken("{{contract_address}}")

func (*Token) DelegateTo 

func (token *Token) DelegateTo(ctx context.Context, delegatreeAddress string) (*types.Transaction, error)

Delegate the connected wallets tokens to a specified wallet.

delegateeAddress: wallet address to delegate tokens to

returns: transaction receipt of the delegation

func (*Token) GetDelegation 

func (token *Token) GetDelegation(ctx context.Context) (string, error)

Get the connected wallets delegatee address for this token.

returns: delegation address of the connected wallet

func (*Token) GetDelegationOf 

func (token *Token) GetDelegationOf(ctx context.Context, address string) (string, error)

Get a specified wallets delegatee for this token.

returns: delegation address of the connected wallet

func (*Token) GetVoteBalance 

func (token *Token) GetVoteBalance(ctx context.Context) (*CurrencyValue, error)

Get the connected wallets voting power in this token.

returns: vote balance of the connected wallet

func (*Token) GetVoteBalanceOf 

func (token *Token) GetVoteBalanceOf(ctx context.Context, address string) (*CurrencyValue, error)

Get the voting power of the specified wallet in this token.

address: wallet address to check the vote balance of

returns: vote balance of the specified wallet

func (*Token) Mint 

func (token *Token) Mint(ctx context.Context, amount float64) (*types.Transaction, error)

Mint tokens to the connected wallet.

amount: amount of tokens to mint

returns: transaction receipt of the mint

func (*Token) MintBatchTo 

func (token *Token) MintBatchTo(ctx context.Context, args []*TokenAmount) (*types.Transaction, error)

Mint tokens to a list of wallets.

args: list of wallet addresses and amounts to mint

returns: transaction receipt of the mint

Example 

args = []*thirdweb.TokenAmount{
	&thirdweb.TokenAmount{
		ToAddress: "{{wallet_address}}",
		Amount:    1
	}
	&thirdweb.TokenAmount{
		ToAddress: "{{wallet_address}}",
		Amount:    2
	}
}

tx, err := contract.MintBatchTo(context.Background(), args)

func (*Token) MintTo 

func (token *Token) MintTo(ctx context.Context, to string, amount float64) (*types.Transaction, error)

Mint tokens to a specified wallet.

to: wallet address to mint tokens to

amount: amount of tokens to mint

returns: transaction receipt of the mint

Example 

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

type TokenAmount 

type TokenAmount struct {
	ToAddress string
	Amount    float64
}

type WalletAuthenticationOptions 

type WalletAuthenticationOptions struct {
	InvalidBefore  time.Time
	ExpirationTime time.Time
}

type WalletAuthenticationPayloadData 

type WalletAuthenticationPayloadData struct {
	Iss string `json:"iss"`
	Sub string `json:"sub"`
	Aud string `json:"aud"`
	Exp int64  `json:"exp"`
	Nbf int64  `json:"nbf"`
	Iat int64  `json:"iat"`
	Jti string `json:"jti"`
}

type WalletAuthenticator 

type WalletAuthenticator struct {
	*ProviderHandler
}

> This API is provided as a preview for developers and may change based on feedback that we receive. Do not use this API in a production environment.

The wallet authenticator enables server-side applications to securely identify the connected wallet address of users on the client-side, and also enables users to authenticate to any backend using just their wallet. It implements the JSON Web Token (JWT) authentication standard.

You can use the wallet authenticator as follows: 

// First we specify the domain of the application to authenticate to
domain := "example.com"

// We can then generate a payload for the connected wallet to login
// This can also be done on the client side with the thirdweb TypeScript SDK
payload, err := sdk.Auth.Login(domain, nil)

// Then, on the server, we can securely verify the connected address that signed the payload
address, err := sdk.Auth.Verify(domain, payload, nil)

// And we can also generate an authentication token to send back to the original payload sender
token, err := sdk.Auth.GenerateAuthToken(domain, payload, nil)

// Finally, the token can be use dby the original payload sender to authenticate to the backend
// And the server can use the following function to authenticate the token and verify the address
address, err := sdk.Auth.Authenticate(domain, token)

func (*WalletAuthenticator) Authenticate 

func (auth *WalletAuthenticator) Authenticate(
	domain string,
	token string,
) (string, error)

Server-side function that authenticates the provided JWT token. This function verifies that the provided authentication token is valid and returns the address of the authenticated wallet.

domain: The domain of the application to authenticate the token to

token: The authentication token to authenticate with

returns: The address of the authenticated wallet

Example 

domain := "example.com"
payload, err := sdk.Auth.Login(domain)
token, err := sdk.Auth.GenerateAuthToken(domain, payload)

// Authenticate the token and get the address of the authenticating wallet
address, err := sdk.Auth.Authenticate(domain, token)

func (*WalletAuthenticator) GenerateAuthToken 

func (auth *WalletAuthenticator) GenerateAuthToken(
	domain string,
	payload *WalletLoginPayload,
	options *WalletAuthenticationOptions,
) (string, error)

Server-side function that generates a JWT token from the provided login request that the client-side wallet can use to authenticate to the server-side application.

domain: The domain of the application to authenticate to

payload: The login payload to authenticate with

options: Optional configuration options for the authentication token

returns: An authentication token that can be used to make authenticated requests to the server

Example 

domain := "example.com"
payload, err := sdk.Auth.Login(domain, nil)

// Generate an authentication token for the logged in wallet
token, err := sdk.Auth.GenerateAuthToken(domain, payload, nil)

func (*WalletAuthenticator) Login 

func (auth *WalletAuthenticator) Login(
	domain string,
	options *WalletLoginOptions,
) (*WalletLoginPayload, error)

Client-side function that allows the connected wallet to login to a server-side application. Generates a login payload that can be sent to the server-side for verification or authentication.

domain: The domain of the application that you want to log in to

options: Optional configuration options for the login payload

returns: A login payload that can be sent to the server-side for verification or authentication

Example 

// Add the domain of the application that you want to log in to
domain := "example.com"

// Generate a signed login payload for the connected wallet to authenticate with
payload, err := sdk.Auth.Login(domain, nil)

func (*WalletAuthenticator) Verify 

func (auth *WalletAuthenticator) Verify(
	domain string,
	payload *WalletLoginPayload,
	options *WalletVerifyOptions,
) (string, error)

Server-side function to securely verify the address of the logged in client-side wallet by validating the provided client-side login request.

domain: The domain of the application to verify the login request for

payload: The login payload to verify

returns: The address of the logged in wallet that signed the payload

Example 

domain := "example.com"
payload, err := sdk.Auth.Login(domain, nil)

// Verify the login request
address, err := sdk.Auth.Verify(domain, payload, nil)

type WalletLoginOptions 

type WalletLoginOptions struct {
	Nonce          string
	ExpirationTime time.Time
	ChainId        int
}

type WalletLoginPayload 

type WalletLoginPayload struct {
	Payload   *WalletLoginPayloadData `json:"payload"`
	Signature string                  `json:"signature"`
}

type WalletLoginPayloadData 

type WalletLoginPayloadData struct {
	Domain         string    `json:"domain"`
	Address        string    `json:"address"`
	Nonce          string    `json:"nonce"`
	ExpirationTime time.Time `json:"expiration_time"`
	ChainId        int       `json:"chain_id"`
}

type WalletVerifyOptions 

type WalletVerifyOptions struct {
	ChainId int
}

type WrappedToken 

type WrappedToken struct {
	// contains filtered or unexported fields
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.