@stellar/stellar-sdk 14.1.1 → 14.3.0

package/lib/no-eventsource/rpc/transaction.d.ts

@@ -1,5 +1,5 @@
-import { FeeBumpTransaction, Transaction, TransactionBuilder } from '@stellar/stellar-base';
-import { Api } from './api';
+import { FeeBumpTransaction, Transaction, TransactionBuilder } from "@stellar/stellar-base";
+import { Api } from "./api";
 /**
  * Combines the given raw transaction alongside the simulation results.
  * If the given transaction already has authorization entries in a host

package/lib/no-eventsource/rpc/transaction.js

@@ -12,20 +12,20 @@ function isSorobanTransaction(tx) {
     return false;
   }
   switch (tx.operations[0].type) {
-    case 'invokeHostFunction':
-    case 'extendFootprintTtl':
-    case 'restoreFootprint':
+    case "invokeHostFunction":
+    case "extendFootprintTtl":
+    case "restoreFootprint":
       return true;
     default:
       return false;
   }
 }
 function assembleTransaction(raw, simulation) {
-  if ('innerTransaction' in raw) {
+  if ("innerTransaction" in raw) {
     return assembleTransaction(raw.innerTransaction, simulation);
   }
   if (!isSorobanTransaction(raw)) {
-    throw new TypeError('unsupported transaction: must contain exactly one ' + 'invokeHostFunction, extendFootprintTtl, or restoreFootprint ' + 'operation');
+    throw new TypeError("unsupported transaction: must contain exactly one " + "invokeHostFunction, extendFootprintTtl, or restoreFootprint " + "operation");
   }
   var success = (0, _parsers.parseRawSimulation)(simulation);
   if (!_api.Api.isSimulationSuccess(success)) {
@@ -38,7 +38,7 @@ function assembleTransaction(raw, simulation) {
     sorobanData: success.transactionData.build(),
     networkPassphrase: raw.networkPassphrase
   });
-  if (raw.operations[0].type === 'invokeHostFunction') {
+  if (raw.operations[0].type === "invokeHostFunction") {
     var _invokeOp$auth;
     txnBuilder.clearOperations();
     var invokeOp = raw.operations[0];

package/lib/no-eventsource/webauth/errors.d.ts

@@ -8,6 +8,4 @@
  * @param {string} message Human-readable error message.
  */
 export declare class InvalidChallengeError extends Error {
-    __proto__: InvalidChallengeError;
-    constructor(message: string);
 }

package/lib/no-eventsource/webauth/errors.js

