@stellar/stellar-base 10.0.0

package/lib/keypair.js

@@ -0,0 +1,308 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Keypair = void 0;
+var _tweetnacl = _interopRequireDefault(require("tweetnacl"));
+var _signing = require("./signing");
+var _strkey = require("./strkey");
+var _hashing = require("./hashing");
+var _xdr = _interopRequireDefault(require("./xdr"));
+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 no-bitwise: ["error", {"allow": ["^"]}] */
+/**
+ * `Keypair` represents public (and secret) keys of the account.
+ *
+ * Currently `Keypair` only supports ed25519 but in a future this class can be abstraction layer for other
+ * public-key signature systems.
+ *
+ * Use more convenient methods to create `Keypair` object:
+ * * `{@link Keypair.fromPublicKey}`
+ * * `{@link Keypair.fromSecret}`
+ * * `{@link Keypair.random}`
+ *
+ * @constructor
+ * @param {object} keys At least one of keys must be provided.
+ * @param {string} keys.type Public-key signature system name. (currently only `ed25519` keys are supported)
+ * @param {Buffer} [keys.publicKey] Raw public key
+ * @param {Buffer} [keys.secretKey] Raw secret key (32-byte secret seed in ed25519`)
+ */
+var Keypair = exports.Keypair = /*#__PURE__*/function () {
+  function Keypair(keys) {
+    _classCallCheck(this, Keypair);
+    if (keys.type !== 'ed25519') {
+      throw new Error('Invalid keys type');
+    }
+    this.type = keys.type;
+    if (keys.secretKey) {
+      keys.secretKey = Buffer.from(keys.secretKey);
+      if (keys.secretKey.length !== 32) {
+        throw new Error('secretKey length is invalid');
+      }
+      this._secretSeed = keys.secretKey;
+      this._publicKey = (0, _signing.generate)(keys.secretKey);
+      this._secretKey = Buffer.concat([keys.secretKey, this._publicKey]);
+      if (keys.publicKey && !this._publicKey.equals(Buffer.from(keys.publicKey))) {
+        throw new Error('secretKey does not match publicKey');
+      }
+    } else {
+      this._publicKey = Buffer.from(keys.publicKey);
+      if (this._publicKey.length !== 32) {
+        throw new Error('publicKey length is invalid');
+      }
+    }
+  }
+
+  /**
+   * Creates a new `Keypair` instance from secret. This can either be secret key or secret seed depending
+   * on underlying public-key signature system. Currently `Keypair` only supports ed25519.
+   * @param {string} secret secret key (ex. `SDAKFNYEIAORZKKCYRILFQKLLOCNPL5SWJ3YY5NM3ZH6GJSZGXHZEPQS`)
+   * @returns {Keypair}
+   */
+  _createClass(Keypair, [{
+    key: "xdrAccountId",
+    value: function xdrAccountId() {
+      return new _xdr["default"].AccountId.publicKeyTypeEd25519(this._publicKey);
+    }
+  }, {
+    key: "xdrPublicKey",
+    value: function xdrPublicKey() {
+      return new _xdr["default"].PublicKey.publicKeyTypeEd25519(this._publicKey);
+    }
+
+    /**
+     * Creates a {@link xdr.MuxedAccount} object from the public key.
+     *
+     * You will get a different type of muxed account depending on whether or not
+     * you pass an ID.
+     *
+     * @param  {string} [id] - stringified integer indicating the underlying muxed
+     *     ID of the new account object
+     *
+     * @return {xdr.MuxedAccount}
+     */
+  }, {
+    key: "xdrMuxedAccount",
+    value: function xdrMuxedAccount(id) {
+      if (typeof id !== 'undefined') {
+        if (typeof id !== 'string') {
+          throw new TypeError("expected string for ID, got ".concat(_typeof(id)));
+        }
+        return _xdr["default"].MuxedAccount.keyTypeMuxedEd25519(new _xdr["default"].MuxedAccountMed25519({
+          id: _xdr["default"].Uint64.fromString(id),
+          ed25519: this._publicKey
+        }));
+      }
+      return new _xdr["default"].MuxedAccount.keyTypeEd25519(this._publicKey);
+    }
+
+    /**
+     * Returns raw public key
+     * @returns {Buffer}
+     */
+  }, {
+    key: "rawPublicKey",
+    value: function rawPublicKey() {
+      return this._publicKey;
+    }
+  }, {
+    key: "signatureHint",
+    value: function signatureHint() {
+      var a = this.xdrAccountId().toXDR();
+      return a.slice(a.length - 4);
+    }
+
+    /**
+     * Returns public key associated with this `Keypair` object.
+     * @returns {string}
+     */
+  }, {
+    key: "publicKey",
+    value: function publicKey() {
+      return _strkey.StrKey.encodeEd25519PublicKey(this._publicKey);
+    }
+
+    /**
+     * Returns secret key associated with this `Keypair` object
+     * @returns {string}
+     */
+  }, {
+    key: "secret",
+    value: function secret() {
+      if (!this._secretSeed) {
+        throw new Error('no secret key available');
+      }
+      if (this.type === 'ed25519') {
+        return _strkey.StrKey.encodeEd25519SecretSeed(this._secretSeed);
+      }
+      throw new Error('Invalid Keypair type');
+    }
+
+    /**
+     * Returns raw secret key.
+     * @returns {Buffer}
+     */
+  }, {
+    key: "rawSecretKey",
+    value: function rawSecretKey() {
+      return this._secretSeed;
+    }
+
+    /**
+     * Returns `true` if this `Keypair` object contains secret key and can sign.
+     * @returns {boolean}
+     */
+  }, {
+    key: "canSign",
+    value: function canSign() {
+      return !!this._secretKey;
+    }
+
+    /**
+     * Signs data.
+     * @param {Buffer} data Data to sign
+     * @returns {Buffer}
+     */
+  }, {
+    key: "sign",
+    value: function sign(data) {
+      if (!this.canSign()) {
+        throw new Error('cannot sign: no secret key available');
+      }
+      return (0, _signing.sign)(data, this._secretKey);
+    }
+
+    /**
+     * Verifies if `signature` for `data` is valid.
+     * @param {Buffer} data Signed data
+     * @param {Buffer} signature Signature
+     * @returns {boolean}
+     */
+  }, {
+    key: "verify",
+    value: function verify(data, signature) {
+      return (0, _signing.verify)(data, signature, this._publicKey);
+    }
+
+    /**
+     * Returns the decorated signature (hint+sig) for arbitrary data.
+     *
+     * @param  {Buffer} data  arbitrary data to sign
+     * @return {xdr.DecoratedSignature}   the raw signature structure which can be
+     *     added directly to a transaction envelope
+     *
+     * @see TransactionBase.addDecoratedSignature
+     */
+  }, {
+    key: "signDecorated",
+    value: function signDecorated(data) {
+      var signature = this.sign(data);
+      var hint = this.signatureHint();
+      return new _xdr["default"].DecoratedSignature({
+        hint: hint,
+        signature: signature
+      });
+    }
+
+    /**
+     * Returns the raw decorated signature (hint+sig) for a signed payload signer.
+     *
+     *  The hint is defined as the last 4 bytes of the signer key XORed with last
+     *  4 bytes of the payload (zero-left-padded if necessary).
+     *
+     * @param  {Buffer} data    data to both sign and treat as the payload
+     * @return {xdr.DecoratedSignature}
+     *
+     * @see https://github.com/stellar/stellar-protocol/blob/master/core/cap-0040.md#signature-hint
+     * @see TransactionBase.addDecoratedSignature
+     */
+  }, {
+    key: "signPayloadDecorated",
+    value: function signPayloadDecorated(data) {
+      var signature = this.sign(data);
+      var keyHint = this.signatureHint();
+      var hint = Buffer.from(data.slice(-4));
+      if (hint.length < 4) {
+        // append zeroes as needed
+        hint = Buffer.concat([hint, Buffer.alloc(4 - data.length, 0)]);
+      }
+      return new _xdr["default"].DecoratedSignature({
+        hint: hint.map(function (_byte, i) {
+          return _byte ^ keyHint[i];
+        }),
+        signature: signature
+      });
+    }
+  }], [{
+    key: "fromSecret",
+    value: function fromSecret(secret) {
+      var rawSecret = _strkey.StrKey.decodeEd25519SecretSeed(secret);
+      return this.fromRawEd25519Seed(rawSecret);
+    }
+
+    /**
+     * Creates a new `Keypair` object from ed25519 secret key seed raw bytes.
+     *
+     * @param {Buffer} rawSeed Raw 32-byte ed25519 secret key seed
+     * @returns {Keypair}
+     */
+  }, {
+    key: "fromRawEd25519Seed",
+    value: function fromRawEd25519Seed(rawSeed) {
+      return new this({
+        type: 'ed25519',
+        secretKey: rawSeed
+      });
+    }
+
+    /**
+     * Returns `Keypair` object representing network master key.
+     * @param {string} networkPassphrase passphrase of the target stellar network (e.g. "Public Global Stellar Network ; September 2015").
+     * @returns {Keypair}
+     */
+  }, {
+    key: "master",
+    value: function master(networkPassphrase) {
+      if (!networkPassphrase) {
+        throw new Error('No network selected. Please pass a network argument, e.g. `Keypair.master(Networks.PUBLIC)`.');
+      }
+      return this.fromRawEd25519Seed((0, _hashing.hash)(networkPassphrase));
+    }
+
+    /**
+     * Creates a new `Keypair` object from public key.
+     * @param {string} publicKey public key (ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`)
+     * @returns {Keypair}
+     */
+  }, {
+    key: "fromPublicKey",
+    value: function fromPublicKey(publicKey) {
+      publicKey = _strkey.StrKey.decodeEd25519PublicKey(publicKey);
+      if (publicKey.length !== 32) {
+        throw new Error('Invalid Stellar public key');
+      }
+      return new this({
+        type: 'ed25519',
+        publicKey: publicKey
+      });
+    }
+
+    /**
+     * Create a random `Keypair` object.
+     * @returns {Keypair}
+     */
+  }, {
+    key: "random",
+    value: function random() {
+      var secret = _tweetnacl["default"].randomBytes(32);
+      return this.fromRawEd25519Seed(secret);
+    }
+  }]);
+  return Keypair;
+}();

