feat: completed spl-token minter

Author: ritikbhatt20

tokens/spl-token-minter/poseidon/spl-token-minter/package.json

@@ -5,16 +5,19 @@
     "lint": "prettier */*.js \"*/**/*{.js,.ts}\" --check"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "^0.30.1"
+    "@coral-xyz/anchor": "^0.30.0",
+    "@solana/web3.js": "^1.95.2"
   },
   "devDependencies": {
-    "chai": "^4.3.4",
-    "mocha": "^9.0.3",
-    "ts-mocha": "^10.0.0",
+    "anchor-bankrun": "^0.4.0",
+    "solana-bankrun": "^0.3.0",
     "@types/bn.js": "^5.1.0",
     "@types/chai": "^4.3.0",
     "@types/mocha": "^9.0.0",
-    "typescript": "^4.3.5",
-    "prettier": "^2.6.2"
+    "chai": "^4.4.1",
+    "mocha": "^9.0.3",
+    "prettier": "^2.6.2",
+    "ts-mocha": "^10.0.0",
+    "typescript": "^4.3.5"
   }
 }

tokens/spl-token-minter/poseidon/spl-token-minter/pnpm-lock.yaml

@@ -14,7 +14,8 @@ cpi = ["no-entrypoint"]
 no-entrypoint = []
 no-idl = []
 no-log-ix-name = []
-idl-build = ["anchor-lang/idl-build"]
+idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]
 
 [dependencies]
-anchor-lang = "0.30.1"
+anchor-lang = { version = "0.30.1", features = ["init-if-needed"] }
+anchor-spl = "0.30.1"

tokens/spl-token-minter/poseidon/spl-token-minter/programs/spl-token-minter/Cargo.toml

@@ -1,16 +1,63 @@
 use anchor_lang::prelude::*;
-
+use anchor_spl::{
+    token::{mint_to, Mint, MintTo, Token, TokenAccount},
+    associated_token::AssociatedToken,
+};
 declare_id!("DmrXSUGWYaqtWg8sbi9JQN48yVZ1y2m7HvWXbND52Mcw");
-
 #[program]
 pub mod spl_token_minter {
     use super::*;
-
-    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
-        msg!("Greetings from: {:?}", ctx.program_id);
+    pub fn create_token_mint(
+        ctx: Context<CreateTokenMintContext>,
+        decimals: u8,
+        freeze_authority: Pubkey,
+    ) -> Result<()> {
+        Ok(())
+    }
+    pub fn mint(ctx: Context<MintContext>, amount: u64) -> Result<()> {
+        let cpi_ctx = CpiContext::new(
+            ctx.accounts.token_program.to_account_info(),
+            MintTo {
+                mint: ctx.accounts.mint_account.to_account_info(),
+                to: ctx.accounts.associated_token_account.to_account_info(),
+                authority: ctx.accounts.mint_authority.to_account_info(),
+            },
+        );
+        mint_to(cpi_ctx, amount)?;
         Ok(())
     }
 }
-
 #[derive(Accounts)]
-pub struct Initialize {}
+#[instruction(decimals: u8)]
+pub struct CreateTokenMintContext<'info> {
+    #[account(mut)]
+    pub mint_authority: Signer<'info>,
+    #[account(
+        init,
+        payer = mint_authority,
+        mint::decimals = decimals,
+        mint::authority = mint_authority.key(),
+    )]
+    pub mint_account: Account<'info, Mint>,
+    pub token_program: Program<'info, Token>,
+    pub system_program: Program<'info, System>,
+}
+#[derive(Accounts)]
+pub struct MintContext<'info> {
+    #[account(mut)]
+    pub mint_account: Account<'info, Mint>,
+    #[account(mut)]
+    pub mint_authority: Signer<'info>,
+    #[account(mut)]
+    pub recipient: SystemAccount<'info>,
+    #[account(
+        init_if_needed,
+        payer = mint_authority,
+        associated_token::mint = mint_account,
+        associated_token::authority = recipient,
+    )]
+    pub associated_token_account: Account<'info, TokenAccount>,
+    pub associated_token_program: Program<'info, AssociatedToken>,
+    pub token_program: Program<'info, Token>,
+    pub system_program: Program<'info, System>,
+}

tokens/spl-token-minter/poseidon/spl-token-minter/programs/spl-token-minter/src/lib.rs

@@ -0,0 +1,78 @@
+import { describe, it } from 'node:test';
+import * as anchor from '@coral-xyz/anchor';
+import { getAccount, getMint } from '@solana/spl-token';
+import { Keypair, PublicKey, SystemProgram } from '@solana/web3.js';
+import { BankrunProvider } from 'anchor-bankrun';
+import { assert } from 'chai';
+import { startAnchor } from 'solana-bankrun';
+import type { SplTokenMinter } from '../target/types/spl_token_minter';
+
+const IDL = require('../target/idl/spl_token_minter.json');
+const PROGRAM_ID = new PublicKey(IDL.address);
+
+describe('Bankrun - SPL Token Minter', async () => {
+  // Start the Bankrun context
+  const context = await startAnchor('', [{ name: 'spl_token_minter', programId: PROGRAM_ID }], []);
+
+  const provider = new BankrunProvider(context);
+  anchor.setProvider(provider);
+  const program = new anchor.Program<SplTokenMinter>(IDL, provider);
+
+  const payer = provider.wallet as anchor.Wallet;
+  let mintAccount: PublicKey;
+  let recipientTokenAccount: PublicKey;
+  const recipient = Keypair.generate();
+
+  it('Creates a new token mint', async () => {
+    const mintAccountKeypair = Keypair.generate();
+    mintAccount = mintAccountKeypair.publicKey;
+
+    const decimals = 9;
+    const freezeAuthority = payer.publicKey;
+
+    const tx = await program.methods
+      .createTokenMint(decimals, freezeAuthority)
+      .accounts({
+        mintAuthority: payer.publicKey,
+        mintAccount: mintAccount,
+      })
+      .signers([payer.payer, mintAccountKeypair])
+      .rpc();
+
+    console.log('Transaction signature for createTokenMint:', tx);
+
+    const mintInfo = await getMint(provider.connection, mintAccount);
+
+    assert.equal(mintInfo.decimals, decimals, 'Mint account decimals should match specified value');
+    assert.equal(mintInfo.mintAuthority?.toBase58(), payer.publicKey.toBase58(), 'Mint authority should be the payer');
+    console.log('Mint created successfully:', mintAccount.toBase58());
+  });
+
+  it('Mints tokens to the associated token account', async () => {
+    const amount = new anchor.BN(1000 * 10 ** 9);
+
+    // Create an associated token account for the recipient
+    recipientTokenAccount = await anchor.utils.token.associatedAddress({
+      mint: mintAccount,
+      owner: recipient.publicKey,
+    });
+
+    const tx = await program.methods
+      .mint(amount)
+      .accounts({
+        mintAccount: mintAccount,
+        mintAuthority: payer.publicKey,
+        recipient: recipient.publicKey,
+      })
+      .signers([payer.payer])
+      .rpc();
+
+    console.log('Transaction signature for mint:', tx);
+
+    const recipientTokenAccountInfo = await getAccount(provider.connection, recipientTokenAccount);
+    const mintedAmount = Number(recipientTokenAccountInfo.amount) / 10 ** 9;
+
+    assert.equal(mintedAmount, 1000, 'Minted token amount does not match');
+    console.log('Recipient Token Account Balance:', mintedAmount);
+  });
+});