Skip to main content

Edition Drop

When using the Edition Drop 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 drop 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;

canClaim​

Check if tokens are currently available for claiming, optionally specifying if a specific wallet address can claim.

const canClaim = await contract.erc1155.claimConditions.canClaim(
  "{{token_id}}",
  "{{quantity}}",
);
Configuration

tokenId (required)​

The token ID of the NFT you want to claim.

Must be a string, number or BigNumber.

quantity (required)​

The amount of tokens to claim.

This checks to see if the specified amount of tokens are available for claiming. i.e.:

  • There is sufficient quantity available for claiming.
  • This amount of tokens can be claimed in a single transaction.

Must be a string or number.

addressToCheck (optional)​

The wallet address to check if it can claim tokens.

This considers all aspects of the active claim phase, including allowlists, previous claims, etc.

Must be a string.

Return Value​

Returns a boolean indicating if the specified amount of tokens can be claimed or not.

boolean;

claim​

Claim a specified number of tokens to the connected wallet.

const txResult = await contract.erc1155.claim("{{token_id}}", "{{quantity}}");
Configuration

tokenId (required)​

The token ID of the NFT you want to claim.

Must be a string, number or BigNumber.

quantity (required)​

The number of tokens to claim.

Must be a string or number.

options (optional)​

Customizable ClaimOptions object that can be used to override the default behaviour of the claim.

There are three options available:

  • checkERC20Allowance - Whether to check the ERC20 allowance of the sender, defaults to true.
  • currencyAddress - The currency to pay for each token claimed, defaults to NATIVE_TOKEN_ADDRESS for native currency.
  • pricePerToken - The price to pay for each token claimed. Not relevant when using claim conditions.
const txResult = await contract.erc1155.claim("{{token_id}}", "{{quantity}}", {
  checkERC20Allowance: true,
  currencyAddress: "{{currency_contract_address}}",
  pricePerToken: "{{price}}",
});

claimTo​

The same as claim, but allows specifying the recipient address rather than using the connected wallet.

const txResult = await contract.erc1155.claimTo(
  "{{wallet_address}}",
  "{{token_id}}",
  "{{quantity}}",
);
Configuration

recipient (required)​

The wallet address to receive the claimed tokens.

Must be a string.

tokenId (required)​

The token ID of the NFT you want to claim.

Must be a string, number or BigNumber.

quantity (required)​

The number of tokens to claim.

Must be a string or number.

options (optional)​

Customizable ClaimOptions object that can be used to override the default behaviour of the claim.

See claim for more details.

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 - 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;
}

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;

getAll​

Get the metadata and current owner of all NFTs in the contract.

By default, returns the first 100 NFTs (in order of token ID). Use queryParams to paginate the results.

const nfts = await contract.erc1155.getAll();
Configuration

queryParams (optional)​

Provide an optional object to configure the query. Useful for paginating the results.

const queryParams = {
  // The number of NFTs to return
  count: 100, // Default is 100
  // The index to start from
  start: 0, // Default is 0
};

const nfts = await contract.erc1155.getAll(queryParams);

Return Value​

Returns an array of NFT objects 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;
  };
  type: "ERC1155";
}[]

getAll - Claim Conditions​

Get all the claim phases configured for a specific token ID.

const claimPhases = await contract.erc1155.claimConditions.getAll(
  "{{token_id}}",
);
Configuration

tokenId (required)​

The token ID of the NFT you want to get the claim conditions for.

Must be a string, number or BigNumber.

options (optional)​

Optionally return the allowlist with each claim phase.

See getActive configuration for more details.

Return Value​

Returns an array of ClaimCondition objects.

{
  maxClaimableSupply: string;
  startTime: Date;
  price: BigNumber;
  currencyAddress: string;
  maxClaimablePerWallet: string;
  waitInSeconds: BigNumber;
  merkleRootHash: string | number[];
  availableSupply: string;
  currentMintSupply: string;
  currencyMetadata: {
      symbol: string;
      value: BigNumber;
      name: string;
      decimals: number;
      displayValue: string;
  };
  metadata?: {
      [x: string]: unknown;
      name?: string | undefined;
  } | undefined;
  snapshot?: {
      price?: string | undefined;
      currencyAddress?: string | undefined;
      address: string;
      maxClaimable: string;
  }[] | null | undefined;
}[]

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[]>>

getActive - Claim Conditions​

Retrieve the currently active claim phase for a specific token ID, if any.

const activePhase = await contract.erc1155.claimConditions.getActive(
  "{{token_id}}",
);
Configuration

tokenId (required)​

The token ID of the NFT you want to get the claim conditions for.

Must be a string, number or BigNumber.

options (optional)​

Provide an object containing a withAllowlist property to include the allowlist in the response.

By default, the method will not include the allowlist in the returned data.

To include the allowlist in the returned data, set the withAllowlist option to true.

This will add a snapshot property to the returned data, which contains the allowlist in an array.

const activePhase = contract.erc1155.claimConditions.getActive(
  "{{token_id}}",
  {
    withAllowlist: true,
  },
);

