Create an AtomicAssets Template
Tags: node, wax, blockchain, tutorial
Published: 2023-08-06 16:37:42

## Introduction

We can move onto templates now that we have a Collection and multiple Schemas for our NFT. A template gives us the ability to mint NFTs with some parts of the schema already set. This is useful when we want to guarantee that every NFT has the same set of attributes.

For example, for our Chick Egg NFTs, we will want them all to have the same name, img, and description. With that in mind, we can create a template that we mint the NFTs from. Not only does this save the hassle of making sure we mint every NFT with the same properties, it also enables additional features on AtomicHub. The AtomicHub UI will show users the template their NFT was minted from, the number of their mint, and how many NFTs from that template can exist, have been minted, and how many have been burned. Now users will know exactly where their NFT came from, how rare their NFT is, and how it is performing on the AtomicHub marketplace.

## Understanding the createtempl Action

Let’s look at the `createtempl` method:

![createtempl snapshot](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/st37v28osu53mylbq0io.png)


Each field is pretty self-explanatory, building off of the collection and schema information that we already have gone over:

- `authorized_creator`  - in our examples, the author will be the same as the payer of our last examples: `waxcourse123`. This should be your account name, or an authorized account from the previous collection creation step.
- `collection_name` - same as before, `babychicknft`**.**
- `schema_name` - this is the name of our schema. We will have a `babychick` and `chickegg`.
- `transferable` - mark whether assets minted with this template will be transferable to other wallets.
- `burnable` - mark whether assets minted with this template will be burnable.
- `max_supply` - how many NFTs can be minted from this template.
- `immutable_data` - this is where we fill in the attributes that will be the same across all NFTs that are minted from this template.

Let’s start with the `immutable_data` for our templates:

```js
const template = [
    { "key": "name", "value": ["string", "Baby Chick Egg"] },
    { "key": "img", "value": ["image", "QmTAJmKRFUo4SnmKiq6ixM4FuhAQeReHuCBKE1NZZRpkM9"] },
    { "key": "description", "value": ["string", "Baby Chick Egg for hatching"] },
    { "key": "url", "value": ["string", "https://capsulecat.com"] },
    { "key": "socials", "value": ["string", JSON.stringify(socials)] }
];
```

Here we are defining that the Baby Chick Egg NFT template. When we mint egg NFTs, this is the template they will derive from. All eggs will have the same name, img, description, url, and social information.

Next, let’s look at the `immutable_data` for Baby Chicks. We are going to mint one of three kinds of Baby Chick NFTs when users hatch their egg – Epic, Rare, and Common chicks.

```js
const templateEpic = [
    { "key": "name", "value": ["string", "Epic Baby Chick"] },
    { "key": "img", "value": ["image", "QmUwqZ64McMgzzP9Hv1qXvEUaubcHQZwAVpdfjKpn9M5vv"] },
    { "key": "description", "value": ["string", "Epic baby chick"] },
    { "key": "rarity", "value": ["string", "Epic"] },
    { "key": "url", "value": ["string", "https://capsulecat.com"] },
    { "key": "socials", "value": ["string", JSON.stringify(socials)] }
];

const templateRare = [
    { "key": "name", "value": ["string", "Rare Baby Chick"] },
    { "key": "img", "value": ["image", "QmdQsG8JNfPSSxNzHE5gwhHmBSJNVYaWLWYwpYpEGX8UJ6"] },
    { "key": "description", "value": ["string", "Rare baby chick"] },
    { "key": "rarity", "value": ["string", "Rare"] },
    { "key": "url", "value": ["string", "https://capsulecat.com"] },
    { "key": "socials", "value": ["string", JSON.stringify(socials)] }
];

const templateCommon = [
    { "key": "name", "value": ["string", "Common Baby Chick"] },
    { "key": "img", "value": ["image", "Qmd2FHnTHw3ernkYegh2xNQK1FFKTd8PwA21ToRhGLvddz"] },
    { "key": "description", "value": ["string", "Common baby chick"] },
    { "key": "rarity", "value": ["string", "Common"] },
    { "key": "url", "value": ["string", "https://capsulecat.com"] },
    { "key": "socials", "value": ["string", JSON.stringify(socials)] }
];
```

## Scripting ChickEgg Templates

Each chick has its own set of attributes to help users identify which type of Baby Chick NFT they have. On AtomicHub, when a user looks up the template their NFT was minted with, they can see the price history of NFTs minted from the same template.

