@stellar/stellar-base 10.0.0

package/lib/account.js

@@ -0,0 +1,80 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Account = void 0;
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _strkey = require("./strkey");
+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); }
+/**
+ * Create a new Account object.
+ *
+ * `Account` represents a single account in the Stellar network and its sequence
+ * number. Account tracks the sequence number as it is used by {@link
+ * TransactionBuilder}. See
+ * [Accounts](https://developers.stellar.org/docs/glossary/accounts/) for
+ * more information about how accounts work in Stellar.
+ *
+ * @constructor
+ *
+ * @param {string} accountId - ID of the account (ex.
+ *     `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`). If you
+ *     provide a muxed account address, this will throw; use {@link
+ *     MuxedAccount} instead.
+ * @param {string} sequence  - current sequence number of the account
+ */
+var Account = exports.Account = /*#__PURE__*/function () {
+  function Account(accountId, sequence) {
+    _classCallCheck(this, Account);
+    if (_strkey.StrKey.isValidMed25519PublicKey(accountId)) {
+      throw new Error('accountId is an M-address; use MuxedAccount instead');
+    }
+    if (!_strkey.StrKey.isValidEd25519PublicKey(accountId)) {
+      throw new Error('accountId is invalid');
+    }
+    if (!(typeof sequence === 'string')) {
+      throw new Error('sequence must be of type string');
+    }
+    this._accountId = accountId;
+    this.sequence = new _bignumber["default"](sequence);
+  }
+
+  /**
+   * Returns Stellar account ID, ex.
+   * `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`.
+   * @returns {string}
+   */
+  _createClass(Account, [{
+    key: "accountId",
+    value: function accountId() {
+      return this._accountId;
+    }
+
+    /**
+     * @returns {string}  sequence number for the account as a string
+     */
+  }, {
+    key: "sequenceNumber",
+    value: function sequenceNumber() {
+      return this.sequence.toString();
+    }
+
+    /**
+     * Increments sequence number in this object by one.
+     * @returns {void}
+     */
+  }, {
+    key: "incrementSequenceNumber",
+    value: function incrementSequenceNumber() {
+      this.sequence = this.sequence.plus(1);
+    }
+  }]);
+  return Account;
+}();

package/lib/address.js