Return Value​

If there is no active claim phase, returns undefined.

If a claim condition is active, returns a ClaimCondition object containing the following properties:

{
  maxClaimableSupply: string;
  startTime: Date;
  price: BigNumber;
  currencyAddress: string;
  maxClaimablePerWallet: string;
  waitInSeconds: BigNumber;
  merkleRootHash: string | number[];
  availableSupply: string;
  currentMintSupply: string;
  currencyMetadata: {
      symbol: string;
      value: BigNumber;
      name: string;
      decimals: number;
      displayValue: string;
  };
  metadata?: {
      [x: string]: unknown;
      name?: string | undefined;
  } | undefined;
  snapshot?: {
      price?: string | undefined;
      currencyAddress?: string | undefined;
      address: string;
      maxClaimable: string;
  }[] | null | undefined;
}

getClaimIneligibilityReasons​

Get an array of reasons why a specific wallet address is not eligible to claim tokens, if any.

const reasons =
  await contract?.erc1155.claimConditions.getClaimIneligibilityReasons(
    "{{token_id}}",
    "{{quantity}}",
    "{{wallet_address}}",
  );
Configuration

tokenId (required)​

The token ID of the NFT you want to check if the wallet address can claim.

Must be a string, number or BigNumber.

quantity (required)​

The amount of tokens to check if the wallet address can claim.

Must be a string or number.

addressToCheck (optional)​

The wallet address to check if it can claim tokens.

Must be a string.

Return Value​

Returns an array of ClaimEligibility strings, which may be empty.

For example, if the user is not in the allowlist, this hook will return ["This address is not on the allowlist."].

If the user is eligible to claim tokens, the hook will return an empty array.

ClaimEligibility[]

// ClaimEligibility Enum
export enum ClaimEligibility {
  NotEnoughSupply = "There is not enough supply to claim.",
  AddressNotAllowed = "This address is not on the allowlist.",
  WaitBeforeNextClaimTransaction = "Not enough time since last claim transaction. Please wait.",
  AlreadyClaimed = "You have already claimed the token.",
  NotEnoughTokens = "There are not enough tokens 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.",
  NoWallet = "No wallet connected.",
  Unknown = "No claim conditions found.",
}

getClaimTransaction​

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

const claimTransaction =
  await contract.erc1155.claimConditions.getClaimTransaction(
    "{{wallet_address}}",
    "{{token_id}}",
    "{{quantity}}",
  );
Configuration

walletAddress (required)​

The wallet address to claim tokens for.

Must be a string.

tokenId (required)​

The token ID of the NFT you want to claim.

Must be a string, number or BigNumber.

quantity (required)​

The amount of tokens to claim.

Must be a string, number or BigNumber.

options (optional)​

See claim configuration for more details.

Return Value​

TransactionTask;

getClaimerProofs​

Returns allowlist information and merkle proofs for a given wallet address. Returns null if no proof is found for the given wallet address.

const claimerProofs = await contract.erc1155.claimConditions.getClaimerProofs(
  "{{token_id}}",
  "{{wallet_address}}",
);
Configuration

tokenId (required)​

The token ID of the NFT you want to get the claimer proofs for.

Must be a string, number or BigNumber.

walletAddress (required)​

The wallet address to get the merkle proofs for.

Must be a string.

Return Value​

{
    price?: string | undefined;
    currencyAddress?: string | undefined;
    address: string;
    proof: string[];
    maxClaimable: string;
} | null | undefined

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;
}

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;
}

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;

getOwned​

Get all the data associated with the NFTs owned by a specific wallet.

// Address of the wallet to get the NFTs of
const address = "{{wallet_address}}";
const nfts = await contract.erc1155.getOwned(address);
Configuration

address​

The address of the wallet to get the NFTs of.

Must be a string.

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

Return Value​

Returns an array of NFT objects 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;
  };
  type: "ERC1155";
}[]

grant - Permissions​

Make a wallet a member of a given role.

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.

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 - Claim Conditions​

Overwrite the claim conditions for a specific token ID.

All properties of a phase are optional, with the default being a free, open, unlimited claim, in the native currency, starting immediately.

const txResult = await contract.erc1155.claimConditions.set(
  "{{token_id}}", // ID of the token to set the claim conditions for
  [
    {
      metadata: {
        name: "Phase 1", // The name of the phase
      },
      currencyAddress: "0x...", // The address of the currency you want users to pay in
      price: 1, // The price of the token in the currency specified above
      maxClaimablePerWallet: 1, // The maximum number of tokens a wallet can claim
      maxClaimableSupply: 100, // The total number of tokens that can be claimed in this phase
      startTime: new Date(), // When the phase starts (i.e. when users can start claiming tokens)
      waitInSeconds: 60 * 60 * 24 * 7, // The period of time users must wait between repeat claims
      snapshot: [
        {
          address: "0x...", // The address of the wallet
          currencyAddress: "0x...", // Override the currency address this wallet pays in
          maxClaimable: 5, // Override the maximum number of tokens this wallet can claim
          price: 0.5, // Override the price this wallet pays
        },
      ],
      merkleRootHash: "0x...", // The merkle root hash of the snapshot
    },
  ],
  false, // Whether to resetClaimEligibilityForAll (i.e. reset state of claims for previous claimers)
);
Configuration

