Edition

When using the Edition smart contract, there is no need to provide a contract type argument, as the functionality of the smart contract is all available through the extensions interface.

The extensions that the edition contract supports are listed below.

airdrop

Transfer NFTs from the connected wallet to multiple different wallets at once.

const txResult = await contract.erc1155.airdrop(
  // Token ID of the NFT to transfer
  "{{token_id}}",

  // Array of wallet addresses to transfer to
  [
    {
      address: "{{wallet_address}}", // Wallet address to transfer to
      quantity: 1, // Quantity of the NFT to transfer
    },
    {
      address: "{{wallet_address}}", // Wallet address to transfer to
      quantity: 2, // Quantity of the NFT to transfer
    },
  ],
);

Configuration

tokenId

The token ID of the NFT to transfer.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.airdrop(
  "{{token_id}}",
  [
    // ...
  ],
);

addresses

An array of objects containing address and quantity properties.

These are the recipients of the airdrop.

const txResult = await contract.erc1155.airdrop("{{token_id}}", [
  {
    address: "{{wallet_address}}",
    quantity: 1,
  },
  {
    address: "{{wallet_address}}",
    quantity: 2,
  },
]);

balance

Get the quantity of a specific NFT owned by the connected wallet.

const tokenId = 0; // Id of the NFT to check
const balance = await contract.erc1155.balanceOf(tokenId);

Configuration

tokenId

The token ID of the NFT to check the balance of.

Must be a string, number, or BigNumber.

const balance = await contract.erc1155.balanceOf(
  "{{token_id}}",
);

Return Value

A BigNumber representing the quantity of the NFT owned by the wallet.

BigNumber;

balanceOf

Get the quantity of a specific NFT owned by a wallet.

// Address of the wallet to check NFT balance
const walletAddress = "{{wallet_address}}";
const tokenId = 0; // Id of the NFT to check
const balance = await contract.erc1155.balanceOf(walletAddress, tokenId);

Configuration

address

The wallet address to check the NFT balance for.

Must be a string.

const balance = await contract.erc1155.balanceOf(
  "{{wallet_address}}",
  "{{token_id}}",
);

tokenId

The token ID of the NFT to check the balance of.

const balance = await contract.erc1155.balanceOf(
  "{{wallet_address}}",
  "{{token_id}}",
);

Return Value

A BigNumber representing the quantity of the NFT owned by the wallet.

BigNumber;

burn

Burn the specified NFTs from the connected wallet.

// The token ID to burn NFTs of
const tokenId = 0;
// The amount of the NFT you want to burn
const amount = 2;

const txResult = await contract.erc1155.burn(tokenId, amount);

Configuration

tokenId

The token ID of the NFT(s) you want to burn.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.burn(
  "{{token_id}}",
  "{{amount}}",
);

amount

The amount of the NFT you want to burn of the specified token ID.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.burn(
  "{{token_id}}",
  "{{amount}}",
);

burnFrom

The same as burn, but allows you to specify the wallet to burn NFTs from.

// The address of the wallet to burn NFTS from
const account = "0x...";
// The token ID to burn NFTs of
const tokenId = 0;
// The amount of this NFT you want to burn
const amount = 2;

const txResult = await contract.erc1155.burnFrom(account, tokenId, amount);

Configuration

account

The address of the wallet to burn NFTs from.

Must be a string.

const txResult = await contract.erc1155.burnFrom(
  "{{wallet_address}}", // Address to burn from
  "{{token_id}}",
  "{{amount}}",
);

tokenId

Same as tokenId in burn.

amount

Same as amount in burn.

burnBatch

Burn multiple different NFTs in the same transaction from the connected wallet.

// The token IDs to burn NFTs of
const tokenIds = [0, 1];
// The amounts of each NFT you want to burn
const amounts = [2, 2];

const result = await contract.erc1155.burnBatch(tokenIds, amounts);

Configuration

tokenIds

An array of token IDs of the NFTs you want to burn.

Must be an array of string, number, or BigNumber.

const result = await contract.erc1155.burnBatch(
  [0, 1], // Burn token ID 0 and token ID 1
  [2, 2],
);

amounts

An array of the amounts of each NFT you want to burn.

The index of each amount corresponds to the index of the token ID in the tokenIds array.

For example, the first item in the tokenIds array will have the first item in the amounts array burned.

Must be an array of string, number, or BigNumber.

const result = await contract.erc1155.burnBatch(
  [0, 1],
  [2, 2], // In this case, 2 of token ID 0 and 2 of token ID 1 will be burned
);

burnBatchFrom

Burn the batch NFTs from the specified wallet

