Building Transactions

import software.sava.core.tx.Instruction;
import software.sava.core.accounts.PublicKey;
import software.sava.core.accounts.meta.AccountMeta;
import java.util.List;

PublicKey programId = PublicKey.fromBase58Encoded("YourProgramId");

// Define instruction accounts
List<AccountMeta> accounts = List.of(
    AccountMeta.createWrite(sourceAccount),
    AccountMeta.createWrite(destinationAccount),
    AccountMeta.createReadOnlySigner(authority)
);

// Create instruction data
byte[] data = new byte[] { 0, 1, 2, 3 }; // Your instruction data

// Create the instruction
Instruction instruction = Instruction.createInstruction(
    programId,
    accounts,
    data
);

AccountMeta programMeta = AccountMeta.createInvoked(programId);

Instruction instruction = Instruction.createInstruction(
    programMeta,
    accounts,
    data
);

Instruction baseInstruction = Instruction.createInstruction(
    programId,
    accounts,
    data
);

// Add single account
AccountMeta extraAccount = AccountMeta.createRead(somePublicKey);
Instruction withExtra = baseInstruction.extraAccount(extraAccount);

// Add multiple accounts
List<AccountMeta> extraAccounts = List.of(
    AccountMeta.createRead(account1),
    AccountMeta.createWrite(account2)
);
Instruction withMultiple = baseInstruction.extraAccounts(extraAccounts);

import software.sava.core.tx.Transaction;
import software.sava.core.accounts.PublicKey;
import software.sava.core.tx.Instruction;
import java.util.List;

PublicKey feePayer = PublicKey.fromBase58Encoded("FeePayerAddress");

List<Instruction> instructions = List.of(
    instruction1,
    instruction2
);

// Create transaction
Transaction transaction = Transaction.createTx(feePayer, instructions);

// For single instruction transactions
Transaction transaction = Transaction.createTx(feePayer, instruction);

// Fee payer will be determined from signers
Transaction transaction = Transaction.createTx(instructions);

import software.sava.core.accounts.Signer;
import java.util.List;

Signer feePayer = // ... your fee payer signer
Signer authority1 = // ... first authority
Signer authority2 = // ... second authority

List<Signer> signers = List.of(
    feePayer,
    authority1,
    authority2
);

// Transaction will track required signers
Transaction transaction = Transaction.createTx(
    feePayer.publicKey(),
    instructions
);

// Fee payer is special signer
AccountMeta feePayerMeta = AccountMeta.createFeePayer(feePayer.publicKey());

// Regular signer (read-only)
AccountMeta signerMeta = AccountMeta.createReadOnlySigner(signer.publicKey());

// Writable signer
AccountMeta writableSignerMeta = AccountMeta.createWritableSigner(
    authority.publicKey()
);

import software.sava.core.accounts.lookup.AddressLookupTable;

AddressLookupTable lookupTable = // ... your lookup table

Transaction transaction = Transaction.createTx(
    feePayer,
    instructions,
    lookupTable
);

System.out.println("Transaction version: " + transaction.version());

import software.sava.core.accounts.meta.LookupTableAccountMeta;

LookupTableAccountMeta[] tables = // ... your lookup table metas

Transaction transaction = Transaction.createTx(
    feePayer,
    instructions,
    null, // no single lookup table
    tables // array of lookup tables
);

import software.sava.core.tx.TransactionSkeleton;

// From transaction data (e.g., fetched from RPC)
byte[] txData = // ... transaction bytes

TransactionSkeleton skeleton = TransactionSkeleton.deserializeSkeleton(txData);

// Parse instructions
Instruction[] instructions = skeleton.parseLegacyInstructions();

for (Instruction ix : instructions) {
    System.out.println("Program: " + ix.programId().publicKey().toBase58());
    System.out.println("Accounts: " + ix.accounts().size());
}

import software.sava.rpc.json.http.client.SolanaRpcClient;
import software.sava.core.tx.TransactionSkeleton;

// Fetch transaction from RPC
var tx = rpcClient.getTransaction(signature).join();

// Parse the skeleton
var skeleton = TransactionSkeleton.deserializeSkeleton(tx.data());
var instructions = skeleton.parseLegacyInstructions();

// Access specific instruction data
var buyIx = instructions[3];
var buyAccounts = buyIx.accounts();

PublicKey mint = buyAccounts.get(2).publicKey();
PublicKey buyer = buyAccounts.get(6).publicKey();

System.out.println("Mint: " + mint.toBase58());
System.out.println("Buyer: " + buyer.toBase58());

import software.sava.core.tx.Instruction;

Transaction originalTx = Transaction.createTx(feePayer, instructions);

// Prepend compute budget instruction
Instruction computeBudget = // ... create compute budget instruction
Transaction withBudget = originalTx.prependIx(computeBudget);

// Append additional instruction
Instruction extraIx = // ... additional instruction
Transaction extended = withBudget.appendIx(extraIx);

// Prepend multiple instructions
List<Instruction> priorityInstructions = List.of(
    computeBudgetIx,
    priorityFeeIx
);
Transaction withPriority = originalTx.prependInstructions(priorityInstructions);

Transaction transaction = Transaction.createTx(feePayer, instructions);

int size = transaction.size();
boolean exceedsLimit = transaction.exceedsSizeLimit();

if (exceedsLimit) {
    System.err.println("Transaction exceeds 1232 byte limit: " + size);
    // Consider using lookup tables or splitting into multiple transactions
}

import java.util.Map;
import java.util.HashMap;

// Accounts are automatically sorted: fee payer, signers, writable, read-only
Map<PublicKey, AccountMeta> accountMap = HashMap.newHashMap(64);

// Add accounts
for (Instruction ix : instructions) {
    for (AccountMeta meta : ix.accounts()) {
        accountMap.merge(meta.publicKey(), meta, Transaction.MERGE_ACCOUNT_META);
    }
}

// Sorted for legacy transactions
AccountMeta[] sorted = Transaction.sortLegacyAccounts(accountMap);

// Sorted for v0 transactions
AccountMeta[] sortedV0 = Transaction.sortV0Accounts(accountMap);

Transaction transaction = Transaction.createTx(feePayer, instructions);

// Replace instruction at index
Instruction newInstruction = // ... replacement
Transaction modified = transaction.replaceInstruction(0, newInstruction);