tokenId​

The token ID of the NFT you want to set the claim conditions for.

price​

The price per token in the currency specified above.

The default value is 0.

maxClaimablePerWallet​

The maximum number of tokens a wallet can claim.

The default value is unlimited.

maxClaimableSupply​

The total number of tokens that can be claimed in this phase.

For example, if you lazy mint 1000 tokens and set the maxClaimableSupply to 100, then only 100 tokens will be claimable in this phase, leaving 900 tokens to be claimed in the next phases (if you have any).

This is useful for "early bird" use cases, where you allow users to claim a limited number of tokens at a discounted price during the first X amount of time.

startTime​

When the phase starts (i.e. when users can start claiming tokens).

The default value is immediately.

waitInSeconds​

The amount of time between claims a wallet must wait before they can claim again.

The default value is 0, meaning users can claim again immediately after claiming.

snapshot​

A list of wallets that you want to override the default claim conditions for.

Wallet addresses within this list can be set to pay in a different currency, have a different price, and have a different maximum claimable amount.

{
  address: string;
  currencyAddress?: string;
  maxClaimable?: number;
  price?: number;
}

Learn more about improved claim conditions.

merkleRootHash​

If you want to provide your own merkle tree for your snapshot, provide the merkle root hash here.

This is only recommended for advanced use cases.

resetClaimEligibilityForAll​

This means you reset any previous claim conditions that existed and allow users to claim again as if the drop had just started.

A boolean value that determines whether to reset the claim conditions or to keep the existing state.

By resetting them, any previous claims that were made will be ignored by the claim condition restrictions.

For example, if you had a limit of 1 token per wallet, and a user claimed a token, then you reset the claim conditions, that user will be able to claim another token.

Must be a boolean.

Defaults to false.

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
}

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,
);

setBatch - Claim Conditions​

Allows you to set claim conditions for multiple token IDs in a single transaction.

All properties of a phase are optional, with the default being a free, open, unlimited claim, in the native currency, starting immediately.

const txResult = await contract?.erc1155.claimConditions.setBatch([
  {
    claimConditions: [
      {
        metadata: {
          name: "Phase 1", // The name of the phase
        },
        currencyAddress: "0x...", // The address of the currency you want users to pay in
        price: 1, // The price of the token in the currency specified above
        maxClaimablePerWallet: 1, // The maximum number of tokens a wallet can claim
        maxClaimableSupply: 100, // The total number of tokens that can be claimed in this phase
        startTime: new Date(), // When the phase starts (i.e. when users can start claiming tokens)
        waitInSeconds: 60 * 60 * 24 * 7, // The period of time users must wait between repeat claims
        snapshot: [
          {
            address: "0x...", // The address of the wallet
            currencyAddress: "0x...", // Override the currency address this wallet pays in
            maxClaimable: 5, // Override the maximum number of tokens this wallet can claim
            price: 0.5, // Override the price this wallet pays
          },
        ],
        merkleRootHash: "0x...", // The merkle root hash of the snapshot
      },
    ],
    tokenId: 1,
  },
]);
Configuration

Provide an array of objects, each containing the tokenId and claimConditions you want to set.

See the set method for more information on the claimConditions configuration.

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.

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.

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.

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}}",
);

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;

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}}",
);

update - Claim Conditions​

Update a single claim phase on a specific token ID, by providing the index of the claim phase and the new phase configuration.

The index is the position of the phase in the list of phases you have made, starting from zero. e.g. if you have two phases, the first phase has an index of 0 and the second phase has an index of 1.

All properties of a phase are optional, with the default being a free, open, unlimited claim, in the native currency, starting immediately.

const txResult = await contract?.erc1155.claimConditions.update(
  "{{token_id}}", // Token ID to update claim phase for
  0, // Index of the claim phase to update
  {
    metadata: {
      name: "Phase 1", // The name of the phase
    },
    currencyAddress: "0x...", // The address of the currency you want users to pay in
    price: 1, // The price of the token in the currency specified above
    maxClaimablePerWallet: 1, // The maximum number of tokens a wallet can claim
    maxClaimableSupply: 100, // The total number of tokens that can be claimed in this phase
    startTime: new Date(), // When the phase starts (i.e. when users can start claiming tokens)
    waitInSeconds: 60 * 60 * 24 * 7, // The period of time users must wait between repeat claims
    snapshot: [
      {
        address: "0x...", // The address of the wallet
        currencyAddress: "0x...", // Override the currency address this wallet pays in
        maxClaimable: 5, // Override the maximum number of tokens this wallet can claim
        price: 0.5, // Override the price this wallet pays
      },
    ],
    merkleRootHash: "0x...", // The merkle root hash of the snapshot
  },
);
Configuration

See set configuration for more details.

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 - 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}}",
);