stelar-sdk 12.3.0

package/lib/index.d.ts

@@ -0,0 +1,37 @@
+export * from './errors';
+export { Config } from './config';
+export { Utils } from './utils';
+export * as StellarToml from './stellartoml';
+export * as Federation from './federation';
+export * as WebAuth from './webauth';
+export * as Friendbot from './friendbot';
+export * as Horizon from './horizon';
+/**
+ * Tools for interacting with the Soroban RPC server, such as `Server`,
+ * `assembleTransaction`, and the `Api` types. You can import these from the
+ * `/rpc` entrypoint, if your version of Node and your TypeScript configuration
+ * allow it:
+ *
+ * ```ts
+ * import { Server } from '@stellar/stellar-sdk/rpc';
+ * ```
+ */
+export * as rpc from './rpc';
+/**
+ * @deprecated Use `rpc` instead
+ */
+export * as SorobanRpc from './rpc';
+/**
+ * Tools for interacting with smart contracts, such as `Client`, `Spec`, and
+ * `AssembledTransaction`. You can import these from the `/contract`
+ * entrypoint, if your version of Node and your TypeScript configuration allow
+ * it:
+ *
+ * ```ts
+ * import { Client } from '@stellar/stellar-sdk/contract';
+ * ```
+ */
+export * as contract from './contract';
+export * from '@stellar/stellar-base';
+declare const _default: any;
+export default _default;

package/lib/index.js

@@ -0,0 +1,77 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Config: true,
+  Utils: true,
+  StellarToml: true,
+  Federation: true,
+  WebAuth: true,
+  Friendbot: true,
+  Horizon: true,
+  rpc: true,
+  SorobanRpc: true,
+  contract: true
+};
+Object.defineProperty(exports, "Config", {
+  enumerable: true,
+  get: function get() {
+    return _config.Config;
+  }
+});
+exports.StellarToml = exports.SorobanRpc = exports.Horizon = exports.Friendbot = exports.Federation = void 0;
+Object.defineProperty(exports, "Utils", {
+  enumerable: true,
+  get: function get() {
+    return _utils.Utils;
+  }
+});
+exports.rpc = exports.default = exports.contract = exports.WebAuth = void 0;
+var _errors = require("./errors");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _errors[key];
+    }
+  });
+});
+var _config = require("./config");
+var _utils = require("./utils");
+var _StellarToml = _interopRequireWildcard(require("./stellartoml"));
+exports.StellarToml = _StellarToml;
+var _Federation = _interopRequireWildcard(require("./federation"));
+exports.Federation = _Federation;
+var _WebAuth = _interopRequireWildcard(require("./webauth"));
+exports.WebAuth = _WebAuth;
+var _Friendbot = _interopRequireWildcard(require("./friendbot"));
+exports.Friendbot = _Friendbot;
+var _Horizon = _interopRequireWildcard(require("./horizon"));
+exports.Horizon = _Horizon;
+var _rpc = _interopRequireWildcard(require("./rpc"));
+var _SorobanRpc = _rpc;
+exports.rpc = _rpc;
+exports.SorobanRpc = _rpc;
+var _contract = _interopRequireWildcard(require("./contract"));
+exports.contract = _contract;
+var _stellarBase = require("@stellar/stellar-base");
+Object.keys(_stellarBase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _stellarBase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _stellarBase[key];
+    }
+  });
+});
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var _default = exports.default = module.exports;

package/lib/rpc/api.d.ts

