Bundle Collection Code Examples

Easy copy and paste snippets to use thirdweb Bundle Collection module

Copy code// The Bundle collection module address received after initializing the Bundle module on the dashboard.
const bundleAddress = "<MODULE_ADDRESS>";

// Initialize the Bundle collection module with the contract address.
const bundle = sdk.getBundleModule(bundleAddress);

Copy codeconst balanceOfToken = async (nftTokenId) => {

  try {
    await bundle.balance(nftTokenId);
  } catch (error) {
    console.log('Failed to get balance. Error: ', error);
  }  
};

balanceOfToken("<NFT_TOKEN_ID>");

Copy codeconst balanceOfTokenForAddress = async (accountAddress, nftTokenId) => {

  try {
    await bundle.balance(accountAddress, nftTokenId);
  } catch (error) {
    console.log(error);
  }
};

balanceOfTokenForAddress("<WALLET_ADDRESS>", "<NFT_TOKEN_ID>");

Copy codeconst burnNftById = async (nftTokenId, amount) => {
  try {
    await bundle.burn({ tokenId: nftTokenId, amount });
  } catch(error) {
    console.log(error);
  }
};

burnNftById("<NFT_TOKEN_ID>", "<AMOUNT>")

Copy codeconst burnNftBatchById = async (tokenArray) => {
  try {
    await bundle.burnBatch(tokenArray);
  } catch (error) {
    console.log(error);
  }
};

burnNftBatchById([
      { tokenId: "<NFT_TOKEN_ID>", amount: "<AMOUNT>" },
      { tokenId: "<NFT_TOKEN_ID>", amount: "<AMOUNT>" }
    ])

Copy codeconst burnNftBatchFrom = async (walletAddress, tokenArray) => {
  try {
    await bundle.burnBatchFrom(walletAddress, tokenArray);
  } catch (error) {
    console.log(error);
  }
};

burnNftBatchFrom('<WALLET_ADDRESS>', [
      { tokenId: "<NFT_TOKEN_ID>", amount: "<AMOUNT>" },
      { tokenId: "<NFT_TOKEN_ID>", amount: "<AMOUNT>" },
      { tokenId: "<NFT_TOKEN_ID>", amount: "<AMOUNT>" }
    ])

Copy codeconst burnFrom = async () => {
  try {
    await bundle.burnFrom(walletAddress, { tokenId: nftTokenId, amount });
  } catch (error) {
    console.log(error);
  }
};

burnFrom("<WALLET_ADDRESS>", "<NFT_TOKEN_ID>", "<AMOUNT>")

Copy codeconst createNft = async (nft) => {
  try {
    await bundle.create(nft)
  } catch(error) {
    console.log(error);
  }
};

create({
  name: '<NFT_NAME>',
  description: '<DESCRIPTION>',
  image: '<LINK>',
  properties: 'PROPERTIES_OBJECT'
})

Copy codeconst createAndMintNft = async (nft) => {
  try {
     await bundle.createAndMint(nft)
  } catch (error) {
    console.log(error)
  }
};

createAndMintNft({
  name: '<NFT_NAME>',
  description: '<DESCRIPTION>',
  image: '<LINK>',
  properties: 'PROPERTIES_OBJECT',
  initialSupply: '<INITIAL_SUPPLY_INT'
});

Copy codeconst createAndMintNftBatch = async (nftArray) => {
  try {
    await bundle.createAndMintBatch(nftArray);
  } catch (error) {
    console.log(error);
  }
};

createAndMintNftBatch([
  {
    name: '<NFT_NAME>',
    description: '<DESCRIPTION>',
    image: '<LINK>',
    properties: 'PROPERTIES_OBJECT',
    initialSupply: '<INITIAL_SUPPLY_INT'
  }, 
  {
    name: '<NFT_NAME>',
    description: '<DESCRIPTION>',
    image: '<LINK>',
    properties: 'PROPERTIES_OBJECT',
    initialSupply: '<INITIAL_SUPPLY_INT'
  }
]);

Copy codeconst createBatch = async (nftArray) => {
  try {
    await bundle.createBatch(nftArray);
  } catch (error) {
    console.log(error);
  }
};

