@stellar/stellar-base 10.0.0

package/lib/operations/manage_data.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.manageData = manageData;
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * This operation adds data entry to the ledger.
+ * @function
+ * @alias Operation.manageData
+ * @param {object} opts Options object
+ * @param {string} opts.name - The name of the data entry.
+ * @param {string|Buffer} opts.value - The value of the data entry.
+ * @param {string} [opts.source] - The optional source account.
+ * @returns {xdr.ManageDataOp} Manage Data operation
+ */
+function manageData(opts) {
+  var attributes = {};
+  if (!(typeof opts.name === 'string' && opts.name.length <= 64)) {
+    throw new Error('name must be a string, up to 64 characters');
+  }
+  attributes.dataName = opts.name;
+  if (typeof opts.value !== 'string' && !Buffer.isBuffer(opts.value) && opts.value !== null) {
+    throw new Error('value must be a string, Buffer or null');
+  }
+  if (typeof opts.value === 'string') {
+    attributes.dataValue = Buffer.from(opts.value);
+  } else {
+    attributes.dataValue = opts.value;
+  }
+  if (attributes.dataValue !== null && attributes.dataValue.length > 64) {
+    throw new Error('value cannot be longer that 64 bytes');
+  }
+  var manageDataOp = new _xdr["default"].ManageDataOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.manageData(manageDataOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/manage_sell_offer.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.manageSellOffer = manageSellOffer;
+var _jsXdr = require("@stellar/js-xdr");
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Returns a XDR ManageSellOfferOp. A "manage sell offer" operation creates, updates, or
+ * deletes an offer.
+ * @function
+ * @alias Operation.manageSellOffer
+ * @param {object} opts Options object
+ * @param {Asset} opts.selling - What you're selling.
+ * @param {Asset} opts.buying - What you're buying.
+ * @param {string} opts.amount - The total amount you're selling. If 0, deletes the offer.
+ * @param {number|string|BigNumber|Object} opts.price - Price of 1 unit of `selling` in terms of `buying`.
+ * @param {number} opts.price.n - If `opts.price` is an object: the price numerator
+ * @param {number} opts.price.d - If `opts.price` is an object: the price denominator
+ * @param {number|string} [opts.offerId ] - If `0`, will create a new offer (default). Otherwise, edits an exisiting offer.
+ * @param {string} [opts.source] - The source account (defaults to transaction source).
+ * @throws {Error} Throws `Error` when the best rational approximation of `price` cannot be found.
+ * @returns {xdr.ManageSellOfferOp} Manage Sell Offer operation
+ */
+function manageSellOffer(opts) {
+  var attributes = {};
+  attributes.selling = opts.selling.toXDRObject();
+  attributes.buying = opts.buying.toXDRObject();
+  if (!this.isValidAmount(opts.amount, true)) {
+    throw new TypeError(this.constructAmountRequirementsError('amount'));
+  }
+  attributes.amount = this._toXDRAmount(opts.amount);
+  if (opts.price === undefined) {
+    throw new TypeError('price argument is required');
+  }
+  attributes.price = this._toXDRPrice(opts.price);
+  if (opts.offerId !== undefined) {
+    opts.offerId = opts.offerId.toString();
+  } else {
+    opts.offerId = '0';
+  }
+  attributes.offerId = _jsXdr.Hyper.fromString(opts.offerId);
+  var manageSellOfferOp = new _xdr["default"].ManageSellOfferOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.manageSellOffer(manageSellOfferOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/path_payment_strict_receive.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathPaymentStrictReceive = pathPaymentStrictReceive;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _decode_encode_muxed_account = require("../util/decode_encode_muxed_account");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Creates a PathPaymentStrictReceive operation.
+ *
+ * A `PathPaymentStrictReceive` operation sends the specified amount to the
+ * destination account. It credits the destination with `destAmount` of
+ * `destAsset`, while debiting at most `sendMax` of `sendAsset` from the source.
+ * The transfer optionally occurs through a path. XLM payments create the
+ * destination account if it does not exist.
+ *
+ * @function
+ * @alias Operation.pathPaymentStrictReceive
+ * @see https://developers.stellar.org/docs/start/list-of-operations/#path-payment-strict-receive
+ *
+ * @param {object}  opts - Options object
+ * @param {Asset}   opts.sendAsset    - asset to pay with
+ * @param {string}  opts.sendMax      - maximum amount of sendAsset to send
+ * @param {string}  opts.destination  - destination account to send to
+ * @param {Asset}   opts.destAsset    - asset the destination will receive
+ * @param {string}  opts.destAmount   - amount the destination receives
+ * @param {Asset[]} opts.path         - array of Asset objects to use as the path
+ *
+ * @param {string}  [opts.source]     - The source account for the payment.
+ *     Defaults to the transaction's source account.
+ *
+ * @returns {xdr.PathPaymentStrictReceiveOp} the resulting path payment op
+ */
+function pathPaymentStrictReceive(opts) {
+  switch (true) {
+    case !opts.sendAsset:
+      throw new Error('Must specify a send asset');
+    case !this.isValidAmount(opts.sendMax):
+      throw new TypeError(this.constructAmountRequirementsError('sendMax'));
+    case !opts.destAsset:
+      throw new Error('Must provide a destAsset for a payment operation');
+    case !this.isValidAmount(opts.destAmount):
+      throw new TypeError(this.constructAmountRequirementsError('destAmount'));
+    default:
+      break;
+  }
+  var attributes = {};
+  attributes.sendAsset = opts.sendAsset.toXDRObject();
+  attributes.sendMax = this._toXDRAmount(opts.sendMax);
+  try {
+    attributes.destination = (0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(opts.destination);
+  } catch (e) {
+    throw new Error('destination is invalid');
+  }
+  attributes.destAsset = opts.destAsset.toXDRObject();
+  attributes.destAmount = this._toXDRAmount(opts.destAmount);
+  var path = opts.path ? opts.path : [];
+  attributes.path = path.map(function (x) {
+    return x.toXDRObject();
+  });
+  var payment = new _xdr["default"].PathPaymentStrictReceiveOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.pathPaymentStrictReceive(payment);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/path_payment_strict_send.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathPaymentStrictSend = pathPaymentStrictSend;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _decode_encode_muxed_account = require("../util/decode_encode_muxed_account");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Creates a PathPaymentStrictSend operation.
+ *
+ * A `PathPaymentStrictSend` operation sends the specified amount to the
+ * destination account crediting at least `destMin` of `destAsset`, optionally
+ * through a path. XLM payments create the destination account if it does not
+ * exist.
+ *
+ * @function
+ * @alias Operation.pathPaymentStrictSend
+ * @see https://developers.stellar.org/docs/start/list-of-operations/#path-payment-strict-send
+ *
+ * @param {object}  opts - Options object
+ * @param {Asset}   opts.sendAsset    - asset to pay with
+ * @param {string}  opts.sendAmount   - amount of sendAsset to send (excluding fees)
+ * @param {string}  opts.destination  - destination account to send to
+ * @param {Asset}   opts.destAsset    - asset the destination will receive
+ * @param {string}  opts.destMin      - minimum amount of destAsset to be receive
+ * @param {Asset[]} opts.path         - array of Asset objects to use as the path
+ *
+ * @param {string}  [opts.source]     - The source account for the payment.
+ *     Defaults to the transaction's source account.
+ *
+ * @returns {xdr.Operation}   the resulting path payment operation
+ *     (xdr.PathPaymentStrictSendOp)
+ */
+function pathPaymentStrictSend(opts) {
+  switch (true) {
+    case !opts.sendAsset:
+      throw new Error('Must specify a send asset');
+    case !this.isValidAmount(opts.sendAmount):
+      throw new TypeError(this.constructAmountRequirementsError('sendAmount'));
+    case !opts.destAsset:
+      throw new Error('Must provide a destAsset for a payment operation');
+    case !this.isValidAmount(opts.destMin):
+      throw new TypeError(this.constructAmountRequirementsError('destMin'));
+    default:
+      break;
+  }
+  var attributes = {};
+  attributes.sendAsset = opts.sendAsset.toXDRObject();
+  attributes.sendAmount = this._toXDRAmount(opts.sendAmount);
+  try {
+    attributes.destination = (0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(opts.destination);
+  } catch (e) {
+    throw new Error('destination is invalid');
+  }
+  attributes.destAsset = opts.destAsset.toXDRObject();
+  attributes.destMin = this._toXDRAmount(opts.destMin);
+  var path = opts.path ? opts.path : [];
+  attributes.path = path.map(function (x) {
+    return x.toXDRObject();
+  });
+  var payment = new _xdr["default"].PathPaymentStrictSendOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.pathPaymentStrictSend(payment);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/payment.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.payment = payment;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _decode_encode_muxed_account = require("../util/decode_encode_muxed_account");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create a payment operation.
+ *
+ * @function
+ * @alias Operation.payment
+ * @see https://developers.stellar.org/docs/start/list-of-operations/#payment
+ *
+ * @param {object}  opts - Options object
+ * @param {string}  opts.destination  - destination account ID
+ * @param {Asset}   opts.asset        - asset to send
+ * @param {string}  opts.amount       - amount to send
+ *
+ * @param {string}  [opts.source]     - The source account for the payment.
+ *     Defaults to the transaction's source account.
+ *
+ * @returns {xdr.Operation}   The resulting payment operation (xdr.PaymentOp)
+ */
+function payment(opts) {
+  if (!opts.asset) {
+    throw new Error('Must provide an asset for a payment operation');
+  }
+  if (!this.isValidAmount(opts.amount)) {
+    throw new TypeError(this.constructAmountRequirementsError('amount'));
+  }
+  var attributes = {};
+  try {
+    attributes.destination = (0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(opts.destination);
+  } catch (e) {
+    throw new Error('destination is invalid');
+  }
+  attributes.asset = opts.asset.toXDRObject();
+  attributes.amount = this._toXDRAmount(opts.amount);
+  var paymentOp = new _xdr["default"].PaymentOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.payment(paymentOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/restore_footprint.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.restoreFootprint = restoreFootprint;
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Builds a footprint restoration operation.
+ *
+ * It takes no parameters because the relevant footprint is derived from the
+ * transaction itself (see {@link TransactionBuilder}'s `opts.sorobanData`
+ * parameter (or {@link TransactionBuilder.setSorobanData} /
+ * {@link TransactionBuilder.setLedgerKeys}), which is a
+ * {@link xdr.SorobanTransactionData} instance that contains fee data & resource
+ * usage as part of {@link xdr.SorobanTransactionData}).
+ *
+ * @function
+ * @alias Operation.restoreFootprint
+ *
+ * @param {object} [opts] - an optional set of parameters
+ * @param {string} [opts.source] - an optional source account
+ *
+ * @returns {xdr.Operation} a Bump Footprint Expiration operation
+ *    (xdr.RestoreFootprintOp)
+ */
+function restoreFootprint() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var op = new _xdr["default"].RestoreFootprintOp({
+    ext: new _xdr["default"].ExtensionPoint(0)
+  });
+  var opAttributes = {
+    body: _xdr["default"].OperationBody.restoreFootprint(op)
+  };
+  this.setSourceAccount(opAttributes, opts !== null && opts !== void 0 ? opts : {});
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/revoke_sponsorship.js

@@ -0,0 +1,301 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.revokeAccountSponsorship = revokeAccountSponsorship;
+exports.revokeClaimableBalanceSponsorship = revokeClaimableBalanceSponsorship;
+exports.revokeDataSponsorship = revokeDataSponsorship;
+exports.revokeLiquidityPoolSponsorship = revokeLiquidityPoolSponsorship;
+exports.revokeOfferSponsorship = revokeOfferSponsorship;
+exports.revokeSignerSponsorship = revokeSignerSponsorship;
+exports.revokeTrustlineSponsorship = revokeTrustlineSponsorship;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _strkey = require("../strkey");
+var _keypair = require("../keypair");
+var _asset = require("../asset");
+var _liquidity_pool_id = require("../liquidity_pool_id");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create a "revoke sponsorship" operation for an account.
+ *
+ * @function
+ * @alias Operation.revokeAccountSponsorship
+ * @param {object} opts Options object
+ * @param {string} opts.account - The sponsored account ID.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr operation
+ *
+ * @example
+ * const op = Operation.revokeAccountSponsorship({
+ *   account: 'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7
+ * });
+ *
+ */
+function revokeAccountSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.account)) {
+    throw new Error('account is invalid');
+  }
+  var ledgerKey = _xdr["default"].LedgerKey.account(new _xdr["default"].LedgerKeyAccount({
+    accountId: _keypair.Keypair.fromPublicKey(opts.account).xdrAccountId()
+  }));
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipLedgerEntry(ledgerKey);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.revokeSponsorship(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+
+/**
+ * Create a "revoke sponsorship" operation for a trustline.
+ *
+ * @function
+ * @alias Operation.revokeTrustlineSponsorship
+ * @param {object} opts Options object
+ * @param {string} opts.account - The account ID which owns the trustline.
+ * @param {Asset | LiquidityPoolId} opts.asset - The trustline asset.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr operation
+ *
+ * @example
+ * const op = Operation.revokeTrustlineSponsorship({
+ *   account: 'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7
+ *   asset: new StellarBase.LiquidityPoolId(
+ *     'USDUSD',
+ *     'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7'
+ *   )
+ * });
+ *
+ */
+function revokeTrustlineSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.account)) {
+    throw new Error('account is invalid');
+  }
+  var asset;
+  if (opts.asset instanceof _asset.Asset) {
+    asset = opts.asset.toTrustLineXDRObject();
+  } else if (opts.asset instanceof _liquidity_pool_id.LiquidityPoolId) {
+    asset = opts.asset.toXDRObject();
+  } else {
+    throw new TypeError('asset must be an Asset or LiquidityPoolId');
+  }
+  var ledgerKey = _xdr["default"].LedgerKey.trustline(new _xdr["default"].LedgerKeyTrustLine({
+    accountId: _keypair.Keypair.fromPublicKey(opts.account).xdrAccountId(),
+    asset: asset
+  }));
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipLedgerEntry(ledgerKey);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.revokeSponsorship(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+
+/**
+ * Create a "revoke sponsorship" operation for an offer.
+ *
+ * @function
+ * @alias Operation.revokeOfferSponsorship
+ * @param {object} opts Options object
+ * @param {string} opts.seller - The account ID which created the offer.
+ * @param {string} opts.offerId - The offer ID.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr operation
+ *
+ * @example
+ * const op = Operation.revokeOfferSponsorship({
+ *   seller: 'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7
+ *   offerId: '1234'
+ * });
+ *
+ */
+function revokeOfferSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.seller)) {
+    throw new Error('seller is invalid');
+  }
+  if (typeof opts.offerId !== 'string') {
+    throw new Error('offerId is invalid');
+  }
+  var ledgerKey = _xdr["default"].LedgerKey.offer(new _xdr["default"].LedgerKeyOffer({
+    sellerId: _keypair.Keypair.fromPublicKey(opts.seller).xdrAccountId(),
+    offerId: _xdr["default"].Int64.fromString(opts.offerId)
+  }));
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipLedgerEntry(ledgerKey);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.revokeSponsorship(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+
+/**
+ * Create a "revoke sponsorship" operation for a data entry.
+ *
+ * @function
+ * @alias Operation.revokeDataSponsorship
+ * @param {object} opts Options object
+ * @param {string} opts.account - The account ID which owns the data entry.
+ * @param {string} opts.name - The name of the data entry
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr operation
+ *
+ * @example
+ * const op = Operation.revokeDataSponsorship({
+ *   account: 'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7
+ *   name: 'foo'
+ * });
+ *
+ */
+function revokeDataSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.account)) {
+    throw new Error('account is invalid');
+  }
+  if (typeof opts.name !== 'string' || opts.name.length > 64) {
+    throw new Error('name must be a string, up to 64 characters');
+  }
+  var ledgerKey = _xdr["default"].LedgerKey.data(new _xdr["default"].LedgerKeyData({
+    accountId: _keypair.Keypair.fromPublicKey(opts.account).xdrAccountId(),
+    dataName: opts.name
+  }));
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipLedgerEntry(ledgerKey);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.revokeSponsorship(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+
+/**
+ * Create a "revoke sponsorship" operation for a claimable balance.
+ *
+ * @function
+ * @alias Operation.revokeClaimableBalanceSponsorship
+ * @param {object} opts Options object
+ * @param {string} opts.balanceId - The sponsored claimable balance ID.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr operation
+ *
+ * @example
+ * const op = Operation.revokeClaimableBalanceSponsorship({
+ *   balanceId: '00000000da0d57da7d4850e7fc10d2a9d0ebc731f7afb40574c03395b17d49149b91f5be',
+ * });
+ *
+ */
+function revokeClaimableBalanceSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (typeof opts.balanceId !== 'string') {
+    throw new Error('balanceId is invalid');
+  }
+  var ledgerKey = _xdr["default"].LedgerKey.claimableBalance(new _xdr["default"].LedgerKeyClaimableBalance({
+    balanceId: _xdr["default"].ClaimableBalanceId.fromXDR(opts.balanceId, 'hex')
+  }));
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipLedgerEntry(ledgerKey);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.revokeSponsorship(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+
+/**
+ * Creates a "revoke sponsorship" operation for a liquidity pool.
+ *
+ * @function
+ * @alias Operation.revokeLiquidityPoolSponsorship
+ * @param {object} opts – Options object.
+ * @param {string} opts.liquidityPoolId - The sponsored liquidity pool ID in 'hex' string.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr Operation.
+ *
+ * @example
+ * const op = Operation.revokeLiquidityPoolSponsorship({
+ *   liquidityPoolId: 'dd7b1ab831c273310ddbec6f97870aa83c2fbd78ce22aded37ecbf4f3380fac7',
+ * });
+ *
+ */
+function revokeLiquidityPoolSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (typeof opts.liquidityPoolId !== 'string') {
+    throw new Error('liquidityPoolId is invalid');
+  }
+  var ledgerKey = _xdr["default"].LedgerKey.liquidityPool(new _xdr["default"].LedgerKeyLiquidityPool({
+    liquidityPoolId: _xdr["default"].PoolId.fromXDR(opts.liquidityPoolId, 'hex')
+  }));
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipLedgerEntry(ledgerKey);
+  var opAttributes = {
+    body: _xdr["default"].OperationBody.revokeSponsorship(op)
+  };
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+
+/**
+ * Create a "revoke sponsorship" operation for a signer.
+ *
+ * @function
+ * @alias Operation.revokeSignerSponsorship
+ * @param {object} opts Options object
+ * @param {string} opts.account - The account ID where the signer sponsorship is being removed from.
+ * @param {object} opts.signer - The signer whose sponsorship is being removed.
+ * @param {string} [opts.signer.ed25519PublicKey] - The ed25519 public key of the signer.
+ * @param {Buffer|string} [opts.signer.sha256Hash] - sha256 hash (Buffer or hex string).
+ * @param {Buffer|string} [opts.signer.preAuthTx] - Hash (Buffer or hex string) of transaction.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} xdr operation
+ *
+ * @example
+ * const op = Operation.revokeSignerSponsorship({
+ *   account: 'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7
+ *   signer: {
+ *     ed25519PublicKey: 'GCEZWKCA5VLDNRLN3RPRJMRZOX3Z6G5CHCGSNFHEYVXM3XOJMDS674JZ'
+ *   }
+ * })
+ *
+ */
+function revokeSignerSponsorship() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.account)) {
+    throw new Error('account is invalid');
+  }
+  var key;
+  if (opts.signer.ed25519PublicKey) {
+    if (!_strkey.StrKey.isValidEd25519PublicKey(opts.signer.ed25519PublicKey)) {
+      throw new Error('signer.ed25519PublicKey is invalid.');
+    }
+    var rawKey = _strkey.StrKey.decodeEd25519PublicKey(opts.signer.ed25519PublicKey);
+    key = new _xdr["default"].SignerKey.signerKeyTypeEd25519(rawKey);
+  } else if (opts.signer.preAuthTx) {
+    var buffer;
+    if (typeof opts.signer.preAuthTx === 'string') {
+      buffer = Buffer.from(opts.signer.preAuthTx, 'hex');
+    } else {
+      buffer = opts.signer.preAuthTx;
+    }
+    if (!(Buffer.isBuffer(buffer) && buffer.length === 32)) {
+      throw new Error('signer.preAuthTx must be 32 bytes Buffer.');
+    }
+    key = new _xdr["default"].SignerKey.signerKeyTypePreAuthTx(buffer);
+  } else if (opts.signer.sha256Hash) {
+    var _buffer;
+    if (typeof opts.signer.sha256Hash === 'string') {
+      _buffer = Buffer.from(opts.signer.sha256Hash, 'hex');
+    } else {
+      _buffer = opts.signer.sha256Hash;
+    }
+    if (!(Buffer.isBuffer(_buffer) && _buffer.length === 32)) {
+      throw new Error('signer.sha256Hash must be 32 bytes Buffer.');
+    }
+    key = new _xdr["default"].SignerKey.signerKeyTypeHashX(_buffer);
+  } else {
+    throw new Error('signer is invalid');
+  }
+  var signer = new _xdr["default"].RevokeSponsorshipOpSigner({
+    accountId: _keypair.Keypair.fromPublicKey(opts.account).xdrAccountId(),
+    signerKey: key
+  });
+  var op = _xdr["default"].RevokeSponsorshipOp.revokeSponsorshipSigner(signer);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.revokeSponsorship(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}