Response Types

public record Context(long slot)

public record AccountInfo<T>(
    PublicKey pubKey,
    Context context,
    boolean executable,
    long lamports,
    PublicKey owner,
    BigInteger rentEpoch,
    int space,
    T data
) implements DecimalIntegerAmount

static BiFunction<PublicKey, byte[], byte[]> BYTES_IDENTITY

// Get account as raw bytes
var accountInfo = client.getAccountInfo(
    publicKey,
    AccountInfo.BYTES_IDENTITY
).join();

byte[] data = accountInfo.data();

public record Lamports(Context context, long lamports)

var balance = client.getBalance(publicKey).join();
System.out.println("Balance: " + balance.lamports() + " lamports");
System.out.println("At slot: " + balance.context().slot());

public record AccountLamports(PublicKey pubKey, long lamports)

public record Tx(
    int slot,
    OptionalLong blockTime,
    TxMeta meta,
    byte[] data,
    int version
)

boolean isLegacy()

public record TxStatus(
    Context context,
    long slot,
    OptionalInt confirmations,
    TransactionError error,
    Commitment confirmationStatus
)

var statuses = client.getSignatureStatuses(List.of(txSig)).join();
var status = statuses.get(txSig);

if (status.error() == null) {
    System.out.println("Success! Status: " + status.confirmationStatus());
} else {
    System.err.println("Failed: " + status.error());
}

public record TxSig(
    String signature,
    long slot,
    Long blockTime,
    TransactionError err,
    String memo,
    Commitment confirmationStatus
)

public record TxResult(
    Context context,
    TransactionError error
)

public record TxLogs(
    String signature,
    TransactionError error,
    List<String> logs
)

public record Block(
    long blockHeight,
    long blockTime,
    String blockHash,
    String previousBlockHash,
    long parentSlot,
    List<TxReward> rewards,
    List<String> signatures,
    List<BlockTx> transactions
)

public record BlockHeight(Context context, long blockHeight)

public record LatestBlockHash(
    Context context,
    String blockHash,
    long lastValidBlockHeight
)

var blockHash = client.getLatestBlockHash().join();

var transaction = Transaction.builder()
    .recentBlockHash(blockHash.blockHash())
    .build();

// Transaction valid until this block height
long validUntil = blockHash.lastValidBlockHeight();

public record EpochInfo(
    long absoluteSlot,
    long blockHeight,
    long epoch,
    long slotIndex,
    long slotsInEpoch,
    long transactionCount
)

public record NodeHealth(String status)

var health = client.getHealth().join();
if ("ok".equals(health.status())) {
    System.out.println("Node is healthy");
}

public record ClusterNode(
    PublicKey pubkey,
    String gossip,
    String tpu,
    String rpc,
    String version,
    Long featureSet,
    int shredVersion
)

public record Identity(PublicKey identity)

public record TokenAmount(
    Context context,
    String amount,
    int decimals,
    String uiAmountString
)

var tokenBalance = client.getTokenAccountBalance(tokenAccount).join();
System.out.println("Balance: " + tokenBalance.uiAmountString());
System.out.println("Raw: " + tokenBalance.amount());
System.out.println("Decimals: " + tokenBalance.decimals());

public record AccountTokenAmount(
    PublicKey address,
    String amount,
    int decimals,
    String uiAmountString
)

public record PerfSample(
    long slot,
    long numTransactions,
    long numSlots,
    long samplePeriodSecs
)

public record PrioritizationFee(
    long slot,
    long prioritizationFee
)

var fees = client.getRecentPrioritizationFees().join();
for (var fee : fees) {
    System.out.println("Slot " + fee.slot() + ": " + fee.prioritizationFee());
}

public record MyAccount(PublicKey owner, long amount) {
    static final BiFunction<PublicKey, byte[], MyAccount> FACTORY = 
        (pubKey, data) -> {
            // Deserialize data into MyAccount
            var owner = PublicKey.readPubKey(data, 0);
            var amount = ByteUtils.readLong(data, 32);
            return new MyAccount(owner, amount);
        };
}

// Use factory with getAccountInfo
var accountInfo = client.getAccountInfo(
    publicKey,
    MyAccount.FACTORY
).join();

MyAccount myAccount = accountInfo.data();
System.out.println("Owner: " + myAccount.owner());
System.out.println("Amount: " + myAccount.amount());

var tx = client.getTransaction(txSig).join();

// Handle optional block time
tx.blockTime().ifPresent(time -> {
    System.out.println("Block time: " + Instant.ofEpochSecond(time));
});

// Handle transaction errors
var status = client.getSignatureStatuses(List.of(txSig)).join().get(txSig);
if (status.error() != null) {
    System.err.println("Transaction failed: " + status.error());
} else {
    System.out.println("Transaction succeeded");
}

var balance = client.getBalance(publicKey).join();

System.out.println("Balance: " + balance.lamports());
System.out.println("Queried at slot: " + balance.context().slot());

// Compare contexts for consistency
var account = client.getAccountInfo(publicKey).join();
if (account.context().slot() == balance.context().slot()) {
    System.out.println("Data from same slot");
}