일시 정지 가능한 민트

import {
  airdropFactory,
  appendTransactionMessageInstructions,
  assertIsTransactionWithBlockhashLifetime,
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  createTransactionMessage,
  generateKeyPairSigner,
  getSignatureFromTransaction,
  lamports,
  pipe,
  sendAndConfirmTransactionFactory,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  signTransactionMessageWithSigners
} from "@solana/kit";
import { getCreateAccountInstruction } from "@solana-program/system";
import {
  extension,
  fetchMint,
  findAssociatedTokenPda,
  getCreateAssociatedTokenInstructionAsync,
  getInitializeMintInstruction,
  getInitializePausableConfigInstruction,
  getMintSize,
  getMintToInstruction,
  getPauseInstruction,
  getResumeInstruction,
  getTransferCheckedInstruction,
  TOKEN_2022_PROGRAM_ADDRESS
} from "@solana-program/token-2022";

// Create Connection, local validator in this example
const rpc = createSolanaRpc("http://localhost:8899");
const rpcSubscriptions = createSolanaRpcSubscriptions("ws://localhost:8900");

const sendAndConfirm = sendAndConfirmTransactionFactory({
  rpc,
  rpcSubscriptions
});

// Generate the authority (fee payer, mint authority, freeze authority, pause authority)
const authority = await generateKeyPairSigner();

// Fund authority/fee payer
await airdropFactory({ rpc, rpcSubscriptions })({
  recipientAddress: authority.address,
  lamports: lamports(5_000_000_000n), // 5 SOL
  commitment: "confirmed"
});

// ---------- Create mint with Pausable extension ----------

const mint = await generateKeyPairSigner();

// Define the pausable extension for size calculation
const pausableExtension = extension("PausableConfig", {
  authority: authority.address,
  paused: false
});

// Calculate space for mint account with the Pausable extension
const space = BigInt(getMintSize([pausableExtension]));

// Get minimum balance for rent exemption
const rent = await rpc.getMinimumBalanceForRentExemption(space).send();

// Get latest blockhash
const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

// 1) Create the mint account
const createMintAccountInstruction = getCreateAccountInstruction({
  payer: authority,
  newAccount: mint,
  lamports: rent,
  space,
  programAddress: TOKEN_2022_PROGRAM_ADDRESS
});

// 2) Initialize the pausable extension (must come BEFORE initializeMint)
const initializePausableInstruction = getInitializePausableConfigInstruction({
  mint: mint.address,
  authority: authority.address
});

// 3) Initialize the mint
const initializeMintInstruction = getInitializeMintInstruction({
  mint: mint.address,
  decimals: 9,
  mintAuthority: authority.address,
  freezeAuthority: authority.address
});

// 4) Create associated token account for authority
const [authorityAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: authority.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const createAtaInstruction = await getCreateAssociatedTokenInstructionAsync({
  payer: authority,
  mint: mint.address,
  owner: authority.address
});

// 5) Mint 100 tokens (100 * 10^9)
const mintToInstruction = getMintToInstruction({
  mint: mint.address,
  token: authorityAta,
  mintAuthority: authority,
  amount: 100_000_000_000n
});

// 6) Create recipient and their ATA
const recipient = await generateKeyPairSigner();

const [recipientAta] = await findAssociatedTokenPda({
  mint: mint.address,
  owner: recipient.address,
  tokenProgram: TOKEN_2022_PROGRAM_ADDRESS
});

const createRecipientAtaInstruction =
  await getCreateAssociatedTokenInstructionAsync({
    payer: authority,
    mint: mint.address,
    owner: recipient.address
  });

// Send transaction to create mint with pausable extension, ATAs, and mint tokens
const createMintTx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayerSigner(authority, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
  (tx) =>
    appendTransactionMessageInstructions(
      [
        createMintAccountInstruction,
        initializePausableInstruction,
        initializeMintInstruction,
        createAtaInstruction,
        mintToInstruction,
        createRecipientAtaInstruction
      ],
      tx
    )
);

const signedCreateMintTx =
  await signTransactionMessageWithSigners(createMintTx);

assertIsTransactionWithBlockhashLifetime(signedCreateMintTx);
await sendAndConfirm(signedCreateMintTx, {
  commitment: "confirmed",
  skipPreflight: true
});

console.log("Mint created with Pausable extension:", mint.address);

// Read back the pausable config from the mint
let mintAccount = await fetchMint(rpc, mint.address);
console.log("Pausable config:", mintAccount.data.extensions);

// ---------- Pause the mint ----------

const pauseInstruction = getPauseInstruction({
  mint: mint.address,
  authority: authority
});

const { value: latestBlockhash2 } = await rpc.getLatestBlockhash().send();

const pauseTx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayerSigner(authority, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash2, tx),
  (tx) => appendTransactionMessageInstructions([pauseInstruction], tx)
);

