Interact with Solana Programs

import { useParaSolanaKit } from './hooks/useParaSolanaKit';
import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
import {
  createTransactionMessage,
  setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstructions,
  signTransactionMessageWithSigners,
  pipe,
} from '@solana/kit';
import { Buffer } from 'buffer';

function InteractWithProgram() {
  const { rpc, signer } = useParaSolanaKit();
  
  const callProgram = async () => {
    if (!signer) {
      console.error("No signer available. Connect wallet first.");
      return;
    }
    
    const programId = new PublicKey("YOUR_PROGRAM_ID");
    
    // Example: Initialize account with custom data
    const [pda] = PublicKey.findProgramAddressSync(
      [Buffer.from("seed"), signer.publicKey.toBuffer()],
      programId
    );
    
    // Create instruction data (program-specific)
    const instructionData = Buffer.alloc(9);
    instructionData.writeUInt8(0, 0); // Instruction index
    instructionData.writeBigUInt64LE(BigInt(1000), 1); // Example parameter
    
    const instruction = new TransactionInstruction({
      keys: [
        { pubkey: signer.publicKey, isSigner: true, isWritable: true },
        { pubkey: pda, isSigner: false, isWritable: true },
        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
      ],
      programId,
      data: instructionData,
    });
    
    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

    const transactionMessage = pipe(
      createTransactionMessage({ version: 0 }),
      (tx) => setTransactionMessageFeePayerSigner(signer.publicKey, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      (tx) => appendTransactionMessageInstructions([instruction], tx)
    );

    const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
    
    const signature = await rpc.sendTransaction(signedTransaction).send();
    
    console.log("Program call signature:", signature);
    
    await rpc.confirmTransaction({
      signature,
      blockhash: latestBlockhash.blockhash,
      lastValidBlockHeight: latestBlockhash.lastValidBlockHeight
    });
    
    console.log("Transaction confirmed");
  };
  
  return <button onClick={callProgram}>Call Program</button>;
}

import { useParaAnchor } from './hooks/useParaAnchor';
import * as anchor from '@project-serum/anchor';
import { SystemProgram } from '@solana/web3.js';
import idl from './idl.json';

function InteractWithAnchorProgram() {
  const provider = useParaAnchor();
  
  const callAnchorProgram = async () => {
    // Initialize program with IDL
    const program = new anchor.Program(idl as any, provider);
    
    // Generate keypair for new account
    const newAccount = anchor.web3.Keypair.generate();
    
    try {
      // Example: Initialize an account
      const tx = await program.methods
        .initialize(new anchor.BN(1000))
        .accounts({
          user: provider.wallet.publicKey,
          dataAccount: newAccount.publicKey,
          systemProgram: SystemProgram.programId,
        })
        .signers([newAccount])
        .rpc();
        
      console.log("Transaction signature:", tx);
      
      // Fetch account data
      const account = await program.account.dataAccount.fetch(newAccount.publicKey);
      console.log("Account data:", account);
      
      // Example: Update the account
      const updateTx = await program.methods
        .update(new anchor.BN(2000))
        .accounts({
          user: provider.wallet.publicKey,
          dataAccount: newAccount.publicKey,
        })
        .rpc();
        
      console.log("Update transaction:", updateTx);
    } catch (error) {
      console.error("Anchor program call failed:", error);
    }
  };
  
  return <button onClick={callAnchorProgram}>Call Anchor Program</button>;
}