@@ -0,0 +1,348 @@
+import { Contract, SorobanDataBuilder, xdr } from '@stellar/stellar-base';
+/** @namespace Api */
+export declare namespace Api {
+    export interface Cost {
+        cpuInsns: string;
+        memBytes: string;
+    }
+    export interface GetHealthResponse {
+        status: 'healthy';
+    }
+    export interface LedgerEntryResult {
+        lastModifiedLedgerSeq?: number;
+        key: xdr.LedgerKey;
+        val: xdr.LedgerEntryData;
+        liveUntilLedgerSeq?: number;
+    }
+    export interface RawLedgerEntryResult {
+        lastModifiedLedgerSeq?: number;
+        /** a base-64 encoded {@link xdr.LedgerKey} instance */
+        key: string;
+        /** a base-64 encoded {@link xdr.LedgerEntryData} instance */
+        xdr: string;
+        /**
+         * optional, a future ledger number upon which this entry will expire
+         *  based on https://github.com/stellar/soroban-tools/issues/1010
+         */
+        liveUntilLedgerSeq?: number;
+    }
+    /** An XDR-parsed version of {@link this.RawLedgerEntryResult} */
+    export interface GetLedgerEntriesResponse {
+        entries: LedgerEntryResult[];
+        latestLedger: number;
+    }
+    /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLedgerEntries */
+    export interface RawGetLedgerEntriesResponse {
+        entries?: RawLedgerEntryResult[];
+        latestLedger: number;
+    }
+    /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/getNetwork */
+    export interface GetNetworkResponse {
+        friendbotUrl?: string;
+        passphrase: string;
+        protocolVersion: string;
+    }
+    /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLatestLedger */
+    export interface GetLatestLedgerResponse {
+        id: string;
+        sequence: number;
+        protocolVersion: string;
+    }
+    export enum GetTransactionStatus {
+        SUCCESS = "SUCCESS",
+        NOT_FOUND = "NOT_FOUND",
+        FAILED = "FAILED"
+    }
+    /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/getTransaction */
+    export type GetTransactionResponse = GetSuccessfulTransactionResponse | GetFailedTransactionResponse | GetMissingTransactionResponse;
+    interface GetAnyTransactionResponse {
+        status: GetTransactionStatus;
+        latestLedger: number;
+        latestLedgerCloseTime: number;
+        oldestLedger: number;
+        oldestLedgerCloseTime: number;
+    }
+    export interface GetMissingTransactionResponse extends GetAnyTransactionResponse {
+        status: GetTransactionStatus.NOT_FOUND;
+    }
+    export interface GetFailedTransactionResponse extends GetAnyTransactionResponse {
+        status: GetTransactionStatus.FAILED;
+        ledger: number;
+        createdAt: number;
+        applicationOrder: number;
+        feeBump: boolean;
+        envelopeXdr: xdr.TransactionEnvelope;
+        resultXdr: xdr.TransactionResult;
+        resultMetaXdr: xdr.TransactionMeta;
+        diagnosticEventsXdr?: xdr.DiagnosticEvent[];
+    }
+    export interface GetSuccessfulTransactionResponse extends GetAnyTransactionResponse {
+        status: GetTransactionStatus.SUCCESS;
+        ledger: number;
+        createdAt: number;
+        applicationOrder: number;
+        feeBump: boolean;
+        envelopeXdr: xdr.TransactionEnvelope;
+        resultXdr: xdr.TransactionResult;
+        resultMetaXdr: xdr.TransactionMeta;
+        diagnosticEventsXdr?: xdr.DiagnosticEvent[];
+        returnValue?: xdr.ScVal;
+    }
+    export interface RawGetTransactionResponse {
+        status: GetTransactionStatus;
+        latestLedger: number;
+        latestLedgerCloseTime: number;
+        oldestLedger: number;
+        oldestLedgerCloseTime: number;
+        applicationOrder?: number;
+        feeBump?: boolean;
+        envelopeXdr?: string;
+        resultXdr?: string;
+        resultMetaXdr?: string;
+        ledger?: number;
+        createdAt?: number;
+        diagnosticEventsXdr?: string[];
+    }
+    export interface GetTransactionsRequest {
+        startLedger: number;
+        cursor?: string;
+        limit?: number;
+    }
+    export interface RawTransactionInfo {
+        status: GetTransactionStatus;
+        ledger: number;
+        createdAt: number;
+        applicationOrder: number;
+        feeBump: boolean;
+        envelopeXdr?: string;
+        resultXdr?: string;
+        resultMetaXdr?: string;
+        diagnosticEventsXdr?: string[];
+    }
+    export interface TransactionInfo {
+        status: GetTransactionStatus;
+        ledger: number;
+        createdAt: number;
+        applicationOrder: number;
+        feeBump: boolean;
+        envelopeXdr: xdr.TransactionEnvelope;
+        resultXdr: xdr.TransactionResult;
+        resultMetaXdr: xdr.TransactionMeta;
+        returnValue?: xdr.ScVal;
+        diagnosticEventsXdr?: xdr.DiagnosticEvent[];
+    }
+    export interface GetTransactionsResponse {
+        transactions: TransactionInfo[];
+        latestLedger: number;
+        latestLedgerCloseTimestamp: number;
+        oldestLedger: number;
+        oldestLedgerCloseTimestamp: number;
+        cursor: string;
+    }
+    export interface RawGetTransactionsResponse {
+        transactions: RawTransactionInfo[];
+        latestLedger: number;
+        latestLedgerCloseTimestamp: number;
+        oldestLedger: number;
+        oldestLedgerCloseTimestamp: number;
+        cursor: string;
+    }
+    export type EventType = 'contract' | 'system' | 'diagnostic';
+    export interface EventFilter {
+        type?: EventType;
+        contractIds?: string[];
+        topics?: string[][];
+    }
+    export interface GetEventsResponse {
+        latestLedger: number;
+        events: EventResponse[];
+    }
+    export interface EventResponse extends BaseEventResponse {
+        contractId?: Contract;
+        topic: xdr.ScVal[];
+        value: xdr.ScVal;
+    }
+    export interface RawGetEventsResponse {
+        latestLedger: number;
+        events: RawEventResponse[];
+    }
+    interface BaseEventResponse {
+        id: string;
+        type: EventType;
+        ledger: number;
+        ledgerClosedAt: string;
+        pagingToken: string;
+        inSuccessfulContractCall: boolean;
+        txHash: string;
+    }
+    export interface RawEventResponse extends BaseEventResponse {
+        contractId: string;
+        topic: string[];
+        value: string;
+    }
+    interface RawLedgerEntryChange {
+        type: number;
+        /** This is LedgerKey in base64 */
+        key: string;
+        /** This is xdr.LedgerEntry in base64 */
+        before: string | null;
+        /** This is xdr.LedgerEntry in base64 */
+        after: string | null;
+    }
+    export interface LedgerEntryChange {
+        type: number;
+        key: xdr.LedgerKey;
+        before: xdr.LedgerEntry | null;
+        after: xdr.LedgerEntry | null;
+    }
+    export type SendTransactionStatus = 'PENDING' | 'DUPLICATE' | 'TRY_AGAIN_LATER' | 'ERROR';
+    export interface SendTransactionResponse extends BaseSendTransactionResponse {
+        errorResult?: xdr.TransactionResult;
+        diagnosticEvents?: xdr.DiagnosticEvent[];
+    }
+    export interface RawSendTransactionResponse extends BaseSendTransactionResponse {
+        /**
+         * This is a base64-encoded instance of {@link xdr.TransactionResult}, set
+         * only when `status` is `"ERROR"`.
+         *
+         * It contains details on why the network rejected the transaction.
+         */
+        errorResultXdr?: string;
+        /**
+         * This is a base64-encoded instance of an array of
+         * {@link xdr.DiagnosticEvent}s, set only when `status` is `"ERROR"` and
+         * diagnostic events are enabled on the server.
+         */
+        diagnosticEventsXdr?: string[];
+    }
+    export interface BaseSendTransactionResponse {
+        status: SendTransactionStatus;
+        hash: string;
+        latestLedger: number;
+        latestLedgerCloseTime: number;
+    }
+    export interface SimulateHostFunctionResult {
+        auth: xdr.SorobanAuthorizationEntry[];
+        retval: xdr.ScVal;
+    }
+    /**
+     * Simplifies {@link Api.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
+     *
+     * @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/simulateTransaction
+     */
+    export type SimulateTransactionResponse = SimulateTransactionSuccessResponse | SimulateTransactionRestoreResponse | SimulateTransactionErrorResponse;
+    export interface BaseSimulateTransactionResponse {
+        /** always present: the JSON-RPC request ID */
+        id: string;
+        /** always present: the LCL known to the server when responding */
+        latestLedger: number;
+        /**
+         * The field is always present, but may be empty in cases where:
+         *   - you didn't simulate an invocation or
+         *   - there were no events
+         */
+        events: xdr.DiagnosticEvent[];
+        /** a private field to mark the schema as parsed */
+        _parsed: boolean;
+    }
+    /** Includes simplified fields only present on success. */
+    export interface SimulateTransactionSuccessResponse extends BaseSimulateTransactionResponse {
+        transactionData: SorobanDataBuilder;
+        minResourceFee: string;
+        cost: Cost;
+        /** present only for invocation simulation */
+        result?: SimulateHostFunctionResult;
+        /** State Difference information */
+        stateChanges?: LedgerEntryChange[];
+    }
+    /** Includes details about why the simulation failed */
+    export interface SimulateTransactionErrorResponse extends BaseSimulateTransactionResponse {
+        error: string;
+        events: xdr.DiagnosticEvent[];
+    }
+    export interface SimulateTransactionRestoreResponse extends SimulateTransactionSuccessResponse {
+        result: SimulateHostFunctionResult;
+        /**
+         * 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;
+        };
+    }
+    export function isSimulationError(sim: SimulateTransactionResponse): sim is SimulateTransactionErrorResponse;
+    export function isSimulationSuccess(sim: SimulateTransactionResponse): sim is SimulateTransactionSuccessResponse;
+    export function isSimulationRestore(sim: SimulateTransactionResponse): sim is SimulateTransactionRestoreResponse;
+    export function isSimulationRaw(sim: Api.SimulateTransactionResponse | Api.RawSimulateTransactionResponse): sim is Api.RawSimulateTransactionResponse;
+    interface RawSimulateHostFunctionResult {
+        auth?: string[];
+        xdr: string;
+    }
+    /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/simulateTransaction */
+    export interface RawSimulateTransactionResponse {
+        id: string;
+        latestLedger: number;
+        error?: string;
+        /** This is an xdr.SorobanTransactionData in base64 */
+        transactionData?: string;
+        /** These are xdr.DiagnosticEvents in base64 */
+        events?: string[];
+        minResourceFee?: string;
+        /**
+         * This will only contain a single element if present, because only a single
+         * invokeHostFunctionOperation is supported per transaction.
+         * */
+        results?: RawSimulateHostFunctionResult[];
+        cost?: Cost;
+        /** Present if succeeded but has expired ledger entries */
+        restorePreamble?: {
+            minResourceFee: string;
+            transactionData: string;
+        };
+        /** State Difference information */
+        stateChanges?: RawLedgerEntryChange[];
+    }
+    export interface GetVersionInfoResponse {
+        version: string;
+        commit_hash: string;
+        build_time_stamp: string;
+        captive_core_version: string;
+        protocol_version: number;
+    }
+    export interface GetFeeStatsResponse {
+        sorobanInclusionFee: FeeDistribution;
+        inclusionFee: FeeDistribution;
+        latestLedger: number;
+    }
+    interface FeeDistribution {
+        max: string;
+        min: string;
+        mode: string;
+        p10: string;
+        p20: string;
+        p30: string;
+        p40: string;
+        p50: string;
+        p60: string;
+        p70: string;
+        p80: string;
+        p90: string;
+        p95: string;
+        p99: string;
+        transactionCount: string;
+        ledgerCount: number;
+    }
+    export {};
+}

package/lib/rpc/api.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Api = void 0;
+var Api;
+(function (_Api) {
+  var GetTransactionStatus = function (GetTransactionStatus) {
+    GetTransactionStatus["SUCCESS"] = "SUCCESS";
+    GetTransactionStatus["NOT_FOUND"] = "NOT_FOUND";
+    GetTransactionStatus["FAILED"] = "FAILED";
+    return GetTransactionStatus;
+  }({});
+  _Api.GetTransactionStatus = GetTransactionStatus;
+  function isSimulationError(sim) {
+    return 'error' in sim;
+  }
+  _Api.isSimulationError = isSimulationError;
+  function isSimulationSuccess(sim) {
+    return 'transactionData' in sim;
+  }
+  _Api.isSimulationSuccess = isSimulationSuccess;
+  function isSimulationRestore(sim) {
+    return isSimulationSuccess(sim) && 'restorePreamble' in sim && !!sim.restorePreamble.transactionData;
+  }
+  _Api.isSimulationRestore = isSimulationRestore;
+  function isSimulationRaw(sim) {
+    return !sim._parsed;
+  }
+  _Api.isSimulationRaw = isSimulationRaw;
+})(Api || (exports.Api = Api = {}));

package/lib/rpc/axios.d.ts

@@ -0,0 +1,3 @@
+export declare const version: any;
+export declare const AxiosClient: import("axios").AxiosInstance;
+export default AxiosClient;

package/lib/rpc/axios.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.version = exports.default = exports.AxiosClient = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var version = exports.version = require('../../package.json').version;
+var AxiosClient = exports.AxiosClient = _axios.default.create({
+  headers: {
+    'X-Client-Name': 'js-soroban-client',
+    'X-Client-Version': version
+  }
+});
+var _default = exports.default = AxiosClient;

package/lib/rpc/browser.d.ts

@@ -0,0 +1,6 @@
+import axios from 'axios';
+export * from './index';
+export * as StellarBase from '@stellar/stellar-base';
+export { axios };
+declare const _default: any;
+export default _default;

package/lib/rpc/browser.js

@@ -0,0 +1,37 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  axios: true,
+  StellarBase: true
+};
+exports.StellarBase = void 0;
+Object.defineProperty(exports, "axios", {
+  enumerable: true,
+  get: function get() {
+    return _axios.default;
+  }
+});
+exports.default = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _index = require("./index");
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _index[key];
+    }
+  });
+});
+var _StellarBase = _interopRequireWildcard(require("@stellar/stellar-base"));
+exports.StellarBase = _StellarBase;
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = module.exports;