// The address of the wallet to burn NFTS from
const address = "0x...";
// The token IDs to burn NFTs of
const tokenIds = [0, 1];
// The amounts of each NFT you want to burn
const amounts = [2, 2];

const result = await contract.erc1155.burnBatchFrom(address, tokenIds, amounts);

Configuration

address

The address of the wallet to burn NFTs from.

Must be a string.

const result = await contract.erc1155.burnBatchFrom(
  "{{address}}",
  [0, 1],
  [2, 2],
);

tokenIds

Same as tokenIds in burnBatch.

amounts

Same as amounts in burnBatch.

generate

Generate a signature that a wallet address can use to mint the specified number of NFTs.

This is typically an admin operation, where the owner of the contract generates a signature that allows another wallet to mint tokens.

const payload = {
  quantity: 100, // (Required) The quantity of tokens to be minted
  to: "{{wallet_address}}", // (Required) Who will receive the tokens
  metadata: {
    name: "Cool NFT #1",
    description: "This is a cool NFT",
    image: "https://example.com/image.png", // URL, IPFS URI, or File object
    // ... Any other metadata you want to include
  },
  currencyAddress: "{{currency_contract_address}}", // (Optional) the currency to pay with
  price: 0.5, // (Optional) the price to pay for minting those tokens (in the currency above)
  mintStartTime: new Date(), // (Optional) can mint anytime from now
  mintEndTime: new Date(Date.now() + 60 * 60 * 24 * 1000), // (Optional) to 24h from now,
  primarySaleRecipient: "0x...", // (Optional) custom sale recipient for this token mint
};

const signedPayload = contract.erc1155.signature.generate(payload);

Configuration

The mintRequest object you provide to the generate function outlines what the signature can be used for.

The quantity, to, and metadata fields are required, while the rest are optional.

quantity (required)

The number of tokens this signature can be used to mint.

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
});

to (required)

The wallet address that can use this signature to mint tokens.

This is to prevent another wallet from intercepting the signature and using it to mint tokens for themselves.

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
});

metadata (required)

The metadata of the NFT to mint.

Can either be a string URL that points to valid metadata that conforms to the metadata standards, or an object that conforms to the same standards.

If you provide an object, the metadata is uploaded and pinned to IPFS before the NFT(s) are minted.

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    name: "Cool NFT #1",
    description: "This is a cool NFT",
    image: "https://example.com/image.png", // URL, IPFS URI, or File object
    // ... Any other metadata you want to include
  },
});

currencyAddress (optional)

The address of the currency to pay for minting the tokens (use the price field to specify the price).

Defaults to NATIVE_TOKEN_ADDRESS (the native currency of the network, e.g. Ether on Ethereum).

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  currencyAddress: "{{currency_contract_address}}",
});

price (optional)

If you want the user to pay for minting the tokens, you can specify the price per token.

Defaults to 0 (free minting).

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  price: "{{price}}", // The user will have to pay `price * quantity` for minting the tokens
});

mintStartTime (optional)

The time from which the signature can be used to mint tokens.

Defaults to Date.now() (now).

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  mintStartTime: new Date(), // The user can mint the tokens from this time
});

mintEndTime (optional)

The time until which the signature can be used to mint tokens.

Defaults to new Date(Date.now() + 1000 * 60 * 60 * 24 * 365 * 10), (10 years from now).

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  mintEndTime: new Date(Date.now() + 60 * 60 * 24 * 1000), // The user can mint the tokens until this time
});

primarySaleRecipient (optional)

If a price is specified, the funds will be sent to the primarySaleRecipient address.

Defaults to the primarySaleRecipient address of the contract.

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  price: "{{price}}",
  primarySaleRecipient: "{{wallet_address}}", // The funds will be sent to this address
});

royaltyBps (optional)

The percentage fee you want to charge for secondary sales.

Defaults to the royaltyBps of the contract.

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  price: "{{price}}",
  royaltyBps: 500, // A 5% royalty fee.
});

royaltyRecipient (optional)

The address that will receive the royalty fees from secondary sales.

Defaults to the royaltyRecipient address of the contract.

const signature = await contract.erc1155.signature.generate({
  quantity: "{{quantity}}",
  to: "{{wallet_address}}",
  metadata: {
    // ... Your NFT metadata
  },
  price: "{{price}}",
  royaltyBps: 500, // A 5% royalty fee.
  royaltyRecipient: "{{wallet_address}}", // The royalty fees will be sent to this address
});

generateBatch

Generate a batch of signatures at once.

This is the same as generate but it allows you to generate multiple signatures at once.

