@stellar/stellar-base 10.0.0

package/lib/transaction.js

@@ -0,0 +1,369 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transaction = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _hashing = require("./hashing");
+var _strkey = require("./strkey");
+var _operation = require("./operation");
+var _memo = require("./memo");
+var _transaction_base = require("./transaction_base");
+var _decode_encode_muxed_account = require("./util/decode_encode_muxed_account");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/**
+ * Use {@link TransactionBuilder} to build a transaction object. If you have an
+ * object or base64-encoded string of the transaction envelope XDR, use {@link
+ * TransactionBuilder.fromXDR}.
+ *
+ * Once a Transaction has been created, its attributes and operations should not
+ * be changed. You should only add signatures (using {@link Transaction#sign})
+ * to a Transaction object before submitting to the network or forwarding on to
+ * additional signers.
+ *
+ * @constructor
+ *
+ * @param {string|xdr.TransactionEnvelope} envelope - transaction envelope
+ *     object or base64 encoded string
+ * @param {string}  [networkPassphrase] - passphrase of the target stellar
+ *     network (e.g. "Public Global Stellar Network ; September 2015")
+ *
+ * @extends TransactionBase
+ */
+var Transaction = exports.Transaction = /*#__PURE__*/function (_TransactionBase) {
+  _inherits(Transaction, _TransactionBase);
+  var _super = _createSuper(Transaction);
+  function Transaction(envelope, networkPassphrase) {
+    var _this;
+    _classCallCheck(this, Transaction);
+    if (typeof envelope === 'string') {
+      var buffer = Buffer.from(envelope, 'base64');
+      envelope = _xdr["default"].TransactionEnvelope.fromXDR(buffer);
+    }
+    var envelopeType = envelope["switch"]();
+    if (!(envelopeType === _xdr["default"].EnvelopeType.envelopeTypeTxV0() || envelopeType === _xdr["default"].EnvelopeType.envelopeTypeTx())) {
+      throw new Error("Invalid TransactionEnvelope: expected an envelopeTypeTxV0 or envelopeTypeTx but received an ".concat(envelopeType.name, "."));
+    }
+    var txEnvelope = envelope.value();
+    var tx = txEnvelope.tx();
+    var fee = tx.fee().toString();
+    var signatures = (txEnvelope.signatures() || []).slice();
+    _this = _super.call(this, tx, signatures, fee, networkPassphrase);
+    _this._envelopeType = envelopeType;
+    _this._memo = tx.memo();
+    _this._sequence = tx.seqNum().toString();
+    switch (_this._envelopeType) {
+      case _xdr["default"].EnvelopeType.envelopeTypeTxV0():
+        _this._source = _strkey.StrKey.encodeEd25519PublicKey(_this.tx.sourceAccountEd25519());
+        break;
+      default:
+        _this._source = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(_this.tx.sourceAccount());
+        break;
+    }
+    var cond = null;
+    var timeBounds = null;
+    switch (_this._envelopeType) {
+      case _xdr["default"].EnvelopeType.envelopeTypeTxV0():
+        timeBounds = tx.timeBounds();
+        break;
+      case _xdr["default"].EnvelopeType.envelopeTypeTx():
+        switch (tx.cond()["switch"]()) {
+          case _xdr["default"].PreconditionType.precondTime():
+            timeBounds = tx.cond().timeBounds();
+            break;
+          case _xdr["default"].PreconditionType.precondV2():
+            cond = tx.cond().v2();
+            timeBounds = cond.timeBounds();
+            break;
+          default:
+            break;
+        }
+        break;
+      default:
+        break;
+    }
+    if (timeBounds) {
+      _this._timeBounds = {
+        minTime: timeBounds.minTime().toString(),
+        maxTime: timeBounds.maxTime().toString()
+      };
+    }
+    if (cond) {
+      var ledgerBounds = cond.ledgerBounds();
+      if (ledgerBounds) {
+        _this._ledgerBounds = {
+          minLedger: ledgerBounds.minLedger(),
+          maxLedger: ledgerBounds.maxLedger()
+        };
+      }
+      var minSeq = cond.minSeqNum();
+      if (minSeq) {
+        _this._minAccountSequence = minSeq.toString();
+      }
+      _this._minAccountSequenceAge = cond.minSeqAge();
+      _this._minAccountSequenceLedgerGap = cond.minSeqLedgerGap();
+      _this._extraSigners = cond.extraSigners();
+    }
+    var operations = tx.operations() || [];
+    _this._operations = operations.map(function (op) {
+      return _operation.Operation.fromXDRObject(op);
+    });
+    return _this;
+  }
+
+  /**
+   * @type {object}
+   * @property {string} 64 bit unix timestamp
+   * @property {string} 64 bit unix timestamp
+   * @readonly
+   */
+  _createClass(Transaction, [{
+    key: "timeBounds",
+    get: function get() {
+      return this._timeBounds;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {object}
+     * @property {number} minLedger - smallest ledger bound (uint32)
+     * @property {number} maxLedger - largest ledger bound (or 0 for inf)
+     * @readonly
+     */
+  }, {
+    key: "ledgerBounds",
+    get: function get() {
+      return this._ledgerBounds;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * 64 bit account sequence
+     * @readonly
+     * @type {string}
+     */
+  }, {
+    key: "minAccountSequence",
+    get: function get() {
+      return this._minAccountSequence;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * 64 bit number of seconds
+     * @type {number}
+     * @readonly
+     */
+  }, {
+    key: "minAccountSequenceAge",
+    get: function get() {
+      return this._minAccountSequenceAge;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * 32 bit number of ledgers
+     * @type {number}
+     * @readonly
+     */
+  }, {
+    key: "minAccountSequenceLedgerGap",
+    get: function get() {
+      return this._minAccountSequenceLedgerGap;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * array of extra signers ({@link StrKey}s)
+     * @type {string[]}
+     * @readonly
+     */
+  }, {
+    key: "extraSigners",
+    get: function get() {
+      return this._extraSigners;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {string}
+     * @readonly
+     */
+  }, {
+    key: "sequence",
+    get: function get() {
+      return this._sequence;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {string}
+     * @readonly
+     */
+  }, {
+    key: "source",
+    get: function get() {
+      return this._source;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {Array.<xdr.Operation>}
+     * @readonly
+     */
+  }, {
+    key: "operations",
+    get: function get() {
+      return this._operations;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {string}
+     * @readonly
+     */
+  }, {
+    key: "memo",
+    get: function get() {
+      return _memo.Memo.fromXDRObject(this._memo);
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * Returns the "signature base" of this transaction, which is the value
+     * that, when hashed, should be signed to create a signature that
+     * validators on the Stellar Network will accept.
+     *
+     * It is composed of a 4 prefix bytes followed by the xdr-encoded form
+     * of this transaction.
+     * @returns {Buffer}
+     */
+  }, {
+    key: "signatureBase",
+    value: function signatureBase() {
+      var tx = this.tx;
+
+      // Backwards Compatibility: Use ENVELOPE_TYPE_TX to sign ENVELOPE_TYPE_TX_V0
+      // we need a Transaction to generate the signature base
+      if (this._envelopeType === _xdr["default"].EnvelopeType.envelopeTypeTxV0()) {
+        tx = _xdr["default"].Transaction.fromXDR(Buffer.concat([
+        // TransactionV0 is a transaction with the AccountID discriminant
+        // stripped off, we need to put it back to build a valid transaction
+        // which we can use to build a TransactionSignaturePayloadTaggedTransaction
+        _xdr["default"].PublicKeyType.publicKeyTypeEd25519().toXDR(), tx.toXDR()]));
+      }
+      var taggedTransaction = new _xdr["default"].TransactionSignaturePayloadTaggedTransaction.envelopeTypeTx(tx);
+      var txSignature = new _xdr["default"].TransactionSignaturePayload({
+        networkId: _xdr["default"].Hash.fromXDR((0, _hashing.hash)(this.networkPassphrase)),
+        taggedTransaction: taggedTransaction
+      });
+      return txSignature.toXDR();
+    }
+
+    /**
+     * To envelope returns a xdr.TransactionEnvelope which can be submitted to the network.
+     * @returns {xdr.TransactionEnvelope}
+     */
+  }, {
+    key: "toEnvelope",
+    value: function toEnvelope() {
+      var rawTx = this.tx.toXDR();
+      var signatures = this.signatures.slice(); // make a copy of the signatures
+
+      var envelope;
+      switch (this._envelopeType) {
+        case _xdr["default"].EnvelopeType.envelopeTypeTxV0():
+          envelope = new _xdr["default"].TransactionEnvelope.envelopeTypeTxV0(new _xdr["default"].TransactionV0Envelope({
+            tx: _xdr["default"].TransactionV0.fromXDR(rawTx),
+            // make a copy of tx
+            signatures: signatures
+          }));
+          break;
+        case _xdr["default"].EnvelopeType.envelopeTypeTx():
+          envelope = new _xdr["default"].TransactionEnvelope.envelopeTypeTx(new _xdr["default"].TransactionV1Envelope({
+            tx: _xdr["default"].Transaction.fromXDR(rawTx),
+            // make a copy of tx
+            signatures: signatures
+          }));
+          break;
+        default:
+          throw new Error("Invalid TransactionEnvelope: expected an envelopeTypeTxV0 or envelopeTypeTx but received an ".concat(this._envelopeType.name, "."));
+      }
+      return envelope;
+    }
+
+    /**
+     * Calculate the claimable balance ID for an operation within the transaction.
+     *
+     * @param   {integer}  opIndex   the index of the CreateClaimableBalance op
+     * @returns {string}   a hex string representing the claimable balance ID
+     *
+     * @throws {RangeError}   for invalid `opIndex` value
+     * @throws {TypeError}    if op at `opIndex` is not `CreateClaimableBalance`
+     * @throws for general XDR un/marshalling failures
+     *
+     * @see https://github.com/stellar/go/blob/d712346e61e288d450b0c08038c158f8848cc3e4/txnbuild/transaction.go#L392-L435
+     *
+     */
+  }, {
+    key: "getClaimableBalanceId",
+    value: function getClaimableBalanceId(opIndex) {
+      // Validate and then extract the operation from the transaction.
+      if (!Number.isInteger(opIndex) || opIndex < 0 || opIndex >= this.operations.length) {
+        throw new RangeError('invalid operation index');
+      }
+      var op = this.operations[opIndex];
+      try {
+        op = _operation.Operation.createClaimableBalance(op);
+      } catch (err) {
+        throw new TypeError("expected createClaimableBalance, got ".concat(op.type, ": ").concat(err));
+      }
+
+      // Always use the transaction's *unmuxed* source.
+      var account = _strkey.StrKey.decodeEd25519PublicKey((0, _decode_encode_muxed_account.extractBaseAddress)(this.source));
+      var operationId = _xdr["default"].HashIdPreimage.envelopeTypeOpId(new _xdr["default"].HashIdPreimageOperationId({
+        sourceAccount: _xdr["default"].AccountId.publicKeyTypeEd25519(account),
+        seqNum: _xdr["default"].SequenceNumber.fromString(this.sequence),
+        opNum: opIndex
+      }));
+      var opIdHash = (0, _hashing.hash)(operationId.toXDR('raw'));
+      var balanceId = _xdr["default"].ClaimableBalanceId.claimableBalanceIdTypeV0(opIdHash);
+      return balanceId.toXDR('hex');
+    }
+  }]);
+  return Transaction;
+}(_transaction_base.TransactionBase);

package/lib/transaction_base.js

@@ -0,0 +1,248 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TransactionBase = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _hashing = require("./hashing");
+var _keypair = require("./keypair");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+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 _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * @ignore
+ */
+var TransactionBase = exports.TransactionBase = /*#__PURE__*/function () {
+  function TransactionBase(tx, signatures, fee, networkPassphrase) {
+    _classCallCheck(this, TransactionBase);
+    if (typeof networkPassphrase !== 'string') {
+      throw new Error("Invalid passphrase provided to Transaction: expected a string but got a ".concat(_typeof(networkPassphrase)));
+    }
+    this._networkPassphrase = networkPassphrase;
+    this._tx = tx;
+    this._signatures = signatures;
+    this._fee = fee;
+  }
+
+  /**
+   * @type {Array.<xdr.DecoratedSignature>}
+   * @readonly
+   */
+  _createClass(TransactionBase, [{
+    key: "signatures",
+    get: function get() {
+      return this._signatures;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+  }, {
+    key: "tx",
+    get: function get() {
+      return this._tx;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {string}
+     * @readonly
+     */
+  }, {
+    key: "fee",
+    get: function get() {
+      return this._fee;
+    },
+    set: function set(value) {
+      throw new Error('Transaction is immutable');
+    }
+
+    /**
+     * @type {string}
+     * @readonly
+     */
+  }, {
+    key: "networkPassphrase",
+    get: function get() {
+      return this._networkPassphrase;
+    },
+    set: function set(networkPassphrase) {
+      this._networkPassphrase = networkPassphrase;
+    }
+
+    /**
+     * Signs the transaction with the given {@link Keypair}.
+     * @param {...Keypair} keypairs Keypairs of signers
+     * @returns {void}
+     */
+  }, {
+    key: "sign",
+    value: function sign() {
+      var _this = this;
+      var txHash = this.hash();
+      for (var _len = arguments.length, keypairs = new Array(_len), _key = 0; _key < _len; _key++) {
+        keypairs[_key] = arguments[_key];
+      }
+      keypairs.forEach(function (kp) {
+        var sig = kp.signDecorated(txHash);
+        _this.signatures.push(sig);
+      });
+    }
+
+    /**
+     * Signs a transaction with the given {@link Keypair}. Useful if someone sends
+     * you a transaction XDR for you to sign and return (see
+     * [addSignature](#addSignature) for more information).
+     *
+     * When you get a transaction XDR to sign....
+     * - Instantiate a `Transaction` object with the XDR
+     * - Use {@link Keypair} to generate a keypair object for your Stellar seed.
+     * - Run `getKeypairSignature` with that keypair
+     * - Send back the signature along with your publicKey (not your secret seed!)
+     *
+     * Example:
+     * ```javascript
+     * // `transactionXDR` is a string from the person generating the transaction
+     * const transaction = new Transaction(transactionXDR, networkPassphrase);
+     * const keypair = Keypair.fromSecret(myStellarSeed);
+     * return transaction.getKeypairSignature(keypair);
+     * ```
+     *
+     * @param {Keypair} keypair Keypair of signer
+     * @returns {string} Signature string
+     */
+  }, {
+    key: "getKeypairSignature",
+    value: function getKeypairSignature(keypair) {
+      return keypair.sign(this.hash()).toString('base64');
+    }
+
+    /**
+     * Add a signature to the transaction. Useful when a party wants to pre-sign
+     * a transaction but doesn't want to give access to their secret keys.
+     * This will also verify whether the signature is valid.
+     *
+     * Here's how you would use this feature to solicit multiple signatures.
+     * - Use `TransactionBuilder` to build a new transaction.
+     * - Make sure to set a long enough timeout on that transaction to give your
+     * signers enough time to sign!
+     * - Once you build the transaction, use `transaction.toXDR()` to get the
+     * base64-encoded XDR string.
+     * - _Warning!_ Once you've built this transaction, don't submit any other
+     * transactions onto your account! Doing so will invalidate this pre-compiled
+     * transaction!
+     * - Send this XDR string to your other parties. They can use the instructions
+     * for [getKeypairSignature](#getKeypairSignature) to sign the transaction.
+     * - They should send you back their `publicKey` and the `signature` string
+     * from [getKeypairSignature](#getKeypairSignature), both of which you pass to
+     * this function.
+     *
+     * @param {string} publicKey The public key of the signer
+     * @param {string} signature The base64 value of the signature XDR
+     * @returns {void}
+     */
+  }, {
+    key: "addSignature",
+    value: function addSignature() {
+      var publicKey = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      var signature = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+      if (!signature || typeof signature !== 'string') {
+        throw new Error('Invalid signature');
+      }
+      if (!publicKey || typeof publicKey !== 'string') {
+        throw new Error('Invalid publicKey');
+      }
+      var keypair;
+      var hint;
+      var signatureBuffer = Buffer.from(signature, 'base64');
+      try {
+        keypair = _keypair.Keypair.fromPublicKey(publicKey);
+        hint = keypair.signatureHint();
+      } catch (e) {
+        throw new Error('Invalid publicKey');
+      }
+      if (!keypair.verify(this.hash(), signatureBuffer)) {
+        throw new Error('Invalid signature');
+      }
+      this.signatures.push(new _xdr["default"].DecoratedSignature({
+        hint: hint,
+        signature: signatureBuffer
+      }));
+    }
+
+    /**
+     * Add a decorated signature directly to the transaction envelope.
+     *
+     * @param {xdr.DecoratedSignature} signature    raw signature to add
+     * @returns {void}
+     *
+     * @see Keypair.signDecorated
+     * @see Keypair.signPayloadDecorated
+     */
+  }, {
+    key: "addDecoratedSignature",
+    value: function addDecoratedSignature(signature) {
+      this.signatures.push(signature);
+    }
+
+    /**
+     * Add `hashX` signer preimage as signature.
+     * @param {Buffer|String} preimage Preimage of hash used as signer
+     * @returns {void}
+     */
+  }, {
+    key: "signHashX",
+    value: function signHashX(preimage) {
+      if (typeof preimage === 'string') {
+        preimage = Buffer.from(preimage, 'hex');
+      }
+      if (preimage.length > 64) {
+        throw new Error('preimage cannnot be longer than 64 bytes');
+      }
+      var signature = preimage;
+      var hashX = (0, _hashing.hash)(preimage);
+      var hint = hashX.slice(hashX.length - 4);
+      this.signatures.push(new _xdr["default"].DecoratedSignature({
+        hint: hint,
+        signature: signature
+      }));
+    }
+
+    /**
+     * Returns a hash for this transaction, suitable for signing.
+     * @returns {Buffer}
+     */
+  }, {
+    key: "hash",
+    value: function hash() {
+      return (0, _hashing.hash)(this.signatureBase());
+    }
+  }, {
+    key: "signatureBase",
+    value: function signatureBase() {
+      throw new Error('Implement in subclass');
+    }
+  }, {
+    key: "toEnvelope",
+    value: function toEnvelope() {
+      throw new Error('Implement in subclass');
+    }
+
+    /**
+     * Get the transaction envelope as a base64-encoded string
+     * @returns {string} XDR string
+     */
+  }, {
+    key: "toXDR",
+    value: function toXDR() {
+      return this.toEnvelope().toXDR().toString('base64');
+    }
+  }]);
+  return TransactionBase;
+}();