Ravina Solana

var jsonConfig = """
    {
      "getProgramAccounts": 2,
      "getTransaction": 5,
      "sendTransaction": 10
    }
    """;

var ji = JsonIterator.parse(jsonConfig);

var rpcCallWeights = CallWeights.parse(ji);

LoadBalancer<SolanaRpcClient> loadBalancer; // See LoadBalancer in Ravina Core
var rpcCallWeights = CallWeights.createDefault();
var executorService = Executors.newVirtualThreadPerTaskExecutor();

var rpcCaller = new RpcCaller(executorService, loadBalancer, rpcCallWeights);

var getEpochInfoCallContext = CallContext.createContext(
    1,    // Call weight.
    0,    // Minimum capacity required before sending.
    1,    // Maximum times to try to claim capacity.
    true, // Eventually force the call.
    0,    // Maximum times to retry call.
    true  // Measure the call time to be tracked by the load balancer for prioritizing items.
);

var epochInfo = rpcCaller.courteousGet(
    SolanaRpcClient::getEpochInfo,
    getEpochInfoCallContext,
    "rpcClient::getEpochInfo"
);

{
  "defaultMillisPerSlot": 410,
  "minMillisPerSlot": 390,
  "maxMillisPerSlot": 500,
  "slotSampleWindow": "13M",
  "fetchSlotSamplesDelay": "8M",
  "fetchEpochInfoAfterEndDelay": "0.5S"
}

RpcCaller rpcCaller; // See the documentation above.

var jsonConfig = "null";
var epochServiceConfig = EpochServiceConfig.parseConfig(ji);
if (epochServiceConfig == null) {
  epochServiceConfig = EpochServiceConfig.createDefault();
}
var epochInfoService = EpochInfoService.createService(epochServiceConfig, rpcCaller);

var executorService = Executors.newSingleThreadExecutor();
executorService.execute(epochInfoService);

epochInfoService.awaitInitialized();

var epochInfo = epochInfoService.epochInfo();
System.out.println(epochInfo);

var backoff = Backoff.exponential(1, 32);
var account = PublicKey.fromBase58Encoded("");

var httpClient = HttpClient.newHttpClient();
var webSocketManager = WebSocketManager.createManager(
    httpClient,
    URI.create("wss://url"),
    backoff,
    webSocket -> webSocket.accountSubscribe(account, System.out::println)
);

for (;;) {
    webSocketManager.checkConnection();
    Thread.sleep(1_000);
}

var jsonConfig = """
    {
      "sig": "https://solscan.io/tx/%s",
      "address": "https://solscan.io/account/%s"
    }
    """;
var ji = JsonIterator.parse(jsonConfig);
var formatter = ChainItemFormatter.parseFormatter(ji);
System.out.println(formatter.formatSig("5yem9DTy4mHa94yKVCSuQYixvtt27aF2L2bcms8jsgv2Yvgj2FY4DXYpUmN5TBvRX8xC99R6ea1k5eJJb2hVGmxF"));

var taskExecutor = Executors.newVirtualThreadPerTaskExecutor();
var tableCache = LookupTableCache.createCache(
    taskExecutor,
    128, // initial map capacity
    rpcCaller.rpcClients(),
    AddressLookupTable.FACTORY
);

AddressLookupTable table = tableCache.getOrFetchTable(PublicKey.fromBase58Encoded(""));

SigningService signingService; // See the Sava KMS project.
var servicePublicKey = signingService.publicKey().join();

WebSocketManager webSocketManager; // See the documentation above.

LoadBalancer<SolanaRpcClient> rpcClients; // See LoadBalancer in Ravina Core
LoadBalancer<SolanaRpcClient> sendClients; // Used only for sending transactions.
LoadBalancer<FeeProvider> feeProviders; // Provides priority fees given a transaction.
var callWeights = CallWeights.createDefault();

var formatter = ChainItemFormatter.createDefault();
var solanaAccounts = SolanaAccounts.MAIN_NET;

var taskExecutor = Executors.newVirtualThreadPerTaskExecutor();

var tableCache = LookupTableCache.createCache(taskExecutor, 128, rpcCaller.rpcClients());

var transactionProcessor = TransactionProcessor.createProcessor(
    taskExecutor,
    signingService,
    tableCache,
    servicePublicKey,
    solanaAccounts,
    formatter,
    rpcClients,
    sendClients,
    feeProviders,
    callWeights,
    webSocketManager
);

// See the documentation above for construction of these components.
WebSocketManager webSocketManager; 
RpcCaller rpcCaller;
EpochInfoService epochInfoService;

// TransactionProcessor extends this interface, otherwise a simpler implementation may be provided.
TxPublisher txPublisher;

var formatter = ChainItemFormatter.createDefault();

var txMonitorJsonConfig = """
    {
      "webSocketConfirmationTimeout": "5S",
      "minSleepBetweenSigStatusPolling": "3S",
      "retrySendDelay": "5S",
      "minBlocksRemainingToResend": 8
    }""";
var ji = JsonIterator.parse(txMonitorJsonConfig);

var txMonitorConfig = TxMonitorConfig.parseConfig(ji);

var txMonitorService = TxMonitorService.createService(
    formatter,
    rpcCaller,
    epochInfoService,
    webSocketManager,
    txMonitorConfig,
    txPublisher
);

// See the documentation above for construction of these components.
EpochInfoService epochInfoService;
RpcCaller rpcCaller;
TransactionProcessor transactionProcessor;
TxMonitorService txMonitorService;

var nativeProgramClient = NativeProgramClient.createClient();

var instructionService = InstructionService.createService(
    rpcCaller,
    transactionProcessor,
    nativeProgramClient,
    epochInfoService,
    txMonitorService
);

// Populated from the Jupiter API.
List<Instruction> jupiterSwapInstructions;
List<PublicKey> lookupTableKeys;

var maxSOLPriorityFee = new BigDecimal("0.001");
var maxLamportPriorityFee = LamportDecimal.fromBigDecimal(maxSOLPriorityFee);

var transactionResult = instructionService.processInstructions(
    1.1, // Compute budget multiplier applied against simulation consumption.
    jupiterSwapInstructions,
    maxLamportPriorityFee, // Caps the priority fee from the Transaction Processor's Fee Provider.
    FINALIZED, // Await finalization if successful.
    CONFIRMED, // Only await confirmed if fails, e.g., slippage exceeded.
    true, // Verify expired, if the network is not aware of the transaction wait 151 blocks to ensure it cannot be applied.
    true, // Continue to re-send the transaction based on the Transaction Monitor configuration.
    0, // Number of times to re-construct the transaction with a new block hash after expiration.
    transactionProcessor.transactionFactory(lookupTableKeys), // Uses an internal address lookup table cache.
    "jupiter swap" // log context.
);