Construindo Transações em Python

 
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solders.hash import Hash
from solders.message import Message
from solders.transaction import VersionedTransaction
from solders.system_program import TransferParams, transfer
from solana.rpc.api import Client
 
client = Client("https://api.devnet.solana.com")
payer = Keypair()
blockhash = Hash.from_string(str(client.get_latest_blockhash().value.blockhash))
ix = transfer(TransferParams(from_pubkey=payer.pubkey(), to_pubkey=Pubkey.default(), lamports=1000))
msg = Message.new_with_blockhash([ix], payer.pubkey(), blockhash)
tx = VersionedTransaction(msg, [payer])
 

 
import asyncio
from solders.compute_budget import set_compute_unit_limit, set_compute_unit_price
from solders.keypair import Keypair
from solders.pubkey import Pubkey
from solders.hash import Hash
from solders.message import Message
from solders.transaction import VersionedTransaction
from solders.system_program import TransferParams, transfer
from solana.rpc.async_api import AsyncClient
from solana.rpc.types import TxOpts
 
RPC = "https://api.devnet.solana.com"
 
async def send_with_budget(dest: Pubkey, lamports: int, micro_lamports: int):
    payer = Keypair()
    async with AsyncClient(RPC) as client:
        bh = await client.get_latest_blockhash()
        blockhash = Hash.from_string(str(bh.value.blockhash))
 
        ixs = [
            set_compute_unit_limit(50_000),
            set_compute_unit_price(micro_lamports),
            transfer(TransferParams(from_pubkey=payer.pubkey(), to_pubkey=dest, lamports=lamports)),
        ]
        msg = Message.new_with_blockhash(ixs, payer.pubkey(), blockhash)
        tx = VersionedTransaction(msg, [payer])
 
        sim = await client.simulate_transaction(tx)
        if sim.value.err:
            raise RuntimeError(f"simulation failed: {sim.value.err} logs={sim.value.logs}")
 
        resp = await client.send_transaction(
            tx,
            opts=TxOpts(skip_preflight=True, preflight_commitment="confirmed"),
        )
        await client.confirm_transaction(resp.value, commitment="confirmed")
        return resp.value
 
asyncio.run(send_with_budget(Pubkey.default(), 10_000, 5_000))
 

 
# Partial signing for multisig or remote signers
tx = VersionedTransaction(msg, [])  # unsigned
tx.sign([local_signer], blockhash)
# ship bytes to cosigner, then merge signatures per your custody model
 
# Read confirmation status
status = client.get_signature_statuses([sig])