drop original "mint-2" dir

tokens/README.md

@@ -1,28 +0,0 @@
-### :warning: All token examples are on devnet!
-
-`https://api.devnet.solana.com/`
-
-### About Tokens
-
-Tokens on Solana are - like everything else on Solana - accounts! They:
-- are owned by the Token Program
-- can only be changed by the Token Program
-- have an associated Mint Authority - the only account that can mint new tokens (by calling the Token program)
-
-How they work:   
-- :apple: `Mint Account` - stores information about the token.
-- :handbag: `Associated Token Account` - stores a specific balance of the Mint Account (this is essentially a counter).
-
-> You can read all about tokens in [Solana's official SPL Token documentation](https://spl.solana.com/token).
-
-### This Folder
-
-All examples in this folder demonstrate the following:
-- How to create a new token mint.
-- How to mint some amount of this token to a wallet.
-- How to transfer this token to a wallet.   
-
-Each example differs in a few key aspects:
-- `mint-1` - The **Mint** and the **Mint Authority** are generated keypairs.
-- `mint-2` - The **Mint** is a generated keypair. The **Mint Authority** is a Program Derived Address (PDA).
-- `mint-3` - The **Mint** and the **Mint Authority** are Program Derived Addresses (PDAs).

tokens/mint-2/README.md

@@ -1,11 +0,0 @@
-# Minting an SPL Token to a Wallet
-
-This example demonstrates how to mint an SPl Token to a Solana users's wallet.
-
-### :key: Keys:
-
-- The person requesting the mint must have an **associated token account** for that mint. We create this token account in the program!
-- Steps:
-    1. Create an associated token account for the Mint.
-    2. Initialize that associated token account.
-    3. Mint some amount of the Mint to the new token account.

tokens/mint-2/anchor/Anchor.toml

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

tokens/mint-2/anchor/Cargo.toml

@@ -1,13 +0,0 @@
-[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/mint-2/anchor/package.json

@@ -1,14 +0,0 @@
-{
-    "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/mint-2/anchor/programs/mint-2/Cargo.toml

@@ -1,21 +0,0 @@
-[package]
-name = "mint-2"
-version = "0.1.0"
-description = "Created with Anchor"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib", "lib"]
-name = "mint_2"
-
-[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/mint-2/anchor/programs/mint-2/Xargo.toml

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

tokens/mint-2/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/mint-2/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/mint-2/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/mint-2/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/mint-2/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/mint-2/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/mint-2/anchor/tests/test.ts

@@ -1,175 +0,0 @@
-import * as anchor from "@project-serum/anchor";
-import { Mint2 } from "../target/types/mint_2";
-
-
-const TOKEN_METADATA_PROGRAM_ID = new anchor.web3.PublicKey(
-  "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
-);
-
-
-describe("mint-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 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 mintKeypair: anchor.web3.Keypair = anchor.web3.Keypair.generate();
-  console.log(`New token: ${mintKeypair.publicKey}`);
-
-  it("Create the mint", 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];
-
-    await program.methods.createTokenMint(
-      testTokenTitle, testTokenSymbol, testTokenUri, mintAuthorityPdaBump
-    )
-    .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();
-  });
-});

tokens/mint-2/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"
-}

tokens/mint-2/anchor/tsconfig.json

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

tokens/mint-2/native/cicd.sh

@@ -1,8 +0,0 @@
-#!/bin/bash
-
-# This script is for quick building & deploying of the program.
-# It also serves as a reference for the commands used for building & deploying Solana programs.
-# Run this bad boy with "bash cicd.sh" or "./cicd.sh"
-
-cargo build-bpf --manifest-path=./program/Cargo.toml --bpf-out-dir=./program/target/so
-solana program deploy ./program/target/so/program.so

tokens/mint-2/native/package.json

@@ -1,21 +0,0 @@
-{
-  "scripts": {
-    "test": "yarn run ts-mocha -p ./tsconfig.json -t 1000000 ./tests/test.ts"
-  },
-  "dependencies": {
-    "@solana/spl-token": "^0.2.0",
-    "@solana/web3.js": "^1.47.3",
-    "borsh": "^0.7.0",
-    "buffer": "^6.0.3",
-    "fs": "^0.0.1-security"
-  },
-  "devDependencies": {
-    "@types/bn.js": "^5.1.0",
-    "@types/chai": "^4.3.1",
-    "@types/mocha": "^9.1.1",
-    "chai": "^4.3.4",
-    "mocha": "^9.0.3",
-    "ts-mocha": "^10.0.0",
-    "typescript": "^4.3.5"
-  }
-}

