@stellar/stellar-sdk 14.2.0 → 14.3.0

package/lib/rpc/api.d.ts

@@ -179,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;
@@ -386,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/axios.js

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

package/lib/rpc/parsers.d.ts

@@ -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;
@@ -172,4 +173,26 @@ function parseRawSimulation(sim) {
     });
   }
   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
+  };
 }

package/lib/rpc/server.d.ts

@@ -20,14 +20,6 @@ export declare enum Durability {
     Temporary = "temporary",
     Persistent = "persistent"
 }
-/**
- * @typedef {object} GetEventsRequest Describes the complex filter combinations available for event queries.
- * @property {Array.<module:rpc.Api.EventFilter>} filters Filters to use when querying events from the RPC server.
- * @property {number} [startLedger] Ledger number (inclusive) to begin querying events.
- * @property {string} [cursor] Page cursor (exclusive) to begin querying events.
- * @property {number} [limit=100] The maximum number of events that should be returned in the RPC response.
- * @memberof module:rpc.Server
- */
 /**
  * @typedef {object} ResourceLeeway Describes additional resource leeways for transaction simulation.
  * @property {number} cpuInstructions Simulate the transaction with more CPU instructions available.
@@ -41,13 +33,11 @@ export declare enum Durability {
  * @memberof module:rpc.Server
  */
 export declare namespace RpcServer {
-    interface GetEventsRequest {
-        filters: Api.EventFilter[];
-        startLedger?: number;
-        endLedger?: number;
-        cursor?: string;
-        limit?: number;
-    }
+    /**
+     * @deprecated Use `Api.GetEventsRequest` instead.
+     * @see {@link Api.GetEventsRequest}
+     */
+    type GetEventsRequest = Api.GetEventsRequest;
     interface PollingOptions {
         attempts?: number;
         sleepStrategy?: SleepStrategy;
@@ -365,20 +355,21 @@ export declare class RpcServer {
     /**
      * Fetch all events that match a given set of filters.
      *
-     * The given filters (see {@link module:rpc.Api.EventFilter | Api.EventFilter}
+     * The given filters (see {@link 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
      * {@link Api.EventResponse} object to set the `cursor` parameter.
      *
-     * @param {module:rpc.Server.GetEventsRequest} request Event filters
+     * @param {Api.GetEventsRequest} request Event filters {@link Api.GetEventsRequest},
      * @returns {Promise<Api.GetEventsResponse>} A paginatable set of the events
      * matching the given event filters
      *
      * @see {@link https://developers.stellar.org/docs/data/rpc/api-reference/methods/getEvents | getEvents docs}
      *
      * @example
+     *
      * server.getEvents({
      *    startLedger: 1000,
      *    endLedger: 2000,
@@ -402,8 +393,8 @@ export declare class RpcServer {
      *    limit: 10,
      * });
      */
-    getEvents(request: RpcServer.GetEventsRequest): Promise<Api.GetEventsResponse>;
-    _getEvents(request: RpcServer.GetEventsRequest): Promise<Api.RawGetEventsResponse>;
+    getEvents(request: Api.GetEventsRequest): Promise<Api.GetEventsResponse>;
+    _getEvents(request: Api.GetEventsRequest): Promise<Api.RawGetEventsResponse>;
     /**
      * Fetch metadata about the network this Soroban RPC server is connected to.
      *
@@ -624,7 +615,7 @@ export declare class RpcServer {
      *    off" if it already exists)
      * @throws If Friendbot is not configured on this network or request failure
      *
-     * @see {@link https://developers.stellar.org/docs/learn/networks#friendbot | Friendbot docs}
+     * @see {@link https://developers.stellar.org/docs/learn/fundamentals/networks#friendbot | Friendbot docs}
      * @see {@link module:Friendbot.Api.Response}
      *
      * @example
@@ -692,4 +683,44 @@ export declare class RpcServer {
      *   "Address has no XLM");
      */
     getSACBalance(address: string | Address, sac: Asset, networkPassphrase?: string): Promise<Api.BalanceResponse>;
+    /**
+     * 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.
+     *
+     * @param {Api.GetLedgersRequest} request - The request parameters for fetching ledgers. {@link Api.GetLedgersRequest}
+     * @returns {Promise<Api.GetLedgersResponse>} A promise that resolves to the
+     *    ledgers response containing an array of ledger data and pagination info. {@link Api.GetLedgersResponse}
+     *
+     * @throws {Error} If startLedger is less than the oldest ledger stored in this
+     *    node, or greater than the latest ledger seen by this node.
+     *
+     * @see {@link https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLedgers | getLedgers docs}
+     *
+     * @example
+     * // Fetch ledgers starting from a specific sequence number
+     * server.getLedgers({
+     *   startLedger: 36233,
+     *   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,
+     *   limit: 5
+     * });
+     *
+     * const nextPage = await server.getLedgers({
+     *   cursor: firstPage.cursor,
+     *   limit: 5
+     * });
+     */
+    getLedgers(request: Api.GetLedgersRequest): Promise<Api.GetLedgersResponse>;
+    _getLedgers(request: Api.GetLedgersRequest): Promise<Api.RawGetLedgersResponse>;
 }

package/lib/rpc/server.js

@@ -936,5 +936,47 @@ var RpcServer = exports.RpcServer = function () {
       }
       return getSACBalance;
     }())
