create token anchor examples

tokens/create-nft/anchor/Anchor.toml

@@ -0,0 +1,14 @@
+[features]
+seeds = false
+[programs.localnet]
+create_nft = "6UxmhKzsfC71xdSX4TdaZQTRnPeKFsimR6tTWGNjpJSw"
+
+[registry]
+url = "https://anchor.projectserum.com"
+
+[provider]
+cluster = "localnet"
+wallet = "~/.config/solana/id.json"
+
+[scripts]
+test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"

tokens/create-nft/anchor/Cargo.toml

@@ -0,0 +1,13 @@
+[workspace]
+members = [
+    "programs/*"
+]
+
+[profile.release]
+overflow-checks = true
+lto = "fat"
+codegen-units = 1
+[profile.release.build-override]
+opt-level = 3
+incremental = false
+codegen-units = 1

tokens/create-nft/anchor/package.json

@@ -0,0 +1,14 @@
+{
+    "dependencies": {
+        "@project-serum/anchor": "^0.24.2"
+    },
+    "devDependencies": {
+        "@types/bn.js": "^5.1.0",
+        "@types/chai": "^4.3.0",
+        "@types/mocha": "^9.0.0",
+        "chai": "^4.3.4",
+        "mocha": "^9.0.3",
+        "ts-mocha": "^10.0.0",
+        "typescript": "^4.3.5"
+    }
+}

tokens/create-spl-token/anchor/programs/mint-2/Cargo.toml → tokens/create-nft/anchor/programs/create-nft/Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-name = "mint-2"
+name = "create-nft"
 version = "0.1.0"
 description = "Created with Anchor"
 edition = "2021"
 
 [lib]
 crate-type = ["cdylib", "lib"]
-name = "mint_2"
+name = "create_nft"
 
 [features]
 no-entrypoint = []

tokens/create-nft/anchor/programs/create-nft/src/lib.rs

@@ -0,0 +1,86 @@
+use {
+    anchor_lang::{
+        prelude::*,
+        solana_program::program::invoke,
+    },
+    anchor_spl::token,
+    mpl_token_metadata::instruction as mpl_instruction,
+};
+
+
+declare_id!("6UxmhKzsfC71xdSX4TdaZQTRnPeKFsimR6tTWGNjpJSw");
+
+
+#[program]
+pub mod create_nft {
+    use super::*;
+
+    pub fn create_token_mint(
+        ctx: Context<CreateTokenMint>, 
+        token_title: String, 
+        token_symbol: String, 
+        token_uri: String,
+    ) -> Result<()> {
+    
+        msg!("Creating metadata account...");
+        msg!("Metadata account address: {}", &ctx.accounts.metadata_account.key());
+        invoke(
+            &mpl_instruction::create_metadata_accounts_v2(
+                ctx.accounts.token_metadata_program.key(),      // Program ID (the Token Metadata Program)
+                ctx.accounts.metadata_account.key(),            // Metadata account
+                ctx.accounts.mint_account.key(),                // Mint account
+                ctx.accounts.mint_authority.key(),              // Mint authority
+                ctx.accounts.payer.key(),                       // Payer
+                ctx.accounts.mint_authority.key(),              // Update authority
+                token_title,                                    // Name
+                token_symbol,                                   // Symbol
+                token_uri,                                      // URI
+                None,                                           // Creators
+                0,                                              // Seller fee basis points
+                true,                                           // Update authority is signer
+                false,                                          // Is mutable
+                None,                                           // Collection
+                None,                                           // Uses
+            ),
+            &[
+                ctx.accounts.metadata_account.to_account_info(),
+                ctx.accounts.mint_account.to_account_info(),
+                ctx.accounts.mint_authority.to_account_info(),
+                ctx.accounts.payer.to_account_info(),
+                ctx.accounts.mint_authority.to_account_info(),
+                ctx.accounts.rent.to_account_info(),
+            ]
+        )?;
+    
+        msg!("Token mint created successfully.");
+    
+        Ok(())
+    }
+}
+
+
+// The macros within the Account Context will create our
+//      Mint account and initialize it as a Mint
+//      We just have to do the metadata
+//
+#[derive(Accounts)]
+pub struct CreateTokenMint<'info> {
+    /// CHECK: We're about to create this with Metaplex
+    #[account(mut)]
+    pub metadata_account: UncheckedAccount<'info>,
+    #[account(
+        init,
+        payer = payer,
+        mint::decimals = 0,         // 0 decimals for the NFT standard
+        mint::authority = mint_authority.key(),
+    )]
+    pub mint_account: Account<'info, token::Mint>,
+    pub mint_authority: SystemAccount<'info>,
+    #[account(mut)]
+    pub payer: Signer<'info>,
+    pub rent: Sysvar<'info, Rent>,
+    pub system_program: Program<'info, System>,
+    pub token_program: Program<'info, token::Token>,
+    /// CHECK: Metaplex will check this
+    pub token_metadata_program: UncheckedAccount<'info>,
+}