tokens/mint-2/native/program/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "program"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-borsh = "0.9.3"
-borsh-derive = "0.9.1"
-solana-program = "1.10.26"
-spl-token = { version="3.3.0", features = [ "no-entrypoint" ] }
-spl-associated-token-account = { version="1.0.5", features = [ "no-entrypoint" ] }
-mpl-token-metadata = { version="1.2.5", features = [ "no-entrypoint" ] }
-
-[lib]
-crate-type = ["cdylib", "lib"]

tokens/mint-2/native/program/src/instructions/create_token_mint.rs

@@ -1,150 +0,0 @@
-use {
-    solana_program::{
-        account_info::{next_account_info, AccountInfo}, 
-        entrypoint::ProgramResult, 
-        msg, 
-        program::invoke_signed,
-        program_pack::Pack,
-        pubkey::Pubkey,
-        rent::Rent,
-        system_instruction,
-        sysvar::Sysvar,
-    },
-    spl_token::{
-        instruction as token_instruction,
-        state::Mint,
-    },
-    mpl_token_metadata::{
-        instruction as mpl_instruction,
-    },
-};
-
-
-pub fn create_token_mint(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    token_title: String,
-    token_symbol: String,
-    token_uri: String,
-    mint_authority_pda_bump: u8,
-) -> ProgramResult {
-
-    let accounts_iter = &mut accounts.iter();
-
-    let mint_account = next_account_info(accounts_iter)?;
-    let mint_authority = next_account_info(accounts_iter)?;
-    let metadata_account = next_account_info(accounts_iter)?;
-    let payer = next_account_info(accounts_iter)?;
-    let rent = next_account_info(accounts_iter)?;
-    let system_program = next_account_info(accounts_iter)?;
-    let token_program = next_account_info(accounts_iter)?;
-    let token_metadata_program = next_account_info(accounts_iter)?;
-
-    msg!("Creating mint authority...");
-    msg!("Mint Authority: {}", mint_authority.key);
-    invoke_signed(
-        &system_instruction::create_account(
-            &payer.key,
-            &mint_authority.key,
-            (Rent::get()?).minimum_balance(8) as u64,
-            8,
-            &program_id,
-        ),
-        &[
-            payer.clone(),
-            mint_authority.clone(),
-            system_program.clone(),
-        ],
-        &[&[
-            b"mint_authority_", 
-            mint_account.key.as_ref(),
-            &[mint_authority_pda_bump],
-        ]]
-    )?;
-    
-    msg!("Creating mint account...");
-    msg!("Mint: {}", mint_account.key);
-    invoke_signed(
-        &system_instruction::create_account(
-            &payer.key,
-            &mint_account.key,
-            (Rent::get()?).minimum_balance(Mint::LEN),
-            Mint::LEN as u64,
-            &token_program.key,
-        ),
-        &[
-            mint_account.clone(),
-            payer.clone(),
-            token_program.clone(),
-        ],
-        &[&[
-            b"mint_authority_", 
-            mint_account.key.as_ref(),
-            &[mint_authority_pda_bump],
-        ]]
-    )?;
-
-    msg!("Initializing mint account...");
-    msg!("Mint: {}", mint_account.key);
-    invoke_signed(
-        &token_instruction::initialize_mint(
-            &token_program.key,
-            &mint_account.key,
-            &mint_authority.key,
-            Some(&mint_authority.key),
-            9,
-        )?,
-        &[
-            mint_account.clone(),
-            mint_authority.clone(),
-            token_program.clone(),
-            rent.clone(),
-        ],
-        &[&[
-            b"mint_authority_", 
-            mint_account.key.as_ref(),
-            &[mint_authority_pda_bump],
-        ]]
-    )?;
-
-    msg!("Creating metadata account...");
-    msg!("Metadata account address: {}", metadata_account.key);
-    invoke_signed(
-        &mpl_instruction::create_metadata_accounts_v2(
-            *token_metadata_program.key,
-            *metadata_account.key,
-            *mint_account.key,
-            *mint_authority.key,
-            *payer.key,
-            *mint_authority.key,
-            token_title,
-            token_symbol,
-            token_uri,
-            None,
-            0,
-            true,
-            false,
-            None,
-            None,
-        ),
-        &[
-            metadata_account.clone(),
-            mint_account.clone(),
-            mint_authority.clone(),
-            payer.clone(),
-            token_metadata_program.clone(),
-            rent.clone(),
-        ],
-        &[&[
-            b"mint_authority_", 
-            mint_account.key.as_ref(),
-            &[mint_authority_pda_bump],
-        ]]
-    )?;
-
-    msg!("Token mint created successfully.");
-
-    Ok(())
-}
-
-pub struct MintAuthority {}

