@stellar/stellar-sdk 12.0.1 → 12.1.0

package/lib/contract/assembled_transaction.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
-import { TransactionBuilder, xdr } from "@stellar/stellar-base";
+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 Client}. This class is used to wrap a
@@ -267,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
@@ -283,6 +288,16 @@ export declare class AssembledTransaction<T> {
             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 | undefined): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
         NeedsMoreSignatures: {
             new (message?: string | undefined): {
                 name: string;
@@ -359,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
@@ -379,7 +402,10 @@ 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: Api.SimulateHostFunctionResult;
         transactionData: xdr.SorobanTransactionData;
@@ -387,12 +413,30 @@ export declare class AssembledTransaction<T> {
     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
@@ -473,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>;
 }