tokens/create-nft/anchor/tests/test.ts

@@ -0,0 +1,63 @@
+import * as anchor from "@project-serum/anchor";
+import { CreateNft } from "../target/types/create_nft";
+
+
+const TOKEN_METADATA_PROGRAM_ID = new anchor.web3.PublicKey(
+  "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
+);
+
+
+describe("Create an NFT", () => {
+  
+  const provider = anchor.AnchorProvider.env();
+  anchor.setProvider(provider);
+  const payer = provider.wallet as anchor.Wallet;
+  const program = anchor.workspace.CreateNft as anchor.Program<CreateNft>;
+
+  const tokenTitle = "Solana Gold";
+  const tokenSymbol = "GOLDSOL";
+  const tokenUri = "https://raw.githubusercontent.com/solana-developers/program-examples/new-examples/tokens/tokens/.assets/spl-token.json";
+
+  const mintKeypair: anchor.web3.Keypair = anchor.web3.Keypair.generate();
+  console.log(`New token: ${mintKeypair.publicKey}`);
+
+  it("Create!", async () => {
+
+    const [mintAuthorityPda, mintAuthorityPdaBump] = await anchor.web3.PublicKey.findProgramAddress(
+      [
+        Buffer.from("mint_authority_"),
+        mintKeypair.publicKey.toBuffer(),
+      ],
+      program.programId,
+    );
+
+    const metadataAddress = (await anchor.web3.PublicKey.findProgramAddress(
+      [
+        Buffer.from("metadata"),
+        TOKEN_METADATA_PROGRAM_ID.toBuffer(),
+        mintKeypair.publicKey.toBuffer(),
+      ],
+      TOKEN_METADATA_PROGRAM_ID
+    ))[0];
+
+    const sx = await program.methods.createTokenMint(
+      tokenTitle, tokenSymbol, tokenUri
+    )
+      .accounts({
+        metadataAccount: metadataAddress,
+        mintAccount: mintKeypair.publicKey,
+        mintAuthority: mintAuthorityPda,
+        payer: payer.publicKey,
+        rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+        systemProgram: anchor.web3.SystemProgram.programId,
+        tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
+        tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
+      })
+      .signers([mintKeypair, payer.payer])
+      .rpc();
+
+    console.log("Success!");
+        console.log(`   Mint Address: ${mintKeypair.publicKey}`);
+        console.log(`   Tx Signature: ${sx}`);
+  });
+});

tokens/create-nft/anchor/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "types": ["mocha", "chai"],
+    "typeRoots": ["./node_modules/@types"],
+    "lib": ["es2015"],
+    "module": "commonjs",
+    "target": "es6",
+    "esModuleInterop": true
+  }
+}

tokens/create-spl-token/anchor/Anchor.toml

@@ -1,13 +1,13 @@
 [features]
 seeds = false
-[programs.devnet]
-mint_2 = "8vbaY8zv9r3AgeLjyAr7LEprJwLN5Jjus97crJBD2AV2"
+[programs.localnet]
+create_token = "8KA4k3czQPARFR1jA9Syc51ZPnJEbTyb8EMNRNdrHWce"
 
 [registry]
 url = "https://anchor.projectserum.com"
 
 [provider]
-cluster = "devnet"
+cluster = "localnet"
 wallet = "~/.config/solana/id.json"
 
 [scripts]

