Network / RPC

rpc.Api.QUERY_EVENTS_INVALID_PARAMS

JSON-RPC error code for every queryEvents rejection with typed data.

const QUERY_EVENTS_INVALID_PARAMS: -32602

Source: src/rpc/api.ts:454

rpc.Api.isQueryEventsError

Checks whether a value thrown by queryEvents is a JSON-RPC error with typed queryEvents error data.

isQueryEventsError(err: unknown): err is { code: number; data: QueryEventsErrorData; message?: string }

Parameters

• err — unknown (required)

Source: src/rpc/api.ts:480

rpc.Api.isSimulationError

Checks if a simulation response indicates an error.

isSimulationError(sim: SimulateTransactionResponse): sim is SimulateTransactionErrorResponse

Parameters

• sim — SimulateTransactionResponse (required) — The simulation response to check.

Returns

True if the response indicates an error, false otherwise.

Source: src/rpc/api.ts:629

rpc.Api.isSimulationRaw

Checks if a simulation response is in raw (unparsed) form.

isSimulationRaw(sim: SimulateTransactionResponse | RawSimulateTransactionResponse): sim is RawSimulateTransactionResponse

Parameters

• sim — SimulateTransactionResponse | RawSimulateTransactionResponse (required) — The simulation response to check.

Returns

True if the response is raw, false otherwise.

Source: src/rpc/api.ts:666

rpc.Api.isSimulationRestore

Checks if a simulation response indicates that a restoration is needed.

isSimulationRestore(sim: SimulateTransactionResponse): sim is SimulateTransactionRestoreResponse

Parameters

• sim — SimulateTransactionResponse (required) — The simulation response to check.

Returns

True if the response indicates a restoration is needed, false otherwise.

Source: src/rpc/api.ts:651

rpc.Api.isSimulationSuccess

Checks if a simulation response indicates success.

isSimulationSuccess(sim: SimulateTransactionResponse): sim is SimulateTransactionSuccessResponse

Parameters

• sim — SimulateTransactionResponse (required) — The simulation response to check.

Returns

True if the response indicates success, false otherwise.

Source: src/rpc/api.ts:640

rpc.BasicSleepStrategy

const BasicSleepStrategy: SleepStrategy

Source: src/rpc/server.ts:231

rpc.LinearSleepStrategy

const LinearSleepStrategy: SleepStrategy

Source: src/rpc/server.ts:234

rpc.Server

Handles the network connection to a Soroban RPC instance, exposing an interface for requests to that instance.

class Server {
  constructor(serverURL: string, opts: Options = {});
  readonly httpClient: HttpClient;
  readonly serverURL: URL;
  _getEvents(request: GetEventsRequest): Promise<RawGetEventsResponse>;
  _getLatestLedger(): Promise<RawGetLatestLedgerResponse>;
  _getLedgerEntries(...keys: LedgerKey[]): Promise<RawGetLedgerEntriesResponse>;
  _getLedgers(request: GetLedgersRequest): Promise<RawGetLedgersResponse>;
  _getTransaction(hash: string): Promise<RawGetTransactionResponse>;
  _getTransactions(request: GetTransactionsRequest): Promise<RawGetTransactionsResponse>;
  _queryEvents(request: RawQueryEventsRequest): Promise<RawQueryEventsResponse>;
  _sendTransaction(transaction: Transaction | FeeBumpTransaction): Promise<RawSendTransactionResponse>;
  _simulateTransaction(transaction: Transaction | FeeBumpTransaction, addlResources?: ResourceLeeway, authMode?: SimulationAuthMode, useUpgradedAuth: boolean = true): Promise<RawSimulateTransactionResponse>;
  fundAddress(address: string, friendbotUrl?: string): Promise<GetSuccessfulTransactionResponse>;
  getAccount(address: string): Promise<Account>;
  getAccountEntry(address: string): Promise<AccountEntry>;
  getAssetBalance(address: string | Address | Contract, asset: Asset, networkPassphrase?: string): Promise<BalanceResponse>;
  getClaimableBalance(id: string): Promise<ClaimableBalanceEntry>;
  getContractData(contract: string | Address | Contract, key: ScVal, durability: Durability = Durability.Persistent): Promise<LedgerEntryResult>;
  getContractInstance(contractId: string): Promise<ScContractInstance>;
  getContractMethods(contractId: string, networkPassphrase?: string): Promise<ContractMethod[]>;
  getContractWasmByContractId(contractId: string): Promise<Uint8Array<ArrayBufferLike>>;
  getContractWasmByHash(wasmHash: string | Uint8Array<ArrayBufferLike>, format: "hex" | "base64" | undefined = undefined): Promise<Uint8Array<ArrayBufferLike>>;
  getEvents(request: GetEventsRequest): Promise<GetEventsResponse>;
  getExternalRefWasmHash(ref: ContractExecutableExternalRef): Promise<Uint8Array<ArrayBufferLike>>;
  getFeeStats(): Promise<GetFeeStatsResponse>;
  getHealth(): Promise<GetHealthResponse>;
  getLatestLedger(): Promise<GetLatestLedgerResponse>;
  getLedgerEntries(...keys: LedgerKey[]): Promise<GetLedgerEntriesResponse>;
  getLedgerEntry(key: LedgerKey): Promise<LedgerEntryResult>;
  getLedgers(request: GetLedgersRequest): Promise<GetLedgersResponse>;
  getNetwork(): Promise<GetNetworkResponse>;
  getSACBalance(address: string | Address, sac: Asset, networkPassphrase?: string): Promise<BalanceResponse>;
  getTransaction(hash: string): Promise<GetTransactionResponse>;
  getTransactions(request: GetTransactionsRequest): Promise<GetTransactionsResponse>;
  getTrustline(account: string, asset: Asset): Promise<TrustLineEntry>;
  getVersionInfo(): Promise<GetVersionInfoResponse>;
  pollTransaction(hash: string, opts?: PollingOptions): Promise<GetTransactionResponse>;
  prepareTransaction(tx: Transaction | FeeBumpTransaction, useUpgradedAuth: boolean = true): Promise<Transaction>;
  queryContract<T = any>(contractId: string, method: string, args: Record<string, unknown> = {}, networkPassphrase?: string): Promise<{ isReadCall: boolean; result: T }>;
  queryEvents(request: QueryEventsRequest): Promise<QueryEventsResponse>;
  requestAirdrop(address: string | Pick<Account, "accountId">, friendbotUrl?: string): Promise<Account>;
  sendTransaction(transaction: Transaction | FeeBumpTransaction): Promise<SendTransactionResponse>;
  simulateTransaction(tx: Transaction | FeeBumpTransaction, addlResources?: ResourceLeeway, authMode?: SimulationAuthMode, useUpgradedAuth: boolean = true): Promise<SimulateTransactionResponse>;
}

See also

• API reference docs

Source: src/rpc/server.ts:81

new Server(serverURL, opts)

constructor(serverURL: string, opts: Options = {});

Parameters

• serverURL — string (required)
• opts — Options (optional) (default: {})

Source: src/rpc/server.ts:340

server.httpClient

HTTP client instance for making requests to Horizon. Exposes interceptors, defaults, and other configuration options.

readonly httpClient: HttpClient;

Example

// Add authentication header
server.httpClient.defaults.headers['Authorization'] = 'Bearer token';

// Add request interceptor
server.httpClient.interceptors.request.use((config) => {
  console.log('Request:', config.url);
  return config;
});

Source: src/rpc/server.ts:339

server.serverURL

readonly serverURL: URL;

Source: src/rpc/server.ts:322

server._getEvents(request)

_getEvents(request: GetEventsRequest): Promise<RawGetEventsResponse>;

Parameters

• request — GetEventsRequest (required)

Source: src/rpc/server.ts:1426

server._getLatestLedger()

_getLatestLedger(): Promise<RawGetLatestLedgerResponse>;

Source: src/rpc/server.ts:1540

server._getLedgerEntries(keys)

_getLedgerEntries(...keys: LedgerKey[]): Promise<RawGetLedgerEntriesResponse>;

Parameters

• ...keys — LedgerKey[] (required)

Source: src/rpc/server.ts:1191

server._getLedgers(request)

_getLedgers(request: GetLedgersRequest): Promise<RawGetLedgersResponse>;

Parameters

• request — GetLedgersRequest (required)

Source: src/rpc/server.ts:2162

server._getTransaction(hash)

_getTransaction(hash: string): Promise<RawGetTransactionResponse>;

Parameters

• hash — string (required)

Source: src/rpc/server.ts:1314

server._getTransactions(request)

_getTransactions(request: GetTransactionsRequest): Promise<RawGetTransactionsResponse>;

Parameters

• request — GetTransactionsRequest (required)

Source: src/rpc/server.ts:1365

server._queryEvents(request)

_queryEvents(request: RawQueryEventsRequest): Promise<RawQueryEventsResponse>;

Parameters

• request — RawQueryEventsRequest (required)

Source: src/rpc/server.ts:1481

server._sendTransaction(transaction)

_sendTransaction(transaction: Transaction | FeeBumpTransaction): Promise<RawSendTransactionResponse>;

Parameters

• transaction — Transaction | FeeBumpTransaction (required)

Source: src/rpc/server.ts:1797

server._simulateTransaction(transaction, addlResources, authMode, useUpgradedAuth)

_simulateTransaction(transaction: Transaction | FeeBumpTransaction, addlResources?: ResourceLeeway, authMode?: SimulationAuthMode, useUpgradedAuth: boolean = true): Promise<RawSimulateTransactionResponse>;

Parameters

• transaction — Transaction | FeeBumpTransaction (required)
• addlResources — ResourceLeeway (optional)
• authMode — SimulationAuthMode (optional)
• useUpgradedAuth — boolean (optional) (default: true)

Source: src/rpc/server.ts:1626

server.fundAddress(address, friendbotUrl)

Fund an address using the network’s Friendbot faucet, if any.

This method supports both account (G…) and contract (C…) addresses.

fundAddress(address: string, friendbotUrl?: string): Promise<GetSuccessfulTransactionResponse>;

Parameters

• address — string (required) — The address to fund. Can be either a Stellar account (G…) or contract (C…) address.
• friendbotUrl — string (optional) — (optional) Optionally, an explicit Friendbot URL (by default: this calls the Stellar RPC getNetwork method to try to discover this network’s Friendbot url).

Returns

The transaction response from the Friendbot funding transaction.

Throws

• If Friendbot is not configured on this network or the funding transaction fails.

Example

// Funding an account (G... address)
const tx = await server.fundAddress("GBZC6Y2Y7...");
console.log("Funded! Hash:", tx.txHash);
// If you need the Account object:
const account = await server.getAccount("GBZC6Y2Y7...");

Example

// Funding a contract (C... address)
const tx = await server.fundAddress("CBZC6Y2Y7...");
console.log("Contract funded! Hash:", tx.txHash);

See also

• Friendbot docs

Source: src/rpc/server.ts:1917

server.getAccount(address)

Fetch 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 with TransactionBuilder.

getAccount(address: string): Promise<Account>;

Parameters

• address — string (required) — The public address of the account to load.

Returns

A promise which resolves to the Account object with a populated sequence number

Example

const accountId = "GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4";
server.getAccount(accountId).then((account) => {
  console.log("sequence:", account.sequence);
});

See also

• getLedgerEntries docs

Source: src/rpc/server.ts:382

server.getAccountEntry(address)

Fetch the full account entry for a Stellar account.

getAccountEntry(address: string): Promise<AccountEntry>;

Parameters

• address — string (required) — The public address of the account to load.

Returns

Resolves to the full on-chain account entry

Example

const accountId = "GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4";
server.getAccountEntry(accountId).then((account) => {
  console.log("sequence:", account.balance().toString());
});

See also

• getLedgerEntries docs

Source: src/rpc/server.ts:405

server.getAssetBalance(address, asset, networkPassphrase)

Fetch the balance of an asset held by an account or contract.

The address argument may be provided as a string (as a StrKey), Address, or Contract.

getAssetBalance(address: string | Address | Contract, asset: Asset, networkPassphrase?: string): Promise<BalanceResponse>;

Parameters

• address — string | Address | Contract (required) — The account or contract whose balance should be fetched.
• asset — Asset (required) — The asset whose balance you want to inspect.
• networkPassphrase — string (optional) — (optional) optionally, when requesting the balance of a contract, the network passphrase to which this token applies. If omitted and necessary, a request about network information will be made (see getNetwork), since contract IDs for assets are specific to a network. You can refer to Networks for a list of built-in passphrases, e.g., Networks.TESTNET.