const signatures = await contract.erc1155.signature.generateBatch([
  {
    to: "{{wallet_address}}",
    quantity: "{{quantity}}",
    metadata: {
      // ... Your NFT metadata
    },
  }
  {
    to: "{{wallet_address}}",
    quantity: "{{quantity}}",
    metadata: {
    // ... Your NFT metadata
    },
  }
]);

Configuration

payloadsToSign

An array of objects containing the configuration options for each signature.

See generate for the configuration options available for each signature.

generateFromTokenId

Generate a signature that can be used to mint additional supply of an existing NFT in the contract.

This is the same as generate but it allows you to specify the tokenId of the NFT you want to mint additional supply for, rather than providing the metadata of the NFT. Each other configuration option is the same as generate.

const signature = await contract.erc1155.signature.generateFromTokenId({
  to: "{{wallet_address}}",
  tokenId: "{{token_id}}",
  quantity: "{{quantity}}",
});

Configuration

The configuration options available are the same as those in generate except for replacing metadata with tokenId.

tokenId

The tokenId of the NFT you want to mint additional supply for.

const signature = await contract.erc1155.signature.generateFromTokenId({
  to: "{{wallet_address}}",
  tokenId: "{{token_id}}",
  quantity: "{{quantity}}",
});

generateBatchFromTokenIds

Generate a batch of signatures that can be used to mint additional supply of existing NFTs in the contract.

This is the same as generateBatch but allows you to generate multiple signatures at once.

const signatures = await contract.erc1155.signature.generateBatchFromTokenIds([
  {
    to: "{{wallet_address}}",
    tokenId: "{{token_id}}",
    quantity: "{{quantity}}",
  },
  {
    to: "{{wallet_address}}",
    tokenId: "{{token_id}}",
    quantity: "{{quantity}}",
  },
]);

Configuration

Provide an array of objects containing the configuration options for each signature.

See generateFromTokenId for the configuration options available for each signature.

get

Get the metadata of an NFT using it’s token ID.

Metadata is fetched from the uri property of the NFT.

If the metadata is hosted on IPFS, the metadata is fetched and made available as an object. The object’s image property will be a URL that is available through the thirdweb IPFS gateway.

const nft = await contract.erc1155.get(0);

Configuration

tokenId

The token ID of the NFT to get the metadata for.

Must be a string, number, or BigNumber.

const nft = await contract.erc1155.get(
  "{{token_id}}",
);

Return Value

Returns an NFT object containing the following properties:

{
    metadata: {
      id: string;
      uri: string; // The raw URI of the metadata
      owner: string;
      name?: string | number | undefined;
      description?: string | null | undefined;
      image?: string | null | undefined; // If the image is hosted on IPFS, the URL is https://gateway.ipfscdn.io/ipfs/<hash>
      external_url?: string | null | undefined;
      animation_url?: string | null | undefined;
      background_color?: string | undefined;
      properties?: {
          [x: string]: unknown;
      } | {
          [x: string]: unknown;
      }[] | undefined;
    };
    owner: string;
    type: "ERC1155";
    supply: number;
    quantityOwned?: number;
}

get - Contract Metadata

Get the metadata of a smart contract.

const metadata = await contract.metadata.get();

Configuration

Return Value

While the actual return type is any, you can expect an object containing properties that follow the contract level metadata standards, outlined below:

{
  name: string; // Name of your smart contract
  description?: string; // Short description of your smart contract
  image?: string; // Image of your smart contract (any URL, or IPFS URI)
  symbol?: string; // Symbol of your smart contract (ticker, e.g. "ETH")
  external_link?: string; // Link to view this smart contract on your website
  seller_fee_basis_points?: number // The fee you charge on secondary sales, e.g. 100 = 1% seller fee.
  fee_recipient?: string; // Wallet address that receives the seller fee
}

get - Owner

Retrieve the wallet address of the owner of the smart contract.

const owner = await contract.owner.get();

Configuration

Return Value

A string representing the owner’s wallet address.

string;

get - Permissions

Get a list of wallet addresses that are members of a given role.

const members = await contract.roles.get("{{role_name}}");

Configuration

role

The name of the role.

Must be a string.

const members = await contract.roles.get(
  "{{role_name}}",
);

Return Value

An array of strings representing the wallet addresses associated with the given role.

string[];

get - Platform Fee

Get the platform fee recipient and basis points.

const feeInfo = await contract.platformFee.get();

Configuration

Return Value

Returns an object containing the platform fee recipient and basis points.

{
  platform_fee_basis_points: number;
  platform_fee_recipient: string;
}

getAll - Permissions

