@stellar/stellar-sdk 12.0.0-rc.1 → 12.0.0-rc.3

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

@@ -1,17 +1,18 @@
-import type { AssembledTransactionOptions, ContractClientOptions, Tx, XDR_BASE64 } from "./types";
-import { SorobanRpc, TransactionBuilder, xdr } from "..";
+import { 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";
 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 +26,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 +57,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 +89,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 +115,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 +196,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 +236,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 +251,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`.
@@ -363,7 +380,7 @@ export declare class AssembledTransaction<T> {
     static build<T>(options: AssembledTransactionOptions<T>): Promise<AssembledTransaction<T>>;
     simulate: () => Promise<this>;
     get simulationData(): {
-        result: SorobanRpc.Api.SimulateHostFunctionResult;
+        result: Api.SimulateHostFunctionResult;
         transactionData: xdr.SorobanTransactionData;
     };
     get result(): T;
@@ -377,13 +394,13 @@ export declare class AssembledTransaction<T> {
      */
     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 +419,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 +460,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