package/lib/rpc/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./api";
+export { Server, Durability } from "./server";
+export { default as AxiosClient } from "./axios";
+export { parseRawSimulation, parseRawEvents } from "./parsers";
+export * from "./transaction";
+declare const _default: any;
+export default _default;

package/lib/rpc/index.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Server: true,
+  Durability: true,
+  AxiosClient: true,
+  parseRawSimulation: true,
+  parseRawEvents: true
+};
+Object.defineProperty(exports, "AxiosClient", {
+  enumerable: true,
+  get: function get() {
+    return _axios.default;
+  }
+});
+Object.defineProperty(exports, "Durability", {
+  enumerable: true,
+  get: function get() {
+    return _server.Durability;
+  }
+});
+Object.defineProperty(exports, "Server", {
+  enumerable: true,
+  get: function get() {
+    return _server.Server;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "parseRawEvents", {
+  enumerable: true,
+  get: function get() {
+    return _parsers.parseRawEvents;
+  }
+});
+Object.defineProperty(exports, "parseRawSimulation", {
+  enumerable: true,
+  get: function get() {
+    return _parsers.parseRawSimulation;
+  }
+});
+var _api = require("./api");
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _api[key];
+    }
+  });
+});
+var _server = require("./server");
+var _axios = _interopRequireDefault(require("./axios"));
+var _parsers = require("./parsers");
+var _transaction = require("./transaction");
+Object.keys(_transaction).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _transaction[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _transaction[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = module.exports;

package/lib/rpc/jsonrpc.d.ts

@@ -0,0 +1,27 @@
+export type Id = string | number;
+export interface Request<T> {
+    jsonrpc: "2.0";
+    id: Id;
+    method: string;
+    params: T;
+}
+export interface Notification<T> {
+    jsonrpc: "2.0";
+    method: string;
+    params?: T;
+}
+export type Response<T, E = any> = {
+    jsonrpc: "2.0";
+    id: Id;
+} & ({
+    error: Error<E>;
+} | {
+    result: T;
+});
+export interface Error<E = any> {
+    code: number;
+    message?: string;
+    data?: E;
+}
+/** Sends the jsonrpc 'params' as a single 'param' object (no array support). */
+export declare function postObject<T>(url: string, method: string, param?: any): Promise<T>;