Retrieve all of the roles and associated wallets.

const allRoles = await contract.roles.getAll();

Configuration

Return Value

An object containing role names as keys and an array of wallet addresses as the value.

<Record<any, string[]>>

getDefaultRoyaltyInfo

Gets the royalty recipient and BPS (basis points) of the smart contract.

const royaltyInfo = await contract.royalties.getDefaultRoyaltyInfo();

Configuration

Return Value

Returns an object containing the royalty recipient address and BPS (basis points) of the smart contract.

{
  seller_fee_basis_points: number;
  fee_recipient: string;
}

getMintTransaction

Construct a mint transaction without executing it. This is useful for estimating the gas cost of a mint transaction, overriding transaction options and having fine grained control over the transaction execution.

const txResult = await contract.erc1155.getMintTransaction(
  "{{wallet_address}}", // Wallet address to mint to
  {
    metadata: {
      name: "Cool NFT #1",
      description: "This is a cool NFT",
      image: "https://example.com/image.png", // URL, IPFS URI, or File object
      // ... Any other metadata you want to include
    },
    supply: 1000, // The number of this NFT you want to mint
  },
);

Configuration

to

The address of the wallet you want to mint the NFT to.

Must be a string.

metadataWithSupply

See metadataWithSupply in the mint method.

Return Value

TransactionTask;

getRecipient

Get the primary sale recipient.

const salesRecipient = await contract.sales.getRecipient();

Configuration

Return Value

Returns a string containing the wallet address of the primary sale recipient.

string;

getTokenRoyaltyInfo

Gets the royalty recipient and BPS (basis points) of a particular token in the contract.

const royaltyInfo = await contract.royalties.getTokenRoyaltyInfo(
  "{{token_id}}",
);

Configuration

tokenId

The token ID to get the royalty info for.

Must be a string, number, or BigNumber.

Return Value

Returns an object containing the royalty recipient address and BPS (basis points) of the token.

{
  seller_fee_basis_points: number;
  fee_recipient: string;
}

grant - Permissions

Make a wallet a member of a given role.

const txResult = await contract.roles.grant(
  "{{role_name}}",
  "{{wallet_address}}",
);

Configuration

role

The name of the role to grant.

Must be a string.

const txResult = await contract.roles.grant(
  "{{role_name}}",
  "{{wallet_address}}",
);

wallet

The wallet address to assign the role to.

Must be a string.

const txResult = await contract.roles.grant(
  "{{role_name}}",
  "{{wallet_address}}",
);

isApproved

Get whether this wallet has approved transfers from the given operator.

This means that the operator can transfer NFTs on behalf of this wallet.

const isApproved = await contract.erc1155.isApproved(
  // Address of the wallet to check
  "{{wallet_address}}",
  // Address of the operator to check
  "{{wallet_address}}",
);

Configuration

owner

The wallet address that owns the NFT.

Must be a string.

const isApproved = await contract.erc1155.isApproved(
  "{{wallet_address}}",
  "{{wallet_address}}",
);

operator

The wallet address of the operator to check (i.e. the wallet that does/does not have approval).

Must be a string.

const isApproved = await contract.erc1155.isApproved(
  "{{wallet_address}}",
  "{{wallet_address}}",
);

lazyMint

Lazy mint a new batch of NFTs into the smart contract.

By default, the NFT metadata is uploaded and pinned to IPFS before minting. You can override this default behavior by providing a string that points to valid metadata instead of objects.

The metadata must conform to the metadata standards.

// Custom metadata of the NFT, note that you can fully customize this metadata with other properties.
const metadataOne = {
  name: "Cool NFT #1",
  description: "This is a cool NFT",
  image: "https://example.com/image.png", // URL, IPFS URI, or File object
  // ... Any other metadata you want to include
};

const metadataTwo = {
  name: "Cool NFT #2",
  description: "This is a cool NFT",
  image: "https://example.com/image.png", // URL, IPFS URI, or File object
  // ... Any other metadata you want to include
};

const txResult = await contract.erc1155.lazyMint([metadataOne, metadataTwo]);

Alternatively, you can provide a string that points to valid metadata instead of objects.

const metadataOne = "ipfs://Qm..."; // IPFS URI
const metadataTwo = "https://my-nft-metadata.json"; // Some other URL

const txResult = await contract.erc1155.lazyMint([metadataOne, metadataTwo]);

Configuration

metadatas

Provide an array of either strings that point to, or objects that contain valid metadata properties.

transfer

Transfer an NFT from the connected wallet to another wallet.

