@stellar/stellar-sdk 13.0.0-beta.1 → 13.0.0-rc.2

package/lib/contract/assembled_transaction.d.ts

@@ -359,6 +359,56 @@ export declare class AssembledTransaction<T> {
             prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
             stackTraceLimit: number;
         };
+        SimulationFailed: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
+        InternalWalletError: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
+        ExternalServiceError: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
+        InvalidClientRequest: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
+        UserRejected: {
+            new (message?: string): {
+                name: string;
+                message: string;
+                stack?: string;
+            };
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+            stackTraceLimit: number;
+        };
     };
     /**
      * Serialize the AssembledTransaction to a JSON string. This is useful for
@@ -383,10 +433,11 @@ export declare class AssembledTransaction<T> {
      * 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 handleWalletError;
     private constructor();
     /**
-     * Construct a new AssembledTransaction. This is the only way to create a new
-     * AssembledTransaction; the main constructor is private.
+     * Construct a new AssembledTransaction. This is the main way to create a new
+     * AssembledTransaction; the constructor is private.
      *
      * This is an asynchronous constructor for two reasons:
      *
@@ -397,6 +448,9 @@ export declare class AssembledTransaction<T> {
      * If you don't want to simulate the transaction, you can set `simulate` to
      * `false` in the options.
      *
+     * If you need to create an operation other than `invokeHostFunction`, you
+     * can use {@link AssembledTransaction.buildWithOp} instead.
+     *
      * @example
      * const tx = await AssembledTransaction.build({
      *   ...,
@@ -404,6 +458,24 @@ export declare class AssembledTransaction<T> {
      * })
      */
     static build<T>(options: AssembledTransactionOptions<T>): Promise<AssembledTransaction<T>>;