Returns

Resolves with balance entry details when available.

Throws

• If the supplied address is not a valid account or contract strkey, or is a muxed address (M... or W...).

Example

const usdc = new Asset(
  "USDC",
  "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5"
);
const balance = await server.getAssetBalance("GD...", usdc);
console.log(balance.balanceEntry?.amount);

Source: src/rpc/server.ts:566

server.getClaimableBalance(id)

Fetch the full claimable balance entry for a Stellar account.

getClaimableBalance(id: string): Promise<ClaimableBalanceEntry>;

Parameters

• id — string (required) — The strkey (B...) or hex (00000000abcde...) (both IDs with and without the 000… version prefix are accepted) of the claimable balance to load

Returns

Resolves to the full on-chain claimable balance entry

Example

const id = "00000000178826fbfe339e1f5c53417c6fedfe2c05e8bec14303143ec46b38981b09c3f9";
server.getClaimableBalance(id).then((entry) => {
  console.log(`Claimable balance {id.substr(0, 12)} has:`);
  console.log(`  asset:  ${Asset.fromOperation(entry.asset).toString()}`);
  console.log(`  amount: ${entry.amount.toString()}`);
});

See also

• getLedgerEntries docs

Source: src/rpc/server.ts:497

server.getContractData(contract, key, durability)

Reads the current value of contract data ledger entries directly.

Allows you to directly inspect the current state of a contract. This is a backup way to access your contract data which may not be available via events or rpc.Server.simulateTransaction.

getContractData(contract: string | Address | Contract, key: ScVal, durability: Durability = Durability.Persistent): Promise<LedgerEntryResult>;

Parameters

• contract — string | Address | Contract (required) — The contract ID containing the data to load as a strkey (C... form), a Contract, or an Address instance
• key — ScVal (required) — The key of the contract data to load
• durability — Durability (optional) (default: Durability.Persistent) — (optional) The “durability keyspace” that this ledger key belongs to, which is either ‘temporary’ or ‘persistent’ (the default), see rpc.Durability.

Returns

The current data value

Throws

• If contract is a muxed address, or key contains a muxed address (M... or W...).

Warning: If the data entry in question is a ‘temporary’ entry, it’s entirely possible that it has expired out of existence.

Example

const contractId = "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5";
const key = xdr.ScVal.scvSymbol("counter");
server.getContractData(contractId, key, Durability.Temporary).then(data => {
  console.log("value:", data.val);
  console.log("liveUntilLedgerSeq:", data.liveUntilLedgerSeq);
  console.log("lastModified:", data.lastModifiedLedgerSeq);
  console.log("latestLedger:", data.latestLedger);
});

See also

• getLedgerEntries docs

Source: src/rpc/server.ts:672

server.getContractInstance(contractId)

Retrieves the deployed contract instance for a given contract ID.

The instance describes the contract’s executable — either a Wasm hash or the built-in Stellar Asset Contract — along with its instance storage.

getContractInstance(contractId: string): Promise<ScContractInstance>;

Parameters

• contractId — string (required) — The contract ID (C...) to look up

Returns

The contract’s xdr.ScContractInstance

Throws

• If the contract instance cannot be found on the network.

Example

const instance = await server.getContractInstance(
  "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5",
);
console.log(instance.executable.type);

Source: src/rpc/server.ts:765

server.getContractMethods(contractId, networkPassphrase)

Lists a contract’s callable methods and their signatures.

A discovery helper for tooling, dapps, and agents that need to inspect an arbitrary contract without knowing its interface up front. It resolves the contract’s spec (embedded in the Wasm for regular contracts, or the built-in spec for Stellar Asset Contracts — see contract.Client.from) and reports each declared function’s name, inputs, and outputs. No method is invoked or simulated; this performs only the spec lookup.

The complement to queryContract: list methods here, then call a read-only one with server.queryContract(contractId, method, args?).

getContractMethods(contractId: string, networkPassphrase?: string): Promise<ContractMethod[]>;

Parameters

• contractId — string (required) — the contract to inspect (C...)
• networkPassphrase — string (optional) — (optional) the network passphrase. If omitted, a request about network information will be made (see getNetwork). You can refer to Networks for a list of built-in passphrases, e.g., Networks.TESTNET.

Returns

The contract’s methods, in the order they appear in the spec

Example

const methods = await server.getContractMethods(
  "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5",
);
// [
//   { name: "decimals", inputs: [], outputs: ["U32"] },
//   { name: "balance", inputs: [{ name: "id", type: "Address" }], outputs: ["I128"] },
//   { name: "transfer", inputs: [...], outputs: [] },
// ]

Source: src/rpc/server.ts:1114

server.getContractWasmByContractId(contractId)

Retrieves the WASM bytecode for a given contract.

This method allows you to fetch the WASM bytecode associated with a contract deployed on the Soroban network. The WASM bytecode represents the executable code of the contract.

This only works for Wasm-based contracts, including one created from a CAP-85 external executable reference, whose reference is resolved to a Wasm hash first (see getExternalRefWasmHash). A built-in Stellar Asset Contract (SAC) has no Wasm bytecode on-chain, so this throws for a SAC; use contract.Client.from to build a client from the embedded SAC spec.

getContractWasmByContractId(contractId: string): Promise<Uint8Array<ArrayBufferLike>>;

Parameters

• contractId — string (required) — The contract ID containing the WASM bytecode to retrieve

Returns

A Uint8Array containing the WASM bytecode

Throws

• If the contract or its associated WASM bytecode cannot be found on the network, or if the contract is a Stellar Asset Contract (SAC).

Example

const contractId = "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5";
server.getContractWasmByContractId(contractId).then(wasmBytes => {
  console.log("WASM bytecode length:", wasmBytes.length);
  // ... do something with the WASM bytecode ...
}).catch(err => {
  console.error("Error fetching WASM bytecode:", err);
});

Source: src/rpc/server.ts:891

server.getContractWasmByHash(wasmHash, format)

Retrieves the WASM bytecode for a given contract hash.

This method allows you to fetch the WASM bytecode associated with a contract deployed on the Soroban network using the contract’s WASM hash. The WASM bytecode represents the executable code of the contract.

getContractWasmByHash(wasmHash: string | Uint8Array<ArrayBufferLike>, format: "hex" | "base64" | undefined = undefined): Promise<Uint8Array<ArrayBufferLike>>;

Parameters

• wasmHash — string | Uint8Array<ArrayBufferLike> (required) — The WASM hash of the contract
• format — "hex" | "base64" | undefined (optional) (default: undefined)

Returns

A Uint8Array containing the WASM bytecode

Throws

• If the contract or its associated WASM bytecode cannot be found on the network.

Example

const wasmHash = hexToUint8Array("...");
server.getContractWasmByHash(wasmHash).then(wasmBytes => {
  console.log("WASM bytecode length:", wasmBytes.length);
  // ... do something with the WASM bytecode ...
}).catch(err => {
  console.error("Error fetching WASM bytecode:", err);
});

Source: src/rpc/server.ts:946

server.getEvents(request)

Fetch all events that match a given set of filters.

The given filters (see Api.EventFilter for detailed fields) are combined only in a logical OR fashion, and all of the fields in each filter are optional.

To page through events, use the pagingToken field on the relevant Api.EventResponse object to set the cursor parameter.

getEvents(request: GetEventsRequest): Promise<GetEventsResponse>;

Parameters

• request — GetEventsRequest (required) — Event filters Api.GetEventsRequest,

Returns

A paginatable set of the events matching the given event filters

Example

server.getEvents({
   startLedger: 1000,
   endLedger: 2000,
   filters: [
    {
     type: "contract",
     contractIds: [ "deadb33f..." ],
     topics: [[ "AAAABQAAAAh0cmFuc2Zlcg==", "AAAAAQB6Mcc=", "*" ]]
    }, {
     type: "system",
     contractIds: [ "...c4f3b4b3..." ],
     topics: [[ "*" ], [ "*", "AAAAAQB6Mcc=" ]]
    }, {
     contractIds: [ "...c4f3b4b3..." ],
     topics: [[ "AAAABQAAAAh0cmFuc2Zlcg==" ]]
    }, {
     type: "diagnostic",
     topics: [[ "AAAAAQB6Mcc=" ]]
    }
   ],
   limit: 10,
});

See also

• getEvents docs

Source: src/rpc/server.ts:1420

server.getExternalRefWasmHash(ref)

Resolves a CAP-85 external executable reference to the Wasm hash it names.

A contract created with an external reference does not carry its own code hash. Instead the reference names an owner contract and a tag, and the owner holds a persistent contract data entry keyed by that tag whose value is the 32-byte hash of an existing Wasm. This performs exactly that lookup — the owner contract is not invoked.

getExternalRefWasmHash(ref: ContractExecutableExternalRef): Promise<Uint8Array<ArrayBufferLike>>;

Parameters

• ref — ContractExecutableExternalRef (required) — the external reference, e.g. from the contractExecutableExternalRef arm of a contract instance’s executable

Returns

the 32-byte Wasm hash the reference resolves to

Throws

• If the owner is not a contract, the tag entry is missing or archived, or the entry does not hold a 32-byte hash.

Example

const instance = await server.getContractInstance(contractId);
if (instance.executable.type === "contractExecutableExternalRef") {
  const hash = await server.getExternalRefWasmHash(
    instance.executable.externalRef,
  );
  const wasm = await server.getContractWasmByHash(hash);
}

Source: src/rpc/server.ts:820

server.getFeeStats()

Provides an analysis of the recent fee stats for regular and smart contract operations.

getFeeStats(): Promise<GetFeeStatsResponse>;

Returns

the fee stats

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getFeeStats

Source: src/rpc/server.ts:1963

server.getHealth()

General node health check.

getHealth(): Promise<GetHealthResponse>;

Returns

A promise which resolves to the Api.GetHealthResponse object with the status of the server (e.g. “healthy”).

Example

server.getHealth().then((health) => {
  console.log("status:", health.status);
});

See also

• getLedgerEntries docs

Source: src/rpc/server.ts:627

server.getLatestLedger()

Fetch the latest ledger meta info from network which this Soroban RPC server is connected to.

getLatestLedger(): Promise<GetLatestLedgerResponse>;

Returns

metadata about the latest ledger on the network that this RPC server is connected to

Example

server.getLatestLedger().then((response) => {
  console.log("hash:", response.id);
  console.log("sequence:", response.sequence);
  console.log("protocolVersion:", response.protocolVersion);
});

See also

• getLatestLedger docs

Source: src/rpc/server.ts:1536

server.getLedgerEntries(keys)

Reads the current value of arbitrary ledger entries directly.

Allows you to directly inspect the current state of contracts, contract’s code, accounts, or any other ledger entries.

To fetch a contract’s WASM byte-code, built the appropriate xdr.LedgerKeyContractCode ledger entry key (or see Contract.getFootprint).

getLedgerEntries(...keys: LedgerKey[]): Promise<GetLedgerEntriesResponse>;

Parameters

• ...keys — LedgerKey[] (required) — One or more ledger entry keys to load

Returns

The current on-chain values for the given ledger keys

Example

const contractId = "CAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD2KM";
const key = xdr.LedgerKey.contractData(new xdr.LedgerKeyContractData({
  contractId: StrKey.decodeContract(contractId),
  key: xdr.ScVal.scvSymbol("counter"),
}));

server.getLedgerEntries([key]).then(response => {
  const ledgerData = response.entries[0];
  console.log("key:", ledgerData.key);
  console.log("value:", ledgerData.val);
  console.log("liveUntilLedgerSeq:", ledgerData.liveUntilLedgerSeq);
  console.log("lastModified:", ledgerData.lastModifiedLedgerSeq);
  console.log("latestLedger:", response.latestLedger);
});

See also

• • getLedgerEntries docs
• RpcServer._getLedgerEntries

Source: src/rpc/server.ts:1187

server.getLedgerEntry(key)

getLedgerEntry(key: LedgerKey): Promise<LedgerEntryResult>;

Parameters

• key — LedgerKey (required)

Source: src/rpc/server.ts:1202

server.getLedgers(request)

Fetch a detailed list of ledgers starting from a specified point.

Returns ledger data with support for pagination as long as the requested pages fall within the history retention of the RPC provider.

getLedgers(request: GetLedgersRequest): Promise<GetLedgersResponse>;

Parameters

• request — GetLedgersRequest (required) — The request parameters for fetching ledgers. Api.GetLedgersRequest

Returns

A promise that resolves to the ledgers response containing an array of ledger data and pagination info. Api.GetLedgersResponse

