同步原生 SOL

use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    signature::{Keypair, Signer},
    transaction::Transaction,
};
use solana_system_interface::instruction::transfer;
use spl_associated_token_account_interface::{
    address::get_associated_token_address, instruction::create_associated_token_account,
};
use spl_token_interface::{
    id as token_program_id, instruction::sync_native, native_mint::ID as NATIVE_MINT_ID,
};

#[tokio::main]
async fn main() -> Result<()> {
    // Create connection to local validator
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );
    let latest_blockhash = client.get_latest_blockhash().await?;

    // Generate a new keypair for the fee payer
    let fee_payer = Keypair::new();

    // Airdrop 2 SOL to fee payer
    let airdrop_signature = client
        .request_airdrop(&fee_payer.pubkey(), 2_000_000_000)
        .await?;
    client.confirm_transaction(&airdrop_signature).await?;

    loop {
        let confirmed = client.confirm_transaction(&airdrop_signature).await?;
        if confirmed {
            break;
        }
    }

    // Get associated token account address for WSOL
    let associated_token_address = get_associated_token_address(
        &fee_payer.pubkey(), // owner
        &NATIVE_MINT_ID,     // mint (Wrapped SOL)
    );

    // Instruction to create associated token account for WSOL
    let create_ata_instruction = create_associated_token_account(
        &fee_payer.pubkey(), // funding address
        &fee_payer.pubkey(), // wallet address
        &NATIVE_MINT_ID,     // mint address
        &token_program_id(), // program id
    );

    // Amount to wrap (1 SOL = 1,000,000,000 lamports)
    let amount = 1_000_000_000;

    // Create transfer instruction to send SOL to the WSOL token account
    let transfer_instruction = transfer(&fee_payer.pubkey(), &associated_token_address, amount);

    // Create sync native instruction to update WSOL balance
    let sync_native_instruction = sync_native(&token_program_id(), &associated_token_address)?;

    // Create transaction and add instructions
    let transaction = Transaction::new_signed_with_payer(
        &[
            create_ata_instruction,
            transfer_instruction,
            sync_native_instruction,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    // Send and confirm transaction
    client.send_and_confirm_transaction(&transaction).await?;

    let token_account = client.get_token_account(&associated_token_address).await?;

    println!("WSOL Token Account Address: {}", associated_token_address);
    if let Some(token_account) = token_account {
        println!("{:#?}", token_account);
    }

    Ok(())
}

#!/usr/bin/env python3

import asyncio
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.transaction import VersionedTransaction
from solders.message import MessageV0
from solders.system_program import transfer, TransferParams
from spl.token.instructions import (
    create_associated_token_account,
    sync_native, SyncNativeParams,
    close_account, CloseAccountParams,
    get_associated_token_address
)
from spl.token.constants import TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID
from solders.pubkey import Pubkey

# Native mint address for wrapped SOL
NATIVE_MINT = Pubkey.from_string("So11111111111111111111111111111111111111112")

async def main():
    rpc = AsyncClient("http://localhost:8899")

    # Example keypairs
    payer = Keypair()
    owner = Keypair()

    # Amount to wrap (in lamports)
    amount_to_wrap = 1000000000  # 1 SOL

    async with rpc:
        # Get associated token address for wrapped SOL
        wrapped_sol_account = get_associated_token_address(
            owner=owner.pubkey(),
            mint=NATIVE_MINT,
            token_program_id=TOKEN_PROGRAM_ID
        )

        # Create associated token account for wrapped SOL
        create_ata_instruction = create_associated_token_account(
            payer=payer.pubkey(),
            owner=owner.pubkey(),
            mint=NATIVE_MINT
        )

        # Transfer SOL to the wrapped SOL account
        transfer_instruction = transfer(
            TransferParams(
                from_pubkey=payer.pubkey(),
                to_pubkey=wrapped_sol_account,
                lamports=amount_to_wrap
            )
        )

        # Sync native instruction to update the wrapped SOL balance
        sync_native_instruction = sync_native(
            SyncNativeParams(
                program_id=TOKEN_PROGRAM_ID,
                account=wrapped_sol_account
            )
        )

        instructions = [
            create_ata_instruction,
            transfer_instruction,
            sync_native_instruction
        ]

        # Get latest blockhash
        recent_blockhash = await rpc.get_latest_blockhash()

        # Create message
        message = MessageV0.try_compile(
            payer=payer.pubkey(),
            instructions=instructions,
            address_lookup_table_accounts=[],
            recent_blockhash=recent_blockhash.value.blockhash
        )

        # Create transaction
        transaction = VersionedTransaction(message, [payer])

        print(f"Wrapped SOL Operations:")
        print(f"Owner: {owner.pubkey()}")
        print(f"Wrapped SOL Account: {wrapped_sol_account}")
        print(f"Amount to wrap: {amount_to_wrap} lamports ({amount_to_wrap / 1e9} SOL)")
        print(f"Native Mint: {NATIVE_MINT}")
        print(f"Payer: {payer.pubkey()}")
        print(f"Wrapped SOL transaction created successfully")

async def unwrap_sol_example():
    """Example of unwrapping SOL (closing wrapped SOL account)"""
    rpc = AsyncClient("http://localhost:8899")

    payer = Keypair()
    owner = Keypair()

    async with rpc:
        # Get wrapped SOL account
        wrapped_sol_account = get_associated_token_address(
            owner=owner.pubkey(),
            mint=NATIVE_MINT,
            token_program_id=TOKEN_PROGRAM_ID
        )

        # Close account instruction (unwraps SOL)
        close_account_instruction = close_account(
            CloseAccountParams(
                program_id=TOKEN_PROGRAM_ID,
                account=wrapped_sol_account,
                dest=owner.pubkey(),  # SOL will be sent back to owner
                owner=owner.pubkey()
            )
        )

        # Get latest blockhash
        recent_blockhash = await rpc.get_latest_blockhash()

        # Create message
        message = MessageV0.try_compile(
            payer=payer.pubkey(),
            instructions=[close_account_instruction],
            address_lookup_table_accounts=[],
            recent_blockhash=recent_blockhash.value.blockhash
        )

        # Create transaction
        transaction = VersionedTransaction(message, [payer, owner])

        print(f"\nUnwrap SOL Example:")
        print(f"Wrapped SOL Account: {wrapped_sol_account}")
        print(f"Owner: {owner.pubkey()}")
        print(f"Destination: {owner.pubkey()}")
        print(f"Unwrap SOL transaction created successfully")

if __name__ == "__main__":
    asyncio.run(main())
    asyncio.run(unwrap_sol_example())