Let’s fill in the rest of the script for creating an egg template:

```js
async function createChickEggTemplates() {
    const author = process.env.WAX_ACCOUNT;

    if (!author) {
        throw new Error("Missing WAX_ACCOUNT");
    }

    try {
        await transact([
            {
                account: "atomicassets",
                name: "createtempl",
                authorization: [
                    {
                        actor: auth,
                        permission: "active",
                    },
                ],
                data: {
                    authorized_creator: auth,
                    collection_name: collectionName('babychicknft'),
                    schema_name: name('chickegg'),

                    transferable: true,
                    burnable: true,
                    max_supply: 100,
                    immutable_data: template
                },
            },
        ])
    } catch (error) {
        console.error(error);
        return false;
    }
}

(async () => {
    const result = await createChickEggTemplates();
    console.log(result);
})();
```

## Scripting BabyChicks Templates

And similarly for the baby chicks, except this time, we are going to execute 3 traces in the same transaction:

```js
async function createBabyChickTemplates() {
    const author = process.env.WAX_ACCOUNT;

    if (!author) {
        throw new Error("Missing WAX_ACCOUNT");
    }

    try {
        await transact([
            {
                account: "atomicassets",
                name: "createtempl",
                authorization: [
                    {
                        actor: auth,
                        permission: "active",
                    },
                ],
                data: {
                    authorized_creator: auth,
                    collection_name: collectionName('babychicknft'),
                    schema_name: name('babychick'),

                    transferable: true,
                    burnable: true,
                    max_supply: 10,
                    immutable_data: templateEpic
                },
            },
            {
                account: "atomicassets",
                name: "createtempl",
                authorization: [
                    {
                        actor: auth,
                        permission: "active",
                    },
                ],
                data: {
                    authorized_creator: auth,
                    collection_name: collectionName('babychicknft'),
                    schema_name: name('babychick'),

                    transferable: true,
                    burnable: true,
                    max_supply: 20,
                    immutable_data: templateRare
                },
            },
            {
                account: "atomicassets",
                name: "createtempl",
                authorization: [
                    {
                        actor: auth,
                        permission: "active",
                    },
                ],
                data: {
                    authorized_creator: auth,
                    collection_name: collectionName('babychicknft'),
                    schema_name: name('babychick'),

                    transferable: true,
                    burnable: true,
                    max_supply: 70,
                    immutable_data: templateCommon
                },
            },
        ])
    } catch (error) {
        console.error(error);
        return false;
    }
}

(async () => {
    const result = await createBabyChickTemplates();
    console.log(result);
})();
```

## Running the Scripts

To run the scripts:

```sh
WAX_ACCOUNT=waxcourse123 \
WAX_PRIVATE_KEY="<YOUR WAX ACCOUNT ACTIVE PRIVATE KEY>" \
WAX_ENDPOINT=<https://testnet.wax.pink.gg> \
  node ./src/030-create-chick-egg-templates.js

WAX_ACCOUNT=waxcourse123 \
WAX_PRIVATE_KEY="<YOUR WAX ACCOUNT ACTIVE PRIVATE KEY>" \
WAX_ENDPOINT=<https://testnet.wax.pink.gg> \
  node ./src/040-create-baby-chick-templates.js
```

Example responses:


![Example response](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mw0jfik8o1rfw1bxogf8.png)

![Another example response](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6i1i1nf7wlt7rurncgb1.png)

After running these scripts, we are ready to mint some NFTs!

Next post: [Manually Minting an AtomicAssets NFT](https://dev.to/idmontie/manually-minting-an-atomicassets-nft-af3)

## E-book

Get this entire WAX tutorial as an [e-book on Amazon](https://amzn.to/3ZjwaK7).

## Additional links

- Github: https://github.com/CapsuleCat/wax-nft-tutorial/blob/main/babychicks/scripts/src/030-create-chick-egg-templates.js
- https://github.com/CapsuleCat/wax-nft-tutorial/blob/main/babychicks/scripts/src/040-create-baby-chick-templates.js
- Documentation: https://github.com/pinknetworkx/atomicassets-contract/wiki/Actions#createtempl
- Further reading: https://developer.wax.io/build/tutorials/howto_atomicassets/templates_js.html
- Photo by [Shubham Dhage](https://unsplash.com/@theshubhamdhage?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/photos/mjl0yIdSi18?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)