Creating NFTs on Solana using Metaplex UMI

Note: This article was written to strengthen my knowledge on the topic and help other Solana Turbin3 cadets that may need a refresher on last week’s class, LET IT RIP!🚀

· Overview
· Prerequisites
∘ Development Environment
∘ Required Dependencies
∘ Project Structure
· Step 1: Upload NFT Image
∘ Key Points
· Step 2: Create and Upload Metadata
∘ Code Implementation
∘ Metadata Structure
· Step 3: Mint NFT
∘ Code Implementation
∘ Minting Parameters
· Running the Process
∘ Setup
∘ Execution
· Verification
· Common Issues and Solutions
· Best Practices
· Conclusion

Overview

This guide explains the complete process of creating NFTs on Solana using the Metaplex UMI framework. The process involves three main steps:
1. Uploading the NFT image to decentralized storage
2. Creating and uploading the NFT metadata
3. Minting the NFT on the Solana blockchain

Prerequisites

Development Environment

- Node.js installed (v14 or higher)
- TypeScript configuration
- Solana CLI tools
- A Solana wallet with devnet SOL

Required Dependencies

npm install \
 @metaplex-foundation/umi \
 @metaplex-foundation/umi-bundle-defaults \
 @metaplex-foundation/umi-uploader-irys \
 @metaplex-foundation/mpl-token-metadata \
bs58

Project Structure

project-root/
├── src/
│ ├── upload-image.ts
│ ├── upload-metadata.ts
│ ├── mint-nft.ts
│ └── public/
│ └── image.png
├── wallet/
│ └── id.json
└── package.json

Step 1: Upload NFT Image

Code Implementation

// upload-image.ts
import wallet from "../wallet/id.json"
import { createUmi } from "@metaplex-foundation/umi-bundle-defaults"
import { createGenericFile, createSignerFromKeypair, signerIdentity } from "@metaplex-foundation/umi"
import { irysUploader } from "@metaplex-foundation/umi-uploader-irys"
import { readFile } from "fs/promises"

// create devnet connection
const umi = createUmi('https://api.devnet.solana.com');


let keypair = umi.eddsa.createKeypairFromSecretKey(new Uint8Array(wallet));
const signer = createSignerFromKeypair(umi, keypair);


umi.use(irysUploader());
umi.use(signerIdentity(signer));


(async () => {
  try {
    // load image
    const imageBuffer = await readFile('./src/public/image.png');

    // create image to generic file
    const image = createGenericFile(
      imageBuffer,
      'image.png',
      {
         contentType: 'image/png',
       }
     );
 
     // upload image
     const [imageUri] = await umi.uploader.upload([image]);
     console.log("Image URI: ", imageUri);
 }
 catch(error) {
     console.log("Error uploading image:", error);
 }
})();

Key Points

- Uses Irys (formerly Bundlr) for decentralized storage
- Supports various image formats (PNG, JPG, etc.)
- Returns a permanent URI for the uploaded image
- Requires devnet SOL in the wallet for storage fees

Note: The generated URI may contain an outdated host like Arweave, copy the string part and concatenate it with the new host like below:

Step 2: Create and Upload Metadata

Code Implementation

import wallet from "../wallet/id.json"
import { createUmi } from "@metaplex-foundation/umi-bundle-defaults"
import { createGenericFile, createSignerFromKeypair, signerIdentity } from "@metaplex-foundation/umi"
import { irysUploader } from "@metaplex-foundation/umi-uploader-irys"

// Create a devnet connection
const umi = createUmi('https://api.devnet.solana.com');

let keypair = umi.eddsa.createKeypairFromSecretKey(new Uint8Array(wallet));
const signer = createSignerFromKeypair(umi, keypair);

umi.use(irysUploader());
umi.use(signerIdentity(signer));

(async () => {
    try {
        // Create metadata object
        const metadata = {
            name: "Saru Generug NFT",
            symbol: "SRUG",
            description: "A unique generated rug design NFT",
            image: "https://devnet.irys.xyz/4an6q1ofnVMctsZk4BWzSCAzeiz8S1kAMFbEe7k1f9TR",
            attributes: [
                { trait_type: 'Pattern', value: 'Geometric' },
                { trait_type: 'Style', value: 'Modern' },
                { trait_type: 'Collection', value: 'Genesis' }
            ],
            properties: {
                files: [
                    {
                        type: "image/png",
                        uri: "https://devnet.irys.xyz/4an6q1ofnVMctsZk4BWzSCAzeiz8S1kAMFbEe7k1f9TR"
                    }
                ]
            },
            creators: [
                {
                    address: signer.publicKey,
                    share: 100
                }
            ]
        };

        // Convert metadata to generic file
        const file = createGenericFile(
            JSON.stringify(metadata),
            'metadata.json',
            {
                contentType: 'application/json',
            }
        );

        // Upload metadata
        const [myUri] = await umi.uploader.upload([file]);
        console.log("Your metadata URI: ", myUri);
    }
    catch(error) {
        console.log("Oops.. Something went wrong", error);
    }
})();

