Mint an NFT that can never leave your wallet.

When you finish this: your own copy of the repo, with packages installed.

1. Open the repo on GitHub and click Fork.
2. The assignment lives on the main branch, so you can keep "Copy the main branch only" ticked.
3. Clone your fork:

git clone https://github.com/YOUR-USERNAME/fall-school-metaplex-core.git
cd fall-school-metaplex-core
npm install

Run npm install once, at the repo root. It installs the packages for the TypeScript tracks (01 and 03) in one go.

When you finish this: a devnet wallet with SOL in it.

cd 01-easy-track
npm run setup

This creates wallet.json at the repo root and asks devnet for 1 SOL. The TypeScript tracks share this wallet, so the bonus uses it too.

If it prints Airdrop failed, copy the address it printed into faucet.solana.com. Sign in with GitHub for a higher limit.

Goal: npm run mint creates a soulbound NFT on devnet and prints its address.

Open 01-easy-track/scripts/2-mint-soulbound.ts. First set NAME to something with your name in it. Then complete the three TODOs.

TODO 1 · A fresh address for the asset

Every Core asset lives at its own new address. Make a signer for it:

const asset = generateSigner(umi);

TODO 2 · Create it with the plugin

This is the important part. Fill in the plugin's two settings from the table at the top:

await create(umi, {
  asset,
  name: NAME,
  uri: URI,
  plugins: [
    {
      type: "PermanentFreezeDelegate",
      frozen: ?,
      authority: { type: ? },
    },
  ],
}).sendAndConfirm(umi);

TODO 3 · Print the result

Log asset.publicKey.toString() and pass it to explorerAddress(...) for a clickable link. Delete the throw new Error(...) line, then run:

npm run mint

When you finish this: proof that your NFT really cannot move.

npm run verify -- YOUR_ASSET_ADDRESS

The script reads the asset from devnet, checks the plugin, then actually tries to send your NFT away. You want five PASS lines:

PASS  Asset exists: ...
PASS  PermanentFreezeDelegate plugin attached
PASS  Asset is frozen
PASS  Plugin authority is None (found: None)
PASS  Transfer attempt was rejected on-chain by MPL Core's freeze check

Submit

Hand in your asset's explorer link:

https://explorer.solana.com/address/YOUR_ASSET_ADDRESS?cluster=devnet

Be ready to explain in one or two sentences why it cannot be transferred.

Goal: your own program mints the same soulbound NFT, by calling Metaplex Core from Rust.

A program calling another program is a CPI (cross-program invocation). Your program builds the "create asset" instruction and hands it to Metaplex Core:

client
 └─ your program      mint_soulbound_nft(name, uri)
     └─ Metaplex Core  CreateV2, with the freeze plugin

What you need installed

This track has its own packages. Install them inside the folder:

cd 02-anchor-track
yarn install
anchor keys sync

anchor keys sync updates the program ID to match your own keypair. Anchor 1.x refuses to build until they match.

The TODOs

Open programs/soulbound-nft/src/instructions/mint_soulbound_nft.rs. Everything is already wired up except the empty .plugins(vec![]). It is the Rust version of what you wrote in TypeScript:

Each entry in the vec pairs a plugin with its authority:

.plugins(vec![PluginAuthorityPair {
    plugin: /* the frozen plugin */,
    authority: Some(/* "nobody" */),
}])

The types you need are already imported at the top of the file.

Build and test

anchor build
anchor test

Goal: your program live on devnet, plus a script that calls it to mint a real asset.

1 · Wallet and SOL for deploying

Anchor uses the Solana CLI wallet, not wallet.json. Create it if you don't have one, then fund it:

solana-keygen new          # skip if ~/.config/solana/id.json exists
solana config set --url devnet
solana address             # paste this into faucet.solana.com
solana balance

2 · Deploy

anchor build
anchor deploy --provider.cluster devnet

It prints your program ID. Save it for your submission.

If the deploy fails halfway, run solana program close --buffers before retrying. A failed deploy leaves SOL stuck in temporary accounts.

3 · Write the client script