// Address of the wallet you want to send the NFT to
const toAddress = "{{wallet_address}}";
const tokenId = "0"; // The token ID of the NFT you want to send
const amount = 3; // How many copies of the NFTs to transfer
await contract.erc1155.transfer(toAddress, tokenId, amount);

Configuration

to

The wallet address to send the NFT to.

Must be a string.

await contract.erc1155.transfer(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{amount}}",
);

tokenId

The token ID of the NFT to transfer.

Must be a string, number, or BigNumber.

await contract.erc1155.transfer(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{amount}}",
);

amount

The quantity of the NFT to transfer.

Must be a string, number, or BigNumber.

await contract.erc1155.transfer(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{amount}}",
);

mint

Mint a new NFT to the connected wallet.

const metadata = {
  name: "Cool NFT #1",
  description: "This is a cool NFT",
  image: "https://example.com/image.png", // URL, IPFS URI, or File object
  // ... Any other metadata you want to include
};

const tx = await contract.erc1155.mint({
  metadata: metadata,
  supply: 1000, // The number of this NFT you want to mint
});

Configuration

metadataWithSupply

An object containing a metadata object and a supply property.

The metadata object can either be a string that points to valid metadata that conforms to the metadata standards, or an object that conforms to the same standards.

If you provide an object, the metadata is uploaded and pinned to IPFS before the NFT(s) are minted.

// Below is an example of using a string rather than an object for metadata
const metadata = "https://example.com/metadata.json"; // Any URL or IPFS URI that points to metadata

const txResult = await contract.erc1155.mint({
  metadata: metadata,
  supply: 1000, // The number of this NFT you want to mint
});

mint - Signature-based

Mint tokens from a previously generated signature (see generate).

// Use the signed payload to mint the tokens
const txResult = contract.erc1155.signature.mint(signature);

Configuration

signature (required)

The signature created by the generate function.

The typical pattern is the admin generates a signature, and the user uses it to mint the tokens, under the conditions specified in the signature.

Must be of type SignedPayload1155.

// Use the signed payload to mint the tokens
const txResult = contract.erc1155.signature.mint(
  signature, // Signature generated by the `generate` function
);

mintAdditionalSupply

Mint additional quantity of an NFT that already exists on the contract.

const tokenId = 0;
const additionalSupply = 1000;
const txResult = await contract.erc1155.mintAdditionalSupply(
  tokenId,
  additionalSupply,
);

Configuration

tokenId

The ID of the NFT you want to mint additional supply for.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.mintAdditionalSupply(
  "{{token_id}}",
  "{{additional_supply}}",
);

additionalSupply

How much additional supply you want to mint.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.mintAdditionalSupply(
  "{{token_id}}",
  "{{additional_supply}}",
);

mintAdditionalSupplyTo

The same as mintAdditionalSupply, but allows you to specify the address of the wallet rather than using the connected wallet.

const toAddress = "{{wallet_address}}";
const tokenId = 0;
const additionalSupply = 1000;

const txResult = await contract.erc1155.mintAdditionalSupplyTo(
  toAddress,
  tokenId,
  additionalSupply,
);

Configuration

to

The address of the wallet you want to mint the NFT to.

Must be a string.

const txResult = await contract.erc1155.mintAdditionalSupplyTo(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{additional_supply}}",
);

tokenId

The ID of the NFT you want to mint additional supply for.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.mintAdditionalSupplyTo(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{additional_supply}}",
);

additionalSupply

How much additional supply you want to mint.

Must be a string, number, or BigNumber.

const txResult = await contract.erc1155.mintAdditionalSupplyTo(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{additional_supply}}",
);

mintBatch

Mint many different NFTs with limited supplies to the connected wallet.

// Custom metadata and supplies of your NFTs
const metadataWithSupply = [
  {
    supply: 50, // The number of this NFT you want to mint
    metadata: {
      name: "Cool NFT #1",
      description: "This is a cool NFT",
      image: "https://example.com/image.png", // URL, IPFS URI, or File object
      // ... Any other metadata you want to include
    },
  },
  {
    supply: 100, // The number of this NFT you want to mint
    metadata: {
      name: "Cool NFT #2",
      description: "This is a cool NFT",
      image: "https://example.com/image.png", // URL, IPFS URI, or File object
      // ... Any other metadata you want to include
    },
  },
];

const txResult = await contract.erc1155.mintBatch(metadataWithSupply);

Configuration

metadataWithSupply

An array of objects that contain the metadata and supply of each NFT you want to mint.

The supply property is the number of this NFT you want to mint. Must be a string, number, bigint, or BigNumber.