createBatch([
  {
    name: '<NFT_NAME>',
    description: '<DESCRIPTION>',
    image: '<LINK>',
    properties: 'PROPERTIES_OBJECT'
  }, 
  {
    name: '<NFT_NAME>',
    description: '<DESCRIPTION>',
    image: '<LINK>',
    properties: 'PROPERTIES_OBJECT'
  }
]);

Copy codeconst createNftWithErc20 = async (tokenContractAddress, amount, token) => {
  try {
    await bundle.createWithERC20(tokenContractAddress, amount, token);
  } catch (error) {
    console.log(error);
  }
};

createNftWithErc20( "<TOKEN_CONTRACT_ADDRESS>", '<AMOUNT>', {
  name: '<TOKEN_NAME>',
  description: '<DESCRIPTION>',
  image: '<IMAGE_LINK>',
  properties: '<PROPERTIES_OBJECT>',
  supply: "<SUPPLY>",
});

Copy codeconst createNftWithErc721 = async (tokenContractAddress, tokenId, nft) => {
  try {
    await bundle.createWithERC721(tokenContractAddress, tokenId, nft);
  } catch (error) {
    console.log(error);
  }
};

createNftWithErc20( "<TOKEN_CONTRACT_ADDRESS>", '<TOKEN_ID>', {
  name: '<NFT_NAME>',
  description: '<DESCRIPTION>',
  image: '<IMAGE_LINK>',
  properties: '<PROPERTIES_OBJECT>'
});

Copy codeconst createWithNft = async (tokenContractAddress, tokenId, nft) => {
  try {
    await bundle.createWithNFT(tokenContractAddress, tokenId, nft);
  } catch (error) {
    console.log(error);
  }
};

createNftWithNft( "<TOKEN_CONTRACT_ADDRESS>", '<TOKEN_ID>', {
  name: '<NFT_NAME>',
  description: '<DESCRIPTION>',
  image: '<IMAGE_LINK>',
  properties: '<PROPERTIES_OBJECT>'
});

Copy codeconst createWithToken = async (tokenContractAddress, amount, token) => {
   try {
    await bundle.createWithToken(tokenContractAddress, amount, token);
  } catch (error) {
    console.log(error);
  }
};

createNftWithToken( "<TOKEN_CONTRACT_ADDRESS>", '<AMOUNT>', {
  name: '<TOKEN_NAME>',
  description: '<DESCRIPTION>',
  image: '<IMAGE_LINK>',
  properties: '<PROPERTIES_OBJECT>',
  supply: "<SUPPLY>",
});

Copy codeconst getNftByIdAndAddress = async (tokenId, walletAddress) => {
  try {
    await bundle.get(tokenId, walletAddress); // Address is optional
  } catch (error) {
    console.log(error);
  }
};

getNftByIdAndAddress('<TOKEN_ID>', '<WALLET_ADDRESS>');

Copy codeconst getAllNfts = async (walletAddress) => {
  try {
    await bundle.getAll(walletAddress);
  } catch (error) {
    console.log(error);
  }
};

getAllNfts('<WALLET_ADDRESS>');

Copy codeconst getAllNftsOwned = async (walletAddress) => {
  try {
    await bundle.getOwned(walletAddress);
  } catch (error) {
    console.log(error);
  }
};

getAllNftsOwned('<WALLET_ADDRESS');

Copy codeconst getRoyaltyBasisPoints = async () => {
  try {
    await bundle.getRoyaltyBps();
  } catch (error) {
    console.log(error);
  }
};

getRoyaltyBasisPoints();

Copy codeconst getRoyaltyRecipientAddress = async () => {
  try {
    await bundle.getRoyaltyRecipientAddress();
  } catch (errror) {
    console.log(error);
  }
};

getRoyaltyRecipientAddress();

Copy codeconst isApproved = async (address, operator) => {
  try {
    await bundle.isApproved(address, operator);
  } catch (error) {
    console.log(error);
  }
};

isApproved('<CONTRACT_ADDRESS>', '<CONTRACT_ADDRESS>');

Copy codeconst isTransferRestricted = async () => {
  try {
    await bundle.isTransferRestricted();
  } catch (error) {
    console.log(error);
  }
};

isTransferRestricted();

Copy codeconst mintNft = async (nft) => {
  try {
    await bundle.mint(nft);
  } catch (error) {
    console.log(error);
  }
};