const signedPauseTx = await signTransactionMessageWithSigners(pauseTx);

assertIsTransactionWithBlockhashLifetime(signedPauseTx);
await sendAndConfirm(signedPauseTx, {
  commitment: "confirmed"
});

console.log("\nMint is now PAUSED");

// Verify paused state
mintAccount = await fetchMint(rpc, mint.address);
console.log("Pausable config:", mintAccount.data.extensions);

// Try a transfer while paused (should fail)
const transferInstruction = getTransferCheckedInstruction({
  source: authorityAta,
  mint: mint.address,
  destination: recipientAta,
  authority: authority,
  amount: 1_000_000_000n, // 1 token
  decimals: 9
});

const { value: latestBlockhash3 } = await rpc.getLatestBlockhash().send();

const transferWhilePausedTx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayerSigner(authority, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash3, tx),
  (tx) => appendTransactionMessageInstructions([transferInstruction], tx)
);

const signedTransferWhilePausedTx = await signTransactionMessageWithSigners(
  transferWhilePausedTx
);

console.log("\nTransfer Expected to Fail with Error:");
try {
  assertIsTransactionWithBlockhashLifetime(signedTransferWhilePausedTx);
  await sendAndConfirm(signedTransferWhilePausedTx, {
    commitment: "confirmed"
  });
} catch (error: any) {
  console.log(" ", error.message ?? error);
}

// ---------- Resume (unpause) the mint ----------

const resumeInstruction = getResumeInstruction({
  mint: mint.address,
  authority: authority
});

const { value: latestBlockhash4 } = await rpc.getLatestBlockhash().send();

const resumeTx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayerSigner(authority, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash4, tx),
  (tx) => appendTransactionMessageInstructions([resumeInstruction], tx)
);

const signedResumeTx = await signTransactionMessageWithSigners(resumeTx);

assertIsTransactionWithBlockhashLifetime(signedResumeTx);
await sendAndConfirm(signedResumeTx, {
  commitment: "confirmed"
});

console.log("\nMint is now RESUMED");

// Verify resumed state
mintAccount = await fetchMint(rpc, mint.address);
console.log("Pausable config:", mintAccount.data.extensions);

// Transfer should now succeed after resume
const { value: latestBlockhash5 } = await rpc.getLatestBlockhash().send();

const transferAfterResumeTx = pipe(
  createTransactionMessage({ version: 0 }),
  (tx) => setTransactionMessageFeePayerSigner(authority, tx),
  (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash5, tx),
  (tx) => appendTransactionMessageInstructions([transferInstruction], tx)
);

const signedTransferAfterResumeTx = await signTransactionMessageWithSigners(
  transferAfterResumeTx
);

assertIsTransactionWithBlockhashLifetime(signedTransferAfterResumeTx);
await sendAndConfirm(signedTransferAfterResumeTx, {
  commitment: "confirmed"
});

const transferSig = getSignatureFromTransaction(signedTransferAfterResumeTx);
console.log("\nTransfer after resume succeeded!");
console.log("Transaction Signature:", transferSig);