package/lib/liquidity_pool_asset.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LiquidityPoolAsset = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _asset = require("./asset");
+var _get_liquidity_pool_id = require("./get_liquidity_pool_id");
+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 ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return 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); }
+/**
+ * LiquidityPoolAsset class represents a liquidity pool trustline change.
+ *
+ * @constructor
+ * @param {Asset} assetA – The first asset in the Pool, it must respect the rule assetA < assetB. See {@link Asset.compare} for more details on how assets are sorted.
+ * @param {Asset} assetB – The second asset in the Pool, it must respect the rule assetA < assetB. See {@link Asset.compare} for more details on how assets are sorted.
+ * @param {number} fee – The liquidity pool fee. For now the only fee supported is `30`.
+ */
+var LiquidityPoolAsset = exports.LiquidityPoolAsset = /*#__PURE__*/function () {
+  function LiquidityPoolAsset(assetA, assetB, fee) {
+    _classCallCheck(this, LiquidityPoolAsset);
+    if (!assetA || !(assetA instanceof _asset.Asset)) {
+      throw new Error('assetA is invalid');
+    }
+    if (!assetB || !(assetB instanceof _asset.Asset)) {
+      throw new Error('assetB is invalid');
+    }
+    if (_asset.Asset.compare(assetA, assetB) !== -1) {
+      throw new Error('Assets are not in lexicographic order');
+    }
+    if (!fee || fee !== _get_liquidity_pool_id.LiquidityPoolFeeV18) {
+      throw new Error('fee is invalid');
+    }
+    this.assetA = assetA;
+    this.assetB = assetB;
+    this.fee = fee;
+  }
+
+  /**
+   * Returns a liquidity pool asset object from its XDR ChangeTrustAsset object
+   * representation.
+   * @param {xdr.ChangeTrustAsset} ctAssetXdr - The asset XDR object.
+   * @returns {LiquidityPoolAsset}
+   */
+  _createClass(LiquidityPoolAsset, [{
+    key: "toXDRObject",
+    value:
+    /**
+     * Returns the `xdr.ChangeTrustAsset` object for this liquidity pool asset.
+     *
+     * Note: To convert from an {@link Asset `Asset`} to `xdr.ChangeTrustAsset`
+     * please refer to the
+     * {@link Asset.toChangeTrustXDRObject `Asset.toChangeTrustXDRObject`} method.
+     *
+     * @returns {xdr.ChangeTrustAsset} XDR ChangeTrustAsset object.
+     */
+    function toXDRObject() {
+      var lpConstantProductParamsXdr = new _xdr["default"].LiquidityPoolConstantProductParameters({
+        assetA: this.assetA.toXDRObject(),
+        assetB: this.assetB.toXDRObject(),
+        fee: this.fee
+      });
+      var lpParamsXdr = new _xdr["default"].LiquidityPoolParameters('liquidityPoolConstantProduct', lpConstantProductParamsXdr);
+      return new _xdr["default"].ChangeTrustAsset('assetTypePoolShare', lpParamsXdr);
+    }
+
+    /**
+     * @returns {LiquidityPoolParameters} Liquidity pool parameters.
+     */
+  }, {
+    key: "getLiquidityPoolParameters",
+    value: function getLiquidityPoolParameters() {
+      return _objectSpread(_objectSpread({}, this), {}, {
+        assetA: this.assetA,
+        assetB: this.assetB,
+        fee: this.fee
+      });
+    }
+
+    /**
+     * @see [Assets concept](https://developers.stellar.org/docs/glossary/assets/)
+     * @returns {AssetType.liquidityPoolShares} asset type. Can only be `liquidity_pool_shares`.
+     */
+  }, {
+    key: "getAssetType",
+    value: function getAssetType() {
+      return 'liquidity_pool_shares';
+    }
+
+    /**
+     * @param {LiquidityPoolAsset} other the LiquidityPoolAsset to compare
+     * @returns {boolean} `true` if this asset equals the given asset.
+     */
+  }, {
+    key: "equals",
+    value: function equals(other) {
+      return this.assetA.equals(other.assetA) && this.assetB.equals(other.assetB) && this.fee === other.fee;
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      var poolId = (0, _get_liquidity_pool_id.getLiquidityPoolId)('constant_product', this.getLiquidityPoolParameters()).toString('hex');
+      return "liquidity_pool:".concat(poolId);
+    }
+  }], [{
+    key: "fromOperation",
+    value: function fromOperation(ctAssetXdr) {
+      var assetType = ctAssetXdr["switch"]();
+      if (assetType === _xdr["default"].AssetType.assetTypePoolShare()) {
+        var liquidityPoolParameters = ctAssetXdr.liquidityPool().constantProduct();
+        return new this(_asset.Asset.fromOperation(liquidityPoolParameters.assetA()), _asset.Asset.fromOperation(liquidityPoolParameters.assetB()), liquidityPoolParameters.fee());
+      }
+      throw new Error("Invalid asset type: ".concat(assetType.name));
+    }
+  }]);
+  return LiquidityPoolAsset;
+}();

