@stellar/stellar-base 10.0.0

package/lib/operations/account_merge.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.accountMerge = accountMerge;
+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 }; }
+/**
+ * Transfers native balance to destination account.
+ *
+ * @function
+ * @alias Operation.accountMerge
+ *
+ * @param {object} opts - options object
+ * @param {string} opts.destination - destination to merge the source account into
+ * @param {string} [opts.source]    - operation source account (defaults to
+ *     transaction source)
+ *
+ * @returns {xdr.Operation} an Account Merge operation (xdr.AccountMergeOp)
+ */
+function accountMerge(opts) {
+  var opAttributes = {};
+  try {
+    opAttributes.body = _xdr["default"].OperationBody.accountMerge((0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(opts.destination));
+  } catch (e) {
+    throw new Error('destination is invalid');
+  }
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/allow_trust.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.allowTrust = allowTrust;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _keypair = require("../keypair");
+var _strkey = require("../strkey");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * @deprecated since v5.0
+ *
+ * Returns an XDR AllowTrustOp. An "allow trust" operation authorizes another
+ * account to hold your account's credit for a given asset.
+ *
+ * @function
+ * @alias Operation.allowTrust
+ *
+ * @param {object} opts Options object
+ * @param {string} opts.trustor - The trusting account (the one being authorized)
+ * @param {string} opts.assetCode - The asset code being authorized.
+ * @param {(0|1|2)} opts.authorize - `1` to authorize, `2` to authorize to maintain liabilities, and `0` to deauthorize.
+ * @param {string} [opts.source] - The source account (defaults to transaction source).
+ *
+ * @returns {xdr.AllowTrustOp} Allow Trust operation
+ */
+function allowTrust(opts) {
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.trustor)) {
+    throw new Error('trustor is invalid');
+  }
+  var attributes = {};
+  attributes.trustor = _keypair.Keypair.fromPublicKey(opts.trustor).xdrAccountId();
+  if (opts.assetCode.length <= 4) {
+    var code = opts.assetCode.padEnd(4, '\0');
+    attributes.asset = _xdr["default"].AssetCode.assetTypeCreditAlphanum4(code);
+  } else if (opts.assetCode.length <= 12) {
+    var _code = opts.assetCode.padEnd(12, '\0');
+    attributes.asset = _xdr["default"].AssetCode.assetTypeCreditAlphanum12(_code);
+  } else {
+    throw new Error('Asset code must be 12 characters at max.');
+  }
+  if (typeof opts.authorize === 'boolean') {
+    if (opts.authorize) {
+      attributes.authorize = _xdr["default"].TrustLineFlags.authorizedFlag().value;
+    } else {
+      attributes.authorize = 0;
+    }
+  } else {
+    attributes.authorize = opts.authorize;
+  }
+  var allowTrustOp = new _xdr["default"].AllowTrustOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.allowTrust(allowTrustOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/begin_sponsoring_future_reserves.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.beginSponsoringFutureReserves = beginSponsoringFutureReserves;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _strkey = require("../strkey");
+var _keypair = require("../keypair");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create a "begin sponsoring future reserves" operation.
+ * @function
+ * @alias Operation.beginSponsoringFutureReserves
+ * @param {object} opts Options object
+ * @param {string} opts.sponsoredId - 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.beginSponsoringFutureReserves({
+ *   sponsoredId: 'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7'
+ * });
+ *
+ */
+function beginSponsoringFutureReserves() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.sponsoredId)) {
+    throw new Error('sponsoredId is invalid');
+  }
+  var op = new _xdr["default"].BeginSponsoringFutureReservesOp({
+    sponsoredId: _keypair.Keypair.fromPublicKey(opts.sponsoredId).xdrAccountId()
+  });
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.beginSponsoringFutureReserves(op);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/bump_sequence.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bumpSequence = bumpSequence;
+var _jsXdr = require("@stellar/js-xdr");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * This operation bumps sequence number.
+ * @function
+ * @alias Operation.bumpSequence
+ * @param {object} opts Options object
+ * @param {string} opts.bumpTo - Sequence number to bump to.
+ * @param {string} [opts.source] - The optional source account.
+ * @returns {xdr.BumpSequenceOp} Operation
+ */
+function bumpSequence(opts) {
+  var attributes = {};
+  if (typeof opts.bumpTo !== 'string') {
+    throw new Error('bumpTo must be a string');
+  }
+  try {
+    // eslint-disable-next-line no-new
+    new _bignumber["default"](opts.bumpTo);
+  } catch (e) {
+    throw new Error('bumpTo must be a stringified number');
+  }
+  attributes.bumpTo = _jsXdr.Hyper.fromString(opts.bumpTo);
+  var bumpSequenceOp = new _xdr["default"].BumpSequenceOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.bumpSequence(bumpSequenceOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/change_trust.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.changeTrust = changeTrust;
+var _jsXdr = require("@stellar/js-xdr");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _asset = require("../asset");
+var _liquidity_pool_asset = require("../liquidity_pool_asset");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+var MAX_INT64 = '9223372036854775807';
+
+/**
+ * Returns an XDR ChangeTrustOp. A "change trust" operation adds, removes, or updates a
+ * trust line for a given asset from the source account to another.
+ * @function
+ * @alias Operation.changeTrust
+ * @param {object} opts Options object
+ * @param {Asset | LiquidityPoolAsset} opts.asset - The asset for the trust line.
+ * @param {string} [opts.limit] - The limit for the asset, defaults to max int64.
+ *                                If the limit is set to "0" it deletes the trustline.
+ * @param {string} [opts.source] - The source account (defaults to transaction source).
+ * @returns {xdr.ChangeTrustOp} Change Trust operation
+ */
+function changeTrust(opts) {
+  var attributes = {};
+  if (opts.asset instanceof _asset.Asset) {
+    attributes.line = opts.asset.toChangeTrustXDRObject();
+  } else if (opts.asset instanceof _liquidity_pool_asset.LiquidityPoolAsset) {
+    attributes.line = opts.asset.toXDRObject();
+  } else {
+    throw new TypeError('asset must be Asset or LiquidityPoolAsset');
+  }
+  if (opts.limit !== undefined && !this.isValidAmount(opts.limit, true)) {
+    throw new TypeError(this.constructAmountRequirementsError('limit'));
+  }
+  if (opts.limit) {
+    attributes.limit = this._toXDRAmount(opts.limit);
+  } else {
+    attributes.limit = _jsXdr.Hyper.fromString(new _bignumber["default"](MAX_INT64).toString());
+  }
+  if (opts.source) {
+    attributes.source = opts.source.masterKeypair;
+  }
+  var changeTrustOP = new _xdr["default"].ChangeTrustOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.changeTrust(changeTrustOP);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/claim_claimable_balance.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.claimClaimableBalance = claimClaimableBalance;
+exports.validateClaimableBalanceId = validateClaimableBalanceId;
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create a new claim claimable balance operation.
+ * @function
+ * @alias Operation.claimClaimableBalance
+ * @param {object} opts Options object
+ * @param {string} opts.balanceId - The claimable balance id to be claimed.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ * @returns {xdr.Operation} Claim claimable balance operation
+ *
+ * @example
+ * const op = Operation.claimClaimableBalance({
+ *   balanceId: '00000000da0d57da7d4850e7fc10d2a9d0ebc731f7afb40574c03395b17d49149b91f5be',
+ * });
+ *
+ */
+function claimClaimableBalance() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  validateClaimableBalanceId(opts.balanceId);
+  var attributes = {};
+  attributes.balanceId = _xdr["default"].ClaimableBalanceId.fromXDR(opts.balanceId, 'hex');
+  var claimClaimableBalanceOp = new _xdr["default"].ClaimClaimableBalanceOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.claimClaimableBalance(claimClaimableBalanceOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}
+function validateClaimableBalanceId(balanceId) {
+  if (typeof balanceId !== 'string' || balanceId.length !== 8 + 64 /* 8b discriminant + 64b string */) {
+    throw new Error('must provide a valid claimable balance id');
+  }
+}

package/lib/operations/clawback.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clawback = clawback;
+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 clawback operation.
+ *
+ * @function
+ * @alias Operation.clawback
+ *
+ * @param {object} opts - Options object
+ * @param {Asset}  opts.asset   - The asset being clawed back.
+ * @param {string} opts.amount  - The amount of the asset to claw back.
+ * @param {string} opts.from    - The public key of the (optionally-muxed)
+ *     account to claw back from.
+ *
+ * @param {string} [opts.source] - The source account for the operation.
+ *     Defaults to the transaction's source account.
+ *
+ * @return {xdr.ClawbackOp}
+ *
+ * @see https://github.com/stellar/stellar-protocol/blob/master/core/cap-0035.md#clawback-operation
+ */
+function clawback(opts) {
+  var attributes = {};
+  if (!this.isValidAmount(opts.amount)) {
+    throw new TypeError(this.constructAmountRequirementsError('amount'));
+  }
+  attributes.amount = this._toXDRAmount(opts.amount);
+  attributes.asset = opts.asset.toXDRObject();
+  try {
+    attributes.from = (0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(opts.from);
+  } catch (e) {
+    throw new Error('from address is invalid');
+  }
+  var opAttributes = {
+    body: _xdr["default"].OperationBody.clawback(new _xdr["default"].ClawbackOp(attributes))
+  };
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/clawback_claimable_balance.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.clawbackClaimableBalance = clawbackClaimableBalance;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _claim_claimable_balance = require("./claim_claimable_balance");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Creates a clawback operation for a claimable balance.
+ *
+ * @function
+ * @alias Operation.clawbackClaimableBalance
+ * @param {object} opts - Options object
+ * @param {string} opts.balanceId - The claimable balance ID to be clawed back.
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ *
+ * @return {xdr.ClawbackClaimableBalanceOp}
+ *
+ * @example
+ * const op = Operation.clawbackClaimableBalance({
+ *   balanceId: '00000000da0d57da7d4850e7fc10d2a9d0ebc731f7afb40574c03395b17d49149b91f5be',
+ * });
+ *
+ * @link https://github.com/stellar/stellar-protocol/blob/master/core/cap-0035.md#clawback-claimable-balance-operation
+ */
+function clawbackClaimableBalance() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  (0, _claim_claimable_balance.validateClaimableBalanceId)(opts.balanceId);
+  var attributes = {
+    balanceId: _xdr["default"].ClaimableBalanceId.fromXDR(opts.balanceId, 'hex')
+  };
+  var opAttributes = {
+    body: _xdr["default"].OperationBody.clawbackClaimableBalance(new _xdr["default"].ClawbackClaimableBalanceOp(attributes))
+  };
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/create_account.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAccount = createAccount;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _keypair = require("../keypair");
+var _strkey = require("../strkey");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create and fund a non existent account.
+ * @function
+ * @alias Operation.createAccount
+ * @param {object} opts Options object
+ * @param {string} opts.destination - Destination account ID to create an account for.
+ * @param {string} opts.startingBalance - Amount in XLM the account should be funded for. Must be greater
+ *                                   than the [reserve balance amount](https://developers.stellar.org/docs/glossary/fees/).
+ * @param {string} [opts.source] - The source account for the payment. Defaults to the transaction's source account.
+ * @returns {xdr.CreateAccountOp} Create account operation
+ */
+function createAccount(opts) {
+  if (!_strkey.StrKey.isValidEd25519PublicKey(opts.destination)) {
+    throw new Error('destination is invalid');
+  }
+  if (!this.isValidAmount(opts.startingBalance, true)) {
+    throw new TypeError(this.constructAmountRequirementsError('startingBalance'));
+  }
+  var attributes = {};
+  attributes.destination = _keypair.Keypair.fromPublicKey(opts.destination).xdrAccountId();
+  attributes.startingBalance = this._toXDRAmount(opts.startingBalance);
+  var createAccountOp = new _xdr["default"].CreateAccountOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.createAccount(createAccountOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/create_claimable_balance.js

@@ -0,0 +1,65 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createClaimableBalance = createClaimableBalance;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _asset = require("../asset");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create a new claimable balance operation.
+ *
+ * @function
+ * @alias Operation.createClaimableBalance
+ *
+ * @param {object} opts Options object
+ * @param {Asset} opts.asset - The asset for the claimable balance.
+ * @param {string} opts.amount - Amount.
+ * @param {Claimant[]} opts.claimants - An array of Claimants
+ * @param {string} [opts.source] - The source account for the operation. Defaults to the transaction's source account.
+ *
+ * @returns {xdr.Operation} Create claimable balance operation
+ *
+ * @example
+ * const asset = new Asset(
+ *   'USD',
+ *   'GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7'
+ * );
+ * const amount = '100.0000000';
+ * const claimants = [
+ *   new Claimant(
+ *     'GCEZWKCA5VLDNRLN3RPRJMRZOX3Z6G5CHCGSNFHEYVXM3XOJMDS674JZ',
+ *      Claimant.predicateBeforeAbsoluteTime("4102444800000")
+ *   )
+ * ];
+ *
+ * const op = Operation.createClaimableBalance({
+ *   asset,
+ *   amount,
+ *   claimants
+ * });
+ *
+ */
+function createClaimableBalance(opts) {
+  if (!(opts.asset instanceof _asset.Asset)) {
+    throw new Error('must provide an asset for create claimable balance operation');
+  }
+  if (!this.isValidAmount(opts.amount)) {
+    throw new TypeError(this.constructAmountRequirementsError('amount'));
+  }
+  if (!Array.isArray(opts.claimants) || opts.claimants.length === 0) {
+    throw new Error('must provide at least one claimant');
+  }
+  var attributes = {};
+  attributes.asset = opts.asset.toXDRObject();
+  attributes.amount = this._toXDRAmount(opts.amount);
+  attributes.claimants = Object.values(opts.claimants).map(function (c) {
+    return c.toXDRObject();
+  });
+  var createClaimableBalanceOp = new _xdr["default"].CreateClaimableBalanceOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.createClaimableBalance(createClaimableBalanceOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/create_passive_sell_offer.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPassiveSellOffer = createPassiveSellOffer;
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Returns a XDR CreatePasiveSellOfferOp. A "create passive offer" operation creates an
+ * offer that won't consume a counter offer that exactly matches this offer. This is
+ * useful for offers just used as 1:1 exchanges for path payments. Use manage offer
+ * to manage this offer after using this operation to create it.
+ * @function
+ * @alias Operation.createPassiveSellOffer
+ * @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 {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.CreatePassiveSellOfferOp} Create Passive Sell Offer operation
+ */
+function createPassiveSellOffer(opts) {
+  var attributes = {};
+  attributes.selling = opts.selling.toXDRObject();
+  attributes.buying = opts.buying.toXDRObject();
+  if (!this.isValidAmount(opts.amount)) {
+    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);
+  var createPassiveSellOfferOp = new _xdr["default"].CreatePassiveSellOfferOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.createPassiveSellOffer(createPassiveSellOfferOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/end_sponsoring_future_reserves.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.endSponsoringFutureReserves = endSponsoringFutureReserves;
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Create an "end sponsoring future reserves" operation.
+ * @function
+ * @alias Operation.endSponsoringFutureReserves
+ * @param {object} opts Options object
+ * @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.endSponsoringFutureReserves();
+ *
+ */
+function endSponsoringFutureReserves() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.endSponsoringFutureReserves();
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/extend_footprint_ttl.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extendFootprintTtl = extendFootprintTtl;
+var _xdr = _interopRequireDefault(require("../xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/**
+ * Builds an operation to bump the expiration of a footprint (read and written
+ * ledger keys). Its only parameter is the number of ledgers to extend
+ * expiration for.
+ *
+ * The footprint itself is derived from the transaction (see
+ * {@link TransactionBuilder}'s `opts.sorobanData` parameter, which is a
+ * {@link xdr.SorobanTransactionData} instance that contains fee data & resource
+ * usage as part of {@link xdr.SorobanResources}).
+ *
+ * @function
+ * @alias Operation.extendFootprintTtl
+ *
+ * @param {object} opts - object holding operation parameters
+ * @param {number} opts.extendTo - the number of ledgers past the LCL
+ *    (last closed ledger) by which to extend the validity of the ledger keys in
+ *    this transaction
+ * @param {string} [opts.source] - an optional source account
+ *
+ * @returns {xdr.Operation} a Bump Footprint Expiration operation
+ *    (xdr.ExtendFootprintTTLOp)
+ */
+function extendFootprintTtl(opts) {
+  var _opts$extendTo;
+  if (((_opts$extendTo = opts.extendTo) !== null && _opts$extendTo !== void 0 ? _opts$extendTo : -1) <= 0) {
+    throw new RangeError("extendTo isn't a ledger quantity (uint32)");
+  }
+  var extendFootprintOp = new _xdr["default"].ExtendFootprintTtlOp({
+    ext: new _xdr["default"].ExtensionPoint(0),
+    extendTo: opts.extendTo
+  });
+  var opAttributes = {
+    body: _xdr["default"].OperationBody.extendFootprintTtl(extendFootprintOp)
+  };
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}