mintNft({
  amount: '<AMOUNT>',
  tokenId: '<TOKEN_ID>'
});

Copy codeconst mintNftBatch = async (nftArray) => {
  try {
    await bundle.mintBatch(nftArray);
  } catch (error) {
    console.log(error);
  }
};

mintNftBatch([
  { 
    amount: '<AMOUNT>', 
    tokenId: '<TOKEN_ID>' 
  },
  { 
    amount: '<AMOUNT>', 
    tokenId: '<TOKEN_ID>' 
  }
]);

Copy codeconst mintNftBatchToAddress = async (walletAddress, nftArray) => {
  try {
    await bundle.mintBatchTo(walletAddress, nftArray);
  } catch (error) {
    console.log(error);
  }
};

mintNftBatchToAddress('WALLET_ADDRESS', [
  { 
    amount: '<AMOUNT>', 
    tokenId: '<TOKEN_ID>' 
  },
  { 
    amount: '<AMOUNT>', 
    tokenId: '<TOKEN_ID>' 
  }
]);

Copy codeconst mintNftToAddress = async (walletAddress, args) => {
  try {
    await bundle.mintTo(walletAddress, args);
  } catch (error) {
    console.log(error);
  }
};

mintNftToAddress('<WALLET_ADDRESS>', { amount: '<AMOUNT>', tokenId: '<TOKEN_ID>' });

Copy codeconst setTokenApproval = async (contractAddress, status) => {
  try {
    await bundle.setApproval(contractAddress, status);
  } catch (error) {
    console.log(error);
  }
};

setTokenApproval('<CONTRACT_ADDRESS>', '<STATUS>');

Copy codeconst setModuleMetadata = async (metadata) => {
  try {
    await bundle.setModuleMetadata(metadata);
  } catch (error) {
    console.log(error);
  }
};

setModuleMetadata({
  name: '<MODULE_NAME>',
  description: '<DESCRIPTION>',
  image: '<IMAGE_LINK>'
});

Copy codeconst setTransferRestriction = async (status) => {
  try {
    await bundle.setRestrictedTransfer(status);
  } catch (error) {
    console.log(error);
  }
};

setTransferRestriction('<STATUS>'); // Status can be true or false

Copy codeconst setRoyaltyBasisPoints = async (amount) => {
  try {
    await bundle.setRoyaltyBps(amount);
  } catch (error) {
    console.log(error);
  }
};

setRoyaltyBasisPoints('<AMOUNT>');

Copy codeconst transferTokenToAddress = async (to, tokenId, amount) => {
  try {
    await bundle.transfer(to, tokenId, amount);
  } catch (error) {
    console.log(error)
  }
};

transferTokenToAddress('<WALLET_ADDRESS>', '<TOKEN_ID>', '<AMOUNT>');

Copy codeconst transferTokenFromAddress = async (from, to, nft) => {
  try{
    await bundle.transferFrom(from, to, nft);
  } catch(error) {
    console.log(error);
  }
};

transferTokenFromAddress('<FROM_WALLET_ADDRESS', '<TO_WALLET_ADDRESS', { tokenId: '<TOKEN_ID>', amount: '<AMOUNT>'});

Copy codeconst transferTokenFromAddressInBatch = async (from, to, nftArray) => {
  try {
    await bundle.transferBatchFrom(from, to, nftArray);
  } catch (error) {
    console.log(error);
  }
};

transferTokenFromAddressInBatch('<FROM_WALLET_ADDRESS>', '<TO_WALLET_ADDRESS>', [
  {
    tokenId: '<TOKEN_ID>',
    amount: '<AMOUNT>'
  },
  {
    tokenId: '<TOKEN_ID>',
    amount: '<AMOUNT>'
  }
]);

Copy codeconst unwrapNft = async (tokenId) => {
  try {
    await bundle.unwrapNFT(tokenId);
  } catch (error) {
    console.log(error);
  }
};

unwrapNft('<TOKEN_ID>');

Copy codeconst unwrapToken = async (tokenId, amount) => {
  try {
    await bundle.unwrapToken(tokenId, amount);
  } catch (error) {
    console.log(error);
  }
};

unwrapToken('<TOKEN_ID>', '<AMOUNT>');