Sync Native

import {
  Connection,
  Keypair,
  PublicKey,
  sendAndConfirmTransaction,
  SystemProgram,
  Transaction,
  LAMPORTS_PER_SOL
} from "@solana/web3.js";
import {
  findAssociatedTokenPda,
  getCreateAssociatedTokenIdempotentInstructionAsync,
  getSyncNativeInstruction,
  getTokenDecoder,
  TOKEN_PROGRAM_ADDRESS
} from "@solana-program/token";

const NATIVE_MINT = new PublicKey(
  "So11111111111111111111111111111111111111112"
).toBase58();

// Setup: create a WSOL ATA before wrapping and syncing SOL.

const result = await sendAndConfirmTransaction(
  connection,
  new Transaction({
    feePayer: feePayer.publicKey,
    blockhash: syncBlockhash.blockhash,
    lastValidBlockHeight: syncBlockhash.lastValidBlockHeight
  }).add(
    SystemProgram.transfer({
      fromPubkey: feePayer.publicKey, // Account sending the SOL to wrap.
      toPubkey: new PublicKey(associatedTokenAccount), // WSOL token account receiving the SOL.
      lamports: 1_000_000 // SOL amount in lamports.
    }),
    getSyncNativeInstruction({
      account: associatedTokenAccount // WSOL token account to synchronize.
    })
  ),
  [feePayer]
);

const tokenAccountInfo = await connection.getAccountInfo(
  new PublicKey(associatedTokenAccount)
);
const tokenAccountData = getTokenDecoder().decode(tokenAccountInfo!.data);

console.log("WSOL Token Account Address:", associatedTokenAccount);
console.log("WSOL Token Account:", tokenAccountData);
console.log("\nTransaction Signature:", result);

use anyhow::Result;
use solana_client::nonblocking::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_sdk::{
    program_pack::Pack,
    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,
    state::Account,
};

#[tokio::main]
async fn main() -> Result<()> {
    let client = RpcClient::new_with_commitment(
        String::from("http://localhost:8899"),
        CommitmentConfig::confirmed(),
    );

    // Setup: create a WSOL ATA before wrapping and syncing SOL.

    let associated_token_address = get_associated_token_address(&fee_payer.pubkey(), &NATIVE_MINT_ID);
    let sync_amount = 1_000_000;
    let transaction = Transaction::new_signed_with_payer(
        &[
            transfer(
                &fee_payer.pubkey(), // Account sending the SOL to wrap.
                &associated_token_address, // WSOL token account receiving the SOL.
                sync_amount, // SOL amount in lamports.
            ),
            sync_native(
                &token_program_id(), // Token program to invoke.
                &associated_token_address, // WSOL token account to synchronize.
            )?,
        ],
        Some(&fee_payer.pubkey()),
        &[&fee_payer],
        latest_blockhash,
    );

    let transaction_signature = client.send_and_confirm_transaction(&transaction).await?;
    let token_account = client.get_account(&associated_token_address).await?;
    let token_data = Account::unpack(&token_account.data)?;

    println!("WSOL Token Account Address: {}", associated_token_address);
    println!("WSOL Token Account: {:#?}", token_data);
    println!("\nTransaction Signature: {}", transaction_signature);

    Ok(())
}

#!/usr/bin/env python3

import asyncio
import json
from solana.rpc.async_api import AsyncClient
from solders.keypair import Keypair
from solders.message import Message
from solders.pubkey import Pubkey
from solders.transaction import Transaction
from solders.system_program import transfer, TransferParams
from spl.token.async_client import AsyncToken
from spl.token.instructions import (
    create_associated_token_account,
    get_associated_token_address,
    sync_native,
    SyncNativeParams,
)
from spl.token.constants import TOKEN_PROGRAM_ID, WRAPPED_SOL_MINT

AMOUNT_TO_WRAP = 1_000_000

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

    async with rpc:
        # Setup: create the wrapped SOL token account before updating its token balance.

        sync_native_instructions = [
            transfer(
                TransferParams(
                    from_pubkey=fee_payer.pubkey(),  # Account sending SOL to the wrapped SOL token account.
                    to_pubkey=wrapped_sol_account,  # Wrapped SOL token account receiving the lamports.
                    lamports=AMOUNT_TO_WRAP,  # Lamports to wrap as WSOL.
                )
            ),
            sync_native(
                SyncNativeParams(
                    program_id=TOKEN_PROGRAM_ID,  # Token program to invoke.
                    account=wrapped_sol_account,  # Wrapped SOL token account whose amount field updates.
                )
            ),
        ]
        latest_blockhash = await rpc.get_latest_blockhash()
        transaction = Transaction(
            [fee_payer],
            Message(sync_native_instructions, fee_payer.pubkey()),
            latest_blockhash.value.blockhash,
        )
        result = await rpc.send_transaction(transaction)

        token_account_info = await token.get_account_info(wrapped_sol_account)
        token_account = {
            key: str(value) if isinstance(value, Pubkey) else value
            for key, value in token_account_info._asdict().items()
        }

        print("Native Mint Address:", WRAPPED_SOL_MINT)
        print("\nWrapped SOL Token Account Address:", wrapped_sol_account)
        print("Token Account:")
        print(json.dumps(token_account, indent=2))
        print("\nTransaction Signature:", result.value)

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