tokens/create-spl-token/anchor/programs/create-spl-token/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "create-token"
+version = "0.1.0"
+description = "Created with Anchor"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "create_token"
+
+[features]
+no-entrypoint = []
+no-idl = []
+no-log-ix-name = []
+cpi = ["no-entrypoint"]
+default = []
+
+[dependencies]
+anchor-lang = "0.25.0"
+anchor-spl = "0.25.0"
+mpl-token-metadata = { version="1.2.5", features = [ "no-entrypoint" ] }

tokens/create-spl-token/anchor/programs/create-spl-token/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

tokens/create-spl-token/anchor/programs/create-spl-token/src/lib.rs

@@ -0,0 +1,86 @@
+use {
+    anchor_lang::{
+        prelude::*,
+        solana_program::program::invoke,
+    },
+    anchor_spl::token,
+    mpl_token_metadata::instruction as mpl_instruction,
+};
+
+
+declare_id!("8KA4k3czQPARFR1jA9Syc51ZPnJEbTyb8EMNRNdrHWce");
+
+
+#[program]
+pub mod create_token {
+    use super::*;
+
+    pub fn create_token_mint(
+        ctx: Context<CreateTokenMint>, 
+        token_title: String, 
+        token_symbol: String, 
+        token_uri: String,
+    ) -> Result<()> {
+    
+        msg!("Creating metadata account...");
+        msg!("Metadata account address: {}", &ctx.accounts.metadata_account.key());
+        invoke(
+            &mpl_instruction::create_metadata_accounts_v2(
+                ctx.accounts.token_metadata_program.key(),      // Program ID (the Token Metadata Program)
+                ctx.accounts.metadata_account.key(),            // Metadata account
+                ctx.accounts.mint_account.key(),                // Mint account
+                ctx.accounts.mint_authority.key(),              // Mint authority
+                ctx.accounts.payer.key(),                       // Payer
+                ctx.accounts.mint_authority.key(),              // Update authority
+                token_title,                                    // Name
+                token_symbol,                                   // Symbol
+                token_uri,                                      // URI
+                None,                                           // Creators
+                0,                                              // Seller fee basis points
+                true,                                           // Update authority is signer
+                false,                                          // Is mutable
+                None,                                           // Collection
+                None,                                           // Uses
+            ),
+            &[
+                ctx.accounts.metadata_account.to_account_info(),
+                ctx.accounts.mint_account.to_account_info(),
+                ctx.accounts.mint_authority.to_account_info(),
+                ctx.accounts.payer.to_account_info(),
+                ctx.accounts.mint_authority.to_account_info(),
+                ctx.accounts.rent.to_account_info(),
+            ]
+        )?;
+    
+        msg!("Token mint created successfully.");
+    
+        Ok(())
+    }
+}
+
+
+// The macros within the Account Context will create our
+//      Mint account and initialize it as a Mint
+//      We just have to do the metadata
+//
+#[derive(Accounts)]
+pub struct CreateTokenMint<'info> {
+    /// CHECK: We're about to create this with Metaplex
+    #[account(mut)]
+    pub metadata_account: UncheckedAccount<'info>,
+    #[account(
+        init,
+        payer = payer,
+        mint::decimals = 9,         // 9 decimals for the default SPL Token standard
+        mint::authority = mint_authority.key(),
+    )]
+    pub mint_account: Account<'info, token::Mint>,
+    pub mint_authority: SystemAccount<'info>,
+    #[account(mut)]
+    pub payer: Signer<'info>,
+    pub rent: Sysvar<'info, Rent>,
+    pub system_program: Program<'info, System>,
+    pub token_program: Program<'info, token::Token>,
+    /// CHECK: Metaplex will check this
+    pub token_metadata_program: UncheckedAccount<'info>,
+}

tokens/create-spl-token/anchor/programs/mint-2/src/instructions/create_token_mint.rs

