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

package/lib/horizon/types/effects.d.ts

@@ -55,86 +55,86 @@ export declare enum EffectType {
     contract_credited = 96,
     contract_debited = 97
 }
-export interface BaseEffectRecord extends HorizonApi.BaseResponse {
+export interface BaseEffectRecord<T extends string = string> extends HorizonApi.BaseResponse {
     id: string;
     account: string;
     paging_token: string;
     type_i: EffectType;
-    type: string;
+    type: T;
     created_at: string;
 }
-export interface AccountCreated extends BaseEffectRecord {
+export interface AccountCreated extends BaseEffectRecord<'account_created'> {
     type_i: EffectType.account_created;
     starting_balance: string;
 }
-export interface AccountCredited extends BaseEffectRecord, OfferAsset {
+export interface AccountCredited extends BaseEffectRecord<'account_credited'>, OfferAsset {
     type_i: EffectType.account_credited;
     amount: string;
 }
-export interface AccountDebited extends BaseEffectRecord {
+export interface AccountDebited extends BaseEffectRecord<'account_debited'>, OfferAsset {
     type_i: EffectType.account_debited;
     amount: string;
 }
-export interface AccountThresholdsUpdated extends BaseEffectRecord {
+export interface AccountThresholdsUpdated extends BaseEffectRecord<'account_thresholds_updated'> {
     type_i: EffectType.account_thresholds_updated;
     low_threshold: number;
     med_threshold: number;
     high_threshold: number;
 }
-export interface AccountHomeDomainUpdated extends BaseEffectRecord {
+export interface AccountHomeDomainUpdated extends BaseEffectRecord<'account_home_domain_updated'> {
     type_i: EffectType.account_home_domain_updated;
     home_domain: string;
 }
-export interface AccountFlagsUpdated extends BaseEffectRecord {
+export interface AccountFlagsUpdated extends BaseEffectRecord<'account_flags_updated'> {
     type_i: EffectType.account_flags_updated;
     auth_required_flag: boolean;
     auth_revokable_flag: boolean;
 }
-interface DataEvents extends BaseEffectRecord {
+interface DataEvents<T extends string> extends BaseEffectRecord<T> {
     name: boolean;
     value: boolean;
 }
-export interface DataCreated extends DataEvents {
+export interface DataCreated extends DataEvents<'data_created'> {
     type_i: EffectType.data_created;
 }
-export interface DataUpdated extends DataEvents {
+export interface DataUpdated extends DataEvents<'data_updated'> {
     type_i: EffectType.data_updated;
 }
-export interface DataRemoved extends DataEvents {
+export interface DataRemoved extends DataEvents<'data_removed'> {
     type_i: EffectType.data_removed;
 }
-export interface SequenceBumped extends BaseEffectRecord {
+export interface SequenceBumped extends BaseEffectRecord<'sequence_bumped'> {
     type_i: EffectType.sequence_bumped;
     new_seq: number | string;
 }
-interface SignerEvents extends BaseEffectRecord {
+interface SignerEvents<T extends string> extends BaseEffectRecord<T> {
     weight: number;
     key: string;
     public_key: string;
 }
-export interface SignerCreated extends SignerEvents {
+export interface SignerCreated extends SignerEvents<'signer_created'> {
     type_i: EffectType.signer_created;
 }
-export interface SignerRemoved extends SignerEvents {
+export interface SignerRemoved extends SignerEvents<'signer_removed'> {
     type_i: EffectType.signer_removed;
 }
-export interface SignerUpdated extends SignerEvents {
+export interface SignerUpdated extends SignerEvents<'signer_updated'> {
     type_i: EffectType.signer_updated;
 }
-interface TrustlineEvents extends BaseEffectRecord, OfferAsset {
+interface TrustlineEvents<T extends string> extends BaseEffectRecord<T>, OfferAsset {
     limit: string;
     liquidity_pool_id?: string;
 }
-export interface TrustlineCreated extends TrustlineEvents {
+export interface TrustlineCreated extends TrustlineEvents<'trustline_created'> {
     type_i: EffectType.trustline_created;
 }
-export interface TrustlineRemoved extends TrustlineEvents {
+export interface TrustlineRemoved extends TrustlineEvents<'trustline_removed'> {
     type_i: EffectType.trustline_removed;
 }
-export interface TrustlineUpdated extends TrustlineEvents {
+export interface TrustlineUpdated extends TrustlineEvents<'trustline_updated'> {
     type_i: EffectType.trustline_updated;
 }
-export interface TrustlineAuthorized extends BaseEffectRecord {
+export interface TrustlineAuthorized extends BaseEffectRecord<'trustline_authorized'> {
     type_i: EffectType.trustline_authorized;
     asset_type: OfferAsset["asset_type"];
     asset_code: OfferAsset["asset_code"];
@@ -146,7 +146,7 @@ export interface TrustlineDeauthorized extends Omit<TrustlineAuthorized, "type_i
 export interface TrustlineAuthorizedToMaintainLiabilities extends Omit<TrustlineAuthorized, "type_i"> {
     type_i: EffectType.trustline_authorized_to_maintain_liabilities;
 }
-export interface ClaimableBalanceCreated extends BaseEffectRecord {
+export interface ClaimableBalanceCreated extends BaseEffectRecord<'claimable_balance_created'> {
     type_i: EffectType.claimable_balance_created;
     amount: string;
     balance_type_i: string;
@@ -163,64 +163,64 @@ interface SponsershipFields {
     new_sponsor: string;
     former_sponsor: string;
 }
-interface AccountSponsorshipEvents extends BaseEffectRecord, SponsershipFields {
+interface AccountSponsorshipEvents<T extends string> extends BaseEffectRecord<T>, SponsershipFields {
 }
-export type AccountSponsorshipCreated = Omit<AccountSponsorshipEvents, "new_sponsor" | "former_sponsor"> & {
+export type AccountSponsorshipCreated = Omit<AccountSponsorshipEvents<'account_sponsorship_created'>, "new_sponsor" | "former_sponsor"> & {
     type_i: EffectType.account_sponsorship_created;
 };
-export type AccountSponsorshipUpdated = Omit<AccountSponsorshipEvents, "sponsor"> & {
+export type AccountSponsorshipUpdated = Omit<AccountSponsorshipEvents<'account_sponsorship_updated'>, "sponsor"> & {
     type_i: EffectType.account_sponsorship_updated;
 };
-export type AccountSponsorshipRemoved = Omit<AccountSponsorshipEvents, "new_sponsor" | "sponsor"> & {
+export type AccountSponsorshipRemoved = Omit<AccountSponsorshipEvents<'account_sponsorship_removed'>, "new_sponsor" | "sponsor"> & {
     type_i: EffectType.account_sponsorship_removed;
 };
-interface TrustlineSponsorshipEvents extends BaseEffectRecord, SponsershipFields {
+interface TrustlineSponsorshipEvents<T extends string> extends BaseEffectRecord<T>, SponsershipFields {
     asset?: string;
     liquidity_pool_id?: string;
 }
-export type TrustlineSponsorshipCreated = Omit<TrustlineSponsorshipEvents, "new_sponsor" | "former_sponsor"> & {
+export type TrustlineSponsorshipCreated = Omit<TrustlineSponsorshipEvents<'trustline_sponsorship_created'>, "new_sponsor" | "former_sponsor"> & {
     type_i: EffectType.trustline_sponsorship_created;
 };
-export type TrustlineSponsorshipUpdated = Omit<TrustlineSponsorshipEvents, "sponsor"> & {
+export type TrustlineSponsorshipUpdated = Omit<TrustlineSponsorshipEvents<'trustline_sponsorship_updated'>, "sponsor"> & {
     type_i: EffectType.trustline_sponsorship_updated;
 };
-export type TrustlineSponsorshipRemoved = Omit<TrustlineSponsorshipEvents, "new_sponsor" | "sponsor"> & {
+export type TrustlineSponsorshipRemoved = Omit<TrustlineSponsorshipEvents<'trustline_sponsorship_removed'>, "new_sponsor" | "sponsor"> & {
     type_i: EffectType.trustline_sponsorship_removed;
 };
-interface DataSponsorshipEvents extends BaseEffectRecord, SponsershipFields {
+interface DataSponsorshipEvents<T extends string> extends BaseEffectRecord<T>, SponsershipFields {
     data_name: string;
 }
-export type DateSponsorshipCreated = Omit<DataSponsorshipEvents, "new_sponsor" | "former_sponsor"> & {
+export type DateSponsorshipCreated = Omit<DataSponsorshipEvents<'data_sponsorship_created'>, "new_sponsor" | "former_sponsor"> & {
     type_i: EffectType.data_sponsorship_created;
 };
-export type DateSponsorshipUpdated = Omit<DataSponsorshipEvents, "sponsor"> & {
+export type DateSponsorshipUpdated = Omit<DataSponsorshipEvents<'data_sponsorship_updated'>, "sponsor"> & {
     type_i: EffectType.data_sponsorship_updated;
 };
-export type DateSponsorshipRemoved = Omit<DataSponsorshipEvents, "new_sponsor" | "sponsor"> & {
+export type DateSponsorshipRemoved = Omit<DataSponsorshipEvents<'data_sponsorship_removed'>, "new_sponsor" | "sponsor"> & {
     type_i: EffectType.data_sponsorship_removed;
 };
-interface ClaimableBalanceSponsorshipEvents extends BaseEffectRecord, SponsershipFields {
+interface ClaimableBalanceSponsorshipEvents<T extends string> extends BaseEffectRecord<T>, SponsershipFields {
     balance_type_i: string;
 }
-export type ClaimableBalanceSponsorshipCreated = Omit<ClaimableBalanceSponsorshipEvents, "new_sponsor" | "former_sponsor"> & {
+export type ClaimableBalanceSponsorshipCreated = Omit<ClaimableBalanceSponsorshipEvents<'claimable_balance_sponsorship_created'>, "new_sponsor" | "former_sponsor"> & {
     type_i: EffectType.claimable_balance_sponsorship_created;
 };
-export type ClaimableBalanceSponsorshipUpdated = Omit<ClaimableBalanceSponsorshipEvents, "sponsor"> & {
+export type ClaimableBalanceSponsorshipUpdated = Omit<ClaimableBalanceSponsorshipEvents<'claimable_balance_sponsorship_updated'>, "sponsor"> & {
     type_i: EffectType.claimable_balance_sponsorship_updated;
 };
-export type ClaimableBalanceSponsorshipRemoved = Omit<ClaimableBalanceSponsorshipEvents, "new_sponsor" | "sponsor"> & {
+export type ClaimableBalanceSponsorshipRemoved = Omit<ClaimableBalanceSponsorshipEvents<'claimable_balance_sponsorship_removed'>, "new_sponsor" | "sponsor"> & {
     type_i: EffectType.claimable_balance_sponsorship_removed;
 };
-interface SignerSponsorshipEvents extends BaseEffectRecord, SponsershipFields {
+interface SignerSponsorshipEvents<T extends string> extends BaseEffectRecord<T>, SponsershipFields {
     signer: string;
 }
-export type SignerSponsorshipCreated = Omit<SignerSponsorshipEvents, "new_sponsor" | "former_sponsor"> & {
+export type SignerSponsorshipCreated = Omit<SignerSponsorshipEvents<'signer_sponsorship_created'>, "new_sponsor" | "former_sponsor"> & {
     type_i: EffectType.signer_sponsorship_created;
 };
-export type SignerSponsorshipUpdated = Omit<SignerSponsorshipEvents, "sponsor"> & {
+export type SignerSponsorshipUpdated = Omit<SignerSponsorshipEvents<'signer_sponsorship_updated'>, "sponsor"> & {
     type_i: EffectType.signer_sponsorship_updated;
 };
-export type SignerSponsorshipRemoved = Omit<SignerSponsorshipEvents, "new_sponsor" | "sponsor"> & {
+export type SignerSponsorshipRemoved = Omit<SignerSponsorshipEvents<'signer_sponsorship_removed'>, "new_sponsor" | "sponsor"> & {
     type_i: EffectType.signer_sponsorship_removed;
 };
 export interface ClaimableBalanceClawedBack extends HorizonApi.BaseResponse {
@@ -234,33 +234,33 @@ export interface LiquidityPoolEffectRecord extends HorizonApi.BaseResponse {
     total_shares: string;
     reserves: HorizonApi.Reserve[];
 }
-export interface LiquidityPoolDeposited extends BaseEffectRecord {
+export interface LiquidityPoolDeposited extends BaseEffectRecord<'liquidity_pool_deposited'> {
     type_i: EffectType.liquidity_pool_deposited;
     liquidity_pool: LiquidityPoolEffectRecord;
     reserves_deposited: HorizonApi.Reserve[];
     shares_received: string;
 }
-export interface LiquidityPoolWithdrew extends BaseEffectRecord {
+export interface LiquidityPoolWithdrew extends BaseEffectRecord<'liquidity_pool_withdrew'> {
     type_i: EffectType.liquidity_pool_withdrew;
     liquidity_pool: LiquidityPoolEffectRecord;
     reserves_received: HorizonApi.Reserve[];
     shares_redeemed: string;
 }
-export interface LiquidityPoolTrade extends BaseEffectRecord {
+export interface LiquidityPoolTrade extends BaseEffectRecord<'liquidity_pool_trade'> {
     type_i: EffectType.liquidity_pool_trade;
     liquidity_pool: LiquidityPoolEffectRecord;
     sold: HorizonApi.Reserve;
     bought: HorizonApi.Reserve;
 }
-export interface LiquidityPoolCreated extends BaseEffectRecord {
+export interface LiquidityPoolCreated extends BaseEffectRecord<'liquidity_pool_created'> {
     type_i: EffectType.liquidity_pool_created;
     liquidity_pool: LiquidityPoolEffectRecord;
 }
-export interface LiquidityPoolRemoved extends BaseEffectRecord {
+export interface LiquidityPoolRemoved extends BaseEffectRecord<'liquidity_pool_removed'> {
     type_i: EffectType.liquidity_pool_removed;
     liquidity_pool_id: string;
 }
-export interface LiquidityPoolRevoked extends BaseEffectRecord {
+export interface LiquidityPoolRevoked extends BaseEffectRecord<'liquidity_pool_revoked'> {
     type_i: EffectType.liquidity_pool_revoked;
     liquidity_pool: LiquidityPoolEffectRecord;
     reserves_revoked: [
@@ -272,12 +272,12 @@ export interface LiquidityPoolRevoked extends BaseEffectRecord {
     ];
     shares_revoked: string;
 }
-export interface ContractCredited extends BaseEffectRecord, OfferAsset {
+export interface ContractCredited extends BaseEffectRecord<'contract_credited'>, OfferAsset {
     type_i: EffectType.contract_credited;
     contract: string;
     amount: string;
 }
-export interface ContractDebited extends BaseEffectRecord, OfferAsset {
+export interface ContractDebited extends BaseEffectRecord<'contract_debited'>, OfferAsset {
     type_i: EffectType.contract_debited;
     contract: string;
     amount: string;

package/lib/horizon/types/trade.d.ts

@@ -1,5 +1,6 @@
-import { BaseEffectRecord } from "./effects";
-export interface Trade extends BaseEffectRecord {
+import { BaseEffectRecord, EffectType } from "./effects";
+export interface Trade extends BaseEffectRecord<'trade'> {
+    type_i: EffectType.trade;
     seller: string;
     offer_id: number | string;
     bought_amount: string;

package/lib/http-client/types.d.ts

@@ -27,6 +27,7 @@ export interface HttpClientRequestConfig<D = any> {
     headers?: HeadersInit;
     params?: Record<string, any>;
     maxContentLength?: number;
+    maxRedirects?: number;
     cancelToken?: CancelToken;
     adapter?: (config: HttpClientRequestConfig) => Promise<HttpClientResponse>;
 }

package/lib/minimal/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/minimal/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.');
@@ -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))
 });