@stellar/stellar-sdk 12.0.0 → 12.1.0

package/lib/browser.js

@@ -31,7 +31,7 @@ Object.keys(_index).forEach(function (key) {
 var _StellarBase = _interopRequireWildcard(require("@stellar/stellar-base"));
 exports.StellarBase = _StellarBase;
 var _axios = _interopRequireDefault(require("axios"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 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/config.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Config = void 0;
 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); }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 var defaultConfig = {

package/lib/{contract_client → contract}/assembled_transaction.d.ts

@@ -1,17 +1,20 @@
-import type { AssembledTransactionOptions, ContractClientOptions, Tx, XDR_BASE64 } from "./types";
-import { SorobanRpc, TransactionBuilder, xdr } from "..";
+/// <reference types="node" />
+import { Account, SorobanDataBuilder, TransactionBuilder, xdr } from "@stellar/stellar-base";
+import type { AssembledTransactionOptions, ClientOptions, Tx, XDR_BASE64 } from "./types";
+import { Api } from "../rpc/api";
 import { SentTransaction } from "./sent_transaction";
+import { Spec } from "./spec";
 export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";
 /**
- * The main workhorse of {@link ContractClient}. This class is used to wrap a
+ * The main workhorse of {@link Client}. This class is used to wrap a
  * transaction-under-construction and provide high-level interfaces to the most
  * common workflows, while still providing access to low-level stellar-sdk
  * transaction manipulation.
  *
  * Most of the time, you will not construct an `AssembledTransaction` directly,
- * but instead receive one as the return value of a `ContractClient` method. If
+ * but instead receive one as the return value of a `Client` method. If
  * you're familiar with the libraries generated by soroban-cli's `contract
- * bindings typescript` command, these also wraps `ContractClient` and return
+ * bindings typescript` command, these also wraps `Client` and return
  * `AssembledTransaction` instances.
  *
  * Let's look at examples of how to use `AssembledTransaction` for a variety of
@@ -25,20 +28,29 @@ export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  * ```ts
  * const { result } = await AssembledTransaction.build({
  *   method: 'myReadMethod',
- *   args: spec.funcArgsToScVals('myReadMethod', { args: 'for', my: 'method', ... }),
+ *   args: spec.funcArgsToScVals('myReadMethod', {
+ *     args: 'for',
+ *     my: 'method',
+ *     ...
+ *   }),
  *   contractId: 'C123…',
  *   networkPassphrase: '…',
  *   rpcUrl: 'https://…',
- *   publicKey: Keypair.random().publicKey(), // keypairs are irrelevant, for simulation-only read calls
- *   parseResultXdr: (result: xdr.ScVal) => spec.funcResToNative('myReadMethod', result),
+ *   publicKey: undefined, // irrelevant, for simulation-only read calls
+ *   parseResultXdr: (result: xdr.ScVal) =>
+ *     spec.funcResToNative('myReadMethod', result),
  * })
  * ```
  *
  * While that looks pretty complicated, most of the time you will use this in
- * conjunction with {@link ContractClient}, which simplifies it to:
+ * conjunction with {@link Client}, which simplifies it to:
  *
  * ```ts
- * const { result }  = await client.myReadMethod({ args: 'for', my: 'method', ... })
+ * const { result }  = await client.myReadMethod({
+ *   args: 'for',
+ *   my: 'method',
+ *   ...
+ * })
  * ```
  *
  * # 2. Simple write call
@@ -47,11 +59,15 @@ export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  * further manipulation, only one more step is needed:
  *
  * ```ts
- * const assembledTx = await client.myWriteMethod({ args: 'for', my: 'method', ... })
+ * const assembledTx = await client.myWriteMethod({
+ *   args: 'for',
+ *   my: 'method',
+ *   ...
+ * })
  * const sentTx = await assembledTx.signAndSend()
  * ```
  *
- * Here we're assuming that you're using a {@link ContractClient}, rather than
+ * Here we're assuming that you're using a {@link Client}, rather than
  * constructing `AssembledTransaction`'s directly.
  *
  * Note that `sentTx`, the return value of `signAndSend`, is a
@@ -75,7 +91,7 @@ export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  *
  * If you need more control over the transaction before simulating it, you can
  * set various {@link MethodOptions} when constructing your
- * `AssembledTransaction`. With a {@link ContractClient}, this is passed as a
+ * `AssembledTransaction`. With a {@link Client}, this is passed as a
  * second object after the arguments (or the only object, if the method takes
  * no arguments):
  *
@@ -101,7 +117,8 @@ export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  * await tx.simulate()
  * ```
  *
- * If you need to inspect the simulation later, you can access it with `tx.simulation`.
+ * If you need to inspect the simulation later, you can access it with
+ * `tx.simulation`.
  *
  * # 4. Multi-auth workflows
  *
@@ -181,7 +198,7 @@ export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  * ```
  *
  * Under the hood, this uses `signAuthEntry`, which you either need to inject
- * during initial construction of the `ContractClient`/`AssembledTransaction`,
+ * during initial construction of the `Client`/`AssembledTransaction`,
  * or which you can pass directly to `signAuthEntries`.
  *
  * Now Bob can again serialize the transaction and send back to Alice, where
@@ -221,13 +238,14 @@ export declare class AssembledTransaction<T> {
      * cached, serializable access to the data needed by AssembledTransaction
      * logic.
      */
-    simulation?: SorobanRpc.Api.SimulateTransactionResponse;
+    simulation?: Api.SimulateTransactionResponse;
     /**
      * Cached simulation result. This is set after the first call to
-     * {@link simulationData}, and is used to facilitate serialization and
-     * deserialization of the AssembledTransaction.
+     * {@link AssembledTransaction#simulationData}, and is used to facilitate
+     * serialization and deserialization of the AssembledTransaction.
      *
-     * Most of the time, if you need this data, you can call `tx.simulation.result`.
+     * Most of the time, if you need this data, you can call
+     * `tx.simulation.result`.
      *
      * If you need access to this data after a transaction has been serialized
      * and then deserialized, you can call `simulationData.result`.
@@ -235,10 +253,11 @@ export declare class AssembledTransaction<T> {
     private simulationResult?;
     /**
      * Cached simulation transaction data. This is set after the first call to
-     * {@link simulationData}, and is used to facilitate serialization and
-     * deserialization of the AssembledTransaction.
+     * {@link AssembledTransaction#simulationData}, and is used to facilitate
+     * serialization and deserialization of the AssembledTransaction.
      *
-     * Most of the time, if you need this data, you can call `simulation.transactionData`.
+     * Most of the time, if you need this data, you can call
+     * `simulation.transactionData`.
      *
      * If you need access to this data after a transaction has been serialized
      * and then deserialized, you can call `simulationData.transactionData`.
@@ -249,6 +268,10 @@ export declare class AssembledTransaction<T> {
      * `rpcUrl` in the options.
      */
     private server;
+    /**
+     * The signed transaction.
+     */
+    signed?: Tx;
     /**
      * A list of the most important errors that various AssembledTransaction
      * methods can throw. Feel free to catch specific errors in your application
@@ -256,72 +279,82 @@ export declare class AssembledTransaction<T> {
      */
     static Errors: {
         ExpiredState: {
-            new (message?: string): {
+            new (message?: string | undefined): {
+                name: string;
+                message: string;
+                stack?: string | undefined;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
+        RestorationFailure: {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
         NeedsMoreSignatures: {
-            new (message?: string): {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
         NoSignatureNeeded: {
-            new (message?: string): {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
         NoUnsignedNonInvokerAuthEntries: {
-            new (message?: string): {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
         NoSigner: {
-            new (message?: string): {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
         NotYetSimulated: {
-            new (message?: string): {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
         FakeAccount: {
-            new (message?: string): {
+            new (message?: string | undefined): {
                 name: string;
                 message: string;
                 stack?: string | undefined;
             };
-            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
@@ -341,6 +374,14 @@ export declare class AssembledTransaction<T> {
         };
         simulationTransactionData: XDR_BASE64;
     }): AssembledTransaction<T>;
+    /**
+     * Serialize the AssembledTransaction to a base64-encoded XDR string.
+     */
+    toXDR(): string;
+    /**
+     * Deserialize the AssembledTransaction from a base64-encoded XDR string.
+     */
+    static fromXDR<T>(options: Omit<AssembledTransactionOptions<T>, "args" | "method" | "parseResultXdr">, encodedXDR: string, spec: Spec): AssembledTransaction<T>;
     private constructor();
     /**
      * Construct a new AssembledTransaction. This is the only way to create a new
@@ -361,29 +402,50 @@ export declare class AssembledTransaction<T> {
      *     })
      */
     static build<T>(options: AssembledTransactionOptions<T>): Promise<AssembledTransaction<T>>;
-    simulate: () => Promise<this>;
+    private static buildFootprintRestoreTransaction;
+    simulate: ({ restore }?: {
+        restore?: boolean;
+    }) => Promise<this>;
     get simulationData(): {
-        result: SorobanRpc.Api.SimulateHostFunctionResult;
+        result: Api.SimulateHostFunctionResult;
         transactionData: xdr.SorobanTransactionData;
     };
     get result(): T;
     private parseError;
     /**
-     * Sign the transaction with the `wallet`, included previously. If you did
-     * not previously include one, you need to include one now that at least
-     * includes the `signTransaction` method. After signing, this method will
-     * send the transaction to the network and return a `SentTransaction` that
+     * Sign the transaction with the signTransaction function included previously.
+     * If you did not previously include one, you need to include one now.
+     */
+    sign: ({ force, signTransaction, }?: {
+        /**
+         * If `true`, sign and send the transaction even if it is a read call
+         */
+        force?: boolean;
+        /**
+         * You must provide this here if you did not provide one before
+         */
+        signTransaction?: ClientOptions["signTransaction"];
+    }) => Promise<void>;
+    /**
+     * Sends the transaction to the network to return a `SentTransaction` that
      * keeps track of all the attempts to fetch the transaction.
      */
+    send(): Promise<SentTransaction<T>>;
+    /**
+     * Sign the transaction with the `signTransaction` function included previously.
+     * If you did not previously include one, you need to include one now.
+     * After signing, this method will send the transaction to the network and
+     * return a `SentTransaction` that keeps track * of all the attempts to fetch the transaction.
+     */
     signAndSend: ({ force, signTransaction, }?: {
         /**
-         * If `true`, sign and send the transaction even if it is a read call.
+         * If `true`, sign and send the transaction even if it is a read call
          */
         force?: boolean;
         /**
          * You must provide this here if you did not provide one before
          */
-        signTransaction?: ContractClientOptions["signTransaction"];
+        signTransaction?: ClientOptions["signTransaction"];
     }) => Promise<SentTransaction<T>>;
     private getStorageExpiration;
     /**
@@ -402,29 +464,31 @@ export declare class AssembledTransaction<T> {
      * One at a time, for each public key in this array, you will need to
      * serialize this transaction with `toJSON`, send to the owner of that key,
      * deserialize the transaction with `txFromJson`, and call
-     * {@link signAuthEntries}. Then re-serialize and send to the next account
-     * in this list.
+     * {@link AssembledTransaction#signAuthEntries}. Then re-serialize and send to
+     * the next account in this list.
      */
     needsNonInvokerSigningBy: ({ includeAlreadySigned, }?: {
         /**
-         * Whether or not to include auth entries that have already been signed. Default: false
+         * Whether or not to include auth entries that have already been signed.
+         * Default: false
          */
         includeAlreadySigned?: boolean;
-    }) => Promise<string[]>;
+    }) => string[];
     /**
-     * If {@link needsNonInvokerSigningBy} returns a non-empty list, you can serialize
-     * the transaction with `toJSON`, send it to the owner of one of the public keys
-     * in the map, deserialize with `txFromJSON`, and call this method on their
-     * machine. Internally, this will use `signAuthEntry` function from connected
-     * `wallet` for each.
+     * If {@link AssembledTransaction#needsNonInvokerSigningBy} returns a
+     * non-empty list, you can serialize the transaction with `toJSON`, send it to
+     * the owner of one of the public keys in the map, deserialize with
+     * `txFromJSON`, and call this method on their machine. Internally, this will
+     * use `signAuthEntry` function from connected `wallet` for each.
      *
      * Then, re-serialize the transaction and either send to the next
      * `needsNonInvokerSigningBy` owner, or send it back to the original account
-     * who simulated the transaction so they can {@link sign} the transaction
-     * envelope and {@link send} it to the network.
+     * who simulated the transaction so they can {@link AssembledTransaction#sign}
+     * the transaction envelope and {@link AssembledTransaction#send} it to the
+     * network.
      *
-     * Sending to all `needsNonInvokerSigningBy` owners in parallel is not currently
-     * supported!
+     * Sending to all `needsNonInvokerSigningBy` owners in parallel is not
+     * currently supported!
      */
     signAuthEntries: ({ expiration, signAuthEntry, publicKey, }?: {
         /**
@@ -441,10 +505,10 @@ export declare class AssembledTransaction<T> {
         publicKey?: string;
         /**
          * You must provide this here if you did not provide one before. Default:
-         * the `signAuthEntry` function from the `ContractClient` options. Must
+         * the `signAuthEntry` function from the `Client` options. Must
          * sign things as the given `publicKey`.
          */
-        signAuthEntry?: ContractClientOptions["signAuthEntry"];
+        signAuthEntry?: ClientOptions["signAuthEntry"];
     }) => Promise<void>;
     /**
      * Whether this transaction is a read call. This is determined by the
@@ -453,4 +517,35 @@ export declare class AssembledTransaction<T> {
      * returns `false`, then you need to call `signAndSend` on this transaction.
      */
     get isReadCall(): boolean;
+    /**
+     * Restores the footprint (resource ledger entries that can be read or written)
+     * of an expired transaction.
+     *
+     * The method will:
+     * 1. Build a new transaction aimed at restoring the necessary resources.
+     * 2. Sign this new transaction if a `signTransaction` handler is provided.
+     * 3. Send the signed transaction to the network.
+     * 4. Await and return the response from the network.
+     *
+     * Preconditions:
+     * - A `signTransaction` function must be provided during the Client initialization.
+     * - The provided `restorePreamble` should include a minimum resource fee and valid
+     *   transaction data.
+     *
+     * @throws {Error} - Throws an error if no `signTransaction` function is provided during
+     * Client initialization.
+     * @throws {AssembledTransaction.Errors.RestoreFailure} - Throws a custom error if the
+     * restore transaction fails, providing the details of the failure.
+   */
+    restoreFootprint(
+    /**
+     * The preamble object containing data required to
+     * build the restore transaction.
+     */
+    restorePreamble: {
+        minResourceFee: string;
+        transactionData: SorobanDataBuilder;
+    }, 
+    /** The account that is executing the footprint restore operation. If omitted, will use the account from the AssembledTransaction. */
+    account?: Account): Promise<Api.GetTransactionResponse>;
 }