@@ -1,95 +0,0 @@
-use {
-    anchor_lang::{
-        prelude::*,
-        solana_program::program::invoke_signed,
-    },
-    anchor_spl::token,
-    mpl_token_metadata::instruction as mpl_instruction,
-};
-
-
-pub fn create_token_mint(
-    ctx: Context<CreateTokenMint>, 
-    metadata_title: String, 
-    metadata_symbol: String, 
-    metadata_uri: String,
-    mint_authority_pda_bump: u8,
-) -> Result<()> {
-
-    msg!("Creating metadata account...");
-    msg!("Metadata account address: {}", &ctx.accounts.metadata_account.key());
-    invoke_signed(
-        &mpl_instruction::create_metadata_accounts_v2(
-            ctx.accounts.token_metadata_program.key(),      // Program ID (the Token Metadata Program)
-            ctx.accounts.metadata_account.key(),            // Metadata account
-            ctx.accounts.mint_account.key(),                // Mint account
-            ctx.accounts.mint_authority.key(),              // Mint authority
-            ctx.accounts.payer.key(),                       // Payer
-            ctx.accounts.mint_authority.key(),              // Update authority
-            metadata_title,                                 // Name
-            metadata_symbol,                                // Symbol
-            metadata_uri,                                   // URI
-            None,                                           // Creators
-            0,                                              // Seller fee basis points
-            true,                                           // Update authority is signer
-            false,                                          // Is mutable
-            None,                                           // Collection
-            None,                                           // Uses
-        ),
-        &[
-            ctx.accounts.metadata_account.to_account_info(),
-            ctx.accounts.mint_account.to_account_info(),
-            ctx.accounts.mint_authority.to_account_info(),
-            ctx.accounts.payer.to_account_info(),
-            ctx.accounts.mint_authority.to_account_info(),
-            ctx.accounts.rent.to_account_info(),
-        ],
-        &[
-            &[
-                b"mint_authority_", 
-                ctx.accounts.mint_account.key().as_ref(),
-                &[mint_authority_pda_bump],
-            ]
-        ]
-    )?;
-
-    msg!("Token mint created successfully.");
-
-    Ok(())
-}
-
-
-#[derive(Accounts)]
-pub struct CreateTokenMint<'info> {
-    /// CHECK: We're about to create this with Metaplex
-    #[account(mut)]
-    pub metadata_account: UncheckedAccount<'info>,
-    #[account(
-        init,
-        payer = payer,
-        mint::decimals = 9,
-        mint::authority = mint_authority.key(),
-    )]
-    pub mint_account: Account<'info, token::Mint>,
-    #[account(
-        init, 
-        payer = payer,
-        space = 8 + 32,
-        seeds = [
-            b"mint_authority_", 
-            mint_account.key().as_ref(),
-        ],
-        bump
-    )]
-    pub mint_authority: Account<'info, MintAuthorityPda>,
-    #[account(mut)]
-    pub payer: Signer<'info>,
-    pub rent: Sysvar<'info, Rent>,
-    pub system_program: Program<'info, System>,
-    pub token_program: Program<'info, token::Token>,
-    /// CHECK: Metaplex will check this
-    pub token_metadata_program: UncheckedAccount<'info>,
-}
-
-#[account]
-pub struct MintAuthorityPda {}

tokens/create-spl-token/anchor/programs/mint-2/src/instructions/mint_to_another_wallet.rs

