SorobanServer

Enable detailed request/response logging for debugging. Default: false.

Creates a new Soroban RPC client instance.

General node health check request. See: https://soroban.stellar.org/api/methods/getHealth

General info about the currently configured network. See: https://soroban.stellar.org/api/methods/getNetwork

Statistics for charged inclusion fees. The inclusion fee statistics are calculated from the inclusion fees that were paid for the transactions to be included onto the ledger. For Soroban transactions and Stellar transactions, they each have their own inclusion fees and own surge pricing. Inclusion fees are used to prevent spam and prioritize transactions during network traffic surge.

See: Stellar developer docs

Version information about the RPC and Captive core. RPC manages its own, pared-down version of Stellar Core optimized for its own subset of needs.

See: Stellar developer docs

For reading the current value of ledger entries directly. Allows you to directly inspect the current state of a contract, a contract’s code, or any other ledger entry. This is a backup way to access your contract data which may not be available via events or simulateTransaction. To fetch contract wasm byte-code, use the ContractCode ledger entry key.

See: https://soroban.stellar.org/api/methods/getLedgerEntries

For finding out the current latest known ledger of this node. This is a subset of the ledger info from Horizon.

See: https://soroban.stellar.org/api/methods/getLatestLedger

Retrieve a list of ledgers starting from the specified starting point. The getLedgers method return a detailed list of ledgers starting from the user specified starting point that you can paginate as long as the pages fall within the history retention of their corresponding RPC provider.

See: Stellar developer docs

Loads the contract code (wasm binary) for the given wasmId.

Loads the contract code (wasm binary) for the given contractId.

Loads contract source byte code for the given contractId and extracts the information (Environment Meta, Contract Spec, Contract Meta).

Loads contract source byte code for the given wasm id and extracts the information (Environment Meta, Contract Spec, Contract Meta).

Fetches a minimal set of current info about a Stellar account. Needed to get the current sequence number for the account, so you can build a successful transaction. Fails if the account was not found or accountId is invalid.

Reads the current value of contract data ledger entries directly.

Simulates a contract invocation without submitting to the network.

Transaction simulation is essential for Soroban contract interactions. It provides:

• Return values from read-only contract calls
• Resource consumption estimates (CPU instructions, memory, ledger I/O)
• Required ledger footprint for the transaction
• Authorization requirements for multi-party transactions

Always simulate before submitting write transactions to ensure they will succeed and to obtain the correct resource limits and footprint.

Example:

let request = SimulateTransactionRequest(transaction: transaction)
let response = await server.simulateTransaction(simulateTxRequest: request)
switch response {
case .success(let simulation):
    if let result = simulation.results?.first {
        print("Contract returned: \(result.returnValue)")
    }
    print("Cost: \(simulation.cost)")
case .failure(let error):
    print("Simulation error: \(error)")
}

See also:

• Stellar developer docs

Submits a transaction to the Stellar network for execution.

This is the only way to make on-chain changes with smart contracts. Before calling this:

1. Simulate the transaction with simulateTransaction
2. Add the resource limits and footprint from simulation
3. Sign the transaction with all required signers

Important: Unlike Horizon, this method does not wait for transaction completion. It validates and enqueues the transaction, then returns immediately. Use getTransaction to poll for completion status.

Example:

// After simulation and signing
let response = await server.sendTransaction(transaction: signedTransaction)
switch response {
case .success(let result):
    print("Transaction hash: \(result.hash)")
    print("Status: \(result.status)")
    // Poll for completion
case .failure(let error):
    print("Submission failed: \(error)")
}

See also:

• Stellar developer docs
• getTransaction(transactionHash:) for status polling

Polls for transaction completion status.

After submitting a transaction with sendTransaction, use this method to check if the transaction has been included in a ledger and whether it succeeded or failed.

Transaction lifecycle:

1. PENDING: Transaction received but not yet in a ledger
2. SUCCESS: Transaction successfully executed
3. FAILED: Transaction failed during execution
4. NOT_FOUND: Transaction not found (may have expired)

Poll this endpoint until status is SUCCESS or FAILED. Typical polling interval is 1-2 seconds.

Example:

func pollTransaction(hash: String) async {
    let response = await server.getTransaction(transactionHash: hash)
    switch response {
    case .success(let txInfo):
        switch txInfo.status {
        case GetTransactionResponse.STATUS_SUCCESS:
            print("Transaction succeeded!")
            if let result = txInfo.resultValue {
                print("Return value: \(result)")
            }
        case GetTransactionResponse.STATUS_FAILED:
            print("Transaction failed: \(txInfo.resultXdr ?? "")")
        default:
            // Still pending, poll again
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            await pollTransaction(hash: hash)
        }
    case .failure(let error):
        print("Error: \(error)")
    }
}

See also:

• Stellar developer docs

The getTransactions method return a detailed list of transactions starting from the user specified starting point that you can paginate as long as the pages fall within the history retention of their corresponding RPC provider.

See: Stellar developer docs

Queries contract events emitted within a specified ledger range.

Contract events provide a way for smart contracts to emit structured data that can be queried by off-chain applications. Use this method to:

• Monitor contract state changes
• Track token transfers in custom assets
• Build event-driven applications
• Populate application databases with on-chain data

Important notes:

• By default, Soroban RPC retains only the most recent 24 hours of events
• Deduplicate events by their unique ID to prevent double-processing

• Use filters to narrow results to specific contracts or event types

Example:

// Query all events from a specific contract
let filter = EventFilter(
    type: "contract",
    contractIds: ["CCONTRACT123..."]
)
let response = await server.getEvents(
    startLedger: 1000000,
    eventFilters: [filter],
    paginationOptions: PaginationOptions(limit: 100)
)
switch response {
case .success(let eventsResponse):
    for event in eventsResponse.events {
        print("Event ID: \(event.id)")
        print("Topics: \(event.topic)")
        print("Value: \(event.value)")
    }
case .failure(let error):
    print("Error: \(error)")
}

See also:

• Stellar developer docs