+    /**
+     * Construct a new AssembledTransaction, specifying an Operation other than
+     * `invokeHostFunction` (the default used by {@link AssembledTransaction.build}).
+     *
+     * Note: `AssembledTransaction` currently assumes these operations can be
+     * simulated. This is not true for classic operations; only for those used by
+     * Soroban Smart Contracts like `invokeHostFunction` and `createCustomContract`.
+     *
+     * @example
+     * const tx = await AssembledTransaction.buildWithOp(
+     *   Operation.createCustomContract({ ... });
+     *   {
+     *     ...,
+     *     simulate: false,
+     *   }
+     * )
+     */
+    static buildWithOp<T>(operation: xdr.Operation, options: AssembledTransactionOptions<T>): Promise<AssembledTransaction<T>>;
     private static buildFootprintRestoreTransaction;
     simulate: ({ restore }?: {
         restore?: boolean;
@@ -511,7 +583,7 @@ export declare class AssembledTransaction<T> {
          * If you have a pro use-case and need to override the default `authorizeEntry` function, rather than using the one in @stellar/stellar-base, you can do that! Your function needs to take at least the first argument, `entry: xdr.SorobanAuthorizationEntry`, and return a `Promise<xdr.SorobanAuthorizationEntry>`.
          *
          * Note that you if you pass this, then `signAuthEntry` will be ignored.
-        */
+         */
         authorizeEntry?: typeof stellarBaseAuthorizeEntry;
     }) => Promise<void>;
     /**

package/lib/contract/assembled_transaction.js

@@ -132,7 +132,10 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
         signTransaction,
         sigsNeeded,
         timeoutInSeconds,
+        signOpts,
+        _yield$signTransactio,
         signature,
+        error,
         _args2 = arguments;
       return _regeneratorRuntime().wrap(function _callee2$(_context2) {
         while (1) switch (_context2.prev = _context2.next) {
@@ -171,14 +174,21 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
               timebounds: undefined,
               sorobanData: _this.simulationData.transactionData
             }).setTimeout(timeoutInSeconds).build();
-            _context2.next = 14;
-            return signTransaction(_this.built.toXDR(), {
+            signOpts = {
               networkPassphrase: _this.options.networkPassphrase
-            });
-          case 14:
-            signature = _context2.sent;
+            };
+            if (_this.options.address) signOpts.address = _this.options.address;
+            if (_this.options.submit !== undefined) signOpts.submit = _this.options.submit;
+            if (_this.options.submitUrl) signOpts.submitUrl = _this.options.submitUrl;
+            _context2.next = 18;
+            return signTransaction(_this.built.toXDR(), signOpts);
+          case 18:
+            _yield$signTransactio = _context2.sent;
+            signature = _yield$signTransactio.signedTxXdr;
+            error = _yield$signTransactio.error;
+            _this.handleWalletError(error);
             _this.signed = _stellarBase.TransactionBuilder.fromXDR(signature, _this.options.networkPassphrase);
-          case 16:
+          case 23:
           case "end":
             return _context2.stop();
         }
@@ -190,27 +200,37 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
         force,
         _ref6$signTransaction,
         signTransaction,
+        originalSubmit,
         _args3 = arguments;
       return _regeneratorRuntime().wrap(function _callee3$(_context3) {
         while (1) switch (_context3.prev = _context3.next) {
           case 0:
             _ref6 = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : {}, _ref6$force = _ref6.force, force = _ref6$force === void 0 ? false : _ref6$force, _ref6$signTransaction = _ref6.signTransaction, signTransaction = _ref6$signTransaction === void 0 ? _this.options.signTransaction : _ref6$signTransaction;
             if (_this.signed) {
-              _context3.next = 4;
+              _context3.next = 10;
               break;
             }
-            _context3.next = 4;
+            originalSubmit = _this.options.submit;
+            if (_this.options.submit) {
+              _this.options.submit = false;
+            }
+            _context3.prev = 4;
+            _context3.next = 7;
             return _this.sign({
               force: force,
               signTransaction: signTransaction
             });
-          case 4:
+          case 7:
+            _context3.prev = 7;
+            _this.options.submit = originalSubmit;
+            return _context3.finish(7);
+          case 10:
             return _context3.abrupt("return", _this.send());
-          case 5:
+          case 11:
           case "end":
             return _context3.stop();
         }
-      }, _callee3);
+      }, _callee3, null, [[4,, 7, 10]]);
     })));
     _defineProperty(this, "needsNonInvokerSigningBy", function () {
       var _rawInvokeHostFunctio;
@@ -325,18 +345,21 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
                     _context6.t1 = entry;
                     _context6.t2 = function () {
                       var _ref11 = _asyncToGenerator(_regeneratorRuntime().mark(function _callee5(preimage) {
+                        var _yield$sign, signedAuthEntry, error;
                         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
                           while (1) switch (_context5.prev = _context5.next) {
                             case 0:
-                              _context5.t0 = Buffer;
-                              _context5.next = 3;
+                              _context5.next = 2;
                               return sign(preimage.toXDR("base64"), {
-                                accountToSign: address
+                                address: address
                               });
-                            case 3:
-                              _context5.t1 = _context5.sent;
-                              return _context5.abrupt("return", _context5.t0.from.call(_context5.t0, _context5.t1, "base64"));
-                            case 5:
+                            case 2:
+                              _yield$sign = _context5.sent;
+                              signedAuthEntry = _yield$sign.signedAuthEntry;
+                              error = _yield$sign.error;
+                              _this.handleWalletError(error);
+                              return _context5.abrupt("return", Buffer.from(signedAuthEntry, "base64"));
+                            case 7:
                             case "end":
                               return _context5.stop();
                           }
@@ -424,6 +447,26 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
       if (!this.built) throw new Error("Transaction has not yet been simulated; " + "call `AssembledTransaction.simulate` first.");
       return (_this$built2 = this.built) === null || _this$built2 === void 0 ? void 0 : _this$built2.toEnvelope().toXDR('base64');
     }
+  }, {
+    key: "handleWalletError",
+    value: function handleWalletError(error) {
+      if (!error) return;
+      var message = error.message,
+        code = error.code;
+      var fullMessage = "".concat(message).concat(error.ext ? " (".concat(error.ext.join(', '), ")") : '');
+      switch (code) {
+        case -1:
+          throw new AssembledTransaction.Errors.InternalWalletError(fullMessage);
+        case -2:
+          throw new AssembledTransaction.Errors.ExternalServiceError(fullMessage);
+        case -3:
+          throw new AssembledTransaction.Errors.InvalidClientRequest(fullMessage);
+        case -4:
+          throw new AssembledTransaction.Errors.UserRejected(fullMessage);
+        default:
+          throw new Error("Unhandled error: ".concat(fullMessage));
+      }
+    }
   }, {
     key: "simulationData",
     get: function get() {
@@ -439,7 +482,7 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
         throw new AssembledTransaction.Errors.NotYetSimulated("Transaction has not yet been simulated");
       }
       if (_api.Api.isSimulationError(simulation)) {
-        throw new Error("Transaction simulation failed: \"".concat(simulation.error, "\""));
+        throw new AssembledTransaction.Errors.SimulationFailed("Transaction simulation failed: \"".concat(simulation.error, "\""));
       }
       if (_api.Api.isSimulationRestore(simulation)) {
         throw new AssembledTransaction.Errors.ExpiredState("You need to restore some contract state before you can invoke this method.\n" + 'You can set `restore` to true in the method options in order to ' + 'automatically restore the contract state when needed.');
@@ -495,7 +538,7 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
               throw new Error("The transaction has not yet been signed. Run `sign` first, or use `signAndSend` instead.");
             case 2:
               _context8.next = 4;
-              return _sent_transaction.SentTransaction.init(undefined, this);
+              return _sent_transaction.SentTransaction.init(this);
             case 4:
               sent = _context8.sent;
               return _context8.abrupt("return", sent);
@@ -615,41 +658,47 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
     }
   }, {
     key: "build",
+    value: function build(options) {
+      var _options$args;
+      var contract = new _stellarBase.Contract(options.contractId);
+      return AssembledTransaction.buildWithOp(contract.call.apply(contract, [options.method].concat(_toConsumableArray((_options$args = options.args) !== null && _options$args !== void 0 ? _options$args : []))), options);
+    }
+  }, {
+    key: "buildWithOp",
     value: (function () {
-      var _build = _asyncToGenerator(_regeneratorRuntime().mark(function _callee9(options) {
-        var _options$fee, _options$args, _options$timeoutInSec;
-        var tx, contract, account;
+      var _buildWithOp = _asyncToGenerator(_regeneratorRuntime().mark(function _callee9(operation, options) {
+        var _options$fee, _options$timeoutInSec;
+        var tx, account;
         return _regeneratorRuntime().wrap(function _callee9$(_context10) {
           while (1) switch (_context10.prev = _context10.next) {
             case 0:
               tx = new AssembledTransaction(options);
-              contract = new _stellarBase.Contract(options.contractId);
-              _context10.next = 4;
+              _context10.next = 3;
               return (0, _utils.getAccount)(options, tx.server);
-            case 4:
+            case 3:
               account = _context10.sent;
               tx.raw = new _stellarBase.TransactionBuilder(account, {
                 fee: (_options$fee = options.fee) !== null && _options$fee !== void 0 ? _options$fee : _stellarBase.BASE_FEE,
                 networkPassphrase: options.networkPassphrase
-              }).addOperation(contract.call.apply(contract, [options.method].concat(_toConsumableArray((_options$args = options.args) !== null && _options$args !== void 0 ? _options$args : [])))).setTimeout((_options$timeoutInSec = options.timeoutInSeconds) !== null && _options$timeoutInSec !== void 0 ? _options$timeoutInSec : _types.DEFAULT_TIMEOUT);
+              }).setTimeout((_options$timeoutInSec = options.timeoutInSeconds) !== null && _options$timeoutInSec !== void 0 ? _options$timeoutInSec : _types.DEFAULT_TIMEOUT).addOperation(operation);
               if (!options.simulate) {
-                _context10.next = 9;
+                _context10.next = 8;
                 break;
               }
-              _context10.next = 9;
+              _context10.next = 8;
               return tx.simulate();
-            case 9:
+            case 8:
               return _context10.abrupt("return", tx);
-            case 10:
+            case 9:
             case "end":
               return _context10.stop();
           }
         }, _callee9);
       }));
-      function build(_x4) {
-        return _build.apply(this, arguments);
+      function buildWithOp(_x4, _x5) {
+        return _buildWithOp.apply(this, arguments);
       }
-      return build;
+      return buildWithOp;
     }())
   }, {
     key: "buildFootprintRestoreTransaction",
@@ -677,7 +726,7 @@ var AssembledTransaction = exports.AssembledTransaction = function () {
           }
         }, _callee10);
       }));
-      function buildFootprintRestoreTransaction(_x5, _x6, _x7, _x8) {
+      function buildFootprintRestoreTransaction(_x6, _x7, _x8, _x9) {
         return _buildFootprintRestoreTransaction.apply(this, arguments);
       }
       return buildFootprintRestoreTransaction;
@@ -748,5 +797,45 @@ _defineProperty(AssembledTransaction, "Errors", {
     }
     _inherits(FakeAccountError, _Error8);
     return _createClass(FakeAccountError);
+  }(_wrapNativeSuper(Error)),
+  SimulationFailed: function (_Error9) {
+    function SimulationFailedError() {
+      _classCallCheck(this, SimulationFailedError);
+      return _callSuper(this, SimulationFailedError, arguments);
+    }
+    _inherits(SimulationFailedError, _Error9);
+    return _createClass(SimulationFailedError);
+  }(_wrapNativeSuper(Error)),
+  InternalWalletError: function (_Error10) {
+    function InternalWalletError() {
+      _classCallCheck(this, InternalWalletError);
+      return _callSuper(this, InternalWalletError, arguments);
+    }
+    _inherits(InternalWalletError, _Error10);
+    return _createClass(InternalWalletError);
+  }(_wrapNativeSuper(Error)),
+  ExternalServiceError: function (_Error11) {
+    function ExternalServiceError() {
+      _classCallCheck(this, ExternalServiceError);
+      return _callSuper(this, ExternalServiceError, arguments);
+    }
+    _inherits(ExternalServiceError, _Error11);
+    return _createClass(ExternalServiceError);
+  }(_wrapNativeSuper(Error)),
+  InvalidClientRequest: function (_Error12) {
+    function InvalidClientRequestError() {
+      _classCallCheck(this, InvalidClientRequestError);
+      return _callSuper(this, InvalidClientRequestError, arguments);
+    }
+    _inherits(InvalidClientRequestError, _Error12);
+    return _createClass(InvalidClientRequestError);
+  }(_wrapNativeSuper(Error)),
+  UserRejected: function (_Error13) {
+    function UserRejectedError() {
+      _classCallCheck(this, UserRejectedError);
+      return _callSuper(this, UserRejectedError, arguments);
+    }
+    _inherits(UserRejectedError, _Error13);
+    return _createClass(UserRejectedError);
   }(_wrapNativeSuper(Error))
 });

package/lib/contract/basic_node_signer.d.ts

@@ -1,4 +1,5 @@
 import { Keypair } from "@stellar/stellar-base";
+import { SignAuthEntry, SignTransaction } from "./types";
 /**
  * For use with {@link Client} and {@link module:contract.AssembledTransaction}.
  * Implements `signTransaction` and `signAuthEntry` with signatures expected by
@@ -12,6 +13,6 @@ import { Keypair } from "@stellar/stellar-base";
  * @param {string} networkPassphrase passphrase of network to sign for
  */
 export declare const basicNodeSigner: (keypair: Keypair, networkPassphrase: string) => {
-    signTransaction: (tx: string) => Promise<string>;
-    signAuthEntry: (entryXdr: string) => Promise<string>;
+    signTransaction: SignTransaction;
+    signAuthEntry: SignAuthEntry;
 };

package/lib/contract/basic_node_signer.js

@@ -12,38 +12,46 @@ function _asyncToGenerator(n) { return function () { var t = this, e = arguments
 var basicNodeSigner = exports.basicNodeSigner = function basicNodeSigner(keypair, networkPassphrase) {
   return {
     signTransaction: function () {
-      var _signTransaction = _asyncToGenerator(_regeneratorRuntime().mark(function _callee(tx) {
+      var _signTransaction = _asyncToGenerator(_regeneratorRuntime().mark(function _callee(xdr, opts) {
         var t;
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
-              t = _stellarBase.TransactionBuilder.fromXDR(tx, networkPassphrase);
+              t = _stellarBase.TransactionBuilder.fromXDR(xdr, (opts === null || opts === void 0 ? void 0 : opts.networkPassphrase) || networkPassphrase);
               t.sign(keypair);
-              return _context.abrupt("return", t.toXDR());
+              return _context.abrupt("return", {
+                signedTxXdr: t.toXDR(),
+                signerAddress: keypair.publicKey()
+              });
             case 3:
             case "end":
               return _context.stop();
           }
         }, _callee);
       }));
-      function signTransaction(_x) {
+      function signTransaction(_x, _x2) {
         return _signTransaction.apply(this, arguments);
       }
       return signTransaction;
     }(),
     signAuthEntry: function () {
-      var _signAuthEntry = _asyncToGenerator(_regeneratorRuntime().mark(function _callee2(entryXdr) {
+      var _signAuthEntry = _asyncToGenerator(_regeneratorRuntime().mark(function _callee2(authEntry) {
+        var signedAuthEntry;
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
-              return _context2.abrupt("return", keypair.sign((0, _stellarBase.hash)(Buffer.from(entryXdr, "base64"))).toString("base64"));
-            case 1:
+              signedAuthEntry = keypair.sign((0, _stellarBase.hash)(Buffer.from(authEntry, "base64"))).toString("base64");
+              return _context2.abrupt("return", {
+                signedAuthEntry: signedAuthEntry,
+                signerAddress: keypair.publicKey()
+              });
+            case 2:
             case "end":
               return _context2.stop();
           }
         }, _callee2);
       }));
-      function signAuthEntry(_x2) {
+      function signAuthEntry(_x3) {
         return _signAuthEntry.apply(this, arguments);
       }
       return signAuthEntry;

package/lib/contract/client.d.ts

@@ -1,6 +1,6 @@
 import { Spec } from "./spec";
 import { AssembledTransaction } from "./assembled_transaction";
-import type { ClientOptions } from "./types";
+import type { ClientOptions, MethodOptions } from "./types";
 /**
  * Generate a class from the contract spec that where each contract method
  * gets included with an identical name.
@@ -18,6 +18,18 @@ import type { ClientOptions } from "./types";
 export declare class Client {
     readonly spec: Spec;
     readonly options: ClientOptions;
+    static deploy<T = Client>(
+    /** Constructor/Initialization Args for the contract's `__constructor` method */
+    args: Record<string, any> | null, 
+    /** Options for initalizing a Client as well as for calling a method, with extras specific to deploying. */
+    options: MethodOptions & Omit<ClientOptions, "contractId"> & {
+        /** The hash of the Wasm blob, which must already be installed on-chain. */
+        wasmHash: Buffer | string;
+        /** Salt used to generate the contract's ID. Passed through to {@link Operation.createCustomContract}. Default: random. */
+        salt?: Buffer | Uint8Array;
+        /** The format used to decode `wasmHash`, if it's provided as a string. */
+        format?: "hex" | "base64";
+    }): Promise<AssembledTransaction<T>>;
     constructor(spec: Spec, options: ClientOptions);
     /**
      * Generates a Client instance from the provided ClientOptions and the contract's wasm hash.