The metadata object must follow the metadata standards. Alternatively, you can provide a strings that points to a valid metadata object to override the default behavior of uploading and pinning the metadata to IPFS (shown below).

const metadatas = [
  {
    metadata: "https://example.com/metadata1.json", // Any URI/URL that points to metadata
    supply: 50,
  },
  {
    metadata: "ipfs://my-ipfs-hash", // Any URI/URL that points to metadata
    supply: 100,
  },
];

const txResult = await contract.erc1155.mintBatch(metadatas);

mintBatch - Signature-based

Use multiple signatures at once to mint tokens.

This is the same as mint but it allows you to provide multiple signatures at once.

// Use the signed payloads to mint the tokens
const txResult = contract.erc1155.signature.mintBatch(signatures);

Configuration

signatures (required)

An array of signatures created by the generate or generateBatch functions.

Must be of type SignedPayload1155[].

mintBatchTo

The same as mintBatch, but allows you to specify the wallet, rather than using the connected one.

// Address of the wallet you want to mint the NFT to
const toAddress = "{{wallet_address}}";

// Custom metadata and supplies of your NFTs
const metadataWithSupply = [
  {
    supply: 50, // The number of this NFT you want to mint
    metadata: {
      name: "Cool NFT #1",
      description: "This is a cool NFT",
      image: "https://example.com/image.png", // URL, IPFS URI, or File object
      // ... Any other metadata you want to include
    },
  },
  {
    supply: 100, // The number of this NFT you want to mint
    metadata: {
      name: "Cool NFT #2",
      description: "This is a cool NFT",
      image: "https://example.com/image.png", // URL, IPFS URI, or File object
      // ... Any other metadata you want to include
    },
  },
];

const txResult = await contract.erc1155.mintBatchTo(
  toAddress,
  metadataWithSupply,
);

Configuration

toAddress

The address of the wallet you want to mint the NFT to.

Must be a string.

// Custom metadata and supplies of your NFTs
const metadataWithSupply = [
  // ...
];

const txResult = await contract.erc1155.mintBatchTo(
  "{{wallet_address}}",
  metadataWithSupply,
);

metadataWithSupply

See mintBatch for more details.

mintTo

The same as mint, but allows you to specify the address of the wallet rather than using the connected wallet.

// Address of the wallet you want to mint the NFT to
const toAddress = "{{wallet_address}}";

// Custom metadata of the NFT, note that you can fully customize this metadata with other properties.
const metadata = {
  name: "Cool NFT #1",
  description: "This is a cool NFT",
  image: "https://example.com/image.png", // URL, IPFS URI, or File object
  // ... Any other metadata you want to include
};

const metadataWithSupply = {
  metadata,
  supply: 1000, // The number of this NFT you want to mint
};

const txResult = await contract.erc1155.mintTo(toAddress, metadataWithSupply);

Configuration

to

The address of the wallet you want to mint the NFT to.

Must be a string.

const metadataWithSupply = {
  // ...
};

const txResult = await contract.erc1155.mintTo(
  "{{wallet_address}}",
  metadataWithSupply,
);

metadataWithSupply

Same as metadataWithSupply in the mint method.

nextTokenIdToMint

Get the next token ID that will be minted on the contract.

const nextTokenId = await contract.erc1155.nextTokenIdToMint();

Configuration

Return Value

Returns a BigNumber representing the next token ID that will be minted on the contract.

BigNumber;

revoke - Permissions

Revoke a given role from a wallet.

const txResult = await contract.roles.revoke(
  "{{role_name}}",
  "{{wallet_address}}",
);

Configuration

role

The name of the role to revoke.

Must be a string.

const txResult = await contract.roles.revoke(
  "{{role_name}}",
  "{{wallet_address}}",
);

wallet

The wallet address to remove the role from.

Must be a string.

const txResult = await contract.roles.revoke(
  "{{role_name}}",
  "{{wallet_address}}",
);

set - Contract Metadata

Overwrite the metadata of a contract, an object following the contract level metadata standards.

This operation ignores any existing metadata and replaces it with the new metadata provided.

const txResult = await contract.metadata.set({
  name: "My Contract",
  description: "My contract description",
});

Configuration

metadata

Provide an object containing the metadata of your smart contract following the contract level metadata standards.

{
  name: string; // Name of your smart contract
  description?: string; // Short description of your smart contract
  image?: string; // Image of your smart contract (any URL, or IPFS URI)
  symbol?: string; // Symbol of your smart contract (ticker, e.g. "ETH")
  external_link?: string; // Link to view this smart contract on your website
  seller_fee_basis_points?: number // The fee you charge on secondary sales, e.g. 100 = 1% seller fee.
  fee_recipient?: string; // Wallet address that receives the seller fee
}