+  }, {
+    key: "getLedgers",
+    value: (function () {
+      var _getLedgers2 = _asyncToGenerator(_regenerator().m(function _callee26(request) {
+        return _regenerator().w(function (_context26) {
+          while (1) switch (_context26.n) {
+            case 0:
+              return _context26.a(2, this._getLedgers(request).then(function (raw) {
+                var result = {
+                  ledgers: (raw.ledgers || []).map(_parsers.parseRawLedger),
+                  latestLedger: raw.latestLedger,
+                  latestLedgerCloseTime: raw.latestLedgerCloseTime,
+                  oldestLedger: raw.oldestLedger,
+                  oldestLedgerCloseTime: raw.oldestLedgerCloseTime,
+                  cursor: raw.cursor
+                };
+                return result;
+              }));
+          }
+        }, _callee26, this);
+      }));
+      function getLedgers(_x31) {
+        return _getLedgers2.apply(this, arguments);
+      }
+      return getLedgers;
+    }())
+  }, {
+    key: "_getLedgers",
+    value: function () {
+      var _getLedgers3 = _asyncToGenerator(_regenerator().m(function _callee27(request) {
+        return _regenerator().w(function (_context27) {
+          while (1) switch (_context27.n) {
+            case 0:
+              return _context27.a(2, jsonrpc.postObject(this.serverURL.toString(), "getLedgers", request));
+          }
+        }, _callee27, this);
+      }));
+      function _getLedgers(_x32) {
+        return _getLedgers3.apply(this, arguments);
+      }
+      return _getLedgers;
+    }()
   }]);
 }();

package/lib/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/stellar-sdk",
-  "version": "14.2.0",
+  "version": "14.3.0",
   "description": "A library for working with the Stellar network, including communication with the Horizon and Soroban RPC servers.",
   "keywords": [
     "stellar"
@@ -111,7 +111,7 @@
     "_build": "yarn build:node:all && yarn build:test && yarn build:browser:all",
     "_babel": "babel --extensions '.ts' --out-dir ${OUTPUT_DIR:-lib} src/",
     "_nyc": "node node_modules/.bin/nyc --nycrc-path config/.nycrc",
-    "_prettier": "prettier --config config/prettier.config.js --ignore-path config/.prettierignore --write './src/**/*.ts' './test/**/*.js'"
+    "_prettier": "prettier --config config/prettier.config.js --ignore-path config/.prettierignore --write './src/**/*.ts' './test/**/*.{js,ts}'"
   },
   "husky": {
     "hooks": {
@@ -215,7 +215,7 @@
     "terser-webpack-plugin": "^5.3.14",
     "ts-node": "^10.9.2",
     "typescript": "5.6.3",
-    "webpack": "^5.101.3",
+    "webpack": "^5.102.1",
     "webpack-cli": "^5.0.1"
   },
   "dependencies": {