Metadata Structure

- Name: NFT display name
- Symbol: Short identifier for the collection
- Description: Detailed description of the NFT
- Image: URI from Step 1
- Attributes: Array of traits and their values
- Properties: Technical details including file information
- Creators: Array of creator addresses and their share in percentages

Step 3: Mint NFT

Code Implementation

import { createUmi } from "@metaplex-foundation/umi-bundle-defaults"
import { createSignerFromKeypair, signerIdentity, generateSigner, percentAmount } from "@metaplex-foundation/umi"
import { createNft, mplTokenMetadata } from "@metaplex-foundation/mpl-token-metadata";

import wallet from "/home/dvrvsimi/.config/solana/id.json"
import base58 from "bs58";

const RPC_ENDPOINT = "https://api.devnet.solana.com";
const umi = createUmi(RPC_ENDPOINT);

let keypair = umi.eddsa.createKeypairFromSecretKey(new Uint8Array(wallet));
const myKeypairSigner = createSignerFromKeypair(umi, keypair);
umi.use(signerIdentity(myKeypairSigner));
umi.use(mplTokenMetadata())

const mint = generateSigner(umi);

(async () => {
    try {
        let tx = createNft(umi, {
            mint,
            name: "SARUGAMI",
            symbol: "$SARU",
            uri: "https://devnet.irys.xyz/BmD558EcZWfD2Z5NF6CRVUdsuRMivMMHbM6sECSbiTVS",
            sellerFeeBasisPoints: percentAmount(5, 2), // 5% royalties
            creators: [
                {
                    address: myKeypairSigner.publicKey,
                    share: 100,
                    verified: false,
                },
            ],
            collection: null,
            uses: null,
        });

        let result = await tx.sendAndConfirm(umi);
        const signature = base58.encode(result.signature);
        
        console.log(`Succesfully Minted! Check out your TX here:\nhttps://explorer.solana.com/tx/${signature}?cluster=devnet`)
        console.log("Mint Address: ", mint.publicKey);
    } catch (error) {
        console.error("Error minting NFT:", error);
    }
})();

Minting Parameters

- Mint: Generated signer for the NFT
- Name: Display name (should match metadata)
- Symbol: Collection symbol (should match metadata)
- URI: Metadata URI from Step 2
- Seller Fee Basis Points: Royalty percentage (e.g., 500 = 5%)
- Creators: Array of creators with shares
- Collection: Optional collection details
- Uses: Optional utility features

Running the Process

Setup

1. Create a Solana wallet and save keypair to wallet/id.json
2. Add devnet SOL to wallet using solana airdrop via CLI or using the faucet
3. Prepare your image file in the public directory

Execution

1. Run image upload:
   ts-node src/upload-image.ts
2. Copy image URI and update metadata script
3. Run metadata upload:
   ts-node src/upload-metadata.ts
4. Copy metadata URI and update mint script
5. Run mint process:
   ts-node src/mint-nft.ts

Verification

1. Check transaction on Solana Explorer using provided link
2. View NFT using mint address on explorer or marketplaces
3. Verify metadata and image are correctly displayed

Common Issues and Solutions

1. Insufficient SOL for storage fees
— Solution: Airdrop more devnet SOL
2. Metadata format errors
— Solution: Verify JSON structure matches Metaplex standard
3. Image upload failures
— Solution: Check file size and format compatibility

Best Practices

1. Always test on devnet first
2. Keep secure backups of URIs and mint addresses
3. Verify all metadata before minting
4. Include comprehensive error handling
5. Follow Metaplex metadata standards strictly

Conclusion

Creating NFTs on Solana using the Metaplex UMI framework is a structured and efficient process that simplifies the complexities of decentralized asset creation. The step-by-step workflow — spanning image uploads, metadata generation, and NFT minting — highlights UMI’s versatility and integration with decentralized storage solutions like Irys. By leveraging Solana’s high-performance blockchain and the rich functionality of Metaplex, developers can create scalable NFT projects while adhering to best practices and maintaining metadata consistency.

Key takeaways from this guide include the importance of error handling, adherence to Metaplex metadata standards, and thorough testing on the devnet. Following these principles ensures successful NFT creation with minimal setbacks, empowering developers to explore advanced use cases such as collections, royalties, and utility-driven NFTs.