tokens/mint-2/native/program/src/instructions/mint_to_wallet.rs

@@ -1,83 +0,0 @@
-use {
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult, 
-        msg, 
-        program::{invoke, invoke_signed},
-        pubkey::Pubkey,
-    },
-    spl_token::{
-        instruction as token_instruction,
-    },
-    spl_associated_token_account::{
-        instruction as token_account_instruction,
-    },
-};
-
-
-pub fn mint_to_wallet(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    amount: u64,
-    mint_authority_pda_bump: u8,
-) -> ProgramResult {
-
-    let accounts_iter = &mut accounts.iter();
-
-    let mint_account = next_account_info(accounts_iter)?;
-    let mint_authority = next_account_info(accounts_iter)?;
-    let token_account = next_account_info(accounts_iter)?;
-    let payer = next_account_info(accounts_iter)?;
-    let rent = next_account_info(accounts_iter)?;
-    let _system_program = next_account_info(accounts_iter)?;
-    let token_program = next_account_info(accounts_iter)?;
-    let associated_token_program = next_account_info(accounts_iter)?;
-
-    msg!("Creating token account...");
-    msg!("Token Address: {}", token_account.key);    
-    invoke(
-        &token_account_instruction::create_associated_token_account(
-            &payer.key,
-            &payer.key,
-            &mint_account.key,
-        ),
-        &[
-            mint_account.clone(),
-            token_account.clone(),
-            payer.clone(),
-            token_program.clone(),
-            associated_token_program.clone(),
-        ]
-    )?;
-
-    msg!("Minting {} tokens to token account...", amount);
-    msg!("Mint: {}", mint_account.key);   
-    msg!("Token Address: {}", token_account.key);
-    invoke_signed(
-        &token_instruction::mint_to(
-            &token_program.key,
-            &mint_account.key,
-            &token_account.key,
-            &mint_authority.key,
-            &[&mint_authority.key],
-            amount,
-        )?,
-        &[
-            mint_account.clone(),
-            mint_authority.clone(),
-            token_account.clone(),
-            token_program.clone(),
-            rent.clone(),
-        ],
-        &[&[
-            b"mint_authority_", 
-            mint_account.key.as_ref(),
-            &[mint_authority_pda_bump],
-        ]]
-    )?;
-
-    msg!("Tokens minted to wallet successfully.");
-
-    Ok(())
-}
-

tokens/mint-2/native/program/src/instructions/mod.rs

@@ -1,3 +0,0 @@
-pub mod create_token_mint;
-pub mod mint_to_wallet;
-pub mod transfer_to_wallet;

tokens/mint-2/native/program/src/instructions/transfer_to_wallet.rs

