diff --git a/docs/tutorials/nft-consolidated.md b/docs/tutorials/nft-consolidated.md
new file mode 100644
index 000000000..8bb79cc13
--- /dev/null
+++ b/docs/tutorials/nft-consolidated.md
@@ -0,0 +1,70 @@
+---
+title: Mint NFTs from a web application
+authors: Tim McMackin
+last_update:
+  date: 7 January 2024
+---
+
+This tutorial shows you how to create a web application that interacts with the Tezos blockchain to mint non-fungible tokens (NFTs).
+NFTs are unique digital assets that can represent art, collectibles, or virtually any kind of digital content on the blockchain.
+Specifically, this application includes a user-facing front end web application and a Tezos smart contract that acts as the backend and manages data about the tokens.
+
+No prior knowledge of NFTs or Tezos is required, but because the tutorial application uses JavaScript, some familiarity with JavaScript makes it easier to understand.
+
+## Learning objectives
+
+In this tutorial, you will learn:
+
+- How to use the [Taquito](https://tezostaquito.io/) JavaScript/TypeScript SDK to access Tezos and user wallets and to send transactions to Tezos
+- What Tezos wallets and accounts are and how to connect to them
+- What smart contracts are and how to call them from a web application
+- How to mint NFTs on behalf of a user
+- How to deploy your own smart contract to manage NFTs
+- How to get information about NFTs and their owners from Tezos
+
+## What is a non-fungible token (NFT)?
+
+An NFT is a special type of blockchain token that represents something unique.
+Fungible tokens such as XTZ and real-world currencies like dollars and euros are interchangeable; each one is the same as every other.
+By contrast, each NFT is unique and not interchangeable.
+NFTs can represent ownership over digital or physical assets like virtual collectibles or unique artwork, or anything that you want them to represent.
+
+Like other types of Tezos tokens, a collection of NFTs is managed by a smart contract.
+The smart contract defines what information is in each token and how the tokens behave, such as what happens when a user transfers an NFT to another user.
+It also keeps a ledger that records which account owns each NFT.
+
+In this tutorial, you create NFTs that comply with the FA2 standard (formally known as the [TZIP-12](https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md) standard), the current standard for tokens on Tezos.
+The FA2 standard creates a framework for how tokens behave on Tezos, including fungible, non-fungible, and other types of tokens.
+It provides a standard API to transfer tokens, check token balances, manage operators (addresses that are permitted to transfer tokens on behalf of the token owner), and manage token metadata.
+
+## Tutorial application
+
+The application that you set up in this tutorial has two parts:
+
+- The **smart contract** runs on the Tezos blockchain to manage the NFTs, including creating, transferring, and destroying them
+- The **frontend application** runs on a web server and allows the user to connect their wallet, send a request to the smart contract to create an NFT, and to see information about the NFTs that they own
+
+The front end of the application shows buttons that users can click to connect and to mint NFTs:
+
+<img src="/img/tutorials/nft-consolidated-show-info-ids.png" alt="The application showing the IDs of the owned NFTs" style={{width: 500}} />
+
+The source code of the completed application is available here: https://github.com/trilitech/tutorial-applications/tree/main/nft-consolidated.
+
+## Prerequisites
+
+To run this tutorial you need Node.JS and NPM installed.
+See https://nodejs.org/.
+You can verify that they are installed by running these commands:
+
+   ```bash
+   node --version
+   npm --version
+   ```
+
+## Tutorial sections
+
+- [Part 1: Setting up the application](/tutorials/nft-consolidated/setting-up-app)
+- [Part 2: Connecting to wallets](/tutorials/nft-consolidated/connect-wallet)
+- [Part 3: Sending transactions](/tutorials/nft-consolidated/send-transactions)
+- [Part 4: Creating the contract](/tutorials/nft-consolidated/create-contract)
+- [Part 5: Showing token information](/tutorials/nft-consolidated/show-info)
diff --git a/docs/tutorials/nft-consolidated/connect-wallet.md b/docs/tutorials/nft-consolidated/connect-wallet.md
new file mode 100644
index 000000000..7fa9d4e28
--- /dev/null
+++ b/docs/tutorials/nft-consolidated/connect-wallet.md
@@ -0,0 +1,147 @@
+---
+title: "Part 2: Connecting to wallets"
+authors: Tim McMackin
+last_update:
+  date: 18 December 2024
+---
+
+Before the application can interact with Tezos, you must connect to the user's wallet.
+Connecting to a wallet allows your application to get the address of the user's account, get information about the tokens in that account, and create transactions for the user to approve.
+Connecting to a wallet doesn't give the application direct control over an account, only the ability to send transactions to the wallet for the user to approve and sign.
+
+To connect to a user's wallet, you use the Beacon toolkit, which is a standard interface for Tezos wallets.
+
+:::note
+
+However you design your app, you must use a single instance of the `BeaconWallet` object.
+It is also highly recommended to use a single instance of the `TezosToolkit` object.
+Creating multiple instances can cause problems in your app and with Taquito in general.
+
+Because this sample application has only one page, it defines the `TezosToolkit` and `BeaconWallet` objects in the code of that page.
+If your application has multiple pages, define these objects in a single file and re-use them on each page.
+
+:::
+
+1. In the file `src/App.svelte`, in the `<script lang="ts">` section, after the existing code, add this code to connect to the user's wallet and get basic information about it, including its address and balance in tez:
+
+   ```javascript
+   let wallet;
+   let address;
+   let balance;
+   let statusMessage = "Connect your wallet.";
+   let buttonActive = false;
+
+   const connectWallet = async () => {
+     try {
+       const newWallet = new BeaconWallet({
+         name: "NFT app tutorial",
+         network: {
+          type: NetworkType.GHOSTNET,
+        },
+       });
+       await newWallet.requestPermissions();
+       address = await newWallet.getPKH();
+       const balanceMutez = await Tezos.tz.getBalance(address);
+       balance = balanceMutez.div(1000000).toFormat(2);
+       buttonActive = true;
+       statusMessage = "Wallet connected. Ready to mint NFTs.";
+       wallet = newWallet;
+     } catch (error) {
+       console.error("Error connecting wallet:", error);
+     }
+   };
+   ```
+
+   This `connectWallet` function provides a name for the app, which appears in the wallet UI when it asks the user to allow the connection.
+   It also includes the network to use, such as the Tezos main network or test network.
+   When it is connected, it sets the `buttonActive` flag to true, which the UI will use to enable the button to create NFTs.
+
+1. After the `connectWallet` function, add a function to disconnect the user's wallet:
+
+   ```javascript
+   const disconnectWallet = () => {
+     wallet.client.clearActiveAccount();
+     statusMessage = "Connect your wallet.";
+     wallet = undefined;
+     buttonActive = false;
+   };
+   ```
+
+   The `disconnectWallet` function runs these steps to disconnect the wallet and reset the state of the app:
+
+   1. It closes the connection to the Beacon SDK with the `wallet.client.clearActiveAccount()` command.
+   1. It nullifies the wallet reference by setting the `wallet` variable to `undefined`.
+   1. It deactivates the NFT button by setting the `buttonActive` flag to false.
+
+1. Update the `<main>` block to have this code, which creates a button that the user can click to connect or disconnect their wallet:
+
+   ```html
+   <main>
+     <h1>Simple NFT dApp</h1>
+
+     <div class="card">
+       {#if wallet}
+         <p>The address of the connected wallet is {address}.</p>
+         <p>Its balance in tez is {balance}.</p>
+         <button on:click={disconnectWallet}>Disconnect wallet</button>
+       {:else}
+         <button on:click={connectWallet}>Connect wallet</button>
+       {/if}
+         <p>{statusMessage}</p>
+     </div>
+   </main>
+   ```
+
+   Now you have functions that allow your application to connect and disconnect wallets.
+
+## Testing the wallet connection
+
+Follow these steps to test that the application can connect to wallets:
+
+1. Make sure that you have a wallet and some tez on the Ghostnet testnet in your account.
+See [Installing and funding a wallet](/developing/wallet-setup).
+
+1. Start the application by running the command `npm run dev` in the folder that contains the `package.json` file.
+
+1. Open the web application in a web browser at `http://localhost:4000`.
+
+   The application shows the connection button and status message:
+
+   <img src="/img/tutorials/nft-consolidated-connect-not-connected.png" alt="The application showing the wallet connection button" style={{width: 300}} />
+
+1. Click the **Connect wallet** button and follow the prompts to connect your wallet.
+The popup window can connect to wallet apps in your web browser or show a barcode to connect to a wallet app on a mobile device.
+
+   When the wallet connects successfully, the web application changes to show the connected account address and its balance in tez:
+
+   <img src="/img/tutorials/nft-consolidated-connect-connected.png" alt="The application showing information about the connected account" style={{width: 300}} />
+
+   If the wallet doesn't connect correctly, make sure that your application matches the application at https://github.com/trilitech/tutorial-applications/tree/main/nft-consolidated/part-2.
+
+1. Click the **Disconnect wallet** button and see that the wallet disconnects and the information disappears from the page.
+
+Now your application can connect to wallets.
+In the next section, you create transactions for the user wallet to send to Tezos.
+
+## Design considerations
+
+Interacting with a wallet in a decentralized application is a new paradigm for many developers and users.
+Follow these practices to make the process easier for users:
+
+- Let users manually connect their wallets instead of prompting users to connect their wallet immediately when the app loads.
+Getting a wallet pop-up window before the user can see the page is annoying.
+Also, users may hesitate to connect a wallet before they have had time to look at and trust the application, even though connecting the wallet is harmless.
+
+- Provide a prominent button to connect or disconnect wallets.
+
+- Put the button in a predictable position, typically at the top right or left corner of the interface.
+
+- Use **Connect** as the label for the button.
+Avoid words like "sync" because they can have different meanings in dApps.
+
+- Display the status of the wallet connection clearly in the UI.
+You can also add information about the wallet, including token balances and the connected network for the user's convenience.
+Showing information about the tokens and updating it after transactions allows the user to verify that the application is working properly.
+
+- Enable and disable functions of the application based on the status of the wallet connection.
+For example, if the wallet is not connected, disable buttons for transactions that require a wallet connection.
diff --git a/docs/tutorials/nft-consolidated/create-contract.md b/docs/tutorials/nft-consolidated/create-contract.md
new file mode 100644
index 000000000..d74690434
--- /dev/null
+++ b/docs/tutorials/nft-consolidated/create-contract.md
@@ -0,0 +1,305 @@
+---
+title: "Part 4: Creating the contract"
+authors: Tim McMackin
+last_update:
+  date: 20 December 2024
+---
+
+Up to this point, your web application used a pre-deployed smart contract to manage tokens.
+In this section, you create and deploy your own smart contract to control your own tokens.
+Creating your own smart contract allows you to customize the tokens and their behavior, such as their metadata, how they are minted, transferred, and burned, and the rules for creating, transferring, and destroying them.
+
+The contract that you create in this section is written in the SmartPy language, which is a language for contracts based on Python.
+For more information about SmartPy, see [SmartPy](/smart-contracts/languages/smartpy) in this documentation or the complete documentation for [SmartPy](https://smartpy.io/).
+
+## The SmartPy FA2 library
+
+SmartPy provides a library that helps you create FA2-compatible token contracts.
+Instead of having to write all of the code yourself, you can import code from the FA2 library that controls how the contract and its tokens behave.
+Then you can customize the behavior and run tests to verify that your contract works before you deploy it.
+
+For more information about the SmartPy FA2 library, see [FA2 Lib](https://smartpy.io/manual/libraries/FA2-lib/overview) in the SmartPy documentation.
+
+## Loading a template in the SmartPy online IDE
+
+You can work with SmartPy contracts in any text or code editor, but an easy way to with with contracts without installing anything is to use the SmartPy online IDE.
+This IDE includes templates for smart contracts and can compile, test, and deploy contracts directly in the browser.
+
+Follow these steps to create a contract using a template for FA2 NFTs:
+
+1. Open the SmartPy online IDE at https://smartpy.io/ide.
+
+1. From the Welcome popup, go to the **TEMPLATES** tab, expand **Token contracts** and click the template named "Example NFT contract using the FA2 library."
+
+   <img src="/img/tutorials/nft-consolidated-contract-template-window.png" alt="Selecting the template in the SmartPy IDE" style={{width: 300}} />
+
+   If the Welcome popup doesn't appear, click the **TEMPLATES** button at the top right of the editor.
+
+1. Specify a name for the new contract such as `fa2-nft` and click **IMPORT CONTRACT**.
+The IDE loads the contract template in the editor.
+
+## The contract template
+
+To use the SmartPy FA2 library in a contract, you create a contract like any other SmartPy contract.
+Then you import one base class from the library and as many mixins as you want.
+
+- Base classes provide the functionality for a single type of FA token:
+
+   - `main.Nft`: Non-fungible tokens, which are unique digital assets
+   - `main.Fungible`: Fungible tokens, which are interchangeable assets, like tez or other cryptocurrencies
+   - `main.SingleAsset`: Single-asset tokens, which are a simplified case of fungible tokens, allowing only one token type per contract
+
+- Mixins provide additional features.
+Some of these mixins include:
+
+   - `main.Admin`: Provides the `is_administrator` method and the `set_administrator` entrypoint to control the administrator of the contract.
+   - `main.BurnNft`: Provides a `burn` entrypoint that destroys tokens.
+   - `main.MintNft`: Provides a `mint` entrypoint that creates tokens.
+   This mixin requires the `main.Admin` mixin and by default allows only the administrator to mint tokens.
+   - `main.OnchainviewBalanceOf`: Provides a view that returns information about who owns tokens.
+
+For more information, see [Base classes](https://smartpy.io/manual/libraries/FA2-lib/base_classes) and [Mixins](https://smartpy.io/manual/libraries/FA2-lib/mixins).
+
+Note the order of the base class and mixins; they must be imported and initialized in a specific order to work properly.
+There is information on the ordering in comments in the template and in the [FA2 lib](https://smartpy.io/manual/libraries/FA2-lib/overview) documentation.
+The main part of the contract template looks like this:
+
+```smartpy
+import smartpy as sp
+from smartpy.templates import fa2_lib as fa2
+
+# Main template for FA2 contracts
+main = fa2.main
+
+
+@sp.module
+def my_module():
+    import main
+
+    # Order of inheritance: [Admin], [<policy>], <base class>, [<other mixins>].
+    class MyNFTContract(
+        main.Admin,
+        main.Nft,
+        main.MintNft,
+        main.BurnNft,
+        main.OnchainviewBalanceOf,
+    ):
+        def __init__(self, admin_address, contract_metadata, ledger, token_metadata):
+            """Initializes the contract with NFT functionalities.
+            The base class is required; all mixins are optional.
+            The initialization must follow this order:
+
+            - Other mixins such as OnchainviewBalanceOf, MintNFT, and BurnNFT
+            - Base class: NFT
+            - Transfer policy
+            - Admin
+            """
+
+            # Initialize on-chain balance view
+            main.OnchainviewBalanceOf.__init__(self)
+
+            # Initialize the NFT-specific entrypoints
+            main.BurnNft.__init__(self)
+            main.MintNft.__init__(self)
+
+            # Initialize the NFT base class
+            main.Nft.__init__(self, contract_metadata, ledger, token_metadata)
+
+            main.Admin.__init__(self, admin_address)
+```
+
+## Customizing the contract template
+
+You can customize the contract by using different a different base class, using different mixins, or overriding the entrypoints that the base class and mixins provide.
+For example, [the pre-deployed contract](https://github.com/trilitech/tutorial-applications/tree/main/nft-consolidated/contract/pre-deployed-fa2-nft.py) overrides the internal function `is_administrator_`.
+The `mint` entrypoint uses this function to determine if an account can mint a token.
+The overridden version always returns true, so anyone can mint a token:
+
+```smartpy
+# Override this function so anyone can mint for the purposes of the tutorial
+@sp.private()
+def is_administrator_(self):
+    return True
+```
+
+You can omit this override to use the default behavior, but in this case you must set an administrator account when you deploy the contract or else you will not be able to mint any tokens.
+You could also implement other behavior such as providing a list of authorized accounts or requiring payment with the mint transaction.
+
+Many token contracts change the metadata from the default, so in these steps you set up custom metadata for your tokens:
+
+1. After the contract code but before the test code that begins with `@sp.add_test()`, add a function to encode token metadata in the format that the contract stores it in:
+
+   ```smartpy
+   # Create token metadata
+   # Adapted from fa2.make_metadata
+   def create_metadata(symbol, name, decimals, displayUri, artifactUri, description, thumbnailUri):
+       return sp.map(
+           l={
+               "name": sp.scenario_utils.bytes_of_string(name),
+               "decimals": sp.scenario_utils.bytes_of_string("%d" % decimals),
+               "symbol": sp.scenario_utils.bytes_of_string(symbol),
+               "displayUri": sp.scenario_utils.bytes_of_string(displayUri),
+               "artifactUri": sp.scenario_utils.bytes_of_string(artifactUri),
+               "description": sp.scenario_utils.bytes_of_string(description),
+               "thumbnailUri": sp.scenario_utils.bytes_of_string(thumbnailUri),
+           }
+       )
+   ```
+
+   This function accepts metadata fields and encodes them as a may where the key is a string and the value is a series of bytes.
+
+1. Optional: Customize the metadata by adding or removing fields.
+
+   Later you will change the web application to include this metadata in the mint transaction.
+
+1. Update the metadata in the test to use this function by removing this code:
+
+   ```smartpy
+   # Define initial token metadata and ownership
+   tok0_md = fa2.make_metadata(name="Token Zero", decimals=1, symbol="Tok0")
+   tok1_md = fa2.make_metadata(name="Token One", decimals=1, symbol="Tok1")
+   tok2_md = fa2.make_metadata(name="Token Two", decimals=1, symbol="Tok2")
+   token_metadata = [tok0_md, tok1_md, tok2_md]
+   ledger = {0: alice.address, 1: alice.address, 2: bob.address}
+   ```
+
+   and replacing it with this code:
+
+   ```smartpy
+   # Precreated image on IPFS
+   token_thumb_uri = "https://gateway.pinata.cloud/ipfs/QmRCp4Qc8afPrEqtM1YdRvNagWCsFGXHgGjbBYrmNsBkcE"
+
+   # Define initial token metadata and ownership
+   tok0_md = create_metadata(
+           "Tok0",
+           "Token Zero",
+           0,
+           token_thumb_uri,
+           token_thumb_uri,
+           "My first token",
+           token_thumb_uri,
+   )
+   tok1_md = create_metadata(
+           "Tok1",
+           "Token One",
+           0,
+           token_thumb_uri,
+           token_thumb_uri,
+           "My second token",
+           token_thumb_uri,
+   )
+   tok2_md = create_metadata(
+           "Tok2",
+           "Token Two",
+           0,
+           token_thumb_uri,
+           token_thumb_uri,
+           "My third token",
+           token_thumb_uri,
+   )
+   token_metadata = [tok0_md, tok1_md, tok2_md]
+   ledger = {0: alice.address, 1: alice.address, 2: bob.address}
+   ```
+
+1. Optional: Edit the metadata for these three tokens.
+You can change the names, symbols, and descriptions or replace the default picture with a picture of your own.
+Usually, developers store token media such as pictures with the InterPlanetary File System (IPFS) protocol using a tool such as [Pinata](https://www.pinata.cloud/).
+
+1. Set yourself as the administrator of the contract:
+
+   1. Replace the line `admin = sp.test_account("Admin")` with this line, using your address for `<MY_ADDRESS>`:
+
+      ```smartpy
+      admin = sp.address("<MY_ADDRESS>")
+      ```
+
+   1. Replace these lines:
+
+      ```smartpy
+      contract = my_module.MyNFTContract(
+          admin.address, sp.big_map(), ledger, token_metadata
+      )
+      ```
+
+      with these lines:
+
+      ```smartpy
+      contract = my_module.MyNFTContract(
+          admin, sp.big_map(), ledger, token_metadata
+      )
+      ```
+
+1. Above the code of the contract, click **Run Code** to compile the contract and run the tests:
+
+   <img src="/img/tutorials/nft-consolidated-contract-template-run-code.png" alt="Running the contract and tests" style={{width: 300}} />
+
+   If you see an error, make sure that your code matches [the completed contract file](https://github.com/trilitech/tutorial-applications/tree/main/nft-consolidated/contract/fa2-from-template.py)
+
+   If the contract compiles and the tests pass, the IDE shows the starting value of the contract storage and the results of the tests in the right-hand pane:
+
+   <img src="/img/tutorials/nft-consolidated-contract-template-completed-tests.png" alt="Information about the compiled contract and completed tests" style={{width: 300}} />
+
+   This storage includes your address as the administrator and test account addresses as the starting token owners.
+   Optionally, you can change the starting token owner address like you changed the admin address.
+
+## Deploying the contract
+
+When you are satisfied with the contract and its tests, you can originate (deploy) it to the test network.
+
+Originating the contract includes specifying the initial value for its storage.
+The IDE generates this value based on how you originated the contract in the tests.
+The tests used generated test accounts, so if you want to have control over the contract you must change the addresses in this generated storage value.
+
+1. In the IDE, under the section that shows the origination storage values for the contract, click **Deploy contract**.
+
+1. In the Michelson pop-up window, click **Continue**.
+
+1. In the Direct Network Contract Origination window, under Node and Network, select the Ghostnet network.
+
+1. In the Wallet section, connect your wallet.
+
+1. Click **ESTIMATE COST FROM RPC**.
+
+1. When you are ready to deploy the contract, go to the Deploy Contract section and click **DEPLOY CONTRACT**.
+
+1. In the Pre-Signature Information window, click **Accept**.
+
+1. Approve the transaction in your wallet.
+
+   When the contract is deployed successfully, the page shows the new contract address under Origination Result, as in this picture:
+
+   <img src="/img/tutorials/nft-consolidated-contract-template-deployed.png" alt="The address of the new contract" style={{width: 300}} />
+
+1. Click **OPEN EXPLORER** to view the contract in the SmartPy block explorer.
+From this block explorer, you can click the links to see the contract in other block explorers.
+
+1. Copy the address of the new contract.
+
+## Using the contract in your application
+
+Now your contract is deployed and you can use it in the frontend application to create NFTs with it.
+
+1. In your application's `App.svelte` file, update this line with the address of your deployed contract:
+
+   ```javascript
+   const nftContractAddress = "KT1Lr8m7HgfY5UF6nXDDcXDxDgEmKyMeds1b";
+   ```
+
+1. If you changed the metadata by adding or removing fields, make updates in the file to change the token metadata to match.
+Remember that the format for metadata fields is a string and a sequence of bytes, as in the current code:
+
+   ```javascript
+   metadata.set("name", stringToBytes("My Token"));
+   metadata.set("symbol", stringToBytes("Tok"));
+   metadata.set("decimals", stringToBytes("0"));
+   metadata.set("artifactUri", stringToBytes(defaultImage));
+   metadata.set("displayUri", stringToBytes(defaultImage));
+   metadata.set("description", stringToBytes("A token I minted"));
+   metadata.set("thumbnailUri", stringToBytes(defaultImage));
+   ```
+
+1. Restart the web application and mint tokens with it from your administrator account.
+The web application creates the NFTs on your new contract just like it did on the prebuilt contract.
+You can use the address of the contract or the link in the log to look them up on a block explorer.
+
+In the next section you use Taquito to retrieve information about your tokens from the contract and show them on the web application.
diff --git a/docs/tutorials/nft-consolidated/send-transactions.md b/docs/tutorials/nft-consolidated/send-transactions.md
new file mode 100644
index 000000000..87570f9cb
--- /dev/null
+++ b/docs/tutorials/nft-consolidated/send-transactions.md
@@ -0,0 +1,239 @@
+---
+title: "Part 3: Sending transactions"
+authors: Tim McMackin
+last_update:
+  date: 18 December 2024
+---
+
+To send a transaction to Tezos, a dApp creates the transaction, including its parameters.
+Then it sends the transaction to the user's wallet application.
+With the user's approval, the wallet encrypts ("signs") the transaction with the user's private key and sends it to Tezos.
+
+In this section, you add functions to the application that send a transaction that creates ("mints") an NFT on Tezos.
+The transaction calls a pre-deployed smart contract that manages NFTs.
+In a later section, you will deploy your own contract to manage your NFTs, but for now you can use the pre-deployed contract to learn about how it works.
+
+## The pre-deployed contract
+
+You can see the pre-deployed contract by looking up its address `KT1SRdvmiXjQxtY78sefFY2qrCHNpNttWZXq` on a block explorer such as these:
+
+- https://ghostnet.tzkt.io/KT1SRdvmiXjQxtY78sefFY2qrCHNpNttWZXq
+- https://better-call.dev/ghostnet/KT1SRdvmiXjQxtY78sefFY2qrCHNpNttWZXq
+
+The block explorer shows the transactions that the contract has received and information about the tokens that it manages.
+Usually the block explorer has a **Tokens** tab for contracts that manage tokens.
+For example, Better Call Dev shows the tokens like this:
+
+<img src="/img/tutorials/nft-consolidated-transaction-existing-tokens.png" alt="The tokens in the pre-deployed contract" style={{width: 300}} />
+
+Most tokens have metadata that describes what the token represents.
+For example, the first token on the pre-deployed contract has this metadata:
+
+<img src="/img/tutorials/nft-consolidated-transaction-token-metadata.png" alt="The metadata of one token" style={{width: 300}} />
+
+Normally, contracts that manage tokens have restrictions on who can mint tokens, but for the purposes of the tutorial, this contract allows any account to mint NFTs.
+
+## Minting NFTs
+
+To call a smart contract, you need the address of the contract, the name of  the entrypoint to call, and a properly formatted parameter.
+
+1. In the `App.svelte` file, in the `<script>` section, add a constant with the address of the pre-deployed contract:
+
+   ```javascript
+   const nftContractAddress = "KT1Lr8m7HgfY5UF6nXDDcXDxDgEmKyMeds1b";
+   ```
+
+1. Add a constant with a pre-deployed image.
+The application will use this image to represent the NFT in wallet applications.
+
+   ```javascript
+   const defaultImage = "https://gateway.pinata.cloud/ipfs/QmRCp4Qc8afPrEqtM1YdRvNagWCsFGXHgGjbBYrmNsBkcE";
+   ```
+
+1. Add a function that creates an NFT, first checking if the button is active because the wallet is connected:
+
+   ```javascript
+   if (!buttonActive) {
+     return;
+   }
+   buttonActive = false;
+   statusMessage = "Minting NFT; please wait...";
+   ```
+
+1. Inside the function, create the metadata for the token:
+
+   ```javascript
+   // Create token metadata
+   const metadata = new MichelsonMap();
+   metadata.set("name", stringToBytes("My Token"));
+   metadata.set("symbol", stringToBytes("Tok"));
+   metadata.set("decimals", stringToBytes("0"));
+   metadata.set("artifactUri", stringToBytes(defaultImage));
+   metadata.set("displayUri", stringToBytes(defaultImage));
+   metadata.set("thumbnailUri", stringToBytes(defaultImage));
+   ```
+
+   These are the metadata fields that the pre-deployed contract expects for new tokens.
+   When you create your own contract you can define the fields, but these fields are commonly used for Tezos FA2 tokens, including NFTs.
+
+   Note that the value of the `decimals` field is set to zero because the token cannot be divided like a fungible token can.
+
+   Also note that each field is converted from a string to bytes because token metadata is stored as a key-value map with string keys and byte values.
+
+1. Create the parameter for the transaction:
+
+   ```javascript
+   const mintItem = {
+     to_: address,
+     metadata: metadata,
+   };
+
+   const mintParameter = [mintItem];
+   ```
+
+   There is no standard way that FA2 contracts mint tokens; in fact, FA2 contracts are not required to have a `mint` entrypoint.
+   In this case, the mint entrypoint accepts a list of tokens to create, with each list item including the address of the token owner and the metadata for the new token.
+   You can set up your contract to mint tokens in any way.
+
+1. Within a `try/catch` block, create an object that represents the contract and call its `mint` entrypoint by adding this code:
+
+   ```javascript
+   try {
+     Tezos.setWalletProvider(wallet);
+
+     console.log("getting contract");
+     const nftContract = await Tezos.wallet.at(nftContractAddress);
+
+     console.log("minting");
+     const op = await nftContract.methodsObject.mint(mintParameter).send();
+
+     console.log(`Waiting for ${op.opHash} to be confirmed...`);
+     const hash = await op.confirmation(2).then(() => op.opHash);
+     console.log(`Operation injected: https://ghostnet.tzkt.io/${hash}`);
+   } catch (error) {
+     console.error("Error minting NFT:", error);
+   } finally {
+     statusMessage = "Ready to mint another NFT.";
+     buttonActive = true;
+   }
+   ```
+
+   When you call the `Tezos.wallet.at()` method, Taquito creates an object that represents the contract.
+   This object has a `methodsObject` property that has a method for each entrypoint in the contract.
+   In this way, the `nftContract.methodsObject.mint()` method represents a call to the contract's `mint` entrypoint.
+
+   The complete function looks like this:
+
+   ```javascript
+   const createNFT = async () => {
+   if (!buttonActive) {
+     return;
+   }
+   buttonActive = false;
+   statusMessage = "Minting NFT; please wait...";
+
+   // Create token metadata
+   const metadata = new MichelsonMap();
+   metadata.set("name", stringToBytes("My Token"));
+   metadata.set("symbol", stringToBytes("Tok"));
+   metadata.set("decimals", stringToBytes("0"));
+   metadata.set("artifactUri", stringToBytes(defaultImage));
+   metadata.set("displayUri", stringToBytes(defaultImage));
+   metadata.set("thumbnailUri", stringToBytes(defaultImage));
+
+   const mintItem = {
+     to_: address,
+     metadata: metadata,
+   };
+
+   const mintParameter = [mintItem];
+
+   try {
+     Tezos.setWalletProvider(wallet);
+
+     console.log("getting contract");
+     const nftContract = await Tezos.wallet.at(nftContractAddress);
+
+     console.log("minting");
+     const op = await nftContract.methodsObject.mint(mintParameter).send();
+
+     console.log(`Waiting for ${op.opHash} to be confirmed...`);
+     const hash = await op.confirmation(2).then(() => op.opHash);
+     console.log(`Operation injected: https://ghostnet.tzkt.io/${hash}`);
+   } catch (error) {
+     console.error("Error minting NFT:", error);
+   } finally {
+     statusMessage = "Ready to mint another NFT.";
+     buttonActive = true;
+   }
+
+   }
+   ```
+
+1. In the `<main>` section, add a button to call the `createNFT` function.
+The `<main>` section looks like this:
+
+   ```javascript
+   <main>
+     <h1>Create NFTs</h1>
+
+     <div class="card">
+       {#if wallet}
+         <p>The address of the connected wallet is {address}.</p>
+         <p>Its balance in tez is {balance}.</p>
+         <button on:click={disconnectWallet}>Disconnect wallet</button>
+         <button on:click={createNFT}>Create NFT</button>
+       {:else}
+         <button on:click={connectWallet}>Connect wallet</button>
+       {/if}
+       <p>{statusMessage}</p>
+     </div>
+   </main>
+   ```
+
+1. Run the application with the command `npm run dev` and connect your wallet as you did previously.
+
+1. Click the **Create NFT** button and approve the transaction in your wallet.
+
+1. Verify that the NFT was created by looking up the transaction hash in a block explorer.
+Here are some ways to get the transaction hash:
+
+   - Open the browser console and find the message that starts with `Operation injected`.
+   - Click the link in the confirmation window in your wallet application.
+   - Open the contract in a block explorer and look at the most recent transaction or search for your address in its recent transactions.
+
+   For example, [this transaction](https://ghostnet.tzkt.io/oopNizDc1p6uuCLsbEP4LEzUvgiJefPFe6W9QZur9kfZzDui9bb/19762971) shows the address of the token creator, the `mint` entrypoint, and the name of the new token:
+
+   <img src="/img/tutorials/nft-consolidated-transaction-completed-transaction.png" alt="The completed transaction" style={{width: 300}} />
+
+## Viewing the NFT in your wallet
+
+Because the contract follows the FA2 standard, Tezos wallets can show information about it.
+However, your wallet is not immediately aware that you have the token.
+You can add the token to your wallet manually to see it and work with it in your wallet:
+
+1. In your wallet, go to the tab that shows NFTs, which is usually called "Collectibles" or "NFTs."
+
+   For example, the Temple wallet shows NFTs on the Collectibles tab:
+
+   <img src="/img/tutorials/nft-consolidated-transaction-temple-no-nfts.png" alt="The Collectibles tab of the Temple wallet, showing no NFTs" style={{width: 300}} />
+
+1. Add the predefined contract address `KT1Lr8m7HgfY5UF6nXDDcXDxDgEmKyMeds1b` as a source of NFTs.
+
+   For example, in Temple, click **Manage assets list > Manage**, click **Add Collectible**, add the contract address in the **Address** field, and click **Add Asset**:
+
+   <img src="/img/tutorials/nft-consolidated-transaction-temple-add-contract.png" alt="Adding a contract to Temple" style={{width: 300}} />
+
+   In most cases you can leave the asset ID blank and the wallet will retrieve all of your tokens in the contract.
+
+   Now the wallet shows the NFT:
+
+   <img src="/img/tutorials/nft-consolidated-transaction-temple-show-nft.png" alt="An NFT in the Temple wallet" style={{width: 300}} />
+
+   You can click the token to see information about it and to send it to another account.
+   Because the contract is FA2-compliant, wallets can perform operations on the token without any further information.
+
+   <img src="/img/tutorials/nft-consolidated-transaction-temple-show-nft-info.png" alt="An NFT in the Temple wallet" style={{width: 300}} />
+
+Now you can create NFTs with your application and the built-in contract.
+In the next section you start creating your own contract to create NFTs your own way.
diff --git a/docs/tutorials/nft-consolidated/setting-up-app.md b/docs/tutorials/nft-consolidated/setting-up-app.md
new file mode 100644
index 000000000..4d4968c2a
--- /dev/null
+++ b/docs/tutorials/nft-consolidated/setting-up-app.md
@@ -0,0 +1,233 @@
+---
+title: "Part 1: Setting up the application"
+authors: Tim McMackin
+last_update:
+  date: 18 December 2024
+---
+
+You can access Tezos through any JavaScript framework.
+This tutorial uses the Svelte framework to create a simple UI quickly.
+The following steps show you how to start a Svelte application and add the Tezos-related dependencies.
+If you are familiar with Svelte, note that this application includes its own Svelte SPA, so it does not require SvelteKit.
+
+## Setting up the application
+
+1. Run these commands to create a starter Svelte project:
+
+   ```bash
+   npm create vite@latest nft-consolidated -- --template svelte
+   cd nft-consolidated
+   npm install
+   ```
+
+1. Install the Tezos-related dependencies:
+
+   ```bash
+   npm install @taquito/taquito @taquito/utils @taquito/beacon-wallet @airgap/beacon-types
+   ```
+
+1. Install the `buffer`, `events`, and `vite-compatible-readable-stream` libraries:
+
+   ```bash
+   npm install --save-dev buffer events vite-compatible-readable-stream
+   ```
+
+1. Update the `vite.config.js` file to the following code:
+
+   ```javascript
+    import { defineConfig, mergeConfig } from "vite";
+    import path from "path";
+    import { svelte } from "@sveltejs/vite-plugin-svelte";
+
+    export default ({ command }) => {
+      const isBuild = command === "build";
+
+    return defineConfig({
+      plugins: [svelte()],
+        define: {
+            global: {}
+        },
+      build: {
+        target: "esnext",
+        commonjsOptions: {
+            transformMixedEsModules: true
+        }
+        },
+      server: {
+        port: 4000
+        },
+      resolve: {
+        alias: {
+         "@airgap/beacon-types": path.resolve(
+           path.resolve(),
+           `./node_modules/@airgap/beacon-types/dist/${
+           isBuild ? "esm" : "cjs"
+           }/index.js`
+          ),
+         // polyfills
+         "readable-stream": "vite-compatible-readable-stream",
+         stream: "vite-compatible-readable-stream"
+        }
+        }
+    });
+    };
+   ```
+
+   This updated file includes these changes to the default Vite configuration:
+
+   - It sets the `global` object to `{}` so the application can provide the value for this object in the HTML file
+   - It includes the a path to the Beacon SDK, which Taquito uses to connect to wallets
+   - It provides polyfills for `readable-stream`
+
+1. Update the default HTML file, `index.html`, to the following code:
+
+   ```html
+   <!DOCTYPE html>
+   <html lang="en">
+     <head>
+       <meta charset="UTF-8" />
+       <link rel="icon" href="/favicon.ico" />
+       <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+       <script>
+         const global = globalThis;
+       </script>
+       <script type="module">
+         import { Buffer } from "buffer";
+         window.Buffer = Buffer;
+       </script>
+       <title>Create NFTs</title>
+     </head>
+     <body>
+       <script type="module" src="/src/main.js"></script>
+     </body>
+   </html>
+   ```
+
+   This updated file sets the `global` variable to `globalThis` and adds a buffer object to the window.
+   The application requires this configuration to use the Beacon SDK to connect to wallets in a Vite app.
+
+1. In the `src/main.js` file, import the style sheets by replacing the default code of the file with this code:
+
+   ```javascript
+   import './app.css'
+   import { mount } from 'svelte';
+   import App from './App.svelte'
+
+   const app = mount(App, { target: document.body });
+
+   export default app
+   ```
+
+   This code targets the `body` tag to inject the HTML produced by JavaScript instead of a `div` tag inside the `body` tag as Svelte apps do by default.
+   Your applications can target any tag on the page.
+
+## File structure
+
+The structure of the tutorial application looks like this:
+
+```
+- src
+  - assets
+  - lib
+  - app.css
+  - App.svelte
+  - main.js
+  - vite-env.d.ts
+- index.html
+- jsconfig.json
+- package-lock.json
+- package.json
+- svelte.config.js
+- vite.config.js
+```
+
+Here are descriptions for each of these files:
+
+- **assets** -> Contains the favicon and other static files such as images for the application.
+- **lib** -> Contains the components that make up the app interface:
+- **app.css** ->  Contains global styles that apply to the entire app.
+- **App.svelte** -> The entrypoint of the application, which contains the components that are bundled into the final application.
+- **main.js** -> Where the JavaScript for the app is bundled before being injected into the HTML file.
+- **vite-env.d.ts** -> A JavaScript declaration file automatically generated by Vite to provide type definitions for environment variables.
+- **index.html** -> Contains the root element where the Svelte app gets attached.
+- **jsconfig.json** ->
+- **package.json** -> Contains metadata about the project like its name, version, and dependencies.
+- **svelte.config.js** -> Configuration file for the Svelte application.
+- **vite.config.js** -> Used to customize Vite's behavior, including defining plugins, setting up aliases, and more.
+
+## Configuring the Svelte application
+
+Svelte files include several different types of code in a single file.
+This example page has separate sections for JavaScript, style, and HTML code:
+
+```html
+<script lang="ts">
+  // Your JavaScript code
+</script>
+
+<style lang="scss">
+  /* Your Sass code */
+</style>
+
+<main>
+  <!-- Your HTML code -->
+</main>
+```
+
+Svelte components are fully contained, which means that the style and JS/TS code that you apply inside a component doesn't leak into the other components of your app.
+Styles and scripts that are shared among components typically go in the `src/styles` and `scripts` or `src/scripts` folders.
+
+Follow these steps to set up the `src/App.svelte` file, which is the container for the other Svelte components:
+
+1. In the `App.svelte` file, replace the default `<main>` section with this code to set up a title for the interface:
+
+   ```html
+   <main>
+     <h1>Create NFTs</h1>
+
+   </main>
+   ```
+
+   You will add elements to the wbe application interface later.
+
+1. Replace the default `<style>` section with this code:
+
+   ```scss
+   <style>
+   </style>
+   ```
+
+   Later, you can add styles to this section or the shared CSS files.
+
+1. Remove the default JavaScript section and replace it with this code, which imports the libraries and components that the app uses:
+
+   ```html
+   <script lang="ts">
+     import { BeaconWallet } from "@taquito/beacon-wallet";
+     import { NetworkType } from "@airgap/beacon-types";
+     import { TezosToolkit, MichelsonMap} from "@taquito/taquito";
+     import { stringToBytes } from '@taquito/utils';
+   </script>
+   ```
+
+   The imports include these elements:
+
+   - `BeaconWallet`: This class provides a user interface for connecting to wallets, ensuring that users can securely sign transactions and call smart contracts
+   - `TezosToolkit`: This is the base class for Taquito, which gives you access to most of its Tezos-related features
+   - `NetworkType`: An enumeration that lists the different types of networks on the Tezos blockchain
+   - `MichelsonMap`: This class represents the Michelson  map data type, which Tezos uses to store data, including the metadata for the NFTs that the application creates
+   - `stringToBytes`: A utility that converts strings to bytes to store in the token metadata
+
+1. In the `<script lang="ts">` section, add the following code to initialize Taquito and set it to use a Ghostnet RPC node:
+
+   ```javascript
+     const rpcUrl = "https://rpc.ghostnet.teztnets.com";
+     const Tezos = new TezosToolkit(rpcUrl);
+   ```
+
+   This code creates an instance of the `TezosToolkit` object, which provides access to the Tezos chain itself.
+   You can change the RPC node to use a different Tezos network (such as switching to Tezos Mainnet when you are ready to deploy the application in production) or if the node you are using is slow or down,
+   For URLs to other RPC nodes, see https://teztnets.com.
+
+Now you have the framework of a web application that can access Tezos.
+In the next part, you add buttons that connect to the user's wallet and send transactions to Tezos on the user's behalf.
diff --git a/docs/tutorials/nft-consolidated/show-info.md b/docs/tutorials/nft-consolidated/show-info.md
new file mode 100644
index 000000000..3e7a132bc
--- /dev/null
+++ b/docs/tutorials/nft-consolidated/show-info.md
@@ -0,0 +1,109 @@
+---
+title: "Part 5: Showing token information"
+authors: Tim McMackin
+last_update:
+  date: 7 January 2025
+---
+
+You can use Taquito to retrieve information about tokens from Tezos.
+In this section, you retrieve information about the connected user's tokens and show them on the web page.
+
+The process takes a few steps because of how the data about the token owners is stored.
+The ledger that records the owner of each token isn't stored as a simple table or as a single object.
+Instead, each entry in the big-map (in this case, an entry that represents the owner of each token) is lazily deserialized.
+In other words, when you look up the owner of a token, Tezos reads only the entry for that token ID, not the entire table of owners.
+Reading a single entry like this reduces the cost of reading data from the ledger, especially as the ledger gets large.
+For more information about maps and big-maps, see [Big-maps and maps](/smart-contracts/data-types/complex-data-types#big-maps).
+
+## Getting token owners
+
+If you ignore the internal complexities of how the data is stored in the big-map, you can imagine that the contract stores data about the NFT owners in a table.
+One column of the table stores the ID of the NFT and the other column stores the address of the owner, as in this example:
+
+Token ID | Owner
+--- | ---
+0 | `tz1QCVQinE8iVj1H2fckqx6oiM85CNJSK9Sx`
+1 | `tz1QCVQinE8iVj1H2fckqx6oiM85CNJSK9Sx`
+2 | `tz1hQKqRPHmxET8du3fNACGyCG8kZRsXm2zD`
+3 | `tz1Z2iXBaFTd1PKhEUxCpXj7LzY7W7nRouqf`
+
+Data about fungible tokens is stored differently; see [Tokens](/architecture/tokens) for examples.
+
+In this section, you create a function to read the data from the contract's ledger to find the IDs of the tokens that the connected account owns.
+
+1. In the `src/App.svelte` file, add a top-level variable to represent the list of tokens that the connected account owns:
+
+   ```javascript
+   let userNfts;
+   ```
+
+1. Add a function that retrieves the NFTs that the user owns and puts them in the top-level variable:
+
+   ```javascript
+   const getUserNfts = async () => {
+     if (!address) {
+       return;
+     }
+     // Get the ID of the big-map that records token owners
+     const contract = await Tezos.wallet.at(nftContractAddress);
+     const nftStorage = await contract.storage();
+     const ledger = nftStorage['ledger'];
+     const ledgerID = ledger.id.toString();
+
+     // Get the contents of the big-map
+     const data = await fetch(`${rpcUrl}/chains/main/blocks/head/context/raw/json/big_maps/index/${ledgerID}/contents`);
+     const keys = await data.json();
+
+     // Get the owner of each NFT
+     const tokenOwners = await Promise.all(
+       keys.map((_k, index) => ledger.get(index.toString()))
+     );
+
+     // Filter to the IDs of the tokens that the connected address owns
+     userNfts = tokenOwners.reduce((matchingIndexes, ownerAddress, index) => {
+       if (ownerAddress === address) {
+         matchingIndexes.push(index);
+       }
+       return matchingIndexes;
+     }, []);
+   };
+   ```
+
+   This function starts by requesting the storage of the contract.
+   However, due to the way that big-maps are stored, the contract storage that Taquito provides does not contain the token owners.
+   Instead, it contains an ID of the big-map, which the code uses to retrieve the current fields in the big-map.
+   Then it retrieves the data in each of these fields, which is the address of the account that owns the token for a given ID.
+
+1. Call the `getUserNfts` function at the end of the `connectWallet` and `createNFT` functions.
+
+1. In the `<main>` section, after the "Create NFT" button, add a section that shows the NFTs that the connected account owns:
+
+   ```javascript
+   <div class="user-nfts">
+     {#if userNfts?.length > 0}
+       <p>
+         IDs of your NFTs:
+         {#each userNfts as nftID, index}
+           {nftID}
+           {#if index < userNfts.length - 1}
+             <span>,&nbsp;</span>
+           {/if}
+         {/each}
+       </p>
+     {:else if userNfts?.length === 0}
+       <p>The connected account has no NFTs.</p>
+     {:else}
+       <p>Loading this account's NFTs...</p>
+     {/if}
+   </div>
+   ```
+
+1. Run the application.
+After you connect your wallet, the application should show the IDs of the NFTs that the connected account owns, as in this picture:
+
+   <img src="/img/tutorials/nft-consolidated-show-info-ids.png" alt="The application showing the IDs of the owned NFTs" style={{width: 300}} />
+
+   If you don't see the IDs of the NFTs that your account owns, compare your source code to the code in https://github.com/trilitech/tutorial-applications/tree/main/nft-consolidated/part-5.
+
+Now you can get information about NFTs in web applications.
+You could extend the application to provide links for each NFT, a table of the NFTs and their owners, or a thumbnail image for each NFT.
diff --git a/docs/tutorials/nft-consolidated/summary.md b/docs/tutorials/nft-consolidated/summary.md
new file mode 100644
index 000000000..8e2004989
--- /dev/null
+++ b/docs/tutorials/nft-consolidated/summary.md
@@ -0,0 +1,26 @@
+---
+title: Summary
+authors: Tim McMackin
+last_update:
+  date: 9 January 2025
+---
+
+Now you have an application that can connect to a user's wallet, send transactions on the user's behalf, and get information from Tezos.
+You also learned:
+
+- How to use Beacon to connect to Tezos-compatible wallets
+- How to use Taquito to send transactions to Tezos and get information from Tezos
+- Best practices for interacting with user wallets in decentralized applications
+- Creating and deploying smart contracts with SmartPy, its FA2 library, and its online IDE
+
+If you want to continue with the application, here are some ideas:
+
+- Customize how the contract behaves, such as requiring a fee to mint a token
+- Provide more information about the tokens on the web interface
+- Allow users to send tokens to other users from the web interface
+
+If you want to expand your knowledge of Tezos and tokens, see these tutorials:
+
+- [Build an NFT marketplace](/tutorials/build-an-nft-marketplace)
+- [Create a fungible token with the SmartPy FA2 library](/tutorials/smartpy-fa2-fungible)
+- [Deploy a Smart Rollup](/tutorials/smartpy-fa2-fungible)
diff --git a/sidebars.js b/sidebars.js
index cdfba51ec..b810d9016 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -347,6 +347,22 @@ const sidebars = {
         'tutorials/join-dal-baker/conclusion',
       ],
     },
+    {
+      type: 'category',
+      label: 'Mint NFTs',
+      link: {
+        type: 'doc',
+        id: 'tutorials/nft-consolidated',
+      },
+      items: [
+        'tutorials/nft-consolidated/setting-up-app',
+        'tutorials/nft-consolidated/connect-wallet',
+        'tutorials/nft-consolidated/send-transactions',
+        'tutorials/nft-consolidated/create-contract',
+        'tutorials/nft-consolidated/show-info',
+        'tutorials/nft-consolidated/summary',
+      ],
+    },
     {
       type: 'html',
       value: '<div>Advanced</div>',
diff --git a/static/img/tutorials/nft-consolidated-connect-connected.png b/static/img/tutorials/nft-consolidated-connect-connected.png
new file mode 100644
index 000000000..aebdfafc8
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-connect-connected.png differ
diff --git a/static/img/tutorials/nft-consolidated-connect-not-connected.png b/static/img/tutorials/nft-consolidated-connect-not-connected.png
new file mode 100644
index 000000000..de5d46e37
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-connect-not-connected.png differ
diff --git a/static/img/tutorials/nft-consolidated-contract-template-completed-tests.png b/static/img/tutorials/nft-consolidated-contract-template-completed-tests.png
new file mode 100644
index 000000000..781e03e2c
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-contract-template-completed-tests.png differ
diff --git a/static/img/tutorials/nft-consolidated-contract-template-deployed.png b/static/img/tutorials/nft-consolidated-contract-template-deployed.png
new file mode 100644
index 000000000..8484231e0
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-contract-template-deployed.png differ
diff --git a/static/img/tutorials/nft-consolidated-contract-template-run-code.png b/static/img/tutorials/nft-consolidated-contract-template-run-code.png
new file mode 100644
index 000000000..f81b7d671
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-contract-template-run-code.png differ
diff --git a/static/img/tutorials/nft-consolidated-contract-template-window.png b/static/img/tutorials/nft-consolidated-contract-template-window.png
new file mode 100644
index 000000000..79efbf69c
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-contract-template-window.png differ
diff --git a/static/img/tutorials/nft-consolidated-show-info-ids.png b/static/img/tutorials/nft-consolidated-show-info-ids.png
new file mode 100644
index 000000000..c73665a5a
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-show-info-ids.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-completed-transaction.png b/static/img/tutorials/nft-consolidated-transaction-completed-transaction.png
new file mode 100644
index 000000000..03c61ef1e
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-completed-transaction.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-existing-tokens.png b/static/img/tutorials/nft-consolidated-transaction-existing-tokens.png
new file mode 100644
index 000000000..03f7e59f2
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-existing-tokens.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-temple-add-contract.png b/static/img/tutorials/nft-consolidated-transaction-temple-add-contract.png
new file mode 100644
index 000000000..6b1d17e34
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-temple-add-contract.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-temple-no-nfts.png b/static/img/tutorials/nft-consolidated-transaction-temple-no-nfts.png
new file mode 100644
index 000000000..0f81b2bf2
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-temple-no-nfts.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-temple-show-nft-info.png b/static/img/tutorials/nft-consolidated-transaction-temple-show-nft-info.png
new file mode 100644
index 000000000..a342cf24b
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-temple-show-nft-info.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-temple-show-nft.png b/static/img/tutorials/nft-consolidated-transaction-temple-show-nft.png
new file mode 100644
index 000000000..84156325d
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-temple-show-nft.png differ
diff --git a/static/img/tutorials/nft-consolidated-transaction-token-metadata.png b/static/img/tutorials/nft-consolidated-transaction-token-metadata.png
new file mode 100644
index 000000000..c9c8d057d
Binary files /dev/null and b/static/img/tutorials/nft-consolidated-transaction-token-metadata.png differ