@@ -1,76 +0,0 @@
-use {
-    anchor_lang::prelude::*,
-    anchor_spl::{
-        token,
-        associated_token,
-    },
-};
-use crate::create_token_mint::MintAuthorityPda;
-
-
-pub fn mint_to_another_wallet(
-    ctx: Context<MintToAnotherWallet>, 
-    amount: u64,
-    mint_authority_pda_bump: u8,
-) -> Result<()> {
-
-    msg!("Minting token to token account...");
-    msg!("Mint: {}", &ctx.accounts.mint_account.to_account_info().key());   
-    msg!("Token Address: {}", &ctx.accounts.token_account.key());     
-    token::mint_to(
-        CpiContext::new_with_signer(
-            ctx.accounts.token_program.to_account_info(),
-            token::MintTo {
-                mint: ctx.accounts.mint_account.to_account_info(),
-                to: ctx.accounts.token_account.to_account_info(),
-                authority: ctx.accounts.mint_authority.to_account_info(),
-            },
-            &[&[
-                b"mint_authority_", 
-                ctx.accounts.mint_account.key().as_ref(),
-                &[mint_authority_pda_bump],
-            ]]
-        ),
-        amount,
-    )?;
-
-    msg!("Token minted to wallet successfully.");
-
-    Ok(())
-}
-
-
-#[derive(Accounts)]
-#[instruction(amount: u64, mint_authority_pda_bump: u8)]
-pub struct MintToAnotherWallet<'info> {
-    #[account(
-        mut,
-        mint::decimals = 9,
-        mint::authority = mint_authority.key(),
-    )]
-    pub mint_account: Account<'info, token::Mint>,
-    #[account(
-        mut, 
-        seeds = [
-            b"mint_authority_", 
-            mint_account.key().as_ref()
-        ],
-        bump = mint_authority_pda_bump
-    )]
-    pub mint_authority: Account<'info, MintAuthorityPda>,
-    /// CHECK: This is for airdrops
-    pub recipient: UncheckedAccount<'info>,
-    #[account(
-        init,
-        payer = payer,
-        associated_token::mint = mint_account,
-        associated_token::authority = recipient,
-    )]
-    pub token_account: Account<'info, token::TokenAccount>,
-    #[account(mut)]
-    pub payer: Signer<'info>,
-    pub rent: Sysvar<'info, Rent>,
-    pub system_program: Program<'info, System>,
-    pub token_program: Program<'info, token::Token>,
-    pub associated_token_program: Program<'info, associated_token::AssociatedToken>,
-}

tokens/create-spl-token/anchor/programs/mint-2/src/instructions/mint_to_your_wallet.rs

@@ -1,74 +0,0 @@
-use {
-    anchor_lang::prelude::*,
-    anchor_spl::{
-        token,
-        associated_token,
-    },
-};
-use crate::create_token_mint::MintAuthorityPda;
-
-
-pub fn mint_to_your_wallet(
-    ctx: Context<MintToYourWallet>, 
-    amount: u64,
-    mint_authority_pda_bump: u8,
-) -> Result<()> {
-
-    msg!("Minting token to token account...");
-    msg!("Mint: {}", &ctx.accounts.mint_account.to_account_info().key());   
-    msg!("Token Address: {}", &ctx.accounts.token_account.key());     
-    token::mint_to(
-        CpiContext::new_with_signer(
-            ctx.accounts.token_program.to_account_info(),
-            token::MintTo {
-                mint: ctx.accounts.mint_account.to_account_info(),
-                to: ctx.accounts.token_account.to_account_info(),
-                authority: ctx.accounts.mint_authority.to_account_info(),
-            },
-            &[&[
-                b"mint_authority_", 
-                ctx.accounts.mint_account.key().as_ref(),
-                &[mint_authority_pda_bump],
-            ]]
-        ),
-        amount,
-    )?;
-
-    msg!("Token minted to wallet successfully.");
-
-    Ok(())
-}
-
-
-#[derive(Accounts)]
-#[instruction(amount: u64, mint_authority_pda_bump: u8)]
-pub struct MintToYourWallet<'info> {
-    #[account(
-        mut,
-        mint::decimals = 9,
-        mint::authority = mint_authority.key(),
-    )]
-    pub mint_account: Account<'info, token::Mint>,
-    #[account(
-        mut, 
-        seeds = [
-            b"mint_authority_", 
-            mint_account.key().as_ref()
-        ],
-        bump = mint_authority_pda_bump
-    )]
-    pub mint_authority: Account<'info, MintAuthorityPda>,
-    #[account(
-        init,
-        payer = payer,
-        associated_token::mint = mint_account,
-        associated_token::authority = payer,
-    )]
-    pub token_account: Account<'info, token::TokenAccount>,
-    #[account(mut)]
-    pub payer: Signer<'info>,
-    pub rent: Sysvar<'info, Rent>,
-    pub system_program: Program<'info, System>,
-    pub token_program: Program<'info, token::Token>,
-    pub associated_token_program: Program<'info, associated_token::AssociatedToken>,
-}

tokens/create-spl-token/anchor/programs/mint-2/src/instructions/mod.rs

@@ -1,9 +0,0 @@
-pub mod create_token_mint;
-pub mod mint_to_your_wallet;
-pub mod mint_to_another_wallet;
-pub mod transfer_to_another_wallet;
-
-pub use create_token_mint::*;
-pub use mint_to_your_wallet::*;
-pub use mint_to_another_wallet::*;
-pub use transfer_to_another_wallet::*;