## setRecipient

Set the primary sale recipient.

await contract.sales.setRecipient("{{wallet_address}}");

Configuration

recipient

The wallet address of the primary sale recipient.

Must be a string.

set - Owner

Set the owner address of the contract.

const txResult = await contract.owner.set("{{wallet_address}}");

Configuration

owner

The wallet address of the new owner.

Must be a string.

const txResult = await contract.owner.set(
  "{{wallet_address}}",
);

set - Platform Fee

Set the platform fee recipient and basis points.

const txResult = await contract.platformFees.set({
  platform_fee_basis_points: 100,
  platform_fee_recipient: "0x123",
});

Configuration

platform_fee_basis_points

The percentage fee to take, in basis points. For example, 100 basis points is 1%.

Must be a number.

platform_fee_recipient

The wallet address that will receive the platform fees.

Must be a string.

setAll - Permissions

Overwrite all roles with new members.

Dangerous Operation

This overwrites all members, INCLUDING YOUR OWN WALLET ADDRESS!

This means you can permanently remove yourself as an admin, which is non-reversible.

Please use this method with caution.

const txResult = await contract.roles.setAll({
  admin: ["0x12", "0x123"],
  minter: ["0x1234"],
});

Configuration

roles

An object containing role names as keys and an array of wallet addresses as the value.

const txResult = await contract.roles.setAll(
  {
    admin: ["0x12", "0x123"], // Grant these two wallets the admin role
    minter: ["0x1234"], // Grant this wallet the minter role
  },
);

setApprovalForAll

Give another address approval (or remove approval) to transfer all of your NFTs from this collection.

Warning

Proceed with caution. Only approve addresses you trust.

const txResult = await contract.erc1155.setApprovalForAll(
  // Address of the wallet to approve
  "{{wallet_address}}",
  // Whether to grant approval (true) or remove approval (false)
  true,
);

Configuration

operator

The wallet address to approve.

Must be a string.

const txResult = await contract.erc1155.setApprovalForAll(
  "{{wallet_address}}",
  true,
);

approved

Whether to grant approval (true) or remove approval (false).

Must be a boolean.

const txResult = await contract.erc1155.setApprovalForAll(
  "{{wallet_address}}",
  true,
);

setDefaultRoyaltyInfo

Set the royalty recipient and fee for the smart contract.

await contract.royalties.setDefaultRoyaltyInfo({
  seller_fee_basis_points: 100, // 1% royalty fee
  fee_recipient: "0x...", // the fee recipient
});

Configuration

seller_fee_basis_points

The royalty fee in BPS (basis points). 100 = 1%.

Must be a number.

fee_recipient

The wallet address that will receive the royalty fees.

Must be a string.

setTokenRoyaltyInfo

Set the royalty recipient and fee for a particular token in the contract.

await contract.royalties.setTokenRoyaltyInfo("{{token_id}}", {
  seller_fee_basis_points: 100, // 1% royalty fee
  fee_recipient: "0x...", // the fee recipient
});

Configuration

tokenId

The token ID to set the royalty info for.

Must be a string, number, or BigNumber.

seller_fee_basis_points

The royalty fee in BPS (basis points). 100 = 1%.

Must be a number.

fee_recipient

The wallet address that will receive the royalty fees.

Must be a string.

totalCirculatingSupply

Get the total circulating supply of a token in the collection.

Circulating supply considers NFTs that have not been burned.

const totalCirculatingSupply = await contract.erc1155.totalCirculatingSupply(
  "{{token_id}}",
);

Configuration

tokenId

The token ID of the NFT to get the total circulating supply of.

Must be a string, number, or BigNumber.

const totalCirculatingSupply = await contract.erc1155.totalCirculatingSupply(
  "{{token_id}}",
);

Return Value

Returns a BigNumber representing the total circulating supply of the token.

BigNumber;

totalCount

Get the total number of unique NFTs in the collection.

const totalCount = await contract.erc1155.totalCount();

Return Value

Returns a BigNumber representing the total number of unique NFTs in the collection.

BigNumber;

totalSupply

Returns the total supply of a token in the collection, including burned tokens.

const totalSupply = await contract.erc1155.totalSupply("{{token_id}}");

Configuration

tokenId

The token ID of the NFT to get the total supply of.

const totalSupply = await contract.erc1155.totalSupply(
  "{{token_id}}",
);

Return Value

Returns a BigNumber representing the total supply of the token.

BigNumber;

update - Contract Metadata

Update the metadata of your smart contract.