package/lib/liquidity_pool_id.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LiquidityPoolId = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+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); }
+/**
+ * LiquidityPoolId class represents the asset referenced by a trustline to a
+ * liquidity pool.
+ *
+ * @constructor
+ * @param {string} liquidityPoolId - The ID of the liquidity pool in string 'hex'.
+ */
+var LiquidityPoolId = exports.LiquidityPoolId = /*#__PURE__*/function () {
+  function LiquidityPoolId(liquidityPoolId) {
+    _classCallCheck(this, LiquidityPoolId);
+    if (!liquidityPoolId) {
+      throw new Error('liquidityPoolId cannot be empty');
+    }
+    if (!/^[a-f0-9]{64}$/.test(liquidityPoolId)) {
+      throw new Error('Liquidity pool ID is not a valid hash');
+    }
+    this.liquidityPoolId = liquidityPoolId;
+  }
+
+  /**
+   * Returns a liquidity pool ID object from its xdr.TrustLineAsset representation.
+   * @param {xdr.TrustLineAsset} tlAssetXdr - The asset XDR object.
+   * @returns {LiquidityPoolId}
+   */
+  _createClass(LiquidityPoolId, [{
+    key: "toXDRObject",
+    value:
+    /**
+     * Returns the `xdr.TrustLineAsset` object for this liquidity pool ID.
+     *
+     * Note: To convert from {@link Asset `Asset`} to `xdr.TrustLineAsset` please
+     * refer to the
+     * {@link Asset.toTrustLineXDRObject `Asset.toTrustLineXDRObject`} method.
+     *
+     * @returns {xdr.TrustLineAsset} XDR LiquidityPoolId object
+     */
+    function toXDRObject() {
+      var xdrPoolId = _xdr["default"].PoolId.fromXDR(this.liquidityPoolId, 'hex');
+      return new _xdr["default"].TrustLineAsset('assetTypePoolShare', xdrPoolId);
+    }
+
+    /**
+     * @returns {string} Liquidity pool ID.
+     */
+  }, {
+    key: "getLiquidityPoolId",
+    value: function getLiquidityPoolId() {
+      return String(this.liquidityPoolId);
+    }
+
+    /**
+     * @see [Assets concept](https://developers.stellar.org/docs/glossary/assets/)
+     * @returns {AssetType.liquidityPoolShares} asset type. Can only be `liquidity_pool_shares`.
+     */
+  }, {
+    key: "getAssetType",
+    value: function getAssetType() {
+      return 'liquidity_pool_shares';
+    }
+
+    /**
+     * @param {LiquidityPoolId} asset LiquidityPoolId to compare.
+     * @returns {boolean} `true` if this asset equals the given asset.
+     */
+  }, {
+    key: "equals",
+    value: function equals(asset) {
+      return this.liquidityPoolId === asset.getLiquidityPoolId();
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "liquidity_pool:".concat(this.liquidityPoolId);
+    }
+  }], [{
+    key: "fromOperation",
+    value: function fromOperation(tlAssetXdr) {
+      var assetType = tlAssetXdr["switch"]();
+      if (assetType === _xdr["default"].AssetType.assetTypePoolShare()) {
+        var liquidityPoolId = tlAssetXdr.liquidityPoolId().toString('hex');
+        return new this(liquidityPoolId);
+      }
+      throw new Error("Invalid asset type: ".concat(assetType.name));
+    }
+  }]);
+  return LiquidityPoolId;
+}();