tokens/create-spl-token/anchor/programs/mint-2/src/instructions/transfer_to_another_wallet.rs

@@ -1,62 +0,0 @@
-use {
-    anchor_lang::prelude::*,
-    anchor_spl::{
-        token,
-        associated_token,
-    },
-};
-
-
-pub fn transfer_to_another_wallet(
-    ctx: Context<TransferToAnotherWallet>, 
-    amount: u64,
-) -> Result<()> {
-
-    msg!("Transferring {} tokens to new token account...", amount);
-    msg!("Mint: {}", &ctx.accounts.mint_account.to_account_info().key());   
-    msg!("Owner Token Address: {}", &ctx.accounts.owner_token_account.key());  
-    msg!("Recipient Token Address: {}", &ctx.accounts.recipient_token_account.key());
-    token::transfer(
-        CpiContext::new(
-            ctx.accounts.token_program.to_account_info(),
-            token::Transfer {
-                from: ctx.accounts.owner_token_account.to_account_info(),
-                to: ctx.accounts.recipient_token_account.to_account_info(),
-                authority: ctx.accounts.owner.to_account_info(),
-            },
-        ),
-        amount,
-    )?;
-
-    msg!("Tokens transferred to wallet successfully.");
-
-    Ok(())
-}
-
-
-#[derive(Accounts)]
-pub struct TransferToAnotherWallet<'info> {
-    #[account(mut)]
-    pub mint_account: Account<'info, token::Mint>,
-    #[account(
-        mut,
-        associated_token::mint = mint_account,
-        associated_token::authority = owner,
-    )]
-    pub owner_token_account: Account<'info, token::TokenAccount>,
-    #[account(
-        init,
-        payer = owner,
-        associated_token::mint = mint_account,
-        associated_token::authority = recipient,
-    )]
-    pub recipient_token_account: Account<'info, token::TokenAccount>,
-    #[account(mut)]
-    pub owner: Signer<'info>,
-    /// CHECK: Crediting not Debiting
-    pub recipient: UncheckedAccount<'info>,
-    pub rent: Sysvar<'info, Rent>,
-    pub system_program: Program<'info, System>,
-    pub token_program: Program<'info, token::Token>,
-    pub associated_token_program: Program<'info, associated_token::AssociatedToken>,
-}

tokens/create-spl-token/anchor/programs/mint-2/src/lib.rs

@@ -1,68 +0,0 @@
-use anchor_lang::prelude::*;
-
-pub mod instructions;
-
-use instructions::*;
-
-
-declare_id!("8vbaY8zv9r3AgeLjyAr7LEprJwLN5Jjus97crJBD2AV2");
-
-
-#[program]
-pub mod mint_2 {
-    use super::*;
-
-    pub fn create_token_mint(
-        ctx: Context<CreateTokenMint>, 
-        metadata_title: String, 
-        metadata_symbol: String, 
-        metadata_uri: String,
-        mint_authority_pda_bump: u8,
-    ) -> Result<()> {
-
-        create_token_mint::create_token_mint(
-            ctx, 
-            metadata_title, 
-            metadata_symbol, 
-            metadata_uri,
-            mint_authority_pda_bump,
-        )
-    }
-
-    pub fn mint_to_your_wallet(
-        ctx: Context<MintToYourWallet>, 
-        amount: u64,
-        mint_authority_pda_bump: u8,
-    ) -> Result<()> {
-
-        mint_to_your_wallet::mint_to_your_wallet(
-            ctx, 
-            amount,
-            mint_authority_pda_bump,
-        )
-    }
-
-    pub fn mint_to_another_wallet(
-        ctx: Context<MintToAnotherWallet>, 
-        amount: u64,
-        mint_authority_pda_bump: u8,
-    ) -> Result<()> {
-
-        mint_to_another_wallet::mint_to_another_wallet(
-            ctx, 
-            amount,
-            mint_authority_pda_bump,
-        )
-    }
-
-    pub fn transfer_to_another_wallet(
-        ctx: Context<TransferToAnotherWallet>, 
-        amount: u64,
-    ) -> Result<()> {
-
-        transfer_to_another_wallet::transfer_to_another_wallet(
-            ctx, 
-            amount,
-        )
-    }
-}