Throws

• If startLedger is less than the oldest ledger stored in this node, or greater than the latest ledger seen by this node.

Example

// Fetch ledgers starting from a specific sequence number
server.getLedgers({
  startLedger: 36233,
  pagination: {
    limit: 10
  }
}).then((response) => {
  console.log("Ledgers:", response.ledgers);
  console.log("Latest Ledger:", response.latestLedger);
  console.log("Cursor:", response.cursor);
});

Example

// Paginate through ledgers using cursor
const firstPage = await server.getLedgers({
  startLedger: 36233,
  pagination: {
    limit: 5
  }
});

const nextPage = await server.getLedgers({
  pagination: {
    cursor: firstPage.cursor,
    limit: 5
  }
});

See also

• getLedgers docs

Source: src/rpc/server.ts:2146

server.getNetwork()

Fetch metadata about the network this Soroban RPC server is connected to.

getNetwork(): Promise<GetNetworkResponse>;

Returns

Metadata about the current network this RPC server is connected to

Example

server.getNetwork().then((network) => {
  console.log("friendbotUrl:", network.friendbotUrl);
  console.log("passphrase:", network.passphrase);
  console.log("protocolVersion:", network.protocolVersion);
});

See also

• getNetwork docs

Source: src/rpc/server.ts:1510

server.getSACBalance(address, sac, networkPassphrase)

Deprecated. Use getAssetBalance, instead

Returns a contract’s balance of a particular SAC asset, if any.

This is a convenience wrapper around Server.getLedgerEntries.

getSACBalance(address: string | Address, sac: Asset, networkPassphrase?: string): Promise<BalanceResponse>;

Parameters

• address — string | Address (required) — the contract (string C...) whose balance of sac you want to know
• sac — Asset (required) — the built-in SAC token (e.g. USDC:GABC...) that you are querying from the given contract.
• networkPassphrase — string (optional) — (optional) optionally, the network passphrase to which this token applies. If omitted, a request about network information will be made (see getNetwork), since contract IDs for assets are specific to a network. You can refer to Networks for a list of built-in passphrases, e.g., Networks.TESTNET.

Returns

, which will contain the balance entry details if and only if the request returned a valid balance ledger entry. If it doesn’t, the balanceEntry field will not exist.

Throws

• If address is not a valid contract ID (C...).

Example

// assume `address` is some contract or account with an XLM balance
// assume server is an instantiated `Server` instance.
const entry = (await server.getSACBalance(
  new Address(address),
  Asset.native(),
  Networks.PUBLIC
));

// assumes BigInt support:
console.log(
  entry.balanceEntry ?
  BigInt(entry.balanceEntry.amount) :
  "Address has no XLM");

See also

• • getLedgerEntries
• https://developers.stellar.org/docs/tokens/stellar-asset-contract

Source: src/rpc/server.ts:2027

server.getTransaction(hash)

Fetch the details of a submitted transaction.

After submitting a transaction, clients should poll this to tell when the transaction has completed.

getTransaction(hash: string): Promise<GetTransactionResponse>;

Parameters

• hash — string (required) — Hex-encoded hash of the transaction to check

Returns

The status, result, and other details about the transaction

Example

const transactionHash = "c4515e3bdc0897f21cc5dbec8c82cf0a936d4741cb74a8e158eb51b9fb00411a";
server.getTransaction(transactionHash).then((tx) => {
  console.log("status:", tx.status);
  console.log("envelopeXdr:", tx.envelopeXdr);
  console.log("resultMetaXdr:", tx.resultMetaXdr);
  console.log("resultXdr:", tx.resultXdr);
});

See also

• getTransaction docs

Source: src/rpc/server.ts:1287

server.getTransactions(request)

Fetch transactions starting from a given start ledger or a cursor. The end ledger is the latest ledger in that RPC instance.

getTransactions(request: GetTransactionsRequest): Promise<GetTransactionsResponse>;

Parameters

• request — GetTransactionsRequest (required) — The request parameters.

Returns

• A promise that resolves to the transactions response.

Example

server.getTransactions({
  startLedger: 10000,
  limit: 10,
}).then((response) => {
  console.log("Transactions:", response.transactions);
  console.log("Latest Ledger:", response.latestLedger);
  console.log("Cursor:", response.cursor);
});

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getTransactions

Source: src/rpc/server.ts:1347

server.getTrustline(account, asset)

Deprecated. Use getAssetBalance, instead

Fetch the full trustline entry for a Stellar account.

getTrustline(account: string, asset: Asset): Promise<TrustLineEntry>;

Parameters

• account — string (required) — The public address of the account whose trustline it is
• asset — Asset (required) — The trustline’s asset

Returns

Resolves to the full on-chain trustline entry

Example