const txResult = await contract.metadata.update({
  name: "My Contract",
  description: "My contract description",
});

Configuration

metadata

Provide an object containing the metadata of your smart contract following the contract level metadata standards.

New properties will be added, and existing properties will be overwritten. If you do not provide a new value for a previously set property, it will remain unchanged.

Below are the properties you can define on your smart contract.

{
  name: string; // Name of your smart contract
  description?: string; // Short description of your smart contract
  image?: string; // Image of your smart contract (any URL, or IPFS URI)
  symbol?: string; // Symbol of your smart contract (ticker, e.g. "ETH")
  external_link?: string; // Link to view this smart contract on your website
  seller_fee_basis_points?: number // The fee you charge on secondary sales, e.g. 100 = 1% seller fee.
  fee_recipient?: string; // Wallet address that receives the seller fee
}

verify - Signature-based

Verify that a payload is correctly signed.

This allows you to provide a payload, and prove that it was valid and was generated by a wallet with permission to generate signatures.

If a payload is not valid, the mint/mintBatch functions will fail, but you can use this function to verify that the payload is valid before attempting to mint the tokens if you want to show a more user-friendly error message.

// Provide the generated payload to verify that it is valid
const isValid = await contract.erc1155.signature.verify(payload);

Configuration

payload (required)

The payload to verify.

Must be of type SignedPayload1155.

Return Value

Returns true if the payload is valid, false otherwise.

boolean;

verify - Permissions

Check to see if a wallet has a set of roles.

Throws an error if the wallet does not have any of the given roles.

const verifyRole = await contract.roles.verify(
  ["admin", "minter"],
  "{{wallet_address}}",
);

Configuration

roles

An array of roles to check.

Must be an array of strings.

const verifyRole = await contract.roles.verify(
  ["admin", "minter"],
  "{{wallet_address}}",
);

wallet

The wallet address to check.

Must be a string.

const verifyRole = await contract.roles.verify(
  ["admin", "minter"],
  "{{wallet_address}}",
);

airdrop​

tokenId​

addresses​

balance​

tokenId​

Return Value​

balanceOf​

address​

tokenId​

Return Value​

burn​

tokenId​

amount​

burnFrom​

account​

tokenId​

amount​

burnBatch​

tokenIds​

amounts​

burnBatchFrom​

address​

tokenIds​

amounts​

generate​

quantity (required)​

to (required)​

metadata (required)​

currencyAddress (optional)​

price (optional)​

mintStartTime (optional)​

mintEndTime (optional)​

primarySaleRecipient (optional)​

royaltyBps (optional)​

royaltyRecipient (optional)​

generateBatch​

payloadsToSign​

generateFromTokenId​

tokenId​

generateBatchFromTokenIds​

get​

tokenId​

Return Value​

get - Contract Metadata​

Return Value​

get - Owner​

Return Value​

get - Permissions​

role​

Return Value​

get - Platform Fee​

Return Value​

getAll - Permissions​

Return Value​

getDefaultRoyaltyInfo​

Return Value​

getMintTransaction​

to​

metadataWithSupply​

Return Value​

getRecipient​

Return Value​

getTokenRoyaltyInfo​

tokenId​

Return Value​

grant - Permissions​

role​

wallet​

isApproved​

owner​

operator​

lazyMint​

metadatas​

transfer​

to​

tokenId​

amount​

mint​

metadataWithSupply​

mint - Signature-based​

airdrop

tokenId

addresses

balance

tokenId

Return Value

balanceOf

address

tokenId

Return Value

burn

tokenId

amount

burnFrom

account

tokenId

amount

burnBatch

tokenIds

amounts

burnBatchFrom

address

tokenIds

amounts

generate

quantity (required)

to (required)

metadata (required)

currencyAddress (optional)

price (optional)

mintStartTime (optional)

mintEndTime (optional)

primarySaleRecipient (optional)

royaltyBps (optional)

royaltyRecipient (optional)

generateBatch

payloadsToSign

generateFromTokenId

tokenId

generateBatchFromTokenIds

get

tokenId

Return Value

get - Contract Metadata

Return Value

get - Owner

Return Value

get - Permissions

role

Return Value

get - Platform Fee

Return Value

getAll - Permissions

Return Value

getDefaultRoyaltyInfo

Return Value

getMintTransaction

to

metadataWithSupply

Return Value

getRecipient

Return Value

getTokenRoyaltyInfo

tokenId

Return Value

grant - Permissions

role

wallet

isApproved

owner

operator

lazyMint

metadatas

transfer

to

tokenId

amount

mint

metadataWithSupply

mint - Signature-based