import {
  createInitializeMintInstruction,
  createInitializeTransferFeeConfigInstruction,
  createInitializeMetadataPointerInstruction,
  ExtensionType,
  getMintLen,
  TOKEN_2022_PROGRAM_ID,
} from '@solana/spl-token';
import {
  Connection,
  Keypair,
  SystemProgram,
  Transaction,
} from '@solana/web3.js';

async function createToken2022WithExtensions(
  connection: Connection,
  payer: Keypair,
  mintAuthority: PublicKey,
  extensions: ExtensionType[]
): Promise<PublicKey> {
  const mintKeypair = Keypair.generate();

  // Calculate required space
  const mintLen = getMintLen(extensions);

  // Get rent
  const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);

  const transaction = new Transaction();

  // Create account
  transaction.add(
    SystemProgram.createAccount({
      fromPubkey: payer.publicKey,
      newAccountPubkey: mintKeypair.publicKey,
      space: mintLen,
      lamports,
      programId: TOKEN_2022_PROGRAM_ID,
    })
  );

  // Initialize extensions (order matters!)
  // Extensions must be initialized BEFORE InitializeMint

  // ... add extension init instructions here ...

  // Initialize mint (must be last)
  transaction.add(
    createInitializeMintInstruction(
      mintKeypair.publicKey,
      6, // decimals
      mintAuthority,
      null, // freeze authority
      TOKEN_2022_PROGRAM_ID
    )
  );

  await sendAndConfirmTransaction(connection, transaction, [payer, mintKeypair]);

  return mintKeypair.publicKey;
}

import {
  createInitializeTransferFeeConfigInstruction,
  createSetTransferFeeInstruction,
  harvestWithheldTokensToMint,
  withdrawWithheldTokensFromMint,
} from '@solana/spl-token';

// Initialize transfer fee (during mint creation)
const transferFeeConfig = createInitializeTransferFeeConfigInstruction(
  mintKeypair.publicKey,
  transferFeeConfigAuthority, // Can update fee
  withdrawWithheldAuthority,   // Can withdraw collected fees
  feeBasisPoints,              // e.g., 100 = 1%
  maxFee,                      // Maximum fee in token base units
  TOKEN_2022_PROGRAM_ID
);

// Fee collection flow:
// 1. Fees accumulate in recipient token accounts (withheld)
// 2. Harvest: Move withheld fees to mint
// 3. Withdraw: Move from mint to treasury

// Harvest fees from all accounts
await harvestWithheldTokensToMint(
  connection,
  payer,
  mint,
  tokenAccounts, // Accounts with withheld fees
);

// Withdraw to treasury
await withdrawWithheldTokensFromMint(
  connection,
  payer,
  mint,
  treasuryAccount,
  withdrawAuthority,
);

fee = min(transferAmount * feeBasisPoints / 10000, maxFee)

Example: 1% fee with 1M max fee
- Transfer 1,000 tokens → Fee: 10 tokens
- Transfer 1B tokens → Fee: 1M tokens (capped)

import { createInitializePermanentDelegateInstruction } from '@solana/spl-token';

// Initialize during mint creation
const permanentDelegateIx = createInitializePermanentDelegateInstruction(
  mintKeypair.publicKey,
  delegateAuthority, // WARNING: This address can take tokens from anyone
  TOKEN_2022_PROGRAM_ID
);

// Use cases:
// - Reclaiming tokens from lost wallets
// - Compliance/clawback requirements
// - Subscription models (auto-debit)

// WARNING: This is powerful and scary to users
// Clearly disclose this capability

import {
  createInitializeMetadataPointerInstruction,
  createInitializeInstruction as createInitializeMetadataInstruction,
  createUpdateFieldInstruction,
  pack,
  TokenMetadata,
} from '@solana/spl-token-metadata';

// Point metadata to the mint itself (self-referential)
const metadataPointerIx = createInitializeMetadataPointerInstruction(
  mintKeypair.publicKey,
  updateAuthority,
  mintKeypair.publicKey, // Metadata stored on mint account
  TOKEN_2022_PROGRAM_ID
);

// Initialize metadata
const metadata: TokenMetadata = {
  mint: mintKeypair.publicKey,
  name: 'My Token',
  symbol: 'MTK',
  uri: 'https://example.com/metadata.json',
  additionalMetadata: [
    ['website', 'https://mytoken.com'],
    ['twitter', '@mytoken'],
  ],
};

const initMetadataIx = createInitializeMetadataInstruction({
  programId: TOKEN_2022_PROGRAM_ID,
  mint: mintKeypair.publicKey,
  metadata: mintKeypair.publicKey,
  name: metadata.name,
  symbol: metadata.symbol,
  uri: metadata.uri,
  mintAuthority: mintAuthority,
  updateAuthority: updateAuthority,
});

import { ExtensionType, createInitializeNonTransferableMintInstruction } from '@solana/spl-token';

// Add to extensions array
const extensions = [ExtensionType.NonTransferable];

// Initialize during mint creation
const nonTransferableIx = createInitializeNonTransferableMintInstruction(
  mintKeypair.publicKey,
  TOKEN_2022_PROGRAM_ID
);

