Deploy your NFTs on BNB Smart Chain with Starton

In this tutorial, we will see how we can deploy a smart contract and interact with it to mint NFTs on BNB Chain testnet in 6 steps. We will use random images uploaded on IPFS (a distributed file storage system) and assigned to an BNB Chain address.

You will:

• Upload the contract-level metadata
• Use a template from Starton for our smart contract (ERC721).
• Deploy it with Starton from the dashboard. To deploy contracts from code, see Deploying a smart contract from code.
• Upload the content of our NFTs and their metadata on IPFS.
• Interact with our smart contract using Starton API in order to mint the NFTs and give it to a specific address.

If you feel stuck or have questions, feel free to get in touch in our Discord. We’ll be glad to help you!

Upload the contract level metadata on IPFS​

To enter a name on the marketplace’s dashboard and perceive fees when someone sells one of our NFTs, we need to implement the contract-level metadata.

Here are the values we will use:

{
	name: "My Super NFT on BNB",
	description: "You’ve never seen NFTs this beautiful.",
	image: "URI of your image", // This will be used as the image of your collection
	external_link: "",
	seller_fee_basis_points: 100,
	fee_recipient: "PUT YOUR ADDRESS HERE",
}

We now have the content of our metadata, we need to upload it on IPFS.

To upload our files on IPFS we will now use the Starton IPFS pinning service.

As the contract-level metadata only needs to be uploaded once, we can directly do it from our dashboard.

1. Go to IPFS.
2. Click Upload.
3. Select JSON.
4. Enter JSON content.
5. Enter a name for the file.
6. Click Upload.

Once done, a column “CID” appears with a value for our file. We will use this data for the Contract Uri Suffix of our smart contract!

Choose a smart contract template​

Several standards of smart contracts have been developed for NFTs.

The most used ones are ERC721 and the ERC1155. If you want to see in more details the differences between the two standards, read The Difference Between ERC721 vs ERC1155.

Today, we will use the ERC721 smart contract template.

Deploy the contract with Starton​

We will deploy the contract only once, so we will do it directly from Starton’s dashboard.

We can access the list of templates in the Smart contract section.

1. Select the ERC721 template.
2. Enter:
   • a name for your contract,
   • a wallet to sign the transaction,
   • a blockchain / network on which to deploy, here BNB testnet.
   • the parameters of our contract. For more information on parameters, check out the Deploying a Smart Contract.

For example, we can call our contract “Best NFTs on BNB” and deploy it on the BNB Testnet network.

The following constructor parameters are:

• Name: This name stored on blockchain, we will use “Best NFTs on BNB”.
• Symbol: The symbol that will be displayed on blockchain explorers for example. We’ll use “BNFTBNB”.
• Base Uri: This corresponds to the root of the url that will be used to find the content. We’ll use “ipfs://ipfs/“ as we store the content on IPFS.
• Owner Or Multi Sig Contract: This is the address of the owner of the smart contract. We will put our Starton account address that can be found in the “Wallets” section and should be the one chosen at the top as well.
• Contract Uri Suffix: This corresponds to the CID of your contract-level metadata on IPFS. This is needed for example if you want to perceive fees when your NFTs are sold on OpenSea.

We can finally deploy our contract!

With our smart contract deployed, you are redirected on the page where we will interact with our contract.

Minting an NFT​

The process of minting a new NFT and sending it to an address goes in three steps:

• We upload the content of our NFT on IPFS (as it is too heavy to be stored on-chain) and get the CID of the content.
• We upload a metadata object as a JSON file on IPFS as we do not reference the content directly in the contract. Instead, we put the CID of the content in a metadata object that we upload on IPFS.
• We call the function “mint” of our smart contract, giving the CID of our metadata object and the address that will receive the NFT.

You can choose to mint NFT from code or from Starton's interface.

const axios = require("axios")
const FormData = require("form-data")
const starton = axios.create({
	baseURL: "https://api.starton.com/v3",
	headers: {
		"x-api-key": "YOUR_STARTON_API_KEY",
	},
})

// The image variable should be a buffer
async function uploadImageOnIpfs(image, name) {
	let data = new FormData()
	data.append("file", image, name)
	data.append("isSync", "true")

	const ipfsImg = await starton.post("/ipfs/file", data, {
		maxBodyLength: "Infinity",
		headers: { "Content-Type": `multipart/form-data; boundary=${data._boundary}` },
	})
	return ipfsImg.data
}

async function uploadMetadataOnIpfs(imgCid) {
	const metadataJson = {
		name: `A Wonderful NFT`,
		description: `Probably the most awesome NFT ever created !`,
		image: `ipfs://ipfs/${imgCid}`,
	}
	const ipfsMetadata = await starton.post("/ipfs/json", {
		name: "My NFT metadata Json",
		content: metadataJson,
		isSync: true,
	})
	return ipfsMetadata.data
}

const SMART_CONTRACT_NETWORK = "binance-testnet"
const SMART_CONTRACT_ADDRESS = ""
const WALLET_IMPORTED_ON_STARTON = ""
async function mintNft(receiverAddress, metadataCid) {
	const nft = await starton.post(`/smart-contract/${SMART_CONTRACT_NETWORK}/${SMART_CONTRACT_ADDRESS}/call`, {
		functionName: "mint",
		signerWallet: WALLET_IMPORTED_ON_STARTON,
		speed: "low",
		params: [receiverAddress, metadataCid],
	})
	return nft.data
}

const RECEIVER_ADDRESS = ""
const imgBuffer = ""
const ipfsImg = await uploadImageOnIpfs(imgBuffer, "filename.png")
const ipfsMetadata = await uploadMetadataOnIpfs(ipfsImgData.cid)
const nft = await mintNft(RECEIVER_ADDRESS, ipfsMetadata.cid)

Results​

Annnnnd it’s done! Congratulations!

Once all of this is executed, the content should be on IPFS, and associated to the given address in our ERC721 contract.

You can check our NFT on the market element marketplace. Use your contract address to modify the following link: https://testnets.element.market/assets/bsctest/YOUR_CONTRACT_ADDRESS/0

Conclusion​

We have seen in this tutorial how to upload NFTs on a decentralised file system, how to deploy an ERC721 smart contract using Starton, how to make it compatible with marketplaces standards and how we can dynamically mint the NFTs from code to send them to people!

We hope you liked this tutorial and that you will follow along in this epic journey of making Web3 the new standard for Internet! We are very eager to see what you can build with NFTs. Do not hesitate to share what you’ve done!