import { createSolanaRpc, Signature, Base64EncodedWireTransaction, address } from "@solana/web3.js";

const main = async () => {
    const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
    const blockHeight = await rpc.getBlockHeight().send();
    console.log(blockHeight);

    const slot = await rpc.getSlot().send();
    console.log(slot);

    const block = await rpc.getBlock(321807014n, { 
        maxSupportedTransactionVersion: 0
    }).send();
    // console.log(block);

    const tx = block?.transactions[0]!;
    // console.log(tx.transaction.message.instructions);

    const txid = tx.transaction.signatures[0] as unknown as Signature
    console.log(txid);

    const status = await rpc.getSignatureStatuses([txid], { 
        searchTransactionHistory: true
    }).send();
    console.log(status)

    const tx2 = await rpc.getTransaction(txid, { 
        maxSupportedTransactionVersion: 0,
        encoding: "base64"
    }).send();
    console.log(tx2);

    const base64Tx = tx2?.transaction[0] as unknown as Base64EncodedWireTransaction;

    const txid2 = await rpc.sendTransaction(base64Tx, { 
        encoding: "base64",
        skipPreflight: true // 标识为 true 之后可以重发，不会报错。去掉该标识会进行 simulate。
    }).send()
    console.log(txid2);

    const result = await rpc.simulateTransaction(base64Tx, { 
        encoding: "base64",
        replaceRecentBlockhash: true // 不标记模拟会返回 BlockhashNotFound，标记后会在新区块上模拟
    }).send()
    // console.log(result);

    const accData = await rpc.getAccountInfo(address('BPFLoader2111111111111111111111111111111111'),
    {
        encoding: "jsonParsed"
    }).send();
    console.log(accData);
}

main().catch(error => {
  console.error("Error occurred:", error);
});

import {
    createSolanaRpc,
    address,
    generateKeyPair,
    createTransactionMessage,
    getAddressFromPublicKey,
    setTransactionMessageFeePayer,
    signTransaction,
    createSignerFromKeyPair,
    appendTransactionMessageInstruction,
    compileTransaction,
    getBase64EncodedWireTransaction,
    setTransactionMessageLifetimeUsingBlockhash,
    pipe,
    lamports,
    appendTransactionMessageInstructions,
    AccountRole,
    Address,
    getProgramDerivedAddress,
    getAddressEncoder
} from "@solana/web3.js";

import {
    getTransferSolInstruction
} from "@solana-program/system"

const main = async () => {

    const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
    const { value: blockhash } = await rpc.getLatestBlockhash().send();
    console.log(blockhash);

    const feePayer = await generateKeyPair();
    // console.log(feePayer);

    const feePayerAddress = await getAddressFromPublicKey(feePayer.publicKey);
    console.log(feePayerAddress);

    const signer = await createSignerFromKeyPair(feePayer);

    const ix = getTransferSolInstruction({
        amount: lamports(12345678n),
        destination: feePayerAddress,
        source: signer,
    });
    console.log(ix);

    const ix2 = {
        accounts: [{
            address: feePayerAddress,
            role: AccountRole.WRITABLE_SIGNER,
            signer: signer
        },
        {
            address: feePayerAddress,
            role: AccountRole.WRITABLE
        }],
        programAddress: address("11111111111111111111111111111111"),
        data: Uint8Array.from([2, 0, 0, 0, 78, 97, 188, 0, 0, 0, 0, 0])
    }

    const tx = pipe(
        createTransactionMessage({ version: 0 }),
        tx => setTransactionMessageFeePayer(feePayerAddress, tx),
        tx => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
        tx => appendTransactionMessageInstructions([ix, ix2], tx),
    );
    console.log(tx)

    const rawTx = compileTransaction(tx);

    // // Attempting to sign the transaction message without a lifetime will throw a type error
    const signedTransaction = await signTransaction([feePayer], rawTx);
    console.log(signedTransaction.signatures);

    const b64tx = getBase64EncodedWireTransaction(signedTransaction);
    console.log(b64tx);

    const result = await rpc.simulateTransaction(b64tx, {
        encoding: "base64"
    }).send();
    console.log(result);

    const programAddress = address('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
    const [pda, bump] = await getProgramDerivedAddress({
        programAddress,
        seeds: [
          getAddressEncoder().encode(feePayerAddress),
          getAddressEncoder().encode(address('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA')),
          getAddressEncoder().encode(feePayerAddress),
        ],
      });
    console.log(pda, bump);
}

main().catch(error => {
    console.error("Error occurred:", error);
});