@stellar/stellar-base 10.0.0

package/lib/fee_bump_transaction.js

@@ -0,0 +1,134 @@
+"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.FeeBumpTransaction = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _hashing = require("./hashing");
+var _transaction = require("./transaction");
+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.buildFeeBumpTransaction} to build a
+ * FeeBumpTransaction object. If you have an object or base64-encoded string of
+ * the transaction envelope XDR use {@link TransactionBuilder.fromXDR}.
+ *
+ * Once a {@link FeeBumpTransaction} has been created, its attributes and operations
+ * should not be changed. You should only add signatures (using {@link FeeBumpTransaction#sign}) before
+ * submitting to the network or forwarding on to additional signers.
+ *
+ * @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 FeeBumpTransaction = exports.FeeBumpTransaction = /*#__PURE__*/function (_TransactionBase) {
+  _inherits(FeeBumpTransaction, _TransactionBase);
+  var _super = _createSuper(FeeBumpTransaction);
+  function FeeBumpTransaction(envelope, networkPassphrase) {
+    var _this;
+    _classCallCheck(this, FeeBumpTransaction);
+    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.envelopeTypeTxFeeBump()) {
+      throw new Error("Invalid TransactionEnvelope: expected an envelopeTypeTxFeeBump but received an ".concat(envelopeType.name, "."));
+    }
+    var txEnvelope = envelope.value();
+    var tx = txEnvelope.tx();
+    var fee = tx.fee().toString();
+    // clone signatures
+    var signatures = (txEnvelope.signatures() || []).slice();
+    _this = _super.call(this, tx, signatures, fee, networkPassphrase);
+    var innerTxEnvelope = _xdr["default"].TransactionEnvelope.envelopeTypeTx(tx.innerTx().v1());
+    _this._feeSource = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(_this.tx.feeSource());
+    _this._innerTransaction = new _transaction.Transaction(innerTxEnvelope, networkPassphrase);
+    return _this;
+  }
+
+  /**
+   * @type {Transaction}
+   * @readonly
+   */
+  _createClass(FeeBumpTransaction, [{
+    key: "innerTransaction",
+    get: function get() {
+      return this._innerTransaction;
+    }
+
+    /**
+     * @type {Operation[]}
+     * @readonly
+     */
+  }, {
+    key: "operations",
+    get: function get() {
+      return this._innerTransaction.operations;
+    }
+
+    /**
+     * @type {string}
+     * @readonly
+     */
+  }, {
+    key: "feeSource",
+    get: function get() {
+      return this._feeSource;
+    }
+
+    /**
+     * 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 taggedTransaction = new _xdr["default"].TransactionSignaturePayloadTaggedTransaction.envelopeTypeTxFeeBump(this.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 envelope = new _xdr["default"].FeeBumpTransactionEnvelope({
+        tx: _xdr["default"].FeeBumpTransaction.fromXDR(this.tx.toXDR()),
+        // make a copy of the tx
+        signatures: this.signatures.slice() // make a copy of the signatures
+      });
+      return new _xdr["default"].TransactionEnvelope.envelopeTypeTxFeeBump(envelope);
+    }
+  }]);
+  return FeeBumpTransaction;
+}(_transaction_base.TransactionBase);