@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Address = void 0;
+var _strkey = require("./strkey");
+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); }
+/**
+ * Create a new Address object.
+ *
+ * `Address` represents a single address in the Stellar network. An address can
+ * represent an account or a contract.
+ *
+ * @constructor
+ *
+ * @param {string} address - ID of the account (ex.
+ *     `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`). If you
+ *     provide a muxed account address, this will throw; use {@link
+ *     MuxedAccount} instead.
+ */
+var Address = exports.Address = /*#__PURE__*/function () {
+  function Address(address) {
+    _classCallCheck(this, Address);
+    if (_strkey.StrKey.isValidEd25519PublicKey(address)) {
+      this._type = 'account';
+      this._key = _strkey.StrKey.decodeEd25519PublicKey(address);
+    } else if (_strkey.StrKey.isValidContract(address)) {
+      this._type = 'contract';
+      this._key = _strkey.StrKey.decodeContract(address);
+    } else {
+      throw new Error('Unsupported address type');
+    }
+  }
+
+  /**
+   * Parses a string and returns an Address object.
+   *
+   * @param {string} address - The address to parse. ex. `GB3KJPLFUYN5VL6R3GU3EGCGVCKFDSD7BEDX42HWG5BWFKB3KQGJJRMA`
+   * @returns {Address}
+   */
+  _createClass(Address, [{
+    key: "toString",
+    value:
+    /**
+     * Serialize an address to string.
+     *
+     * @returns {string}
+     */
+    function toString() {
+      switch (this._type) {
+        case 'account':
+          return _strkey.StrKey.encodeEd25519PublicKey(this._key);
+        case 'contract':
+          return _strkey.StrKey.encodeContract(this._key);
+        default:
+          throw new Error('Unsupported address type');
+      }
+    }
+
+    /**
+     * Convert this Address to an xdr.ScVal type.
+     *
+     * @returns {xdr.ScVal}
+     */
+  }, {
+    key: "toScVal",
+    value: function toScVal() {
+      return _xdr["default"].ScVal.scvAddress(this.toScAddress());
+    }
+
+    /**
+     * Convert this Address to an xdr.ScAddress type.
+     *
+     * @returns {xdr.ScAddress}
+     */
+  }, {
+    key: "toScAddress",
+    value: function toScAddress() {
+      switch (this._type) {
+        case 'account':
+          return _xdr["default"].ScAddress.scAddressTypeAccount(_xdr["default"].PublicKey.publicKeyTypeEd25519(this._key));
+        case 'contract':
+          return _xdr["default"].ScAddress.scAddressTypeContract(this._key);
+        default:
+          throw new Error('Unsupported address type');
+      }
+    }
+
+    /**
+     * Return the raw public key bytes for this address.
+     *
+     * @returns {Buffer}
+     */
+  }, {
+    key: "toBuffer",
+    value: function toBuffer() {
+      return this._key;
+    }
+  }], [{
+    key: "fromString",
+    value: function fromString(address) {
+      return new Address(address);
+    }
+
+    /**
+     * Creates a new account Address object from a buffer of raw bytes.
+     *
+     * @param {Buffer} buffer - The bytes of an address to parse.
+     * @returns {Address}
+     */
+  }, {
+    key: "account",
+    value: function account(buffer) {
+      return new Address(_strkey.StrKey.encodeEd25519PublicKey(buffer));
+    }
+
+    /**
+     * Creates a new contract Address object from a buffer of raw bytes.
+     *
+     * @param {Buffer} buffer - The bytes of an address to parse.
+     * @returns {Address}
+     */
+  }, {
+    key: "contract",
+    value: function contract(buffer) {
+      return new Address(_strkey.StrKey.encodeContract(buffer));
+    }
+
+    /**
+     * Convert this from an xdr.ScVal type
+     *
+     * @param {xdr.ScVal} scVal - The xdr.ScVal type to parse
+     * @returns {Address}
+     */
+  }, {
+    key: "fromScVal",
+    value: function fromScVal(scVal) {
+      return Address.fromScAddress(scVal.address());
+    }
+
+    /**
+     * Convert this from an xdr.ScAddress type
+     *
+     * @param {xdr.ScAddress} scAddress - The xdr.ScAddress type to parse
+     * @returns {Address}
+     */
+  }, {
+    key: "fromScAddress",
+    value: function fromScAddress(scAddress) {
+      switch (scAddress["switch"]()) {
+        case _xdr["default"].ScAddressType.scAddressTypeAccount():
+          return Address.account(scAddress.accountId().ed25519());
+        case _xdr["default"].ScAddressType.scAddressTypeContract():
+          return Address.contract(scAddress.contractId());
+        default:
+          throw new Error('Unsupported address type');
+      }
+    }
+  }]);
+  return Address;
+}();

package/lib/asset.js