@@ -21,15 +21,9 @@ function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).in
 function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
 function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
 var InvalidChallengeError = exports.InvalidChallengeError = function (_Error) {
-  function InvalidChallengeError(message) {
-    var _this;
+  function InvalidChallengeError() {
     _classCallCheck(this, InvalidChallengeError);
-    var trueProto = (this instanceof InvalidChallengeError ? this.constructor : void 0).prototype;
-    _this = _callSuper(this, InvalidChallengeError, [message]);
-    _this.__proto__ = trueProto;
-    _this.constructor = InvalidChallengeError;
-    _this.name = "InvalidChallengeError";
-    return _this;
+    return _callSuper(this, InvalidChallengeError, arguments);
   }
   _inherits(InvalidChallengeError, _Error);
   return _createClass(InvalidChallengeError);

package/lib/no-eventsource/webauth/index.d.ts

@@ -1,2 +1,2 @@
-export * from './utils';
-export { InvalidChallengeError } from './errors';
+export * from "./utils";
+export { InvalidChallengeError } from "./errors";

package/lib/rpc/api.d.ts

@@ -1,7 +1,7 @@
-import { Contract, SorobanDataBuilder, xdr } from '@stellar/stellar-base';
+import { Contract, SorobanDataBuilder, xdr } from "@stellar/stellar-base";
 export declare namespace Api {
     export interface GetHealthResponse {
-        status: 'healthy';
+        status: "healthy";
     }
     export interface LedgerEntryResult {
         lastModifiedLedgerSeq?: number;
@@ -103,11 +103,19 @@ export declare namespace Api {
         diagnosticEventsXdr?: string[];
         events?: RawTransactionEvents;
     }
-    export interface GetTransactionsRequest {
+    export type GetTransactionsRequest = {
         startLedger: number;
-        cursor?: string;
-        limit?: number;
-    }
+        pagination?: {
+            cursor?: never;
+            limit?: number;
+        };
+    } | {
+        startLedger?: never;
+        pagination: {
+            cursor: string;
+            limit?: number;
+        };
+    };
     export interface RawTransactionEvents {
         transactionEventsXdr?: string[];
         contractEventsXdr?: string[][];
@@ -159,7 +167,7 @@ export declare namespace Api {
         oldestLedgerCloseTimestamp: number;
         cursor: string;
     }
-    export type EventType = 'contract' | 'system';
+    export type EventType = "contract" | "system";
     export interface EventFilter {
         type?: EventType;
         contractIds?: string[];
@@ -171,6 +179,55 @@ export declare namespace Api {
         latestLedgerCloseTime: string;
         oldestLedgerCloseTime: string;
     }
+    /**
+     * 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)
+     *
+     * @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 {@link https://developers.stellar.org/docs/data/rpc/api-reference/methods/getEvents | getEvents API reference}
+     */
+    export type GetEventsRequest = {
+        filters: Api.EventFilter[];
+        startLedger: number;
+        endLedger: number;
+        cursor?: never;
+        limit?: number;
+    } | {
+        filters: Api.EventFilter[];
+        cursor: string;
+        startLedger?: never;
+        endLedger?: never;
+        limit?: number;
+    };
     export interface GetEventsResponse extends RetentionState {
         events: EventResponse[];
         cursor: string;
@@ -214,7 +271,7 @@ export declare namespace Api {
         before: xdr.LedgerEntry | null;
         after: xdr.LedgerEntry | null;
     }
-    export type SendTransactionStatus = 'PENDING' | 'DUPLICATE' | 'TRY_AGAIN_LATER' | 'ERROR';
+    export type SendTransactionStatus = "PENDING" | "DUPLICATE" | "TRY_AGAIN_LATER" | "ERROR";
     export interface SendTransactionResponse extends BaseSendTransactionResponse {
         errorResult?: xdr.TransactionResult;
         diagnosticEvents?: xdr.DiagnosticEvent[];
@@ -378,5 +435,88 @@ export declare namespace Api {
             liveUntilLedgerSeq?: number;
         };
     }
+    /**
+     * 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
+     *
+     * @typedef {object} GetLedgersRequest
+     * @property {number} [startLedger] - Ledger sequence number to start fetching from (inclusive).
+     *   Must be omitted if cursor is provided. Cannot be less than the oldest ledger or greater
+     *   than the latest ledger stored on the RPC node.
+     * @property {object} [pagination] - Pagination configuration for the request.
+     * @property {string} [pagination.cursor] - Page cursor for continuing pagination from a previous
+     *   response. Must be omitted if startLedger is provided.
+     * @property {number} [pagination.limit=100] - Maximum number of ledgers to return per page.
+     *   Valid range: 1-10000. Defaults to 100 if not specified.
+     *
+     * @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 {@link https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLedgers | getLedgers API reference}
+     */
+    export type GetLedgersRequest = {
+        startLedger: number;
+        pagination?: {
+            cursor?: never;
+            limit?: number;
+        };
+    } | {
+        startLedger?: never;
+        pagination: {
+            cursor: string;
+            limit?: number;
+        };
+    };
+    /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLedgers */
+    export interface GetLedgersResponse {
+        ledgers: LedgerResponse[];
+        latestLedger: number;
+        latestLedgerCloseTime: number;
+        oldestLedger: number;
+        oldestLedgerCloseTime: number;
+        cursor: string;
+    }
+    export interface RawGetLedgersResponse {
+        ledgers: RawLedgerResponse[];
+        latestLedger: number;
+        latestLedgerCloseTime: number;
+        oldestLedger: number;
+        oldestLedgerCloseTime: number;
+        cursor: string;
+    }
+    export interface LedgerResponse {
+        hash: string;
+        sequence: number;
+        ledgerCloseTime: string;
+        headerXdr: xdr.LedgerHeaderHistoryEntry;
+        metadataXdr: xdr.LedgerCloseMeta;
+    }
+    export interface RawLedgerResponse {
+        hash: string;
+        sequence: number;
+        ledgerCloseTime: string;
+        /** a base-64 encoded {@link xdr.LedgerHeaderHistoryEntry} instance */
+        headerXdr: string;
+        /** a base-64 encoded {@link xdr.LedgerCloseMeta} instance */
+        metadataXdr: string;
+    }
     export {};
 }

package/lib/rpc/api.js

@@ -14,15 +14,15 @@ var Api;
   }({});
   _Api.GetTransactionStatus = GetTransactionStatus;
   function isSimulationError(sim) {
-    return 'error' in sim;
+    return "error" in sim;
   }
   _Api.isSimulationError = isSimulationError;
   function isSimulationSuccess(sim) {
-    return 'transactionData' in sim;
+    return "transactionData" in sim;
   }
   _Api.isSimulationSuccess = isSimulationSuccess;
   function isSimulationRestore(sim) {
-    return isSimulationSuccess(sim) && 'restorePreamble' in sim && !!sim.restorePreamble.transactionData;
+    return isSimulationSuccess(sim) && "restorePreamble" in sim && !!sim.restorePreamble.transactionData;
   }
   _Api.isSimulationRestore = isSimulationRestore;
   function isSimulationRaw(sim) {

package/lib/rpc/axios.js

@@ -5,11 +5,11 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.version = exports.default = exports.AxiosClient = void 0;
 var _httpClient = require("../http-client");
-var version = exports.version = "14.1.1";
+var version = exports.version = "14.3.0";
 var AxiosClient = exports.AxiosClient = (0, _httpClient.create)({
   headers: {
-    'X-Client-Name': 'js-soroban-client',
-    'X-Client-Version': version
+    "X-Client-Name": "js-soroban-client",
+    "X-Client-Version": version
   }
 });
 var _default = exports.default = AxiosClient;

package/lib/rpc/browser.d.ts

@@ -1,4 +1,4 @@
-export * from './index';
-export * as StellarBase from '@stellar/stellar-base';
+export * from "./index";
+export * as StellarBase from "@stellar/stellar-base";
 declare const _default: any;
 export default _default;

package/lib/rpc/index.d.ts

@@ -1,6 +1,6 @@
 /** @module rpc */
 export * from "./api";
-export { RpcServer as Server, BasicSleepStrategy, LinearSleepStrategy, Durability } from "./server";
+export { RpcServer as Server, BasicSleepStrategy, LinearSleepStrategy, Durability, } from "./server";
 export { default as AxiosClient } from "./axios";
 export { parseRawSimulation, parseRawEvents } from "./parsers";
 export * from "./transaction";

package/lib/rpc/parsers.d.ts

@@ -1,4 +1,4 @@
-import { Api } from './api';
+import { Api } from "./api";
 /**
  * Parse the response from invoking the `submitTransaction` method of a RPC server.
  * @memberof module:rpc
@@ -8,7 +8,7 @@ import { Api } from './api';
  * @returns {Api.SendTransactionResponse} transaction response parsed from the RPC server's response
  */
 export declare function parseRawSendTransaction(raw: Api.RawSendTransactionResponse): Api.SendTransactionResponse;
-export declare function parseTransactionInfo(raw: Api.RawTransactionInfo | Api.RawGetTransactionResponse): Omit<Api.TransactionInfo, 'status' | 'txHash'>;
+export declare function parseTransactionInfo(raw: Api.RawTransactionInfo | Api.RawGetTransactionResponse): Omit<Api.TransactionInfo, "status" | "txHash">;
 export declare function parseRawTransactions(r: Api.RawTransactionInfo): Api.TransactionInfo;
 /**
  * Parse and return the retrieved events, if any, from a raw response from a
@@ -43,3 +43,4 @@ export declare function parseRawLedgerEntries(raw: Api.RawGetLedgerEntriesRespon
  * @returns {Api.SimulateTransactionResponse} the original parameter (if already parsed), parsed otherwise
  */
 export declare function parseRawSimulation(sim: Api.SimulateTransactionResponse | Api.RawSimulateTransactionResponse): Api.SimulateTransactionResponse;
+export declare function parseRawLedger(raw: Api.RawLedgerResponse): Api.LedgerResponse;

package/lib/rpc/parsers.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseRawEvents = parseRawEvents;
+exports.parseRawLedger = parseRawLedger;
 exports.parseRawLedgerEntries = parseRawLedgerEntries;
 exports.parseRawSendTransaction = parseRawSendTransaction;
 exports.parseRawSimulation = parseRawSimulation;
@@ -25,24 +26,24 @@ function parseRawSendTransaction(raw) {
   if (errorResultXdr) {
     return _objectSpread(_objectSpread(_objectSpread({}, raw), diagnosticEventsXdr !== undefined && diagnosticEventsXdr.length > 0 && {
       diagnosticEvents: diagnosticEventsXdr.map(function (evt) {
-        return _stellarBase.xdr.DiagnosticEvent.fromXDR(evt, 'base64');
+        return _stellarBase.xdr.DiagnosticEvent.fromXDR(evt, "base64");
       })
     }), {}, {
-      errorResult: _stellarBase.xdr.TransactionResult.fromXDR(errorResultXdr, 'base64')
+      errorResult: _stellarBase.xdr.TransactionResult.fromXDR(errorResultXdr, "base64")
     });
   }
   return _objectSpread({}, raw);
 }
 function parseTransactionInfo(raw) {
   var _raw$events$contractE, _raw$events, _raw$events$transacti, _raw$events2;
-  var meta = _stellarBase.xdr.TransactionMeta.fromXDR(raw.resultMetaXdr, 'base64');
+  var meta = _stellarBase.xdr.TransactionMeta.fromXDR(raw.resultMetaXdr, "base64");
   var info = {
     ledger: raw.ledger,
     createdAt: raw.createdAt,
     applicationOrder: raw.applicationOrder,
     feeBump: raw.feeBump,
-    envelopeXdr: _stellarBase.xdr.TransactionEnvelope.fromXDR(raw.envelopeXdr, 'base64'),
-    resultXdr: _stellarBase.xdr.TransactionResult.fromXDR(raw.resultXdr, 'base64'),
+    envelopeXdr: _stellarBase.xdr.TransactionEnvelope.fromXDR(raw.envelopeXdr, "base64"),
+    resultXdr: _stellarBase.xdr.TransactionResult.fromXDR(raw.resultXdr, "base64"),
     resultMetaXdr: meta,
     events: {
       contractEventsXdr: ((_raw$events$contractE = (_raw$events = raw.events) === null || _raw$events === void 0 ? void 0 : _raw$events.contractEventsXdr) !== null && _raw$events$contractE !== void 0 ? _raw$events$contractE : []).map(function (lst) {
@@ -66,7 +67,7 @@ function parseTransactionInfo(raw) {
   }
   if (raw.diagnosticEventsXdr) {
     info.diagnosticEventsXdr = raw.diagnosticEventsXdr.map(function (e) {
-      return _stellarBase.xdr.DiagnosticEvent.fromXDR(e, 'base64');
+      return _stellarBase.xdr.DiagnosticEvent.fromXDR(e, "base64");
     });
   }
   return info;
@@ -88,13 +89,13 @@ function parseRawEvents(raw) {
     events: ((_raw$events3 = raw.events) !== null && _raw$events3 !== void 0 ? _raw$events3 : []).map(function (evt) {
       var clone = _objectSpread({}, evt);
       delete clone.contractId;
-      return _objectSpread(_objectSpread(_objectSpread({}, clone), evt.contractId !== '' && {
+      return _objectSpread(_objectSpread(_objectSpread({}, clone), evt.contractId !== "" && {
         contractId: new _stellarBase.Contract(evt.contractId)
       }), {}, {
         topic: evt.topic.map(function (topic) {
-          return _stellarBase.xdr.ScVal.fromXDR(topic, 'base64');
+          return _stellarBase.xdr.ScVal.fromXDR(topic, "base64");
         }),
-        value: _stellarBase.xdr.ScVal.fromXDR(evt.value, 'base64')
+        value: _stellarBase.xdr.ScVal.fromXDR(evt.value, "base64")
       });
     })
   };
@@ -109,8 +110,8 @@ function parseRawLedgerEntries(raw) {
       }
       return _objectSpread({
         lastModifiedLedgerSeq: rawEntry.lastModifiedLedgerSeq,
-        key: _stellarBase.xdr.LedgerKey.fromXDR(rawEntry.key, 'base64'),
-        val: _stellarBase.xdr.LedgerEntryData.fromXDR(rawEntry.xdr, 'base64')
+        key: _stellarBase.xdr.LedgerKey.fromXDR(rawEntry.key, "base64"),
+        val: _stellarBase.xdr.LedgerEntryData.fromXDR(rawEntry.xdr, "base64")
       }, rawEntry.liveUntilLedgerSeq !== undefined && {
         liveUntilLedgerSeq: rawEntry.liveUntilLedgerSeq
       });
@@ -127,22 +128,22 @@ function parseSuccessful(sim, partial) {
       var _row$auth;
       return {
         auth: ((_row$auth = row.auth) !== null && _row$auth !== void 0 ? _row$auth : []).map(function (entry) {
-          return _stellarBase.xdr.SorobanAuthorizationEntry.fromXDR(entry, 'base64');
+          return _stellarBase.xdr.SorobanAuthorizationEntry.fromXDR(entry, "base64");
         }),
-        retval: row.xdr ? _stellarBase.xdr.ScVal.fromXDR(row.xdr, 'base64') : _stellarBase.xdr.ScVal.scvVoid()
+        retval: row.xdr ? _stellarBase.xdr.ScVal.fromXDR(row.xdr, "base64") : _stellarBase.xdr.ScVal.scvVoid()
       };
     })[0]
   }), ((_sim$stateChanges$len = (_sim$stateChanges = sim.stateChanges) === null || _sim$stateChanges === void 0 ? void 0 : _sim$stateChanges.length) !== null && _sim$stateChanges$len !== void 0 ? _sim$stateChanges$len : 0 > 0) && {
     stateChanges: (_sim$stateChanges2 = sim.stateChanges) === null || _sim$stateChanges2 === void 0 ? void 0 : _sim$stateChanges2.map(function (entryChange) {
       return {
         type: entryChange.type,
-        key: _stellarBase.xdr.LedgerKey.fromXDR(entryChange.key, 'base64'),
-        before: entryChange.before ? _stellarBase.xdr.LedgerEntry.fromXDR(entryChange.before, 'base64') : null,
-        after: entryChange.after ? _stellarBase.xdr.LedgerEntry.fromXDR(entryChange.after, 'base64') : null
+        key: _stellarBase.xdr.LedgerKey.fromXDR(entryChange.key, "base64"),
+        before: entryChange.before ? _stellarBase.xdr.LedgerEntry.fromXDR(entryChange.before, "base64") : null,
+        after: entryChange.after ? _stellarBase.xdr.LedgerEntry.fromXDR(entryChange.after, "base64") : null
       };
     })
   });
-  if (!sim.restorePreamble || sim.restorePreamble.transactionData === '') {
+  if (!sim.restorePreamble || sim.restorePreamble.transactionData === "") {
     return success;
   }
   return _objectSpread(_objectSpread({}, success), {}, {
@@ -163,13 +164,35 @@ function parseRawSimulation(sim) {
     id: sim.id,
     latestLedger: sim.latestLedger,
     events: (_sim$events$map = (_sim$events = sim.events) === null || _sim$events === void 0 ? void 0 : _sim$events.map(function (evt) {
-      return _stellarBase.xdr.DiagnosticEvent.fromXDR(evt, 'base64');
+      return _stellarBase.xdr.DiagnosticEvent.fromXDR(evt, "base64");
     })) !== null && _sim$events$map !== void 0 ? _sim$events$map : []
   };
-  if (typeof sim.error === 'string') {
+  if (typeof sim.error === "string") {
     return _objectSpread(_objectSpread({}, base), {}, {
       error: sim.error
     });
   }
   return parseSuccessful(sim, base);
+}
+function parseRawLedger(raw) {
+  if (!raw.metadataXdr || !raw.headerXdr) {
+    var missingFields;
+    if (!raw.metadataXdr && !raw.headerXdr) {
+      missingFields = "metadataXdr and headerXdr";
+    } else if (!raw.metadataXdr) {
+      missingFields = "metadataXdr";
+    } else {
+      missingFields = "headerXdr";
+    }
+    throw new TypeError("invalid ledger missing fields: ".concat(missingFields));
+  }
+  var metadataXdr = _stellarBase.xdr.LedgerCloseMeta.fromXDR(raw.metadataXdr, "base64");
+  var headerXdr = _stellarBase.xdr.LedgerHeaderHistoryEntry.fromXDR(raw.headerXdr, "base64");
+  return {
+    hash: raw.hash,
+    sequence: raw.sequence,
+    ledgerCloseTime: raw.ledgerCloseTime,
+    metadataXdr: metadataXdr,
+    headerXdr: headerXdr
+  };
 }