@stellar/stellar-base 10.0.0

package/lib/operation.js

@@ -0,0 +1,715 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Operation = exports.AuthRevocableFlag = exports.AuthRequiredFlag = exports.AuthImmutableFlag = exports.AuthClawbackEnabledFlag = void 0;
+var _jsXdr = require("@stellar/js-xdr");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("./util/util");
+var _continued_fraction = require("./util/continued_fraction");
+var _asset = require("./asset");
+var _liquidity_pool_asset = require("./liquidity_pool_asset");
+var _claimant = require("./claimant");
+var _strkey = require("./strkey");
+var _liquidity_pool_id = require("./liquidity_pool_id");
+var _xdr = _interopRequireDefault(require("./xdr"));
+var ops = _interopRequireWildcard(require("./operations"));
+var _decode_encode_muxed_account = require("./util/decode_encode_muxed_account");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+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); } /* eslint-disable no-bitwise */
+var ONE = 10000000;
+var MAX_INT64 = '9223372036854775807';
+
+/**
+ * When set using `{@link Operation.setOptions}` option, requires the issuing
+ * account to give other accounts permission before they can hold the issuing
+ * account’s credit.
+ *
+ * @constant
+ * @see [Account flags](https://developers.stellar.org/docs/glossary/accounts/#flags)
+ */
+var AuthRequiredFlag = exports.AuthRequiredFlag = 1 << 0;
+/**
+ * When set using `{@link Operation.setOptions}` option, allows the issuing
+ * account to revoke its credit held by other accounts.
+ *
+ * @constant
+ * @see [Account flags](https://developers.stellar.org/docs/glossary/accounts/#flags)
+ */
+var AuthRevocableFlag = exports.AuthRevocableFlag = 1 << 1;
+/**
+ * When set using `{@link Operation.setOptions}` option, then none of the
+ * authorization flags can be set and the account can never be deleted.
+ *
+ * @constant
+ * @see [Account flags](https://developers.stellar.org/docs/glossary/accounts/#flags)
+ */
+var AuthImmutableFlag = exports.AuthImmutableFlag = 1 << 2;
+
+/**
+ * When set using `{@link Operation.setOptions}` option, then any trustlines
+ * created by this account can have a ClawbackOp operation submitted for the
+ * corresponding asset.
+ *
+ * @constant
+ * @see [Account flags](https://developers.stellar.org/docs/glossary/accounts/#flags)
+ */
+var AuthClawbackEnabledFlag = exports.AuthClawbackEnabledFlag = 1 << 3;
+
+/**
+ * `Operation` class represents
+ * [operations](https://developers.stellar.org/docs/glossary/operations/) in
+ * Stellar network.
+ *
+ * Use one of static methods to create operations:
+ * * `{@link Operation.createAccount}`
+ * * `{@link Operation.payment}`
+ * * `{@link Operation.pathPaymentStrictReceive}`
+ * * `{@link Operation.pathPaymentStrictSend}`
+ * * `{@link Operation.manageSellOffer}`
+ * * `{@link Operation.manageBuyOffer}`
+ * * `{@link Operation.createPassiveSellOffer}`
+ * * `{@link Operation.setOptions}`
+ * * `{@link Operation.changeTrust}`
+ * * `{@link Operation.allowTrust}`
+ * * `{@link Operation.accountMerge}`
+ * * `{@link Operation.inflation}`
+ * * `{@link Operation.manageData}`
+ * * `{@link Operation.bumpSequence}`
+ * * `{@link Operation.createClaimableBalance}`
+ * * `{@link Operation.claimClaimableBalance}`
+ * * `{@link Operation.beginSponsoringFutureReserves}`
+ * * `{@link Operation.endSponsoringFutureReserves}`
+ * * `{@link Operation.revokeAccountSponsorship}`
+ * * `{@link Operation.revokeTrustlineSponsorship}`
+ * * `{@link Operation.revokeOfferSponsorship}`
+ * * `{@link Operation.revokeDataSponsorship}`
+ * * `{@link Operation.revokeClaimableBalanceSponsorship}`
+ * * `{@link Operation.revokeLiquidityPoolSponsorship}`
+ * * `{@link Operation.revokeSignerSponsorship}`
+ * * `{@link Operation.clawback}`
+ * * `{@link Operation.clawbackClaimableBalance}`
+ * * `{@link Operation.setTrustLineFlags}`
+ * * `{@link Operation.liquidityPoolDeposit}`
+ * * `{@link Operation.liquidityPoolWithdraw}`
+ * * `{@link Operation.invokeHostFunction}`
+ * * `{@link Operation.extendFootprintTtlOp}`
+ * * `{@link Operation.restoreFootprint}`
+ *
+ * @class Operation
+ */
+var Operation = exports.Operation = /*#__PURE__*/function () {
+  function Operation() {
+    _classCallCheck(this, Operation);
+  }
+  _createClass(Operation, null, [{
+    key: "setSourceAccount",
+    value: function setSourceAccount(opAttributes, opts) {
+      if (opts.source) {
+        try {
+          opAttributes.sourceAccount = (0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(opts.source);
+        } catch (e) {
+          throw new Error('Source address is invalid');
+        }
+      }
+    }
+
+    /**
+     * Deconstructs the raw XDR operation object into the structured object that
+     * was used to create the operation (i.e. the `opts` parameter to most ops).
+     *
+     * @param {xdr.Operation}   operation - An XDR Operation.
+     * @return {Operation}
+     */
+  }, {
+    key: "fromXDRObject",
+    value: function fromXDRObject(operation) {
+      var result = {};
+      if (operation.sourceAccount()) {
+        result.source = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(operation.sourceAccount());
+      }
+      var attrs = operation.body().value();
+      var operationName = operation.body()["switch"]().name;
+      switch (operationName) {
+        case 'createAccount':
+          {
+            result.type = 'createAccount';
+            result.destination = accountIdtoAddress(attrs.destination());
+            result.startingBalance = this._fromXDRAmount(attrs.startingBalance());
+            break;
+          }
+        case 'payment':
+          {
+            result.type = 'payment';
+            result.destination = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(attrs.destination());
+            result.asset = _asset.Asset.fromOperation(attrs.asset());
+            result.amount = this._fromXDRAmount(attrs.amount());
+            break;
+          }
+        case 'pathPaymentStrictReceive':
+          {
+            result.type = 'pathPaymentStrictReceive';
+            result.sendAsset = _asset.Asset.fromOperation(attrs.sendAsset());
+            result.sendMax = this._fromXDRAmount(attrs.sendMax());
+            result.destination = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(attrs.destination());
+            result.destAsset = _asset.Asset.fromOperation(attrs.destAsset());
+            result.destAmount = this._fromXDRAmount(attrs.destAmount());
+            result.path = [];
+            var path = attrs.path();
+
+            // note that Object.values isn't supported by node 6!
+            Object.keys(path).forEach(function (pathKey) {
+              result.path.push(_asset.Asset.fromOperation(path[pathKey]));
+            });
+            break;
+          }
+        case 'pathPaymentStrictSend':
+          {
+            result.type = 'pathPaymentStrictSend';
+            result.sendAsset = _asset.Asset.fromOperation(attrs.sendAsset());
+            result.sendAmount = this._fromXDRAmount(attrs.sendAmount());
+            result.destination = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(attrs.destination());
+            result.destAsset = _asset.Asset.fromOperation(attrs.destAsset());
+            result.destMin = this._fromXDRAmount(attrs.destMin());
+            result.path = [];
+            var _path = attrs.path();
+
+            // note that Object.values isn't supported by node 6!
+            Object.keys(_path).forEach(function (pathKey) {
+              result.path.push(_asset.Asset.fromOperation(_path[pathKey]));
+            });
+            break;
+          }
+        case 'changeTrust':
+          {
+            result.type = 'changeTrust';
+            switch (attrs.line()["switch"]()) {
+              case _xdr["default"].AssetType.assetTypePoolShare():
+                result.line = _liquidity_pool_asset.LiquidityPoolAsset.fromOperation(attrs.line());
+                break;
+              default:
+                result.line = _asset.Asset.fromOperation(attrs.line());
+                break;
+            }
+            result.limit = this._fromXDRAmount(attrs.limit());
+            break;
+          }
+        case 'allowTrust':
+          {
+            result.type = 'allowTrust';
+            result.trustor = accountIdtoAddress(attrs.trustor());
+            result.assetCode = attrs.asset().value().toString();
+            result.assetCode = (0, _util.trimEnd)(result.assetCode, '\0');
+            result.authorize = attrs.authorize();
+            break;
+          }
+        case 'setOptions':
+          {
+            result.type = 'setOptions';
+            if (attrs.inflationDest()) {
+              result.inflationDest = accountIdtoAddress(attrs.inflationDest());
+            }
+            result.clearFlags = attrs.clearFlags();
+            result.setFlags = attrs.setFlags();
+            result.masterWeight = attrs.masterWeight();
+            result.lowThreshold = attrs.lowThreshold();
+            result.medThreshold = attrs.medThreshold();
+            result.highThreshold = attrs.highThreshold();
+            // home_domain is checked by iscntrl in stellar-core
+            result.homeDomain = attrs.homeDomain() !== undefined ? attrs.homeDomain().toString('ascii') : undefined;
+            if (attrs.signer()) {
+              var signer = {};
+              var arm = attrs.signer().key().arm();
+              if (arm === 'ed25519') {
+                signer.ed25519PublicKey = accountIdtoAddress(attrs.signer().key());
+              } else if (arm === 'preAuthTx') {
+                signer.preAuthTx = attrs.signer().key().preAuthTx();
+              } else if (arm === 'hashX') {
+                signer.sha256Hash = attrs.signer().key().hashX();
+              } else if (arm === 'ed25519SignedPayload') {
+                var signedPayload = attrs.signer().key().ed25519SignedPayload();
+                signer.ed25519SignedPayload = _strkey.StrKey.encodeSignedPayload(signedPayload.toXDR());
+              }
+              signer.weight = attrs.signer().weight();
+              result.signer = signer;
+            }
+            break;
+          }
+        // the next case intentionally falls through!
+        case 'manageOffer':
+        case 'manageSellOffer':
+          {
+            result.type = 'manageSellOffer';
+            result.selling = _asset.Asset.fromOperation(attrs.selling());
+            result.buying = _asset.Asset.fromOperation(attrs.buying());
+            result.amount = this._fromXDRAmount(attrs.amount());
+            result.price = this._fromXDRPrice(attrs.price());
+            result.offerId = attrs.offerId().toString();
+            break;
+          }
+        case 'manageBuyOffer':
+          {
+            result.type = 'manageBuyOffer';
+            result.selling = _asset.Asset.fromOperation(attrs.selling());
+            result.buying = _asset.Asset.fromOperation(attrs.buying());
+            result.buyAmount = this._fromXDRAmount(attrs.buyAmount());
+            result.price = this._fromXDRPrice(attrs.price());
+            result.offerId = attrs.offerId().toString();
+            break;
+          }
+        // the next case intentionally falls through!
+        case 'createPassiveOffer':
+        case 'createPassiveSellOffer':
+          {
+            result.type = 'createPassiveSellOffer';
+            result.selling = _asset.Asset.fromOperation(attrs.selling());
+            result.buying = _asset.Asset.fromOperation(attrs.buying());
+            result.amount = this._fromXDRAmount(attrs.amount());
+            result.price = this._fromXDRPrice(attrs.price());
+            break;
+          }
+        case 'accountMerge':
+          {
+            result.type = 'accountMerge';
+            result.destination = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(attrs);
+            break;
+          }
+        case 'manageData':
+          {
+            result.type = 'manageData';
+            // manage_data.name is checked by iscntrl in stellar-core
+            result.name = attrs.dataName().toString('ascii');
+            result.value = attrs.dataValue();
+            break;
+          }
+        case 'inflation':
+          {
+            result.type = 'inflation';
+            break;
+          }
+        case 'bumpSequence':
+          {
+            result.type = 'bumpSequence';
+            result.bumpTo = attrs.bumpTo().toString();
+            break;
+          }
+        case 'createClaimableBalance':
+          {
+            result.type = 'createClaimableBalance';
+            result.asset = _asset.Asset.fromOperation(attrs.asset());
+            result.amount = this._fromXDRAmount(attrs.amount());
+            result.claimants = [];
+            attrs.claimants().forEach(function (claimant) {
+              result.claimants.push(_claimant.Claimant.fromXDR(claimant));
+            });
+            break;
+          }
+        case 'claimClaimableBalance':
+          {
+            result.type = 'claimClaimableBalance';
+            result.balanceId = attrs.toXDR('hex');
+            break;
+          }
+        case 'beginSponsoringFutureReserves':
+          {
+            result.type = 'beginSponsoringFutureReserves';
+            result.sponsoredId = accountIdtoAddress(attrs.sponsoredId());
+            break;
+          }
+        case 'endSponsoringFutureReserves':
+          {
+            result.type = 'endSponsoringFutureReserves';
+            break;
+          }
+        case 'revokeSponsorship':
+          {
+            extractRevokeSponshipDetails(attrs, result);
+            break;
+          }
+        case 'clawback':
+          {
+            result.type = 'clawback';
+            result.amount = this._fromXDRAmount(attrs.amount());
+            result.from = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(attrs.from());
+            result.asset = _asset.Asset.fromOperation(attrs.asset());
+            break;
+          }
+        case 'clawbackClaimableBalance':
+          {
+            result.type = 'clawbackClaimableBalance';
+            result.balanceId = attrs.toXDR('hex');
+            break;
+          }
+        case 'setTrustLineFlags':
+          {
+            result.type = 'setTrustLineFlags';
+            result.asset = _asset.Asset.fromOperation(attrs.asset());
+            result.trustor = accountIdtoAddress(attrs.trustor());
+
+            // Convert from the integer-bitwised flag into a sensible object that
+            // indicates true/false for each flag that's on/off.
+            var clears = attrs.clearFlags();
+            var sets = attrs.setFlags();
+            var mapping = {
+              authorized: _xdr["default"].TrustLineFlags.authorizedFlag(),
+              authorizedToMaintainLiabilities: _xdr["default"].TrustLineFlags.authorizedToMaintainLiabilitiesFlag(),
+              clawbackEnabled: _xdr["default"].TrustLineFlags.trustlineClawbackEnabledFlag()
+            };
+            var getFlagValue = function getFlagValue(key) {
+              var bit = mapping[key].value;
+              if (sets & bit) {
+                return true;
+              }
+              if (clears & bit) {
+                return false;
+              }
+              return undefined;
+            };
+            result.flags = {};
+            Object.keys(mapping).forEach(function (flagName) {
+              result.flags[flagName] = getFlagValue(flagName);
+            });
+            break;
+          }
+        case 'liquidityPoolDeposit':
+          {
+            result.type = 'liquidityPoolDeposit';
+            result.liquidityPoolId = attrs.liquidityPoolId().toString('hex');
+            result.maxAmountA = this._fromXDRAmount(attrs.maxAmountA());
+            result.maxAmountB = this._fromXDRAmount(attrs.maxAmountB());
+            result.minPrice = this._fromXDRPrice(attrs.minPrice());
+            result.maxPrice = this._fromXDRPrice(attrs.maxPrice());
+            break;
+          }
+        case 'liquidityPoolWithdraw':
+          {
+            result.type = 'liquidityPoolWithdraw';
+            result.liquidityPoolId = attrs.liquidityPoolId().toString('hex');
+            result.amount = this._fromXDRAmount(attrs.amount());
+            result.minAmountA = this._fromXDRAmount(attrs.minAmountA());
+            result.minAmountB = this._fromXDRAmount(attrs.minAmountB());
+            break;
+          }
+        case 'invokeHostFunction':
+          {
+            var _attrs$auth;
+            result.type = 'invokeHostFunction';
+            result.func = attrs.hostFunction();
+            result.auth = (_attrs$auth = attrs.auth()) !== null && _attrs$auth !== void 0 ? _attrs$auth : [];
+            break;
+          }
+        case 'extendFootprintTtl':
+          {
+            result.type = 'extendFootprintTtl';
+            result.extendTo = attrs.extendTo();
+            break;
+          }
+        case 'restoreFootprint':
+          {
+            result.type = 'restoreFootprint';
+            break;
+          }
+        default:
+          {
+            throw new Error("Unknown operation: ".concat(operationName));
+          }
+      }
+      return result;
+    }
+
+    /**
+     * Validates that a given amount is possible for a Stellar asset.
+     *
+     * Specifically, this means that the amount is well, a valid number, but also
+     * that it is within the int64 range and has no more than 7 decimal levels of
+     * precision.
+     *
+     * Note that while smart contracts allow larger amounts, this is oriented
+     * towards validating the standard Stellar operations.
+     *
+     * @param {string}  value       the amount to validate
+     * @param {boolean} allowZero   optionally, whether or not zero is valid (default: no)
+     *
+     * @returns {boolean}
+     */
+  }, {
+    key: "isValidAmount",
+    value: function isValidAmount(value) {
+      var allowZero = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      if (typeof value !== 'string') {
+        return false;
+      }
+      var amount;
+      try {
+        amount = new _bignumber["default"](value);
+      } catch (e) {
+        return false;
+      }
+      if (
+      // == 0
+      !allowZero && amount.isZero() ||
+      // < 0
+      amount.isNegative() ||
+      // > Max value
+      amount.times(ONE).gt(new _bignumber["default"](MAX_INT64).toString()) ||
+      // Decimal places (max 7)
+      amount.decimalPlaces() > 7 ||
+      // NaN or Infinity
+      amount.isNaN() || !amount.isFinite()) {
+        return false;
+      }
+      return true;
+    }
+  }, {
+    key: "constructAmountRequirementsError",
+    value: function constructAmountRequirementsError(arg) {
+      return "".concat(arg, " argument must be of type String, represent a positive number and have at most 7 digits after the decimal");
+    }
+
+    /**
+     * Returns value converted to uint32 value or undefined.
+     * If `value` is not `Number`, `String` or `Undefined` then throws an error.
+     * Used in {@link Operation.setOptions}.
+     * @private
+     * @param {string} name Name of the property (used in error message only)
+     * @param {*} value Value to check
+     * @param {function(value, name)} isValidFunction Function to check other constraints (the argument will be a `Number`)
+     * @returns {undefined|Number}
+     */
+  }, {
+    key: "_checkUnsignedIntValue",
+    value: function _checkUnsignedIntValue(name, value) {
+      var isValidFunction = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      if (typeof value === 'undefined') {
+        return undefined;
+      }
+      if (typeof value === 'string') {
+        value = parseFloat(value);
+      }
+      switch (true) {
+        case typeof value !== 'number' || !Number.isFinite(value) || value % 1 !== 0:
+          throw new Error("".concat(name, " value is invalid"));
+        case value < 0:
+          throw new Error("".concat(name, " value must be unsigned"));
+        case !isValidFunction || isValidFunction && isValidFunction(value, name):
+          return value;
+        default:
+          throw new Error("".concat(name, " value is invalid"));
+      }
+    }
+    /**
+     * @private
+     * @param {string|BigNumber} value Value
+     * @returns {Hyper} XDR amount
+     */
+  }, {
+    key: "_toXDRAmount",
+    value: function _toXDRAmount(value) {
+      var amount = new _bignumber["default"](value).times(ONE);
+      return _jsXdr.Hyper.fromString(amount.toString());
+    }
+
+    /**
+     * @private
+     * @param {string|BigNumber} value XDR amount
+     * @returns {BigNumber} Number
+     */
+  }, {
+    key: "_fromXDRAmount",
+    value: function _fromXDRAmount(value) {
+      return new _bignumber["default"](value).div(ONE).toFixed(7);
+    }
+
+    /**
+     * @private
+     * @param {object} price Price object
+     * @param {function} price.n numerator function that returns a value
+     * @param {function} price.d denominator function that returns a value
+     * @returns {BigNumber} Big string
+     */
+  }, {
+    key: "_fromXDRPrice",
+    value: function _fromXDRPrice(price) {
+      var n = new _bignumber["default"](price.n());
+      return n.div(new _bignumber["default"](price.d())).toString();
+    }
+
+    /**
+     * @private
+     * @param {object} price Price object
+     * @param {function} price.n numerator function that returns a value
+     * @param {function} price.d denominator function that returns a value
+     * @returns {object} XDR price object
+     */
+  }, {
+    key: "_toXDRPrice",
+    value: function _toXDRPrice(price) {
+      var xdrObject;
+      if (price.n && price.d) {
+        xdrObject = new _xdr["default"].Price(price);
+      } else {
+        var approx = (0, _continued_fraction.best_r)(price);
+        xdrObject = new _xdr["default"].Price({
+          n: parseInt(approx[0], 10),
+          d: parseInt(approx[1], 10)
+        });
+      }
+      if (xdrObject.n() < 0 || xdrObject.d() < 0) {
+        throw new Error('price must be positive');
+      }
+      return xdrObject;
+    }
+  }]);
+  return Operation;
+}();
+function extractRevokeSponshipDetails(attrs, result) {
+  switch (attrs["switch"]().name) {
+    case 'revokeSponsorshipLedgerEntry':
+      {
+        var ledgerKey = attrs.ledgerKey();
+        switch (ledgerKey["switch"]().name) {
+          case _xdr["default"].LedgerEntryType.account().name:
+            {
+              result.type = 'revokeAccountSponsorship';
+              result.account = accountIdtoAddress(ledgerKey.account().accountId());
+              break;
+            }
+          case _xdr["default"].LedgerEntryType.trustline().name:
+            {
+              result.type = 'revokeTrustlineSponsorship';
+              result.account = accountIdtoAddress(ledgerKey.trustLine().accountId());
+              var xdrAsset = ledgerKey.trustLine().asset();
+              switch (xdrAsset["switch"]()) {
+                case _xdr["default"].AssetType.assetTypePoolShare():
+                  result.asset = _liquidity_pool_id.LiquidityPoolId.fromOperation(xdrAsset);
+                  break;
+                default:
+                  result.asset = _asset.Asset.fromOperation(xdrAsset);
+                  break;
+              }
+              break;
+            }
+          case _xdr["default"].LedgerEntryType.offer().name:
+            {
+              result.type = 'revokeOfferSponsorship';
+              result.seller = accountIdtoAddress(ledgerKey.offer().sellerId());
+              result.offerId = ledgerKey.offer().offerId().toString();
+              break;
+            }
+          case _xdr["default"].LedgerEntryType.data().name:
+            {
+              result.type = 'revokeDataSponsorship';
+              result.account = accountIdtoAddress(ledgerKey.data().accountId());
+              result.name = ledgerKey.data().dataName().toString('ascii');
+              break;
+            }
+          case _xdr["default"].LedgerEntryType.claimableBalance().name:
+            {
+              result.type = 'revokeClaimableBalanceSponsorship';
+              result.balanceId = ledgerKey.claimableBalance().balanceId().toXDR('hex');
+              break;
+            }
+          case _xdr["default"].LedgerEntryType.liquidityPool().name:
+            {
+              result.type = 'revokeLiquidityPoolSponsorship';
+              result.liquidityPoolId = ledgerKey.liquidityPool().liquidityPoolId().toString('hex');
+              break;
+            }
+          default:
+            {
+              throw new Error("Unknown ledgerKey: ".concat(attrs["switch"]().name));
+            }
+        }
+        break;
+      }
+    case 'revokeSponsorshipSigner':
+      {
+        result.type = 'revokeSignerSponsorship';
+        result.account = accountIdtoAddress(attrs.signer().accountId());
+        result.signer = convertXDRSignerKeyToObject(attrs.signer().signerKey());
+        break;
+      }
+    default:
+      {
+        throw new Error("Unknown revokeSponsorship: ".concat(attrs["switch"]().name));
+      }
+  }
+}
+function convertXDRSignerKeyToObject(signerKey) {
+  var attrs = {};
+  switch (signerKey["switch"]().name) {
+    case _xdr["default"].SignerKeyType.signerKeyTypeEd25519().name:
+      {
+        attrs.ed25519PublicKey = _strkey.StrKey.encodeEd25519PublicKey(signerKey.ed25519());
+        break;
+      }
+    case _xdr["default"].SignerKeyType.signerKeyTypePreAuthTx().name:
+      {
+        attrs.preAuthTx = signerKey.preAuthTx().toString('hex');
+        break;
+      }
+    case _xdr["default"].SignerKeyType.signerKeyTypeHashX().name:
+      {
+        attrs.sha256Hash = signerKey.hashX().toString('hex');
+        break;
+      }
+    default:
+      {
+        throw new Error("Unknown signerKey: ".concat(signerKey["switch"]().name));
+      }
+  }
+  return attrs;
+}
+function accountIdtoAddress(accountId) {
+  return _strkey.StrKey.encodeEd25519PublicKey(accountId.ed25519());
+}
+
+// Attach all imported operations as static methods on the Operation class
+Operation.accountMerge = ops.accountMerge;
+Operation.allowTrust = ops.allowTrust;
+Operation.bumpSequence = ops.bumpSequence;
+Operation.changeTrust = ops.changeTrust;
+Operation.createAccount = ops.createAccount;
+Operation.createClaimableBalance = ops.createClaimableBalance;
+Operation.claimClaimableBalance = ops.claimClaimableBalance;
+Operation.clawbackClaimableBalance = ops.clawbackClaimableBalance;
+Operation.createPassiveSellOffer = ops.createPassiveSellOffer;
+Operation.inflation = ops.inflation;
+Operation.manageData = ops.manageData;
+Operation.manageSellOffer = ops.manageSellOffer;
+Operation.manageBuyOffer = ops.manageBuyOffer;
+Operation.pathPaymentStrictReceive = ops.pathPaymentStrictReceive;
+Operation.pathPaymentStrictSend = ops.pathPaymentStrictSend;
+Operation.payment = ops.payment;
+Operation.setOptions = ops.setOptions;
+Operation.beginSponsoringFutureReserves = ops.beginSponsoringFutureReserves;
+Operation.endSponsoringFutureReserves = ops.endSponsoringFutureReserves;
+Operation.revokeAccountSponsorship = ops.revokeAccountSponsorship;
+Operation.revokeTrustlineSponsorship = ops.revokeTrustlineSponsorship;
+Operation.revokeOfferSponsorship = ops.revokeOfferSponsorship;
+Operation.revokeDataSponsorship = ops.revokeDataSponsorship;
+Operation.revokeClaimableBalanceSponsorship = ops.revokeClaimableBalanceSponsorship;
+Operation.revokeLiquidityPoolSponsorship = ops.revokeLiquidityPoolSponsorship;
+Operation.revokeSignerSponsorship = ops.revokeSignerSponsorship;
+Operation.clawback = ops.clawback;
+Operation.setTrustLineFlags = ops.setTrustLineFlags;
+Operation.liquidityPoolDeposit = ops.liquidityPoolDeposit;
+Operation.liquidityPoolWithdraw = ops.liquidityPoolWithdraw;
+Operation.invokeHostFunction = ops.invokeHostFunction;
+Operation.extendFootprintTtl = ops.extendFootprintTtl;
+Operation.restoreFootprint = ops.restoreFootprint;
+
+// these are not `xdr.Operation`s directly, but are proxies for complex but
+// common versions of `Operation.invokeHostFunction`
+Operation.createStellarAssetContract = ops.createStellarAssetContract;
+Operation.invokeContractFunction = ops.invokeContractFunction;
+Operation.createCustomContract = ops.createCustomContract;
+Operation.uploadContractWasm = ops.uploadContractWasm;