@@ -1,81 +0,0 @@
-use {
-    solana_program::{
-        account_info::{next_account_info, AccountInfo},
-        entrypoint::ProgramResult, 
-        msg, 
-        program::invoke,
-        pubkey::Pubkey,
-    },
-    spl_token::{
-        instruction as token_instruction,
-    },
-    spl_associated_token_account::{
-        instruction as token_account_instruction,
-    },
-};
-
-
-pub fn transfer_to_wallet(
-    _program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    amount: u64,
-) -> ProgramResult {
-
-    let accounts_iter = &mut accounts.iter();
-
-    let mint_account = next_account_info(accounts_iter)?;
-    let owner_token_account = next_account_info(accounts_iter)?;
-    let recipient_token_account = next_account_info(accounts_iter)?;
-    let owner = next_account_info(accounts_iter)?;
-    let recipient = next_account_info(accounts_iter)?;
-    let _system_program = next_account_info(accounts_iter)?;
-    let token_program = next_account_info(accounts_iter)?;
-    let associated_token_program = next_account_info(accounts_iter)?;
-
-    msg!("Creating token account for recipient...");
-    msg!("Recipient Token Address: {}", recipient_token_account.key); 
-    let create_recipient_token_account_ix = &token_account_instruction::create_associated_token_account(
-        &recipient.key,
-        &recipient.key,
-        &mint_account.key,
-    );
-    let create_recipient_token_account_accts = &[
-        mint_account.clone(),
-        recipient_token_account.clone(),
-        recipient.clone(),
-        token_program.clone(),
-        associated_token_program.clone(),
-    ];
-    match invoke(create_recipient_token_account_ix, create_recipient_token_account_accts) {
-        Ok(_) => msg!("Recipient token account created successfully."),
-        Err(_) => msg!("Recipient token account exists! Using..."),
-    }
-
-    msg!("Minting {} tokens to token account...", amount);
-    msg!("Mint: {}", mint_account.key);   
-    msg!("Owner Token Address: {}", owner_token_account.key);
-    msg!("Recipient Token Address: {}", recipient_token_account.key);
-    invoke(
-        &token_instruction::transfer(
-            &token_program.key,
-            &owner_token_account.key,
-            &recipient_token_account.key,
-            &owner.key,
-            &[&owner.key, &recipient.key],
-            amount,
-        )?,
-        &[
-            mint_account.clone(),
-            owner_token_account.clone(),
-            recipient_token_account.clone(),
-            owner.clone(),
-            recipient.clone(),
-            token_program.clone(),
-        ]
-    )?;
-
-    msg!("Tokens transferred to wallet successfully.");
-
-    Ok(())
-}
-

tokens/mint-2/native/program/src/lib.rs

@@ -1,23 +0,0 @@
-use solana_program::{
-    account_info::AccountInfo, 
-    entrypoint, 
-    entrypoint::ProgramResult, 
-    pubkey::Pubkey,
-};
-
-pub mod processor;
-pub mod instructions;
-pub mod state;
-
-
-entrypoint!(process_instruction);
-
-
-fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-
-    processor::process_instruction(program_id, accounts, instruction_data)
-}

tokens/mint-2/native/program/src/processor.rs

@@ -1,53 +0,0 @@
-use {
-    borsh::BorshDeserialize,
-    solana_program::{
-        account_info::AccountInfo, 
-        entrypoint::ProgramResult, 
-        program_error::ProgramError, 
-        pubkey::Pubkey,
-    },
-};
-
-use crate::instructions::{ create_token_mint, mint_to_wallet, transfer_to_wallet };
-use crate::state::mint_state::{ TokenMetadata, MintTokensTo, TransferTokensTo };
-
-
-pub fn process_instruction(
-    program_id: &Pubkey,
-    accounts: &[AccountInfo],
-    instruction_data: &[u8],
-) -> ProgramResult {
-
-    match TokenMetadata::try_from_slice(instruction_data) {
-        Ok(token_metadata_instruction) => return create_token_mint::create_token_mint(
-            program_id,
-            accounts,
-            token_metadata_instruction.title,
-            token_metadata_instruction.symbol,
-            token_metadata_instruction.uri,
-            token_metadata_instruction.mint_authority_pda_bump,
-        ),
-        Err(_) => {},
-    };
-
-    match MintTokensTo::try_from_slice(instruction_data) {
-        Ok(mint_to_wallet_instruction) => return mint_to_wallet::mint_to_wallet(
-            program_id,
-            accounts,
-            mint_to_wallet_instruction.amount,
-            mint_to_wallet_instruction.mint_authority_pda_bump,
-        ),
-        Err(_) => {},
-    };
-
-    match TransferTokensTo::try_from_slice(instruction_data) {
-        Ok(transfer_to_wallet_instruction) => return transfer_to_wallet::transfer_to_wallet(
-            program_id,
-            accounts,
-            transfer_to_wallet_instruction.amount,
-        ),
-        Err(_) => {},
-    };
-
-    Err(ProgramError::InvalidInstructionData)
-}

tokens/mint-2/native/program/src/state/mint_state.rs