@@ -0,0 +1,323 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Asset = void 0;
+var _util = require("./util/util");
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _keypair = require("./keypair");
+var _strkey = require("./strkey");
+var _hashing = require("./hashing");
+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); }
+/**
+ * Asset class represents an asset, either the native asset (`XLM`)
+ * or an asset code / issuer account ID pair.
+ *
+ * An asset code describes an asset code and issuer pair. In the case of the native
+ * asset XLM, the issuer will be null.
+ *
+ * @constructor
+ * @param {string} code - The asset code.
+ * @param {string} issuer - The account ID of the issuer.
+ */
+var Asset = exports.Asset = /*#__PURE__*/function () {
+  function Asset(code, issuer) {
+    _classCallCheck(this, Asset);
+    if (!/^[a-zA-Z0-9]{1,12}$/.test(code)) {
+      throw new Error('Asset code is invalid (maximum alphanumeric, 12 characters at max)');
+    }
+    if (String(code).toLowerCase() !== 'xlm' && !issuer) {
+      throw new Error('Issuer cannot be null');
+    }
+    if (issuer && !_strkey.StrKey.isValidEd25519PublicKey(issuer)) {
+      throw new Error('Issuer is invalid');
+    }
+    if (String(code).toLowerCase() === 'xlm') {
+      // transform all xLM, Xlm, etc. variants -> XLM
+      this.code = 'XLM';
+    } else {
+      this.code = code;
+    }
+    this.issuer = issuer;
+  }
+
+  /**
+   * Returns an asset object for the native asset.
+   * @Return {Asset}
+   */
+  _createClass(Asset, [{
+    key: "toXDRObject",
+    value:
+    /**
+     * Returns the xdr.Asset object for this asset.
+     * @returns {xdr.Asset} XDR asset object
+     */
+    function toXDRObject() {
+      return this._toXDRObject(_xdr["default"].Asset);
+    }
+
+    /**
+     * Returns the xdr.ChangeTrustAsset object for this asset.
+     * @returns {xdr.ChangeTrustAsset} XDR asset object
+     */
+  }, {
+    key: "toChangeTrustXDRObject",
+    value: function toChangeTrustXDRObject() {
+      return this._toXDRObject(_xdr["default"].ChangeTrustAsset);
+    }
+
+    /**
+     * Returns the xdr.TrustLineAsset object for this asset.
+     * @returns {xdr.TrustLineAsset} XDR asset object
+     */
+  }, {
+    key: "toTrustLineXDRObject",
+    value: function toTrustLineXDRObject() {
+      return this._toXDRObject(_xdr["default"].TrustLineAsset);
+    }
+
+    /**
+     * Returns the would-be contract ID (`C...` format) for this asset on a given
+     * network.
+     *
+     * @param {string}    networkPassphrase   indicates which network the contract
+     *    ID should refer to, since every network will have a unique ID for the
+     *    same contract (see {@link Networks} for options)
+     *
+     * @returns {string}  the strkey-encoded (`C...`) contract ID for this asset
+     *
+     * @warning This makes no guarantee that this contract actually *exists*.
+     */
+  }, {
+    key: "contractId",
+    value: function contractId(networkPassphrase) {
+      var networkId = (0, _hashing.hash)(Buffer.from(networkPassphrase));
+      var preimage = _xdr["default"].HashIdPreimage.envelopeTypeContractId(new _xdr["default"].HashIdPreimageContractId({
+        networkId: networkId,
+        contractIdPreimage: _xdr["default"].ContractIdPreimage.contractIdPreimageFromAsset(this.toXDRObject())
+      }));
+      return _strkey.StrKey.encodeContract((0, _hashing.hash)(preimage.toXDR()));
+    }
+
+    /**
+     * Returns the xdr object for this asset.
+     * @param {xdr.Asset | xdr.ChangeTrustAsset} xdrAsset - The asset xdr object.
+     * @returns {xdr.Asset | xdr.ChangeTrustAsset | xdr.TrustLineAsset} XDR Asset object
+     */
+  }, {
+    key: "_toXDRObject",
+    value: function _toXDRObject() {
+      var xdrAsset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _xdr["default"].Asset;
+      if (this.isNative()) {
+        return xdrAsset.assetTypeNative();
+      }
+      var xdrType;
+      var xdrTypeString;
+      if (this.code.length <= 4) {
+        xdrType = _xdr["default"].AlphaNum4;
+        xdrTypeString = 'assetTypeCreditAlphanum4';
+      } else {
+        xdrType = _xdr["default"].AlphaNum12;
+        xdrTypeString = 'assetTypeCreditAlphanum12';
+      }
+
+      // pad code with null bytes if necessary
+      var padLength = this.code.length <= 4 ? 4 : 12;
+      var paddedCode = this.code.padEnd(padLength, '\0');
+
+      // eslint-disable-next-line new-cap
+      var assetType = new xdrType({
+        assetCode: paddedCode,
+        issuer: _keypair.Keypair.fromPublicKey(this.issuer).xdrAccountId()
+      });
+      return new xdrAsset(xdrTypeString, assetType);
+    }
+
+    /**
+     * @returns {string} Asset code
+     */
+  }, {
+    key: "getCode",
+    value: function getCode() {
+      if (this.code === undefined) {
+        return undefined;
+      }
+      return String(this.code);
+    }
+
+    /**
+     * @returns {string} Asset issuer
+     */
+  }, {
+    key: "getIssuer",
+    value: function getIssuer() {
+      if (this.issuer === undefined) {
+        return undefined;
+      }
+      return String(this.issuer);
+    }
+
+    /**
+     * @see [Assets concept](https://developers.stellar.org/docs/glossary/assets/)
+     * @returns {string} Asset type. Can be one of following types:
+     *
+     *  - `native`,
+     *  - `credit_alphanum4`,
+     *  - `credit_alphanum12`, or
+     *  - `unknown` as the error case (which should never occur)
+     */
+  }, {
+    key: "getAssetType",
+    value: function getAssetType() {
+      switch (this.getRawAssetType()) {
+        case _xdr["default"].AssetType.assetTypeNative():
+          return 'native';
+        case _xdr["default"].AssetType.assetTypeCreditAlphanum4():
+          return 'credit_alphanum4';
+        case _xdr["default"].AssetType.assetTypeCreditAlphanum12():
+          return 'credit_alphanum12';
+        default:
+          return 'unknown';
+      }
+    }
+
+    /**
+     * @returns {xdr.AssetType}  the raw XDR representation of the asset type
+     */
+  }, {
+    key: "getRawAssetType",
+    value: function getRawAssetType() {
+      if (this.isNative()) {
+        return _xdr["default"].AssetType.assetTypeNative();
+      }
+      if (this.code.length <= 4) {
+        return _xdr["default"].AssetType.assetTypeCreditAlphanum4();
+      }
+      return _xdr["default"].AssetType.assetTypeCreditAlphanum12();
+    }
+
+    /**
+     * @returns {boolean}  true if this asset object is the native asset.
+     */
+  }, {
+    key: "isNative",
+    value: function isNative() {
+      return !this.issuer;
+    }
+
+    /**
+     * @param {Asset} asset Asset to compare
+     * @returns {boolean} true if this asset equals the given asset.
+     */
+  }, {
+    key: "equals",
+    value: function equals(asset) {
+      return this.code === asset.getCode() && this.issuer === asset.getIssuer();
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      if (this.isNative()) {
+        return 'native';
+      }
+      return "".concat(this.getCode(), ":").concat(this.getIssuer());
+    }
+
+    /**
+     * Compares two assets according to the criteria:
+     *
+     *  1. First compare the type (native < alphanum4 < alphanum12).
+     *  2. If the types are equal, compare the assets codes.
+     *  3. If the asset codes are equal, compare the issuers.
+     *
+     * @param   {Asset} assetA - the first asset
+     * @param   {Asset} assetB - the second asset
+     * @returns {number} `-1` if assetA < assetB, `0` if assetA == assetB, `1` if assetA > assetB.
+     *
+     * @static
+     * @memberof Asset
+     */
+  }], [{
+    key: "native",
+    value: function native() {
+      return new Asset('XLM');
+    }
+
+    /**
+     * Returns an asset object from its XDR object representation.
+     * @param {xdr.Asset} assetXdr - The asset xdr object.
+     * @returns {Asset}
+     */
+  }, {
+    key: "fromOperation",
+    value: function fromOperation(assetXdr) {
+      var anum;
+      var code;
+      var issuer;
+      switch (assetXdr["switch"]()) {
+        case _xdr["default"].AssetType.assetTypeNative():
+          return this["native"]();
+        case _xdr["default"].AssetType.assetTypeCreditAlphanum4():
+          anum = assetXdr.alphaNum4();
+        /* falls through */
+        case _xdr["default"].AssetType.assetTypeCreditAlphanum12():
+          anum = anum || assetXdr.alphaNum12();
+          issuer = _strkey.StrKey.encodeEd25519PublicKey(anum.issuer().ed25519());
+          code = (0, _util.trimEnd)(anum.assetCode(), '\0');
+          return new this(code, issuer);
+        default:
+          throw new Error("Invalid asset type: ".concat(assetXdr["switch"]().name));
+      }
+    }
+  }, {
+    key: "compare",
+    value: function compare(assetA, assetB) {
+      if (!assetA || !(assetA instanceof Asset)) {
+        throw new Error('assetA is invalid');
+      }
+      if (!assetB || !(assetB instanceof Asset)) {
+        throw new Error('assetB is invalid');
+      }
+      if (assetA.equals(assetB)) {
+        return 0;
+      }
+
+      // Compare asset types.
+      var xdrAtype = assetA.getRawAssetType().value;
+      var xdrBtype = assetB.getRawAssetType().value;
+      if (xdrAtype !== xdrBtype) {
+        return xdrAtype < xdrBtype ? -1 : 1;
+      }
+
+      // Compare asset codes.
+      var result = asciiCompare(assetA.getCode(), assetB.getCode());
+      if (result !== 0) {
+        return result;
+      }
+
+      // Compare asset issuers.
+      return asciiCompare(assetA.getIssuer(), assetB.getIssuer());
+    }
+  }]);
+  return Asset;
+}();
+/**
+ * Compares two ASCII strings in lexographic order with uppercase precedence.
+ *
+ * @param   {string} a - the first string to compare
+ * @param   {string} b - the second
+ * @returns {number} like all `compare()`s:
+ *     -1 if `a < b`, 0 if `a == b`, and 1 if `a > b`
+ *
+ * @warning No type-checks are done on the parameters
+ */
+function asciiCompare(a, b) {
+  return Buffer.compare(Buffer.from(a, 'ascii'), Buffer.from(b, 'ascii'));
+}