// These tokens:
// - Cannot be transferred between wallets
// - Can still be burned
// - Can be minted to any wallet
// Use case: Credentials, achievements, membership

import { createInitializeTransferHookInstruction } from '@solana/spl-token';

// Initialize hook (points to your program)
const transferHookIx = createInitializeTransferHookInstruction(
  mintKeypair.publicKey,
  hookAuthority,
  hookProgramId, // Your custom program
  TOKEN_2022_PROGRAM_ID
);

// Your hook program must implement:
// - Execute: Called on every transfer
// - Must not fail (or transfer fails)

// Use cases:
// - Allowlist/blocklist enforcement
// - Dynamic fee calculation
// - Transfer logging
// - Royalty enforcement

// Check DEX compatibility before launch
const DEX_SUPPORT = {
  jupiter: {
    transferFee: true,
    permanentDelegate: false, // Users scared
    metadataPointer: true,
    nonTransferable: false,
    transferHook: 'limited', // Some hooks
    confidentialTransfers: false,
  },
  raydium: {
    transferFee: true,
    // Check current status: https://docs.raydium.io
  },
  orca: {
    // Token-2022 support in progress
  },
};

// Always verify current support before launch

undefined

undefined

undefined

undefined

import {
  createInitializeTransferFeeConfigInstruction,
  createInitializeMintInstruction,
  createInitializeMetadataPointerInstruction,
  ExtensionType,
  getMintLen,
  TOKEN_2022_PROGRAM_ID,
} from '@solana/spl-token';

async function createFeeToken(
  connection: Connection,
  payer: Keypair,
  treasury: PublicKey
) {
  const mint = Keypair.generate();

  // Extensions needed
  const extensions = [
    ExtensionType.TransferFeeConfig,
    ExtensionType.MetadataPointer,
  ];

  const mintLen = getMintLen(extensions);
  const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);

  const tx = new Transaction();

  // 1. Create account
  tx.add(
    SystemProgram.createAccount({
      fromPubkey: payer.publicKey,
      newAccountPubkey: mint.publicKey,
      space: mintLen,
      lamports,
      programId: TOKEN_2022_PROGRAM_ID,
    })
  );

  // 2. Initialize transfer fee (1% = 100 basis points)
  tx.add(
    createInitializeTransferFeeConfigInstruction(
      mint.publicKey,
      payer.publicKey, // Fee authority
      treasury,        // Withdraw authority
      100,             // 1% fee
      BigInt(1_000_000_000), // Max 1B tokens fee
      TOKEN_2022_PROGRAM_ID
    )
  );

  // 3. Initialize metadata pointer
  tx.add(
    createInitializeMetadataPointerInstruction(
      mint.publicKey,
      payer.publicKey,
      mint.publicKey,
      TOKEN_2022_PROGRAM_ID
    )
  );

  // 4. Initialize mint (LAST)
  tx.add(
    createInitializeMintInstruction(
      mint.publicKey,
      6,
      payer.publicKey,
      null,
      TOKEN_2022_PROGRAM_ID
    )
  );

  await sendAndConfirmTransaction(connection, tx, [payer, mint]);

  console.log('Token created:', mint.publicKey.toBase58());
  console.log('Fee: 1% per transfer');
  console.log('Treasury can withdraw fees:', treasury.toBase58());
}

// WARNING: Permanent delegate is powerful
// Users must clearly understand and consent

async function createSubscriptionToken(
  connection: Connection,
  payer: Keypair,
  subscriptionManager: PublicKey // Authority that can debit
) {
  const mint = Keypair.generate();

  const extensions = [
    ExtensionType.PermanentDelegate,
    ExtensionType.MetadataPointer,
  ];

  const mintLen = getMintLen(extensions);
  const lamports = await connection.getMinimumBalanceForRentExemption(mintLen);

  const tx = new Transaction();

  tx.add(
    SystemProgram.createAccount({
      fromPubkey: payer.publicKey,
      newAccountPubkey: mint.publicKey,
      space: mintLen,
      lamports,
      programId: TOKEN_2022_PROGRAM_ID,
    })
  );

  // Permanent delegate - subscription manager can debit
  tx.add(
    createInitializePermanentDelegateInstruction(
      mint.publicKey,
      subscriptionManager, // Can transfer from ANY holder
      TOKEN_2022_PROGRAM_ID
    )
  );

  // Metadata for clarity
  tx.add(
    createInitializeMetadataPointerInstruction(
      mint.publicKey,
      payer.publicKey,
      mint.publicKey,
      TOKEN_2022_PROGRAM_ID
    )
  );

  tx.add(
    createInitializeMintInstruction(
      mint.publicKey,
      6,
      payer.publicKey,
      null,
      TOKEN_2022_PROGRAM_ID
    )
  );

  await sendAndConfirmTransaction(connection, tx, [payer, mint]);

  // REQUIRED DISCLOSURE:
  console.log(`
  ⚠️ SUBSCRIPTION TOKEN CREATED

  This token has PERMANENT DELEGATE enabled.
  The subscription manager (${subscriptionManager.toBase58()})
  can transfer tokens FROM any holder's wallet.

  Use case: Auto-debiting subscription payments

  USERS MUST BE CLEARLY INFORMED before receiving this token.
  `);
}