@@ -1,21 +0,0 @@
-use borsh::{ BorshSerialize, BorshDeserialize };
-
-
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
-pub struct TokenMetadata {
-    pub title: String,
-    pub symbol: String,
-    pub uri: String,
-    pub mint_authority_pda_bump: u8,
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
-pub struct MintTokensTo {
-    pub amount: u64,
-    pub mint_authority_pda_bump: u8,
-}
-
-#[derive(BorshSerialize, BorshDeserialize, Debug)]
-pub struct TransferTokensTo {
-    pub amount: u64,
-}

tokens/mint-2/native/program/src/state/mod.rs

@@ -1 +0,0 @@
-pub mod mint_state;

tokens/mint-2/native/tests/test.ts

@@ -1,240 +0,0 @@
-import {
-    Connection,
-    Keypair,
-    PublicKey,
-    SystemProgram,
-    SYSVAR_RENT_PUBKEY,
-    TransactionInstruction,
-    Transaction,
-    sendAndConfirmTransaction,
-    LAMPORTS_PER_SOL,
-} from '@solana/web3.js';
-import {
-    ASSOCIATED_TOKEN_PROGRAM_ID,
-    getAssociatedTokenAddress,
-    TOKEN_PROGRAM_ID,
-} from '@solana/spl-token';
-import * as borsh from "borsh";
-import { Buffer } from "buffer";
-
-
-const TOKEN_METADATA_PROGRAM_ID = new PublicKey(
-    "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
-);
-
-
-function createKeypairFromFile(path: string): Keypair {
-    return Keypair.fromSecretKey(
-        Buffer.from(JSON.parse(require('fs').readFileSync(path, "utf-8")))
-    )
-};
-
-
-class Assignable {
-    constructor(properties) {
-        Object.keys(properties).map((key) => {
-            return (this[key] = properties[key]);
-        });
-    };
-};
-
-class TokenMetadata extends Assignable {
-    toBuffer() {
-        return Buffer.from(borsh.serialize(TokenMetadataSchema, this));
-    }
-};
-const TokenMetadataSchema = new Map([
-    [
-        TokenMetadata, {
-            kind: 'struct',
-            fields: [
-                ['title', 'string'],
-                ['symbol', 'string'],
-                ['uri', 'string'],
-                ['mint_authority_pda_bump', 'u8'],
-            ]
-        }
-    ]
-]);
-
-class MintTokensTo extends Assignable {
-    toBuffer() {
-        return Buffer.from(borsh.serialize(MintTokensToSchema, this));
-    }
-};
-const MintTokensToSchema = new Map([
-    [
-        MintTokensTo, {
-            kind: 'struct',
-            fields: [
-                ['amount', 'u64'],
-                ['mint_authority_pda_bump', 'u8'],
-            ]
-        }
-    ]
-]);
-
-class TransferTokensTo extends Assignable {
-    toBuffer() {
-        return Buffer.from(borsh.serialize(TransferTokensToSchema, this));
-    }
-};
-const TransferTokensToSchema = new Map([
-    [
-        TransferTokensTo, {
-            kind: 'struct',
-            fields: [
-                ['amount', 'u64'],
-            ]
-        }
-    ]
-]);
-
-
-describe("mint-token", async () => {
-
-    const connection = new Connection(`http://api.devnet.solana.com/`, 'confirmed');
-    const payer = createKeypairFromFile(require('os').homedir() + '/.config/solana/id.json');
-    const program = createKeypairFromFile('./program/target/so/program-keypair.json');
-
-    const mintKeypair: Keypair = Keypair.generate();
-    console.log(`New token: ${mintKeypair.publicKey}`);
-
-    it("Mint!", async () => {
-
-        const [mintAuthorityPda, mintAuthorityPdaBump] = await PublicKey.findProgramAddress(
-            [
-              Buffer.from("mint_authority_"),
-              mintKeypair.publicKey.toBuffer(),
-            ],
-            program.publicKey,
-        );
-
-        const metadataAddress = (await PublicKey.findProgramAddress(
-            [
-              Buffer.from("metadata"),
-              TOKEN_METADATA_PROGRAM_ID.toBuffer(),
-              mintKeypair.publicKey.toBuffer(),
-            ],
-            TOKEN_METADATA_PROGRAM_ID
-        ))[0];
-        
-        const metadataInstructionData = new TokenMetadata({
-            title: "Solana Gold",
-            symbol: "GOLDSOL",
-            uri: "https://raw.githubusercontent.com/solana-developers/program-examples/main/tokens/mint-2/native/tests/token_metadata.json",
-            mint_authority_pda_bump: mintAuthorityPdaBump
-        });
-
-        let ix = new TransactionInstruction({
-            keys: [
-                { pubkey: mintKeypair.publicKey, isSigner: true, isWritable: true },            // Mint account
-                { pubkey: mintAuthorityPda, isSigner: false, isWritable: true },                // Mint authority account
-                { pubkey: metadataAddress, isSigner: false, isWritable: true },                 // Metadata account
-                { pubkey: payer.publicKey, isSigner: true, isWritable: true },                  // Payer
-                { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },             // Rent account
-                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },        // System program
-                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },               // Token program
-                { pubkey: TOKEN_METADATA_PROGRAM_ID, isSigner: false, isWritable: false },      // Token metadata program
-            ],
-            programId: program.publicKey,
-            data: metadataInstructionData.toBuffer(),
-        });
-
-        await sendAndConfirmTransaction(
-            connection, 
-            new Transaction().add(ix),
-            [payer, mintKeypair]
-        );
-    });
-
-
-    it("Mint to a wallet!", async () => {
-
-        const [mintAuthorityPda, mintAuthorityPdaBump] = await PublicKey.findProgramAddress(
-            [
-              Buffer.from("mint_authority_"),
-              mintKeypair.publicKey.toBuffer(),
-            ],
-            program.publicKey,
-        );
-
-        const tokenAddress = await getAssociatedTokenAddress(
-            mintKeypair.publicKey,
-            payer.publicKey
-        );
-        console.log(`Token Address: ${tokenAddress}`);
-
-        const mintToInstructionData = new MintTokensTo({
-            amount: 1,
-            mint_authority_pda_bump: mintAuthorityPdaBump,
-        });
-
-        let ix = new TransactionInstruction({
-            keys: [
-                { pubkey: mintKeypair.publicKey, isSigner: false, isWritable: true },           // Mint account
-                { pubkey: mintAuthorityPda, isSigner: false, isWritable: false },               // Mint authority account
-                { pubkey: tokenAddress, isSigner: false, isWritable: true },                    // Token account
-                { pubkey: payer.publicKey, isSigner: true, isWritable: true },                  // Payer
-                { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },             // Rent account
-                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },        // System program
-                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },               // Token program
-                { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },    // Associated token program
-            ],
-            programId: program.publicKey,
-            data: mintToInstructionData.toBuffer(),
-        });
-
-        await sendAndConfirmTransaction(
-            connection, 
-            new Transaction().add(ix),
-            [payer]
-        );
-    });
-
-    it("Transfer to a wallet!", async () => {
-
-        const recipientWallet = Keypair.generate();
-        await connection.confirmTransaction(
-            await connection.requestAirdrop(recipientWallet.publicKey, 2 * LAMPORTS_PER_SOL)
-        );
-        console.log(`Recipient Pubkey: ${recipientWallet.publicKey}`);
-
-        const ownerTokenAddress = await getAssociatedTokenAddress(
-            mintKeypair.publicKey,
-            payer.publicKey
-        );
-        console.log(`Owner Token Address: ${ownerTokenAddress}`);
-        const recipientTokenAddress = await getAssociatedTokenAddress(
-            mintKeypair.publicKey,
-            recipientWallet.publicKey
-        );
-        console.log(`Recipient Token Address: ${recipientTokenAddress}`);
-
-        const transferToInstructionData = new TransferTokensTo({
-            amount: 1,
-        });
-
-        let ix = new TransactionInstruction({
-            keys: [
-                { pubkey: mintKeypair.publicKey, isSigner: false, isWritable: true },           // Mint account
-                { pubkey: ownerTokenAddress, isSigner: false, isWritable: true },               // Owner Token account
-                { pubkey: recipientTokenAddress, isSigner: false, isWritable: true },           // Recipient Token account
-                { pubkey: payer.publicKey, isSigner: true, isWritable: true },                  // Owner
-                { pubkey: recipientWallet.publicKey, isSigner: true, isWritable: true },        // Recipient
-                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },        // System program
-                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },               // Token program
-                { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },    // Associated token program
-            ],
-            programId: program.publicKey,
-            data: transferToInstructionData.toBuffer(),
-        });
-
-        await sendAndConfirmTransaction(
-            connection, 
-            new Transaction().add(ix),
-            [payer, recipientWallet]
-        );
-    });
-  });
-  

tokens/mint-2/native/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"
-}

tokens/mint-2/native/tsconfig.json

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