This part has no starter file. Create submissions/YOUR-HANDLE/mint.ts. It does what the first test does, but on devnet:

import * as anchor from "@anchor-lang/core";
import { Keypair, PublicKey, SystemProgram } from "@solana/web3.js";
import { SoulboundNft } from "../../target/types/soulbound_nft";

const MPL_CORE = new PublicKey("CoREENxT6tW1HoK8ypY1SxRMZTcVPm7R94rH4PZNhX7d");

async function main() {
  // Reads ANCHOR_PROVIDER_URL and ANCHOR_WALLET (see the run command below)
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);
  const program = anchor.workspace.SoulboundNft as anchor.Program<SoulboundNft>;

  const asset = Keypair.generate();   // the new NFT's address

  const sig = await program.methods
    .mintSoulboundNft("YOUR NAME's Diploma", "YOUR METADATA URI")
    .accountsPartial({
      // payer, asset, owner, mplCoreProgram, systemProgram
    })
    .signers([asset])
    .rpc();

  // print the asset address and the transaction signature
}

main();

Three things to get right in accountsPartial:

1. asset is the new keypair's public key, and the keypair goes in .signers([...]). Metaplex Core requires the new asset to sign.
2. owner is who the NFT is bound to forever. Use your own wallet: provider.wallet.publicKey.
3. payer is also provider.wallet.publicKey. The wallet signs automatically, so don't add it to signers.

Run it from inside 02-anchor-track, so Anchor can find your program:

ANCHOR_PROVIDER_URL=https://api.devnet.solana.com \
ANCHOR_WALLET=$HOME/.config/solana/id.json \
npx ts-node submissions/YOUR-HANDLE/mint.ts

4 · Check it and open a pull request

1. Open the asset's explorer link with ?cluster=devnet at the end.
2. Copy submissions/SUBMISSION-template.md into your folder as SUBMISSION.md and fill in the program ID, asset and transaction links.
3. Commit, push to your fork, and open a pull request against the main branch.

02-anchor-track/submissions/YOUR-HANDLE/
├── mint.ts
└── SUBMISSION.md

Goal: one "original" collection and three numbered prints, each earning a different royalty when resold.

Think of a painting and its numbered prints. The collection is the painting. Each asset inside it is print #1, #2 or #3.

The plugins you will use

Work in 03-bonus-editions/editions.ts. It uses the same wallet.json as track 1.

TODO 1 · The collection

const collectionSigner = generateSigner(umi);

await createCollection(umi, {
  collection: collectionSigner,
  name: "...",
  uri: URI,
  plugins: [
    { type: "MasterEdition", maxSupply: ? },
    {
      type: "Royalties",
      basisPoints: 500,
      creators: [{ address: umi.identity.publicKey, percentage: 100 }],
      ruleSet: ruleSet("None"),
    },
  ],
}).sendAndConfirm(umi);

creators lists who gets paid. The percentages must add up to 100. ruleSet("None") means no marketplace is blocked.

TODO 2 · Three prints in a loop

Load the collection first, because create needs the full collection, not just its address:

const collection = await fetchCollection(umi, collectionSigner.publicKey);
const ROYALTIES = [250, 500, 1000];

for (let i = 1; i <= 3; i++) {
  const asset = generateSigner(umi);
  await create(umi, {
    asset,
    collection,
    name: `... #${i}`,
    uri: URI,
    plugins: [
      // 1. the Edition plugin with this print's number
      // 2. a Royalties plugin using ROYALTIES[i - 1]
    ],
  }).sendAndConfirm(umi);
  // TODO 3: print the explorer link for this asset
}

Remove the throw new Error(...) line, then run:

cd 03-bonus-editions
npm run editions

You should get 4 explorer links: the collection and 3 prints.

const onChain = await fetchAsset(umi, asset.publicKey);
console.log("royalty:", onChain.royalties?.basisPoints);

Submit

Open a pull request with this folder:

03-bonus-editions/submissions/YOUR-HANDLE/
├── editions.ts
└── SUBMISSION.md     # from SUBMISSION-template.md: 4 links

The template asks: which royalty applies to Edition #2, and why? The note on basis points above has the answer.