tokens/create-spl-token/anchor/tests/test.ts

@@ -1,5 +1,5 @@
 import * as anchor from "@project-serum/anchor";
-import { Mint2 } from "../target/types/mint_2";
+import { CreateToken } from "../target/types/create_token";
 
 
 const TOKEN_METADATA_PROGRAM_ID = new anchor.web3.PublicKey(
@@ -7,21 +7,21 @@ const TOKEN_METADATA_PROGRAM_ID = new anchor.web3.PublicKey(
 );
 
 
-describe("mint-token", () => {
+describe("Create an SPL Token", () => {
   
   const provider = anchor.AnchorProvider.env();
   anchor.setProvider(provider);
   const payer = provider.wallet as anchor.Wallet;
-  const program = anchor.workspace.Mint2 as anchor.Program<Mint2>;
+  const program = anchor.workspace.CreateToken as anchor.Program<CreateToken>;
 
-  const testTokenTitle = "Solana Gold";
-  const testTokenSymbol = "GOLDSOL";
-  const testTokenUri = "https://raw.githubusercontent.com/solana-developers/program-examples/main/tokens/mint-2/anchor/tests/token_metadata.json";
+  const tokenTitle = "Solana Gold";
+  const tokenSymbol = "GOLDSOL";
+  const tokenUri = "https://raw.githubusercontent.com/solana-developers/program-examples/new-examples/tokens/tokens/.assets/spl-token.json";
 
   const mintKeypair: anchor.web3.Keypair = anchor.web3.Keypair.generate();
   console.log(`New token: ${mintKeypair.publicKey}`);
 
-  it("Create the mint", async () => {
+  it("Create!", async () => {
 
     const [mintAuthorityPda, mintAuthorityPdaBump] = await anchor.web3.PublicKey.findProgramAddress(
       [
@@ -40,136 +40,24 @@ describe("mint-token", () => {
       TOKEN_METADATA_PROGRAM_ID
     ))[0];
 
-    await program.methods.createTokenMint(
-      testTokenTitle, testTokenSymbol, testTokenUri, mintAuthorityPdaBump
+    const sx = await program.methods.createTokenMint(
+      tokenTitle, tokenSymbol, tokenUri
     )
-    .accounts({
-      metadataAccount: metadataAddress,
-      mintAccount: mintKeypair.publicKey,
-      mintAuthority: mintAuthorityPda,
-      payer: payer.publicKey,
-      rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-      systemProgram: anchor.web3.SystemProgram.programId,
-      tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
-      tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
-    })
-    .signers([mintKeypair, payer.payer])
-    .rpc();
-  });
-
-  it("Mint to your wallet!", async () => {
-
-    const [mintAuthorityPda, mintAuthorityPdaBump] = await anchor.web3.PublicKey.findProgramAddress(
-      [
-        Buffer.from("mint_authority_"),
-        mintKeypair.publicKey.toBuffer(),
-      ],
-      program.programId,
-    );
-
-    const amountToMint = 1;
-
-    const tokenAddress = await anchor.utils.token.associatedAddress({
-        mint: mintKeypair.publicKey,
-        owner: payer.publicKey
-    });
-    console.log(`Token Address: ${tokenAddress}`);
-
-    await program.methods.mintToYourWallet(
-      new anchor.BN(amountToMint), mintAuthorityPdaBump
-    )
-    .accounts({
-      mintAccount: mintKeypair.publicKey,
-      mintAuthority: mintAuthorityPda,
-      tokenAccount: tokenAddress,
-      payer: payer.publicKey,
-      rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-      systemProgram: anchor.web3.SystemProgram.programId,
-      tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
-      associatedTokenProgram: anchor.utils.token.ASSOCIATED_PROGRAM_ID,
-    })
-    .signers([payer.payer])
-    .rpc();
-  });
-
-  it("Mint to another person's wallet (airdrop)!", async () => {
-
-    const recipientKeypair = anchor.web3.Keypair.generate();
-    await provider.connection.confirmTransaction(
-      await provider.connection.requestAirdrop(recipientKeypair.publicKey, 1 * anchor.web3.LAMPORTS_PER_SOL)
-    );
-    console.log(`Recipient pubkey: ${recipientKeypair.publicKey}`);
-
-    const [mintAuthorityPda, mintAuthorityPdaBump] = await anchor.web3.PublicKey.findProgramAddress(
-      [
-        Buffer.from("mint_authority_"),
-        mintKeypair.publicKey.toBuffer(),
-      ],
-      program.programId,
-    );
-
-    const amountToMint = 1;
-
-    const tokenAddress = await anchor.utils.token.associatedAddress({
-        mint: mintKeypair.publicKey,
-        owner: recipientKeypair.publicKey
-    });
-    console.log(`Token Address: ${tokenAddress}`);
-
-    await program.methods.mintToAnotherWallet(
-      new anchor.BN(amountToMint), mintAuthorityPdaBump
-    )
-    .accounts({
-      mintAccount: mintKeypair.publicKey,
-      mintAuthority: mintAuthorityPda,
-      recipient: recipientKeypair.publicKey,
-      tokenAccount: tokenAddress,
-      payer: payer.publicKey,
-      rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-      systemProgram: anchor.web3.SystemProgram.programId,
-      tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
-      associatedTokenProgram: anchor.utils.token.ASSOCIATED_PROGRAM_ID,
-    })
-    .signers([payer.payer])
-    .rpc();
-  });
-
-  it("Transfer to another person's wallet!", async () => {
-
-    const recipientWallet = anchor.web3.Keypair.generate();
-    await provider.connection.confirmTransaction(
-        await provider.connection.requestAirdrop(recipientWallet.publicKey, 2 * anchor.web3.LAMPORTS_PER_SOL)
-    );
-    console.log(`Recipient Pubkey: ${recipientWallet.publicKey}`);
-
-    const amountToTransfer = 1;
-
-    const ownerTokenAddress = await anchor.utils.token.associatedAddress({
-        mint: mintKeypair.publicKey,
-        owner: payer.publicKey
-    });
-    console.log(`Owner Token Address: ${ownerTokenAddress}`);
-    const recipientTokenAddress = await anchor.utils.token.associatedAddress({
-        mint: mintKeypair.publicKey,
-        owner: recipientWallet.publicKey
-    });
-    console.log(`Recipient Token Address: ${recipientTokenAddress}`);
-
-    await program.methods.transferToAnotherWallet(
-      new anchor.BN(amountToTransfer)
-    )
-    .accounts({
-      mintAccount: mintKeypair.publicKey,
-      ownerTokenAccount: ownerTokenAddress,
-      recipientTokenAccount: recipientTokenAddress,
-      owner: payer.publicKey,
-      recipient: recipientWallet.publicKey,
-      rent: anchor.web3.SYSVAR_RENT_PUBKEY,
-      systemProgram: anchor.web3.SystemProgram.programId,
-      tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
-      associatedTokenProgram: anchor.utils.token.ASSOCIATED_PROGRAM_ID,
-    })
-    .signers([payer.payer])
-    .rpc();
+      .accounts({
+        metadataAccount: metadataAddress,
+        mintAccount: mintKeypair.publicKey,
+        mintAuthority: mintAuthorityPda,
+        payer: payer.publicKey,
+        rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+        systemProgram: anchor.web3.SystemProgram.programId,
+        tokenProgram: anchor.utils.token.TOKEN_PROGRAM_ID,
+        tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
+      })
+      .signers([mintKeypair, payer.payer])
+      .rpc();
+
+    console.log("Success!");
+        console.log(`   Mint Address: ${mintKeypair.publicKey}`);
+        console.log(`   Tx Signature: ${sx}`);
   });
 });

tokens/create-spl-token/anchor/tests/token_metadata.json

@@ -1,6 +0,0 @@
-{
-    "name": "Solana Gold",
-    "symbol": "GOLDSOL",
-    "description": "A gold Solana SPL token :)",
-    "image": "https://images.all-free-download.com/images/graphiclarge/solana_coin_sign_icon_shiny_golden_symmetric_geometrical_design_6919941.jpg"
-}