const accountId = "GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4";
const asset = new Asset(
 "USDC",
 "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5"
);
server.getTrustline(accountId, asset).then((entry) => {
  console.log(`{asset.toString()} balance for ${accountId}:", entry.balance().toString());
});

See also

• getLedgerEntries docs

Source: src/rpc/server.ts:449

server.getVersionInfo()

Provides information about the current version details of the Soroban RPC and captive-core

getVersionInfo(): Promise<GetVersionInfoResponse>;

Returns

the version info

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getVersionInfo

Source: src/rpc/server.ts:1977

server.pollTransaction(hash, opts)

Poll for a particular transaction with certain parameters.

After submitting a transaction, clients can use this to poll for transaction completion and return a definitive state of success or failure.

pollTransaction(hash: string, opts?: PollingOptions): Promise<GetTransactionResponse>;

Parameters

• hash — string (required) — the transaction you’re polling for
• opts — PollingOptions (optional) — (optional) polling options
  • attempts (optional): (optional) the number of attempts to make before returning the last-seen status. By default or on invalid inputs, try 5 times.
  • sleepStrategy (optional): (optional) the amount of time to wait for between each attempt. By default, sleep for 1 second between each attempt.

Returns

the response after a “found” response (which may be success or failure) or the last response obtained after polling the maximum number of specified attempts.

Example

const h = "c4515e3bdc0897f21cc5dbec8c82cf0a936d4741cb74a8e158eb51b9fb00411a";
const txStatus = await server.pollTransaction(h, {
   attempts: 100, // I'm a maniac
   sleepStrategy: rpc.LinearSleepStrategy
}); // this will take 5,050 seconds to complete

Source: src/rpc/server.ts:1240

server.prepareTransaction(tx, useUpgradedAuth)

Submit a trial contract invocation, first run a simulation of the contract invocation as defined on the incoming transaction, and apply the results to a new copy of the transaction which is then returned. Setting the ledger footprint and authorization, so the resulting transaction is ready for signing & sending.

The returned transaction will also have an updated fee that is the sum of fee set on incoming transaction with the contract resource fees estimated from simulation. It is advisable to check the fee on returned transaction and validate or take appropriate measures for interaction with user to confirm it is acceptable.

You can call the rpc.Server.simulateTransaction method directly first if you want to inspect estimated fees for a given transaction in detail first, then re-assemble it manually or via rpc.assembleTransaction.

prepareTransaction(tx: Transaction | FeeBumpTransaction, useUpgradedAuth: boolean = true): Promise<Transaction>;

Parameters

• tx — Transaction | FeeBumpTransaction (required) — the transaction to prepare. It should include exactly one operation, which must be one of xdr.InvokeHostFunctionOp, xdr.ExtendFootprintTtlOp, or xdr.RestoreFootprintOp.

  Any provided footprint will be overwritten. However, if your operation has existing auth entries, they will be preferred over ALL auth entries from the simulation. In other words, if you include auth entries, you don’t care about the auth returned from the simulation. Other fields (footprint, etc.) will be filled as normal.

• useUpgradedAuth — boolean (optional) (default: true) — (optional) whether the underlying simulation records v2 address credentials (CAP-71) instead of the legacy v1 address credentials. Defaults to true; pass false to ask for the legacy v1 format. It only affects the recording auth modes.

  Deprecated: this flag is transitional. Once the RPC server returns v2 credentials by default (protocol 28), it becomes a no-op — do not rely on passing false to keep receiving the legacy v1 format.

Returns

A copy of the transaction with the expected authorizations (in the case of invocation), resources, and ledger footprints added. The transaction fee will also automatically be padded with the contract’s minimum resource fees discovered from the simulation.

Throws

• • If simulation fails

Example

const contractId = 'CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE';
const contract = new StellarSdk.Contract(contractId);

// Right now, this is just the default fee for this example.
const fee = StellarSdk.BASE_FEE;
const transaction = new StellarSdk.TransactionBuilder(account, { fee })
  // Uncomment the following line to build transactions for the live network. Be
  // sure to also change the horizon hostname.
  //.setNetworkPassphrase(StellarSdk.Networks.PUBLIC)
  .setNetworkPassphrase(StellarSdk.Networks.FUTURENET)
  .setTimeout(30) // valid for the next 30s
  // Add an operation to call increment() on the contract
  .addOperation(contract.call("increment"))
  .build();

const preparedTransaction = await server.prepareTransaction(transaction);

// Sign this transaction with the secret key
// NOTE: signing is transaction is network specific. Test network transactions
// won't work in the public network. To switch networks, use the Network object
// as explained above (look for StellarSdk.Network).
const sourceKeypair = StellarSdk.Keypair.fromSecret(sourceSecretKey);
preparedTransaction.sign(sourceKeypair);

server.sendTransaction(transaction).then(result => {
  console.log("hash:", result.hash);
  console.log("status:", result.status);
  console.log("errorResultXdr:", result.errorResultXdr);
});

See also

• • module:rpc.assembleTransaction
• simulateTransaction docs

Source: src/rpc/server.ts:1728

server.queryContract(contractId, method, args, networkPassphrase)

Performs a read-only call to a contract method and returns the decoded result.

This is a convenience wrapper for one-line contract state queries: it builds a contract.Client for the contract, simulates the method call, and returns the spec-decoded return value — no manual transaction assembly, signing, or submission required.

Works for both Wasm contracts and built-in Stellar Asset Contracts (SACs): the embedded SAC spec is used automatically for SACs (see contract.Client.from). The query reuses this server’s transport (headers, interceptors, allowHttp).

queryContract<T = any>(contractId: string, method: string, args: Record<string, unknown> = {}, networkPassphrase?: string): Promise<{ isReadCall: boolean; result: T }>;

Parameters

• contractId — string (required) — the contract to query (C...)
• method — string (required) — the contract method to call
• args — Record<string, unknown> (optional) (default: {}) — named arguments for the method, keyed by parameter name (omit for methods that take no arguments)
• networkPassphrase — string (optional) — (optional) the network passphrase. If omitted, a request about network information will be made (see getNetwork). You can refer to Networks for a list of built-in passphrases, e.g., Networks.TESTNET.

Returns

An object with the method’s decoded return value (result) and isReadCall: whether this specific call is a side-effect-free read that needs no signature (it wrote no state and required no authorization). isReadCall is per-call, not per-method: it reflects the given args. Since queryContract never signs or sends, isReadCall: false means the result is a simulation preview of a call that would change state.

Throws

• If the contract has no such method, or if the simulation fails.

Example

const { result: decimals, isReadCall } = await server.queryContract<number>(
  "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5",
  "decimals",
);
const { result: balance } = await server.queryContract<bigint>(
  "CCJZ5DGASBWQXR5MPFCJXMBI333XE5U3FSJTNQU7RIKE3P5GN2K2WYD5",
  "balance",
  { id: "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ" },
);

Source: src/rpc/server.ts:1029

server.queryEvents(request)

Fetch one page of contract and system events with the queryEvents method, which only the archival RPC node serves (in beta). To page, send { cursor, limit } from the response while scanStatus is HAS_MORE, wait and retry on WAITING_FOR_LEDGERS, and stop on OLDEST_REACHED or COMPLETE.

queryEvents(request: QueryEventsRequest): Promise<QueryEventsResponse>;

Parameters

• request — QueryEventsRequest (required) — a ledger range query or a cursor continuation

Returns

one page of parsed events and the scan status

Example

let res = await server.queryEvents({ minLedger: 1000, limit: 50 });
for (;;) {
  handle(res.events);
  if (res.scanStatus === rpc.Api.QueryEventsScanStatus.WAITING_FOR_LEDGERS) {
    await new Promise((resolve) => setTimeout(resolve, 5000));
  } else if (res.scanStatus !== rpc.Api.QueryEventsScanStatus.HAS_MORE) {
    break;
  }
  res = await server.queryEvents({ cursor: res.cursor!, limit: 50 });
}

Source: src/rpc/server.ts:1473

server.requestAirdrop(address, friendbotUrl)

Deprecated. Use Server.fundAddress instead, which supports both account (G…) and contract (C…) addresses.

Fund a new account using the network’s Friendbot faucet, if any.

requestAirdrop(address: string | Pick<Account, "accountId">, friendbotUrl?: string): Promise<Account>;

Parameters

• address — string | Pick<Account, "accountId"> (required) — The address or account instance that we want to create and fund with Friendbot
• friendbotUrl — string (optional) — (optional) Optionally, an explicit address for friendbot (by default: this calls the Soroban RPC getNetwork method to try to discover this network’s Friendbot url).

Returns

An Account object for the created account, or the existing account if it’s already funded with the populated sequence number (note that the account will not be “topped off” if it already exists)

Throws

• If Friendbot is not configured on this network or request failure

Example

server
   .requestAirdrop("GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4")
   .then((accountCreated) => {
     console.log("accountCreated:", accountCreated);
   }).catch((error) => {
     console.error("error:", error);
   });

See also

• • Friendbot docs
• Friendbot.Api.Response

Source: src/rpc/server.ts:1842

server.sendTransaction(transaction)

Submit a real transaction to the Stellar network.

Unlike Horizon, RPC does not wait for transaction completion. It simply validates the transaction and enqueues it. Clients should call rpc.Server.getTransaction to learn about transaction success/failure.

sendTransaction(transaction: Transaction | FeeBumpTransaction): Promise<SendTransactionResponse>;

Parameters

• transaction — Transaction | FeeBumpTransaction (required) — to submit

Returns

the transaction id, status, and any error if available

Example

const contractId = 'CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE';
const contract = new StellarSdk.Contract(contractId);

// Right now, this is just the default fee for this example.
const fee = StellarSdk.BASE_FEE;
const transaction = new StellarSdk.TransactionBuilder(account, { fee })
  // Uncomment the following line to build transactions for the live network. Be
  // sure to also change the horizon hostname.
  //.setNetworkPassphrase(StellarSdk.Networks.PUBLIC)
  .setNetworkPassphrase(StellarSdk.Networks.FUTURENET)
  .setTimeout(30) // valid for the next 30s
  // Add an operation to call increment() on the contract
  .addOperation(contract.call("increment"))
  .build();

// Sign this transaction with the secret key
// NOTE: signing is transaction is network specific. Test network transactions
// won't work in the public network. To switch networks, use the Network object
// as explained above (look for StellarSdk.Network).
const sourceKeypair = StellarSdk.Keypair.fromSecret(sourceSecretKey);
transaction.sign(sourceKeypair);

server.sendTransaction(transaction).then((result) => {
  console.log("hash:", result.hash);
  console.log("status:", result.status);
  console.log("errorResultXdr:", result.errorResultXdr);
});

See also

• • transaction docs
• sendTransaction docs

Source: src/rpc/server.ts:1791

server.simulateTransaction(tx, addlResources, authMode, useUpgradedAuth)

Submit a trial contract invocation to get back return values, expected ledger footprint, expected authorizations, and expected costs.

simulateTransaction(tx: Transaction | FeeBumpTransaction, addlResources?: ResourceLeeway, authMode?: SimulationAuthMode, useUpgradedAuth: boolean = true): Promise<SimulateTransactionResponse>;

Parameters

• tx — Transaction | FeeBumpTransaction (required) — the transaction to simulate, which should include exactly one operation (one of xdr.InvokeHostFunctionOp, xdr.ExtendFootprintTtlOp, or xdr.RestoreFootprintOp). Any provided footprint or auth information will be ignored.

• addlResources — ResourceLeeway (optional) — (optional) any additional resources to add to the simulation-provided ones, for example if you know you will need extra CPU instructions

• authMode — SimulationAuthMode (optional) — (optional) optionally, specify the type of auth mode to use for simulation: enforce for enforcement mode, record for recording mode, or record_allow_nonroot for recording mode that allows non-root authorization

• useUpgradedAuth — boolean (optional) (default: true) — (optional) whether simulation records v2 address credentials (CAP-71) instead of the legacy v1 address credentials. Defaults to true; pass false to ask for the legacy v1 format. It only affects the recording auth modes.

  Deprecated: this flag is transitional. Once the network returns v2 credentials by default (protocol 28), it becomes a no-op — do not rely on passing false to keep receiving the legacy v1 format.

Returns

An object with the cost, footprint, result/auth requirements (if applicable), and error of the transaction

Example

const contractId = 'CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE';
const contract = new StellarSdk.Contract(contractId);

// Right now, this is just the default fee for this example.
const fee = StellarSdk.BASE_FEE;
const transaction = new StellarSdk.TransactionBuilder(account, { fee })
  // Uncomment the following line to build transactions for the live network. Be
  // sure to also change the horizon hostname.
  //.setNetworkPassphrase(StellarSdk.Networks.PUBLIC)
  .setNetworkPassphrase(StellarSdk.Networks.FUTURENET)
  .setTimeout(30) // valid for the next 30s
  // Add an operation to call increment() on the contract
  .addOperation(contract.call("increment"))
  .build();

server.simulateTransaction(transaction).then((sim) => {
  console.log("cost:", sim.cost);
  console.log("result:", sim.result);
  console.log("error:", sim.error);
  console.log("latestLedger:", sim.latestLedger);
});

See also

• • transaction docs
• simulateTransaction docs
• authorization modes
• module:rpc.Server#prepareTransaction
• module:rpc.assembleTransaction

Source: src/rpc/server.ts:1612

rpc.assembleTransaction

Combines the given raw transaction alongside the simulation results. If the given transaction already has authorization entries in a host function invocation (see Operation.invokeHostFunction), the simulation entries are ignored.

If the given transaction already has authorization entries in a host function invocation (see Operation.invokeHostFunction), the simulation entries are ignored.

assembleTransaction(raw: Transaction | FeeBumpTransaction, simulation: SimulateTransactionResponse | RawSimulateTransactionResponse): TransactionBuilder

Parameters

• raw — Transaction | FeeBumpTransaction (required) — the initial transaction, w/o simulation applied
• simulation — SimulateTransactionResponse | RawSimulateTransactionResponse (required) — the Soroban RPC simulation result (see rpc.Server.simulateTransaction)

Returns

a new, cloned transaction with the proper auth and resource (fee, footprint) simulation data applied

Throws

• If the transaction’s resourceFee is below 0 or above 2^50.

See also

• • rpc.Server.simulateTransaction
• rpc.Server.prepareTransaction

Source: src/rpc/transaction.ts:46

rpc.parseRawEvents

Parse and return the retrieved events, if any, from a raw response from a RPC server.

parseRawEvents(raw: RawGetEventsResponse): GetEventsResponse

Parameters

• raw — RawGetEventsResponse (required) — the raw getEvents response from the RPC server to parse

Returns

events parsed from the RPC server’s response

Source: src/rpc/parsers.ts:112

rpc.parseRawQueryEvents

Parse a raw queryEvents response. It needs base64 events, so it throws on a response fetched with xdrFormat: "json".

parseRawQueryEvents(raw: RawQueryEventsResponse): QueryEventsResponse

Parameters

• raw — RawQueryEventsResponse (required) — the raw queryEvents response from the RPC server to parse

Returns

the page of events parsed from the RPC server’s response

Source: src/rpc/parsers.ts:148

rpc.parseRawSimulation

Converts a raw response schema into one with parsed XDR fields and a simplified interface.

Warning: This API is only exported for testing purposes and should not be relied on or considered “stable”.

parseRawSimulation(sim: SimulateTransactionResponse | RawSimulateTransactionResponse): SimulateTransactionResponse

Parameters

• sim — SimulateTransactionResponse | RawSimulateTransactionResponse (required) — the raw response schema (parsed ones are allowed, best-effort detected, and returned untouched)

Returns

the original parameter (if already parsed), parsed otherwise

Source: src/rpc/parsers.ts:278

Types

rpc.Api.BalanceResponse

interface BalanceResponse {
  balanceEntry?: { amount: string; authorized: boolean; authorizedToMaintainLiabilities?: boolean; clawback: boolean; lastModifiedLedgerSeq?: number; liveUntilLedgerSeq?: number; revocable?: boolean };
  latestLedger: number;
}

Source: src/rpc/api.ts:747

balanceResponse.balanceEntry

present only on success, otherwise request malformed or no balance

balanceEntry?: { amount: string; authorized: boolean; authorizedToMaintainLiabilities?: boolean; clawback: boolean; lastModifiedLedgerSeq?: number; liveUntilLedgerSeq?: number; revocable?: boolean };

Source: src/rpc/api.ts:750

balanceResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:748

rpc.Api.BaseSendTransactionResponse

interface BaseSendTransactionResponse {
  hash: string;
  latestLedger: number;
  latestLedgerCloseTime: number;
  status: SendTransactionStatus;
}

Source: src/rpc/api.ts:539

baseSendTransactionResponse.hash

hash: string;

Source: src/rpc/api.ts:541

baseSendTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:542

baseSendTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:543

baseSendTransactionResponse.status

status: SendTransactionStatus;

Source: src/rpc/api.ts:540

rpc.Api.BaseSimulateTransactionResponse

interface BaseSimulateTransactionResponse {
  _parsed: boolean;
  events: DiagnosticEvent[];
  id: string;
  latestLedger: number;
}

Source: src/rpc/api.ts:571

baseSimulateTransactionResponse._parsed

a private field to mark the schema as parsed

_parsed: boolean;

Source: src/rpc/api.ts:586

baseSimulateTransactionResponse.events

The field is always present, but may be empty in cases where:

• you didn’t simulate an invocation or
• there were no events

events: DiagnosticEvent[];

Source: src/rpc/api.ts:583

baseSimulateTransactionResponse.id

always present: the JSON-RPC request ID

id: string;

Source: src/rpc/api.ts:573

baseSimulateTransactionResponse.latestLedger

always present: the LCL known to the server when responding

latestLedger: number;

Source: src/rpc/api.ts:576

rpc.Api.ContractMethod

A callable method declared in a contract’s spec, as returned by RpcServer.getContractMethods.

interface ContractMethod {
  doc?: string;
  inputs: ContractMethodInput[];
  name: string;
  outputs: string[];
}

Source: src/rpc/api.ts:878

contractMethod.doc

the method’s spec doc string, when the contract declares one

doc?: string;

Source: src/rpc/api.ts:886

contractMethod.inputs

the method’s parameters, in declaration order

inputs: ContractMethodInput[];

Source: src/rpc/api.ts:882

contractMethod.name

the on-chain method name

name: string;

Source: src/rpc/api.ts:880

contractMethod.outputs

human-readable return type name(s); empty when the method returns void

outputs: string[];

Source: src/rpc/api.ts:884

rpc.Api.ContractMethodInput

A single input parameter of a ContractMethod.

interface ContractMethodInput {
  name: string;
  type: string;
}

Source: src/rpc/api.ts:867

contractMethodInput.name

the declared parameter name

name: string;

Source: src/rpc/api.ts:869

contractMethodInput.type

a human-readable type name, e.g. U32, Address, or a UDT’s name

type: string;

Source: src/rpc/api.ts:871

rpc.Api.EventFilter

interface EventFilter {
  contractIds?: string[];
  topics?: string[][];
  type?: EventType;
}

Source: src/rpc/api.ts:244

eventFilter.contractIds

contractIds?: string[];

Source: src/rpc/api.ts:246

eventFilter.topics

topics?: string[][];

Source: src/rpc/api.ts:247

eventFilter.type

type?: EventType;

Source: src/rpc/api.ts:245

rpc.Api.EventResponse

interface EventResponse extends BaseEventResponse {
  contractId?: Contract;
  id: string;
  inSuccessfulContractCall?: boolean;
  ledger: number;
  ledgerClosedAt: string;
  operationIndex: number;
  topic: ScVal[];
  transactionIndex: number;
  txHash: string;
  type: EventType;
  value: ScVal;
}

Source: src/rpc/api.ts:320

eventResponse.contractId

contractId?: Contract;

Source: src/rpc/api.ts:321

eventResponse.id

id: string;

Source: src/rpc/api.ts:332

eventResponse.inSuccessfulContractCall

Deprecated. Newer RPC servers no longer return this field; it will be removed in the next major release.

inSuccessfulContractCall?: boolean;

Source: src/rpc/api.ts:342

eventResponse.ledger

ledger: number;

Source: src/rpc/api.ts:334

eventResponse.ledgerClosedAt

ledgerClosedAt: string;

Source: src/rpc/api.ts:335

eventResponse.operationIndex

operationIndex: number;

Source: src/rpc/api.ts:337

eventResponse.topic

topic: ScVal[];

Source: src/rpc/api.ts:322

eventResponse.transactionIndex

transactionIndex: number;

Source: src/rpc/api.ts:336

eventResponse.txHash

txHash: string;

Source: src/rpc/api.ts:343

eventResponse.type

type: EventType;

Source: src/rpc/api.ts:333

eventResponse.value

value: ScVal;

Source: src/rpc/api.ts:323

rpc.Api.EventType

type EventType = "contract" | "system"

Source: src/rpc/api.ts:242

rpc.Api.GetEventsRequest

Request parameters for fetching events from the Stellar network.

Important: This type enforces mutually exclusive pagination modes:

• Ledger range mode: Use startLedger and endLedger (cursor must be omitted)
• Cursor pagination mode: Use cursor (startLedger and endLedger must be omitted)

type GetEventsRequest = { cursor?: never; endLedger?: number; filters: Api.EventFilter[]; limit?: number; startLedger: number } | { cursor: string; endLedger?: never; filters: Api.EventFilter[]; limit?: number; startLedger?: never }

Example

// ✅ Correct: Ledger range mode
const rangeRequest: GetEventsRequest = {
  filters: [],
  startLedger: 1000,
  endLedger: 2000,
  limit: 100
};

Example

// ✅ Correct: Cursor pagination mode
const cursorRequest: GetEventsRequest = {
  filters: [],
  cursor: "some-cursor-value",
  limit: 100
};

Example

// ❌ Invalid: Cannot mix cursor with ledger range
const invalidRequest = {
  filters: [],
  startLedger: 1000,  // ❌ Cannot use with cursor
  endLedger: 2000,    // ❌ Cannot use with cursor
  cursor: "cursor",   // ❌ Cannot use with ledger range
  limit: 100
};

See also

• getEvents API reference

Source: src/rpc/api.ts:299

rpc.Api.GetEventsResponse

interface GetEventsResponse extends RetentionState {
  cursor: string;
  events: EventResponse[];
  latestLedger: number;
  latestLedgerCloseTime: string;
  oldestLedger: number;
  oldestLedgerCloseTime: string;
}

Source: src/rpc/api.ts:315

getEventsResponse.cursor

cursor: string;

Source: src/rpc/api.ts:317

getEventsResponse.events

events: EventResponse[];

Source: src/rpc/api.ts:316

getEventsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:251

getEventsResponse.latestLedgerCloseTime

latestLedgerCloseTime: string;

Source: src/rpc/api.ts:253

getEventsResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:252

getEventsResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: string;

Source: src/rpc/api.ts:254

rpc.Api.GetFailedTransactionResponse

interface GetFailedTransactionResponse extends GetAnyTransactionResponse {
  applicationOrder: number;
  createdAt: number;
  diagnosticEventsXdr?: DiagnosticEvent[];
  envelopeXdr: TransactionEnvelope;
  events: TransactionEvents;
  feeBump: boolean;
  latestLedger: number;
  latestLedgerCloseTime: number;
  ledger: number;
  oldestLedger: number;
  oldestLedgerCloseTime: number;
  resultMetaXdr: TransactionMeta;
  resultXdr: TransactionResult;
  status: FAILED;
  txHash: string;
}

Source: src/rpc/api.ts:113

getFailedTransactionResponse.applicationOrder

applicationOrder: number;

Source: src/rpc/api.ts:118

getFailedTransactionResponse.createdAt

createdAt: number;

Source: src/rpc/api.ts:117

getFailedTransactionResponse.diagnosticEventsXdr

diagnosticEventsXdr?: DiagnosticEvent[];

Source: src/rpc/api.ts:123

getFailedTransactionResponse.envelopeXdr

envelopeXdr: TransactionEnvelope;

Source: src/rpc/api.ts:120

getFailedTransactionResponse.events

events: TransactionEvents;

Source: src/rpc/api.ts:124

getFailedTransactionResponse.feeBump

feeBump: boolean;

Source: src/rpc/api.ts:119

getFailedTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:103

getFailedTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:104

getFailedTransactionResponse.ledger

ledger: number;

Source: src/rpc/api.ts:116

getFailedTransactionResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:105

getFailedTransactionResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: number;

Source: src/rpc/api.ts:106

getFailedTransactionResponse.resultMetaXdr

resultMetaXdr: TransactionMeta;

Source: src/rpc/api.ts:122

getFailedTransactionResponse.resultXdr

resultXdr: TransactionResult;

Source: src/rpc/api.ts:121

getFailedTransactionResponse.status

status: FAILED;

Source: src/rpc/api.ts:114

getFailedTransactionResponse.txHash

txHash: string;

Source: src/rpc/api.ts:102

rpc.Api.GetFeeStatsResponse

interface GetFeeStatsResponse {
  inclusionFee: FeeDistribution;
  latestLedger: number;
  sorobanInclusionFee: FeeDistribution;
}

Source: src/rpc/api.ts:721

getFeeStatsResponse.inclusionFee

inclusionFee: FeeDistribution;

Source: src/rpc/api.ts:723

getFeeStatsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:724

getFeeStatsResponse.sorobanInclusionFee

sorobanInclusionFee: FeeDistribution;

Source: src/rpc/api.ts:722

rpc.Api.GetHealthResponse

interface GetHealthResponse {
  latestLedger: number;
  ledgerRetentionWindow: number;
  oldestLedger: number;
  status: "healthy";
}

Source: src/rpc/api.ts:21

getHealthResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:22

getHealthResponse.ledgerRetentionWindow

ledgerRetentionWindow: number;

Source: src/rpc/api.ts:23

getHealthResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:24

getHealthResponse.status

status: "healthy";

Source: src/rpc/api.ts:25

rpc.Api.GetLatestLedgerResponse

interface GetLatestLedgerResponse {
  closeTime: string;
  headerXdr: LedgerHeader;
  id: string;
  metadataXdr: LedgerCloseMeta;
  protocolVersion: string;
  sequence: number;
}

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLatestLedger

Source: src/rpc/api.ts:68

getLatestLedgerResponse.closeTime

closeTime: string;

Source: src/rpc/api.ts:72

getLatestLedgerResponse.headerXdr

headerXdr: LedgerHeader;

Source: src/rpc/api.ts:73

getLatestLedgerResponse.id

id: string;

Source: src/rpc/api.ts:69

getLatestLedgerResponse.metadataXdr

metadataXdr: LedgerCloseMeta;

Source: src/rpc/api.ts:74

getLatestLedgerResponse.protocolVersion

protocolVersion: string;

Source: src/rpc/api.ts:71

getLatestLedgerResponse.sequence

sequence: number;

Source: src/rpc/api.ts:70

rpc.Api.GetLedgerEntriesResponse

An XDR-parsed version of RawLedgerEntryResult

interface GetLedgerEntriesResponse {
  entries: LedgerEntryResult[];
  latestLedger: number;
}

Source: src/rpc/api.ts:49

getLedgerEntriesResponse.entries

entries: LedgerEntryResult[];

Source: src/rpc/api.ts:50

getLedgerEntriesResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:51

rpc.Api.GetLedgersRequest

Request parameters for fetching a sequential list of ledgers.

This type supports two distinct pagination modes that are mutually exclusive:

• Ledger-based pagination: Use startLedger to begin fetching from a specific ledger sequence
• Cursor-based pagination: Use cursor to continue from a previous response’s pagination token

type GetLedgersRequest = { pagination?: { cursor?: never; limit?: number }; startLedger: number } | { pagination: { cursor: string; limit?: number }; startLedger?: never }

Example

// Ledger-based pagination - start from specific ledger
const ledgerRequest: GetLedgersRequest = {
  startLedger: 36233,
  pagination: {
    limit: 10
  }
};

Example

// Cursor-based pagination - continue from previous response
const cursorRequest: GetLedgersRequest = {
  pagination: {
    cursor: "36234",
    limit: 5
  }
};

See also

• getLedgers API reference

Source: src/rpc/api.ts:794

rpc.Api.GetLedgersResponse

interface GetLedgersResponse {
  cursor: string;
  latestLedger: number;
  latestLedgerCloseTime: number;
  ledgers: LedgerResponse[];
  oldestLedger: number;
  oldestLedgerCloseTime: number;
}

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLedgers

Source: src/rpc/api.ts:830

getLedgersResponse.cursor

cursor: string;

Source: src/rpc/api.ts:836

getLedgersResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:832

getLedgersResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:833

getLedgersResponse.ledgers

ledgers: LedgerResponse[];

Source: src/rpc/api.ts:831

getLedgersResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:834

getLedgersResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: number;

Source: src/rpc/api.ts:835

rpc.Api.GetMissingTransactionResponse

interface GetMissingTransactionResponse extends GetAnyTransactionResponse {
  latestLedger: number;
  latestLedgerCloseTime: number;
  oldestLedger: number;
  oldestLedgerCloseTime: number;
  status: NOT_FOUND;
  txHash: string;
}

Source: src/rpc/api.ts:109

getMissingTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:103

getMissingTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:104

getMissingTransactionResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:105

getMissingTransactionResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: number;

Source: src/rpc/api.ts:106

getMissingTransactionResponse.status

status: NOT_FOUND;

Source: src/rpc/api.ts:110

getMissingTransactionResponse.txHash

txHash: string;

Source: src/rpc/api.ts:102

rpc.Api.GetNetworkResponse

interface GetNetworkResponse {
  friendbotUrl?: string;
  passphrase: string;
  protocolVersion: string;
}

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getNetwork

Source: src/rpc/api.ts:61

getNetworkResponse.friendbotUrl

friendbotUrl?: string;

Source: src/rpc/api.ts:62

getNetworkResponse.passphrase

passphrase: string;

Source: src/rpc/api.ts:63

getNetworkResponse.protocolVersion

protocolVersion: string;

Source: src/rpc/api.ts:64

rpc.Api.GetSuccessfulTransactionResponse

interface GetSuccessfulTransactionResponse extends GetAnyTransactionResponse {
  applicationOrder: number;
  createdAt: number;
  diagnosticEventsXdr?: DiagnosticEvent[];
  envelopeXdr: TransactionEnvelope;
  events: TransactionEvents;
  feeBump: boolean;
  latestLedger: number;
  latestLedgerCloseTime: number;
  ledger: number;
  oldestLedger: number;
  oldestLedgerCloseTime: number;
  resultMetaXdr: TransactionMeta;
  resultXdr: TransactionResult;
  returnValue?: ScVal;
  status: SUCCESS;
  txHash: string;
}

Source: src/rpc/api.ts:127

getSuccessfulTransactionResponse.applicationOrder

applicationOrder: number;

Source: src/rpc/api.ts:132

getSuccessfulTransactionResponse.createdAt

createdAt: number;

Source: src/rpc/api.ts:131

getSuccessfulTransactionResponse.diagnosticEventsXdr

diagnosticEventsXdr?: DiagnosticEvent[];

Source: src/rpc/api.ts:137

getSuccessfulTransactionResponse.envelopeXdr

envelopeXdr: TransactionEnvelope;

Source: src/rpc/api.ts:134

getSuccessfulTransactionResponse.events

events: TransactionEvents;

Source: src/rpc/api.ts:140

getSuccessfulTransactionResponse.feeBump

feeBump: boolean;

Source: src/rpc/api.ts:133

getSuccessfulTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:103

getSuccessfulTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:104

getSuccessfulTransactionResponse.ledger

ledger: number;

Source: src/rpc/api.ts:130

getSuccessfulTransactionResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:105

getSuccessfulTransactionResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: number;

Source: src/rpc/api.ts:106

getSuccessfulTransactionResponse.resultMetaXdr

resultMetaXdr: TransactionMeta;

Source: src/rpc/api.ts:136

getSuccessfulTransactionResponse.resultXdr

resultXdr: TransactionResult;

Source: src/rpc/api.ts:135

getSuccessfulTransactionResponse.returnValue

returnValue?: ScVal;

Source: src/rpc/api.ts:139

getSuccessfulTransactionResponse.status

status: SUCCESS;

Source: src/rpc/api.ts:128

getSuccessfulTransactionResponse.txHash

txHash: string;

Source: src/rpc/api.ts:102

rpc.Api.GetTransactionResponse

type GetTransactionResponse = GetSuccessfulTransactionResponse | GetFailedTransactionResponse | GetMissingTransactionResponse

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getTransaction

Source: src/rpc/api.ts:95

rpc.Api.GetTransactionStatus

enum GetTransactionStatus

Source: src/rpc/api.ts:88

rpc.Api.GetTransactionsRequest

type GetTransactionsRequest = { pagination?: { cursor?: never; limit?: number }; startLedger: number } | { pagination: { cursor: string; limit?: number }; startLedger?: never }

Source: src/rpc/api.ts:165

rpc.Api.GetTransactionsResponse

interface GetTransactionsResponse {
  cursor: string;
  latestLedger: number;
  latestLedgerCloseTimestamp: number;
  oldestLedger: number;
  oldestLedgerCloseTimestamp: number;
  transactions: TransactionInfo[];
}

Source: src/rpc/api.ts:224

getTransactionsResponse.cursor

cursor: string;

Source: src/rpc/api.ts:230

getTransactionsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:226

getTransactionsResponse.latestLedgerCloseTimestamp

latestLedgerCloseTimestamp: number;

Source: src/rpc/api.ts:227

getTransactionsResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:228

getTransactionsResponse.oldestLedgerCloseTimestamp

oldestLedgerCloseTimestamp: number;

Source: src/rpc/api.ts:229

getTransactionsResponse.transactions

transactions: TransactionInfo[];

Source: src/rpc/api.ts:225

rpc.Api.GetVersionInfoResponse

interface GetVersionInfoResponse {
  build_timestamp: string;
  buildTimestamp: string;
  captive_core_version: string;
  captiveCoreVersion: string;
  commit_hash: string;
  commitHash: string;
  protocol_version: number;
  protocolVersion: number;
  version: string;
}

Source: src/rpc/api.ts:704

getVersionInfoResponse.build_timestamp

build_timestamp: string;

Source: src/rpc/api.ts:714

getVersionInfoResponse.buildTimestamp

buildTimestamp: string;

Source: src/rpc/api.ts:707

getVersionInfoResponse.captive_core_version

captive_core_version: string;

Source: src/rpc/api.ts:716

getVersionInfoResponse.captiveCoreVersion

captiveCoreVersion: string;

Source: src/rpc/api.ts:708

getVersionInfoResponse.commit_hash

commit_hash: string;

Source: src/rpc/api.ts:712

getVersionInfoResponse.commitHash

commitHash: string;

Source: src/rpc/api.ts:706

getVersionInfoResponse.protocol_version

protocol_version: number;

Source: src/rpc/api.ts:718

getVersionInfoResponse.protocolVersion

protocolVersion: number;

Source: src/rpc/api.ts:709

getVersionInfoResponse.version

version: string;

Source: src/rpc/api.ts:705

rpc.Api.LedgerEntryChange

interface LedgerEntryChange {
  after: LedgerEntry | null;
  before: LedgerEntry | null;
  key: LedgerKey;
  type: number;
}

Source: src/rpc/api.ts:508

ledgerEntryChange.after

after: LedgerEntry | null;

Source: src/rpc/api.ts:512

ledgerEntryChange.before

before: LedgerEntry | null;

Source: src/rpc/api.ts:511

ledgerEntryChange.key

key: LedgerKey;

Source: src/rpc/api.ts:510

ledgerEntryChange.type

type: number;

Source: src/rpc/api.ts:509

rpc.Api.LedgerEntryResult

interface LedgerEntryResult {
  key: LedgerKey;
  lastModifiedLedgerSeq?: number;
  liveUntilLedgerSeq?: number;
  val: LedgerEntryData;
}

Source: src/rpc/api.ts:28

ledgerEntryResult.key

key: LedgerKey;

Source: src/rpc/api.ts:30

ledgerEntryResult.lastModifiedLedgerSeq

lastModifiedLedgerSeq?: number;

Source: src/rpc/api.ts:29

ledgerEntryResult.liveUntilLedgerSeq

liveUntilLedgerSeq?: number;

Source: src/rpc/api.ts:32

ledgerEntryResult.val

val: LedgerEntryData;

Source: src/rpc/api.ts:31

rpc.Api.LedgerResponse

interface LedgerResponse {
  hash: string;
  headerXdr: LedgerHeaderHistoryEntry;
  ledgerCloseTime: string;
  metadataXdr: LedgerCloseMeta;
  sequence: number;
}

Source: src/rpc/api.ts:848

ledgerResponse.hash

hash: string;

Source: src/rpc/api.ts:849

ledgerResponse.headerXdr

headerXdr: LedgerHeaderHistoryEntry;

Source: src/rpc/api.ts:852

ledgerResponse.ledgerCloseTime

ledgerCloseTime: string;

Source: src/rpc/api.ts:851

ledgerResponse.metadataXdr

metadataXdr: LedgerCloseMeta;

Source: src/rpc/api.ts:853

ledgerResponse.sequence

sequence: number;

Source: src/rpc/api.ts:850

rpc.Api.QueryEventsCursorRequest

type QueryEventsCursorRequest = QueryEventsPaging & { cursor: string; filters?: never; maxLedger?: never; minLedger?: never; order?: never }

Source: src/rpc/api.ts:384

rpc.Api.QueryEventsErrorData

type QueryEventsErrorData = { reason: "invalid_params"; termBudget?: number; termsUsed?: number } | { latestLedger: number; missingLedger: number; oldestLedger: number; reason: "ledger_out_of_range" } | { latestLedger: number; oldestLedger: number; reason: "cursor_malformed" }

Source: src/rpc/api.ts:456

rpc.Api.QueryEventsFilter

One queryEvents filter. Each topic is base64 XDR or an ScVal.

interface QueryEventsFilter {
  contractId?: string;
  topic0?: string | ScVal;
  topic1?: string | ScVal;
  topic2?: string | ScVal;
  topic3?: string | ScVal;
  type?: EventType;
}

Source: src/rpc/api.ts:355

queryEventsFilter.contractId

contractId?: string;

Source: src/rpc/api.ts:357

queryEventsFilter.topic0

topic0?: string | ScVal;

Source: src/rpc/api.ts:358

queryEventsFilter.topic1

topic1?: string | ScVal;

Source: src/rpc/api.ts:359

queryEventsFilter.topic2

topic2?: string | ScVal;

Source: src/rpc/api.ts:360

queryEventsFilter.topic3

topic3?: string | ScVal;

Source: src/rpc/api.ts:361

queryEventsFilter.type

type?: EventType;

Source: src/rpc/api.ts:356

rpc.Api.QueryEventsOrder

type QueryEventsOrder = "asc" | "desc"

Source: src/rpc/api.ts:352

rpc.Api.QueryEventsRangeRequest

type QueryEventsRangeRequest = QueryEventsPaging & { cursor?: never; filters?: QueryEventsFilter[]; maxLedger?: number; minLedger?: number; order?: QueryEventsOrder }

Source: src/rpc/api.ts:372

rpc.Api.QueryEventsRequest

A queryEvents request: a ledger range query or a cursor continuation.

type QueryEventsRequest = QueryEventsRangeRequest | QueryEventsCursorRequest

Source: src/rpc/api.ts:393

rpc.Api.QueryEventsResponse

interface QueryEventsResponse {
  cursor?: string;
  events: EventResponse[];
  latestLedger: number;
  oldestLedger: number;
  scannedLedger: number;
  scanStatus: QueryEventsScanStatus;
}

Source: src/rpc/api.ts:425

queryEventsResponse.cursor

Absent only when scanStatus is COMPLETE.

cursor?: string;

Source: src/rpc/api.ts:428

queryEventsResponse.events

events: EventResponse[];

Source: src/rpc/api.ts:426

queryEventsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:432

queryEventsResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:431

queryEventsResponse.scannedLedger

scannedLedger: number;

Source: src/rpc/api.ts:430

queryEventsResponse.scanStatus

scanStatus: QueryEventsScanStatus;

Source: src/rpc/api.ts:429

rpc.Api.QueryEventsScanStatus

How far a queryEvents scan got. A switch over it needs a default branch, since the server may add statuses.

enum QueryEventsScanStatus

Source: src/rpc/api.ts:418

rpc.Api.RawEventResponse

interface RawEventResponse extends BaseEventResponse {
  contractId: string;
  id: string;
  inSuccessfulContractCall?: boolean;
  ledger: number;
  ledgerClosedAt: string;
  operationIndex: number;
  topic?: string[];
  transactionIndex: number;
  txHash: string;
  type: EventType;
  value: string;
}

Source: src/rpc/api.ts:346

rawEventResponse.contractId

contractId: string;

Source: src/rpc/api.ts:347

rawEventResponse.id

id: string;

Source: src/rpc/api.ts:332

rawEventResponse.inSuccessfulContractCall

Deprecated. Newer RPC servers no longer return this field; it will be removed in the next major release.

inSuccessfulContractCall?: boolean;

Source: src/rpc/api.ts:342

rawEventResponse.ledger

ledger: number;

Source: src/rpc/api.ts:334

rawEventResponse.ledgerClosedAt

ledgerClosedAt: string;

Source: src/rpc/api.ts:335

rawEventResponse.operationIndex

operationIndex: number;

Source: src/rpc/api.ts:337

rawEventResponse.topic

topic?: string[];

Source: src/rpc/api.ts:348

rawEventResponse.transactionIndex

transactionIndex: number;

Source: src/rpc/api.ts:336

rawEventResponse.txHash

txHash: string;

Source: src/rpc/api.ts:343

rawEventResponse.type

type: EventType;

Source: src/rpc/api.ts:333

rawEventResponse.value

value: string;

Source: src/rpc/api.ts:349

rpc.Api.RawGetEventsResponse

interface RawGetEventsResponse extends RetentionState {
  cursor: string;
  events: RawEventResponse[];
  latestLedger: number;
  latestLedgerCloseTime: string;
  oldestLedger: number;
  oldestLedgerCloseTime: string;
}

Source: src/rpc/api.ts:326

rawGetEventsResponse.cursor

cursor: string;

Source: src/rpc/api.ts:328

rawGetEventsResponse.events

events: RawEventResponse[];

Source: src/rpc/api.ts:327

rawGetEventsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:251

rawGetEventsResponse.latestLedgerCloseTime

latestLedgerCloseTime: string;

Source: src/rpc/api.ts:253

rawGetEventsResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:252

rawGetEventsResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: string;

Source: src/rpc/api.ts:254

rpc.Api.RawGetLatestLedgerResponse

interface RawGetLatestLedgerResponse {
  closeTime: string;
  headerXdr: string;
  id: string;
  metadataXdr: string;
  protocolVersion: string;
  sequence: number;
}

Source: src/rpc/api.ts:77

rawGetLatestLedgerResponse.closeTime

closeTime: string;

Source: src/rpc/api.ts:81

rawGetLatestLedgerResponse.headerXdr

a base-64 encoded LedgerHeader instance

headerXdr: string;

Source: src/rpc/api.ts:83

rawGetLatestLedgerResponse.id

id: string;

Source: src/rpc/api.ts:78

rawGetLatestLedgerResponse.metadataXdr

a base-64 encoded LedgerCloseMeta instance

metadataXdr: string;

Source: src/rpc/api.ts:85

rawGetLatestLedgerResponse.protocolVersion

protocolVersion: string;

Source: src/rpc/api.ts:80

rawGetLatestLedgerResponse.sequence

sequence: number;

Source: src/rpc/api.ts:79

rpc.Api.RawGetLedgerEntriesResponse

interface RawGetLedgerEntriesResponse {
  entries?: RawLedgerEntryResult[];
  latestLedger: number;
}

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLedgerEntries

Source: src/rpc/api.ts:55

rawGetLedgerEntriesResponse.entries

entries?: RawLedgerEntryResult[];

Source: src/rpc/api.ts:56

rawGetLedgerEntriesResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:57

rpc.Api.RawGetLedgersResponse

interface RawGetLedgersResponse {
  cursor: string;
  latestLedger: number;
  latestLedgerCloseTime: number;
  ledgers: RawLedgerResponse[];
  oldestLedger: number;
  oldestLedgerCloseTime: number;
}

Source: src/rpc/api.ts:839

rawGetLedgersResponse.cursor

cursor: string;

Source: src/rpc/api.ts:845

rawGetLedgersResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:841

rawGetLedgersResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:842

rawGetLedgersResponse.ledgers

ledgers: RawLedgerResponse[];

Source: src/rpc/api.ts:840

rawGetLedgersResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:843

rawGetLedgersResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: number;

Source: src/rpc/api.ts:844

rpc.Api.RawGetTransactionResponse

interface RawGetTransactionResponse {
  applicationOrder?: number;
  createdAt?: number;
  diagnosticEventsXdr?: string[];
  envelopeXdr?: string;
  events?: RawTransactionEvents;
  feeBump?: boolean;
  latestLedger: number;
  latestLedgerCloseTime: number;
  ledger?: number;
  oldestLedger: number;
  oldestLedgerCloseTime: number;
  resultMetaXdr?: string;
  resultXdr?: string;
  status: GetTransactionStatus;
  txHash: string;
}

Source: src/rpc/api.ts:143

rawGetTransactionResponse.applicationOrder

applicationOrder?: number;

Source: src/rpc/api.ts:152

rawGetTransactionResponse.createdAt

createdAt?: number;

Source: src/rpc/api.ts:155

rawGetTransactionResponse.diagnosticEventsXdr

diagnosticEventsXdr?: string[];

Source: src/rpc/api.ts:160

rawGetTransactionResponse.envelopeXdr

envelopeXdr?: string;

Source: src/rpc/api.ts:157

rawGetTransactionResponse.events

events?: RawTransactionEvents;

Source: src/rpc/api.ts:162

rawGetTransactionResponse.feeBump

feeBump?: boolean;

Source: src/rpc/api.ts:153

rawGetTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:145

rawGetTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:146

rawGetTransactionResponse.ledger

ledger?: number;

Source: src/rpc/api.ts:154

rawGetTransactionResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:147

rawGetTransactionResponse.oldestLedgerCloseTime

oldestLedgerCloseTime: number;

Source: src/rpc/api.ts:148

rawGetTransactionResponse.resultMetaXdr

resultMetaXdr?: string;

Source: src/rpc/api.ts:159

rawGetTransactionResponse.resultXdr

resultXdr?: string;

Source: src/rpc/api.ts:158

rawGetTransactionResponse.status

status: GetTransactionStatus;

Source: src/rpc/api.ts:144

rawGetTransactionResponse.txHash

txHash: string;

Source: src/rpc/api.ts:149

rpc.Api.RawGetTransactionsResponse

interface RawGetTransactionsResponse {
  cursor: string;
  latestLedger: number;
  latestLedgerCloseTimestamp: number;
  oldestLedger: number;
  oldestLedgerCloseTimestamp: number;
  transactions: RawTransactionInfo[] | null;
}

Source: src/rpc/api.ts:233

rawGetTransactionsResponse.cursor

cursor: string;

Source: src/rpc/api.ts:239

rawGetTransactionsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:235

rawGetTransactionsResponse.latestLedgerCloseTimestamp

latestLedgerCloseTimestamp: number;

Source: src/rpc/api.ts:236

rawGetTransactionsResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:237

rawGetTransactionsResponse.oldestLedgerCloseTimestamp

oldestLedgerCloseTimestamp: number;

Source: src/rpc/api.ts:238

rawGetTransactionsResponse.transactions

transactions: RawTransactionInfo[] | null;

Source: src/rpc/api.ts:234

rpc.Api.RawLedgerEntryResult

interface RawLedgerEntryResult {
  key: string;
  lastModifiedLedgerSeq?: number;
  liveUntilLedgerSeq?: number;
  xdr: string;
}

Source: src/rpc/api.ts:35

rawLedgerEntryResult.key

a base-64 encoded LedgerKey instance

key: string;

Source: src/rpc/api.ts:38

rawLedgerEntryResult.lastModifiedLedgerSeq

lastModifiedLedgerSeq?: number;

Source: src/rpc/api.ts:36

rawLedgerEntryResult.liveUntilLedgerSeq

optional, a future ledger number upon which this entry will expire based on https://github.com/stellar/soroban-tools/issues/1010

liveUntilLedgerSeq?: number;

Source: src/rpc/api.ts:45

rawLedgerEntryResult.xdr

a base-64 encoded LedgerEntryData instance

xdr: string;

Source: src/rpc/api.ts:40

rpc.Api.RawLedgerResponse

interface RawLedgerResponse {
  hash: string;
  headerXdr: string;
  ledgerCloseTime: string;
  metadataXdr: string;
  sequence: number;
}

Source: src/rpc/api.ts:856

rawLedgerResponse.hash

hash: string;

Source: src/rpc/api.ts:857

rawLedgerResponse.headerXdr

a base-64 encoded LedgerHeaderHistoryEntry instance

headerXdr: string;

Source: src/rpc/api.ts:861

rawLedgerResponse.ledgerCloseTime

ledgerCloseTime: string;

Source: src/rpc/api.ts:859

rawLedgerResponse.metadataXdr

a base-64 encoded LedgerCloseMeta instance

metadataXdr: string;

Source: src/rpc/api.ts:863

rawLedgerResponse.sequence

sequence: number;

Source: src/rpc/api.ts:858

rpc.Api.RawQueryEventResponse

interface RawQueryEventResponse extends BaseEventResponse {
  contractId: string;
  id: string;
  inSuccessfulContractCall?: boolean;
  ledger: number;
  ledgerClosedAt: string;
  operationIndex: number;
  topic?: string[];
  topicJson?: unknown[];
  transactionIndex: number;
  txHash: string;
  type: EventType;
  value?: string;
  valueJson?: unknown;
}

Source: src/rpc/api.ts:435

rawQueryEventResponse.contractId

"" for events without a contract.

contractId: string;

Source: src/rpc/api.ts:437

rawQueryEventResponse.id

id: string;

Source: src/rpc/api.ts:332

rawQueryEventResponse.inSuccessfulContractCall

Deprecated. Newer RPC servers no longer return this field; it will be removed in the next major release.

inSuccessfulContractCall?: boolean;

Source: src/rpc/api.ts:342

rawQueryEventResponse.ledger

ledger: number;

Source: src/rpc/api.ts:334

rawQueryEventResponse.ledgerClosedAt

ledgerClosedAt: string;

Source: src/rpc/api.ts:335

rawQueryEventResponse.operationIndex

operationIndex: number;

Source: src/rpc/api.ts:337

rawQueryEventResponse.topic

topic?: string[];

Source: src/rpc/api.ts:438

rawQueryEventResponse.topicJson

topicJson?: unknown[];

Source: src/rpc/api.ts:440

rawQueryEventResponse.transactionIndex

transactionIndex: number;

Source: src/rpc/api.ts:336

rawQueryEventResponse.txHash

txHash: string;

Source: src/rpc/api.ts:343

rawQueryEventResponse.type

type: EventType;

Source: src/rpc/api.ts:333

rawQueryEventResponse.value

value?: string;

Source: src/rpc/api.ts:439

rawQueryEventResponse.valueJson

valueJson?: unknown;

Source: src/rpc/api.ts:441

rpc.Api.RawQueryEventsFilter

interface RawQueryEventsFilter {
  contractId?: string;
  topic0?: string;
  topic1?: string;
  topic2?: string;
  topic3?: string;
  type?: EventType;
}

Source: src/rpc/api.ts:396

rawQueryEventsFilter.contractId

contractId?: string;

Source: src/rpc/api.ts:398

rawQueryEventsFilter.topic0

topic0?: string;

Source: src/rpc/api.ts:399

rawQueryEventsFilter.topic1

topic1?: string;

Source: src/rpc/api.ts:400

rawQueryEventsFilter.topic2

topic2?: string;

Source: src/rpc/api.ts:401

rawQueryEventsFilter.topic3

topic3?: string;

Source: src/rpc/api.ts:402

rawQueryEventsFilter.type

type?: EventType;

Source: src/rpc/api.ts:397

rpc.Api.RawQueryEventsRequest

The queryEvents wire params, posted as is by _queryEvents.

type RawQueryEventsRequest = ((Omit<QueryEventsRangeRequest, "filters"> & { filters?: RawQueryEventsFilter[]; xdrInputFormat?: "base64" | "json" }) | QueryEventsCursorRequest) & { xdrFormat?: "base64" | "json" }

Source: src/rpc/api.ts:406

rpc.Api.RawQueryEventsResponse

interface RawQueryEventsResponse {
  cursor?: string;
  events: RawQueryEventResponse[] | null;
  latestLedger: number;
  oldestLedger: number;
  scannedLedger: number;
  scanStatus: QueryEventsScanStatus;
}

Source: src/rpc/api.ts:444

rawQueryEventsResponse.cursor

cursor?: string;

Source: src/rpc/api.ts:446

rawQueryEventsResponse.events

events: RawQueryEventResponse[] | null;

Source: src/rpc/api.ts:445

rawQueryEventsResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:450

rawQueryEventsResponse.oldestLedger

oldestLedger: number;

Source: src/rpc/api.ts:449

rawQueryEventsResponse.scannedLedger

scannedLedger: number;

Source: src/rpc/api.ts:448

rawQueryEventsResponse.scanStatus

scanStatus: QueryEventsScanStatus;

Source: src/rpc/api.ts:447

rpc.Api.RawSendTransactionResponse

interface RawSendTransactionResponse extends BaseSendTransactionResponse {
  diagnosticEventsXdr?: string[];
  errorResultXdr?: string;
  hash: string;
  latestLedger: number;
  latestLedgerCloseTime: number;
  status: SendTransactionStatus;
}

Source: src/rpc/api.ts:523

rawSendTransactionResponse.diagnosticEventsXdr

This is a base64-encoded instance of an array of DiagnosticEvents, set only when status is "ERROR" and diagnostic events are enabled on the server.

diagnosticEventsXdr?: string[];

Source: src/rpc/api.ts:536

rawSendTransactionResponse.errorResultXdr

This is a base64-encoded instance of TransactionResult, set only when status is "ERROR".

It contains details on why the network rejected the transaction.

errorResultXdr?: string;

Source: src/rpc/api.ts:530

rawSendTransactionResponse.hash

hash: string;

Source: src/rpc/api.ts:541

rawSendTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:542

rawSendTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:543

rawSendTransactionResponse.status

status: SendTransactionStatus;

Source: src/rpc/api.ts:540

rpc.Api.RawSimulateTransactionResponse

interface RawSimulateTransactionResponse {
  error?: string;
  events?: string[];
  id: string;
  latestLedger: number;
  minResourceFee?: string;
  restorePreamble?: { minResourceFee: string; transactionData: string };
  results?: RawSimulateHostFunctionResult[];
  stateChanges?: RawLedgerEntryChange[];
  transactionData?: string;
}

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/simulateTransaction

Source: src/rpc/api.ts:680

rawSimulateTransactionResponse.error

error?: string;

Source: src/rpc/api.ts:683

rawSimulateTransactionResponse.events

These are DiagnosticEvents in base64

events?: string[];

Source: src/rpc/api.ts:687

rawSimulateTransactionResponse.id

id: string;

Source: src/rpc/api.ts:681

rawSimulateTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:682

rawSimulateTransactionResponse.minResourceFee

minResourceFee?: string;

Source: src/rpc/api.ts:688

rawSimulateTransactionResponse.restorePreamble

Present if succeeded but has expired ledger entries

restorePreamble?: { minResourceFee: string; transactionData: string };

Source: src/rpc/api.ts:695

rawSimulateTransactionResponse.results

This will only contain a single element if present, because only a single invokeHostFunctionOperation is supported per transaction.

results?: RawSimulateHostFunctionResult[];

Source: src/rpc/api.ts:693

rawSimulateTransactionResponse.stateChanges

State difference information

stateChanges?: RawLedgerEntryChange[];

Source: src/rpc/api.ts:701

rawSimulateTransactionResponse.transactionData

This is an SorobanTransactionData in base64

transactionData?: string;

Source: src/rpc/api.ts:685

rpc.Api.RawTransactionEvents

interface RawTransactionEvents {
  contractEventsXdr?: string[][];
  transactionEventsXdr?: string[];
}

Source: src/rpc/api.ts:181

rawTransactionEvents.contractEventsXdr

contractEventsXdr?: string[][];

Source: src/rpc/api.ts:183

rawTransactionEvents.transactionEventsXdr

transactionEventsXdr?: string[];

Source: src/rpc/api.ts:182

rpc.Api.RawTransactionInfo

interface RawTransactionInfo {
  applicationOrder: number;
  createdAt: number;
  diagnosticEventsXdr?: string[];
  envelopeXdr?: string;
  events?: RawTransactionEvents;
  feeBump: boolean;
  ledger: number;
  resultMetaXdr?: string;
  resultXdr?: string;
  status: GetTransactionStatus;
  txHash: string;
}

Source: src/rpc/api.ts:186

rawTransactionInfo.applicationOrder

applicationOrder: number;

Source: src/rpc/api.ts:190

rawTransactionInfo.createdAt

createdAt: number;

Source: src/rpc/api.ts:189

rawTransactionInfo.diagnosticEventsXdr

diagnosticEventsXdr?: string[];

Source: src/rpc/api.ts:197

rawTransactionInfo.envelopeXdr

envelopeXdr?: string;

Source: src/rpc/api.ts:194

rawTransactionInfo.events

events?: RawTransactionEvents;

Source: src/rpc/api.ts:199

rawTransactionInfo.feeBump

feeBump: boolean;

Source: src/rpc/api.ts:191

rawTransactionInfo.ledger

ledger: number;

Source: src/rpc/api.ts:188

rawTransactionInfo.resultMetaXdr

resultMetaXdr?: string;

Source: src/rpc/api.ts:196

rawTransactionInfo.resultXdr

resultXdr?: string;

Source: src/rpc/api.ts:195

rawTransactionInfo.status

status: GetTransactionStatus;

Source: src/rpc/api.ts:187

rawTransactionInfo.txHash

txHash: string;

Source: src/rpc/api.ts:192

rpc.Api.SendTransactionResponse

interface SendTransactionResponse extends BaseSendTransactionResponse {
  diagnosticEvents?: DiagnosticEvent[];
  errorResult?: TransactionResult;
  hash: string;
  latestLedger: number;
  latestLedgerCloseTime: number;
  status: SendTransactionStatus;
}

Source: src/rpc/api.ts:518

sendTransactionResponse.diagnosticEvents

diagnosticEvents?: DiagnosticEvent[];

Source: src/rpc/api.ts:520

sendTransactionResponse.errorResult

errorResult?: TransactionResult;

Source: src/rpc/api.ts:519

sendTransactionResponse.hash

hash: string;

Source: src/rpc/api.ts:541

sendTransactionResponse.latestLedger

latestLedger: number;

Source: src/rpc/api.ts:542

sendTransactionResponse.latestLedgerCloseTime

latestLedgerCloseTime: number;

Source: src/rpc/api.ts:543

sendTransactionResponse.status

status: SendTransactionStatus;

Source: src/rpc/api.ts:540

rpc.Api.SendTransactionStatus

type SendTransactionStatus = "PENDING" | "DUPLICATE" | "TRY_AGAIN_LATER" | "ERROR"

Source: src/rpc/api.ts:515

rpc.Api.SimulateHostFunctionResult

interface SimulateHostFunctionResult {
  auth: SorobanAuthorizationEntry[];
  retval: ScVal;
}

Source: src/rpc/api.ts:546

simulateHostFunctionResult.auth

auth: SorobanAuthorizationEntry[];

Source: src/rpc/api.ts:547

simulateHostFunctionResult.retval

retval: ScVal;

Source: src/rpc/api.ts:548

rpc.Api.SimulateTransactionErrorResponse

Includes details about why the simulation failed

interface SimulateTransactionErrorResponse extends BaseSimulateTransactionResponse {
  _parsed: boolean;
  error: string;
  events: DiagnosticEvent[];
  id: string;
  latestLedger: number;
}

Source: src/rpc/api.ts:602

simulateTransactionErrorResponse._parsed

a private field to mark the schema as parsed

_parsed: boolean;

Source: src/rpc/api.ts:586

simulateTransactionErrorResponse.error

error: string;

Source: src/rpc/api.ts:603

simulateTransactionErrorResponse.events

The field is always present, but may be empty in cases where:

• you didn’t simulate an invocation or
• there were no events

events: DiagnosticEvent[];

Source: src/rpc/api.ts:604

simulateTransactionErrorResponse.id

always present: the JSON-RPC request ID

id: string;

Source: src/rpc/api.ts:573

simulateTransactionErrorResponse.latestLedger

always present: the LCL known to the server when responding

latestLedger: number;

Source: src/rpc/api.ts:576

rpc.Api.SimulateTransactionResponse

Simplifies RawSimulateTransactionResponse into separate interfaces based on status:

• on success, this includes all fields, though result is only present if an invocation was simulated (since otherwise there’s nothing to “resultify”)
• if there was an expiration error, this includes error and restoration fields
• for all other errors, this only includes error fields

type SimulateTransactionResponse = SimulateTransactionSuccessResponse | SimulateTransactionRestoreResponse | SimulateTransactionErrorResponse

See also

• https://developers.stellar.org/docs/data/rpc/api-reference/methods/simulateTransaction

Source: src/rpc/api.ts:566

rpc.Api.SimulateTransactionRestoreResponse

Includes simplified fields only present on success.

interface SimulateTransactionRestoreResponse extends SimulateTransactionSuccessResponse {
  _parsed: boolean;
  events: DiagnosticEvent[];
  id: string;
  latestLedger: number;
  minResourceFee: string;
  restorePreamble: { minResourceFee: string; transactionData: SorobanDataBuilder };
  result: SimulateHostFunctionResult;
  stateChanges?: LedgerEntryChange[];
  transactionData: SorobanDataBuilder;
}

Source: src/rpc/api.ts:607

simulateTransactionRestoreResponse._parsed

a private field to mark the schema as parsed

_parsed: boolean;

Source: src/rpc/api.ts:586

simulateTransactionRestoreResponse.events

The field is always present, but may be empty in cases where:

• you didn’t simulate an invocation or
• there were no events

events: DiagnosticEvent[];

Source: src/rpc/api.ts:583

simulateTransactionRestoreResponse.id

always present: the JSON-RPC request ID

id: string;

Source: src/rpc/api.ts:573

simulateTransactionRestoreResponse.latestLedger

always present: the LCL known to the server when responding

latestLedger: number;

Source: src/rpc/api.ts:576

simulateTransactionRestoreResponse.minResourceFee

minResourceFee: string;

Source: src/rpc/api.ts:592

simulateTransactionRestoreResponse.restorePreamble

Indicates that a restoration is necessary prior to submission.

In other words, seeing a restoration preamble means that your invocation was executed AS IF the required ledger entries were present, and this field includes information about what you need to restore for the simulation to succeed.

restorePreamble: { minResourceFee: string; transactionData: SorobanDataBuilder };

Source: src/rpc/api.ts:618

simulateTransactionRestoreResponse.result

present only for invocation simulation

result: SimulateHostFunctionResult;

Source: src/rpc/api.ts:608

simulateTransactionRestoreResponse.stateChanges

State Difference information

stateChanges?: LedgerEntryChange[];

Source: src/rpc/api.ts:598

simulateTransactionRestoreResponse.transactionData

transactionData: SorobanDataBuilder;

Source: src/rpc/api.ts:591

rpc.Api.SimulateTransactionSuccessResponse

Includes simplified fields only present on success.

interface SimulateTransactionSuccessResponse extends BaseSimulateTransactionResponse {
  _parsed: boolean;
  events: DiagnosticEvent[];
  id: string;
  latestLedger: number;
  minResourceFee: string;
  result?: SimulateHostFunctionResult;
  stateChanges?: LedgerEntryChange[];
  transactionData: SorobanDataBuilder;
}

Source: src/rpc/api.ts:590

simulateTransactionSuccessResponse._parsed

a private field to mark the schema as parsed

_parsed: boolean;

Source: src/rpc/api.ts:586

simulateTransactionSuccessResponse.events

The field is always present, but may be empty in cases where:

• you didn’t simulate an invocation or
• there were no events

events: DiagnosticEvent[];

Source: src/rpc/api.ts:583

simulateTransactionSuccessResponse.id

always present: the JSON-RPC request ID

id: string;

Source: src/rpc/api.ts:573

simulateTransactionSuccessResponse.latestLedger

always present: the LCL known to the server when responding

latestLedger: number;

Source: src/rpc/api.ts:576

simulateTransactionSuccessResponse.minResourceFee

minResourceFee: string;

Source: src/rpc/api.ts:592

simulateTransactionSuccessResponse.result

present only for invocation simulation

result?: SimulateHostFunctionResult;

Source: src/rpc/api.ts:595

simulateTransactionSuccessResponse.stateChanges

State Difference information

stateChanges?: LedgerEntryChange[];

Source: src/rpc/api.ts:598

simulateTransactionSuccessResponse.transactionData

transactionData: SorobanDataBuilder;

Source: src/rpc/api.ts:591

rpc.Api.SimulationAuthMode

type SimulationAuthMode = "enforce" | "record" | "record_allow_nonroot"

Source: src/rpc/api.ts:551

rpc.Api.TransactionEvents

interface TransactionEvents {
  contractEventsXdr: ContractEvent[][];
  transactionEventsXdr: TransactionEvent[];
}

Source: src/rpc/api.ts:202

transactionEvents.contractEventsXdr

contractEventsXdr: ContractEvent[][];

Source: src/rpc/api.ts:204

transactionEvents.transactionEventsXdr

transactionEventsXdr: TransactionEvent[];

Source: src/rpc/api.ts:203

rpc.Api.TransactionInfo

interface TransactionInfo {
  applicationOrder: number;
  createdAt: number;
  diagnosticEventsXdr?: DiagnosticEvent[];
  envelopeXdr: TransactionEnvelope;
  events: TransactionEvents;
  feeBump: boolean;
  ledger: number;
  resultMetaXdr: TransactionMeta;
  resultXdr: TransactionResult;
  returnValue?: ScVal;
  status: GetTransactionStatus;
  txHash: string;
}

Source: src/rpc/api.ts:207

transactionInfo.applicationOrder

applicationOrder: number;

Source: src/rpc/api.ts:211

transactionInfo.createdAt

createdAt: number;

Source: src/rpc/api.ts:210

transactionInfo.diagnosticEventsXdr

diagnosticEventsXdr?: DiagnosticEvent[];

Source: src/rpc/api.ts:219

transactionInfo.envelopeXdr

envelopeXdr: TransactionEnvelope;

Source: src/rpc/api.ts:215

transactionInfo.events

events: TransactionEvents;

Source: src/rpc/api.ts:221

transactionInfo.feeBump

feeBump: boolean;

Source: src/rpc/api.ts:212

transactionInfo.ledger

ledger: number;

Source: src/rpc/api.ts:209

transactionInfo.resultMetaXdr

resultMetaXdr: TransactionMeta;

Source: src/rpc/api.ts:217

transactionInfo.resultXdr

resultXdr: TransactionResult;

Source: src/rpc/api.ts:216

transactionInfo.returnValue

returnValue?: ScVal;

Source: src/rpc/api.ts:218

transactionInfo.status

status: GetTransactionStatus;

Source: src/rpc/api.ts:208

transactionInfo.txHash

txHash: string;

Source: src/rpc/api.ts:213

rpc.Durability

Specifies the durability namespace of contract-related ledger entries.

enum Durability

See also

• • State Archival docs
• Rust SDK Storage docs

Source: src/rpc/server.ts:76

rpc.Server.GetEventsRequest

Deprecated. Use Api.GetEventsRequest instead.

type GetEventsRequest = Api.GetEventsRequest

See also

• Api.GetEventsRequest

Source: src/rpc/server.ts:86

rpc.Server.Options

Options for configuring connections to RPC servers.

interface Options {
  allowHttp?: boolean;
  headers?: Record<string, string>;
  timeout?: number;
}

Source: src/rpc/server.ts:104

options.allowHttp

Allow connecting to http servers, default: false. This must be set to false in production deployments!

allowHttp?: boolean;

Source: src/rpc/server.ts:106

options.headers

Additional headers that should be added to any requests to the RPC server. A redirect to another origin can receive these headers. In the Fetch build, set maxRedirects on server.httpClient.defaults to strip them in Node, or maxRedirects: 0 to refuse redirects.

headers?: Record<string, string>;

Source: src/rpc/server.ts:110

options.timeout

Timeout for each request, in whole milliseconds, at most 2147483647. 0 or unset means no limit.

timeout?: number;

Source: src/rpc/server.ts:108

rpc.Server.PollingOptions

interface PollingOptions {
  attempts?: number;
  sleepStrategy?: SleepStrategy;
}

Source: src/rpc/server.ts:88

pollingOptions.attempts

attempts?: number;

Source: src/rpc/server.ts:89

pollingOptions.sleepStrategy

sleepStrategy?: SleepStrategy;

Source: src/rpc/server.ts:90

rpc.Server.ResourceLeeway

Describes additional resource leeways for transaction simulation.

interface ResourceLeeway {
  cpuInstructions: number;
}

Source: src/rpc/server.ts:96

resourceLeeway.cpuInstructions

Simulate the transaction with more CPU instructions available.

cpuInstructions: number;

Source: src/rpc/server.ts:98