@stellar/stellar-base 10.0.0

package/lib/signerkey.js

@@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SignerKey = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+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); }
+/**
+ * A container class with helpers to convert between signer keys
+ * (`xdr.SignerKey`) and {@link StrKey}s.
+ *
+ * It's primarly used for manipulating the `extraSigners` precondition on a
+ * {@link Transaction}.
+ *
+ * @see {@link TransactionBuilder.setExtraSigners}
+ */
+var SignerKey = exports.SignerKey = /*#__PURE__*/function () {
+  function SignerKey() {
+    _classCallCheck(this, SignerKey);
+  }
+  _createClass(SignerKey, null, [{
+    key: "decodeAddress",
+    value:
+    /**
+     * Decodes a StrKey address into an xdr.SignerKey instance.
+     *
+     * Only ED25519 public keys (G...), pre-auth transactions (T...), hashes
+     * (H...), and signed payloads (P...) can be signer keys.
+     *
+     * @param   {string} address  a StrKey-encoded signer address
+     * @returns {xdr.SignerKey}
+     */
+    function decodeAddress(address) {
+      var signerKeyMap = {
+        ed25519PublicKey: _xdr["default"].SignerKey.signerKeyTypeEd25519,
+        preAuthTx: _xdr["default"].SignerKey.signerKeyTypePreAuthTx,
+        sha256Hash: _xdr["default"].SignerKey.signerKeyTypeHashX,
+        signedPayload: _xdr["default"].SignerKey.signerKeyTypeEd25519SignedPayload
+      };
+      var vb = _strkey.StrKey.getVersionByteForPrefix(address);
+      var encoder = signerKeyMap[vb];
+      if (!encoder) {
+        throw new Error("invalid signer key type (".concat(vb, ")"));
+      }
+      var raw = (0, _strkey.decodeCheck)(vb, address);
+      switch (vb) {
+        case 'signedPayload':
+          return encoder(new _xdr["default"].SignerKeyEd25519SignedPayload({
+            ed25519: raw.slice(0, 32),
+            payload: raw.slice(32 + 4)
+          }));
+        case 'ed25519PublicKey': // falls through
+        case 'preAuthTx': // falls through
+        case 'sha256Hash': // falls through
+        default:
+          return encoder(raw);
+      }
+    }
+
+    /**
+     * Encodes a signer key into its StrKey equivalent.
+     *
+     * @param   {xdr.SignerKey} signerKey   the signer
+     * @returns {string} the StrKey representation of the signer
+     */
+  }, {
+    key: "encodeSignerKey",
+    value: function encodeSignerKey(signerKey) {
+      var strkeyType;
+      var raw;
+      switch (signerKey["switch"]()) {
+        case _xdr["default"].SignerKeyType.signerKeyTypeEd25519():
+          strkeyType = 'ed25519PublicKey';
+          raw = signerKey.value();
+          break;
+        case _xdr["default"].SignerKeyType.signerKeyTypePreAuthTx():
+          strkeyType = 'preAuthTx';
+          raw = signerKey.value();
+          break;
+        case _xdr["default"].SignerKeyType.signerKeyTypeHashX():
+          strkeyType = 'sha256Hash';
+          raw = signerKey.value();
+          break;
+        case _xdr["default"].SignerKeyType.signerKeyTypeEd25519SignedPayload():
+          strkeyType = 'signedPayload';
+          raw = signerKey.ed25519SignedPayload().toXDR('raw');
+          break;
+        default:
+          throw new Error("invalid SignerKey (type: ".concat(signerKey["switch"](), ")"));
+      }
+      return (0, _strkey.encodeCheck)(strkeyType, raw);
+    }
+  }]);
+  return SignerKey;
+}();

package/lib/signing.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FastSigning = void 0;
+exports.generate = generate;
+exports.sign = sign;
+exports.verify = verify;
+//  This module provides the signing functionality used by the stellar network
+//  The code below may look a little strange... this is because we try to provide
+//  the most efficient signing method possible.  First, we try to load the
+//  native `sodium-native` package for node.js environments, and if that fails we
+//  fallback to `tweetnacl`
+
+var actualMethods = {};
+
+/**
+ * Use this flag to check if fast signing (provided by `sodium-native` package) is available.
+ * If your app is signing a large number of transaction or verifying a large number
+ * of signatures make sure `sodium-native` package is installed.
+ */
+var FastSigning = exports.FastSigning = checkFastSigning();
+function sign(data, secretKey) {
+  return actualMethods.sign(data, secretKey);
+}
+function verify(data, signature, publicKey) {
+  return actualMethods.verify(data, signature, publicKey);
+}
+function generate(secretKey) {
+  return actualMethods.generate(secretKey);
+}
+function checkFastSigning() {
+  return typeof window === 'undefined' ? checkFastSigningNode() : checkFastSigningBrowser();
+}
+function checkFastSigningNode() {
+  // NOTE: we use commonjs style require here because es6 imports
+  // can only occur at the top level.  thanks, obama.
+  var sodium;
+  try {
+    // eslint-disable-next-line
+    sodium = require('sodium-native');
+  } catch (err) {
+    return checkFastSigningBrowser();
+  }
+  if (!Object.keys(sodium).length) {
+    return checkFastSigningBrowser();
+  }
+  actualMethods.generate = function (secretKey) {
+    var pk = Buffer.alloc(sodium.crypto_sign_PUBLICKEYBYTES);
+    var sk = Buffer.alloc(sodium.crypto_sign_SECRETKEYBYTES);
+    sodium.crypto_sign_seed_keypair(pk, sk, secretKey);
+    return pk;
+  };
+  actualMethods.sign = function (data, secretKey) {
+    data = Buffer.from(data);
+    var signature = Buffer.alloc(sodium.crypto_sign_BYTES);
+    sodium.crypto_sign_detached(signature, data, secretKey);
+    return signature;
+  };
+  actualMethods.verify = function (data, signature, publicKey) {
+    data = Buffer.from(data);
+    try {
+      return sodium.crypto_sign_verify_detached(signature, data, publicKey);
+    } catch (e) {
+      return false;
+    }
+  };
+  return true;
+}
+function checkFastSigningBrowser() {
+  // fallback to `tweetnacl` if we're in the browser or
+  // if there was a failure installing `sodium-native`
+  // eslint-disable-next-line
+  var nacl = require('tweetnacl');
+  actualMethods.generate = function (secretKey) {
+    var secretKeyUint8 = new Uint8Array(secretKey);
+    var naclKeys = nacl.sign.keyPair.fromSeed(secretKeyUint8);
+    return Buffer.from(naclKeys.publicKey);
+  };
+  actualMethods.sign = function (data, secretKey) {
+    data = Buffer.from(data);
+    data = new Uint8Array(data.toJSON().data);
+    secretKey = new Uint8Array(secretKey.toJSON().data);
+    var signature = nacl.sign.detached(data, secretKey);
+    return Buffer.from(signature);
+  };
+  actualMethods.verify = function (data, signature, publicKey) {
+    data = Buffer.from(data);
+    data = new Uint8Array(data.toJSON().data);
+    signature = new Uint8Array(signature.toJSON().data);
+    publicKey = new Uint8Array(publicKey.toJSON().data);
+    return nacl.sign.detached.verify(data, signature, publicKey);
+  };
+  return false;
+}

package/lib/soroban.js

@@ -0,0 +1,96 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Soroban = void 0;
+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 _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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); }
+/* Helper class to assist with formatting and parsing token amounts. */
+var Soroban = exports.Soroban = /*#__PURE__*/function () {
+  function Soroban() {
+    _classCallCheck(this, Soroban);
+  }
+  _createClass(Soroban, null, [{
+    key: "formatTokenAmount",
+    value:
+    /**
+     * Given a whole number smart contract amount of a token and an amount of
+     * decimal places (if the token has any), it returns a "display" value.
+     *
+     * All arithmetic inside the contract is performed on integers to avoid
+     * potential precision and consistency issues of floating-point.
+     *
+     * @param {string} amount   the token amount you want to display
+     * @param {number} decimals specify how many decimal places a token has
+     *
+     * @returns {string} the display value
+     * @throws {TypeError} if the given amount has a decimal point already
+     * @example
+     * formatTokenAmount("123000", 4) === "12.3";
+     */
+    function formatTokenAmount(amount, decimals) {
+      if (amount.includes('.')) {
+        throw new TypeError('No decimals are allowed');
+      }
+      var formatted = amount;
+      if (decimals > 0) {
+        if (decimals > formatted.length) {
+          formatted = ['0', formatted.toString().padStart(decimals, '0')].join('.');
+        } else {
+          formatted = [formatted.slice(0, -decimals), formatted.slice(-decimals)].join('.');
+        }
+      }
+
+      // remove trailing zero if any
+      return formatted.replace(/(\.\d*?)0+$/, '$1');
+    }
+
+    /**
+     * Parse a token amount to use it on smart contract
+     *
+     * This function takes the display value and its decimals (if the token has
+     * any) and returns a string that'll be used within the smart contract.
+     *
+     * @param {string} value      the token amount you want to use it on smart
+     *    contract which you've been displaying in a UI
+     * @param {number} decimals   the number of decimal places expected in the
+     *    display value (different than the "actual" number, because suffix zeroes
+     *    might not be present)
+     *
+     * @returns {string}  the whole number token amount represented by the display
+     *    value with the decimal places shifted over
+     *
+     * @example
+     * const displayValueAmount = "123.4560"
+     * const parsedAmtForSmartContract = parseTokenAmount(displayValueAmount, 5);
+     * parsedAmtForSmartContract === "12345600"
+     */
+  }, {
+    key: "parseTokenAmount",
+    value: function parseTokenAmount(value, decimals) {
+      var _fraction$padEnd;
+      var _value$split$slice = value.split('.').slice(),
+        _value$split$slice2 = _toArray(_value$split$slice),
+        whole = _value$split$slice2[0],
+        fraction = _value$split$slice2[1],
+        rest = _value$split$slice2.slice(2);
+      if (rest.length) {
+        throw new Error("Invalid decimal value: ".concat(value));
+      }
+      var shifted = BigInt(whole + ((_fraction$padEnd = fraction === null || fraction === void 0 ? void 0 : fraction.padEnd(decimals, '0')) !== null && _fraction$padEnd !== void 0 ? _fraction$padEnd : '0'.repeat(decimals)));
+      return shifted.toString();
+    }
+  }]);
+  return Soroban;
+}();

package/lib/sorobandata_builder.js

@@ -0,0 +1,218 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SorobanDataBuilder = 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 _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 _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); }
+/**
+ * Supports building {@link xdr.SorobanTransactionData} structures with various
+ * items set to specific values.
+ *
+ * This is recommended for when you are building
+ * {@link Operation.extendFootprintTtl} / {@link Operation.restoreFootprint}
+ * operations and need to {@link TransactionBuilder.setSorobanData} to avoid
+ * (re)building the entire data structure from scratch.
+ *
+ * @constructor
+ *
+ * @param {string | xdr.SorobanTransactionData} [sorobanData]  either a
+ *      base64-encoded string that represents an
+ *      {@link xdr.SorobanTransactionData} instance or an XDR instance itself
+ *      (it will be copied); if omitted or "falsy" (e.g. an empty string), it
+ *      starts with an empty instance
+ *
+ * @example
+ * // You want to use an existing data blob but override specific parts.
+ * const newData = new SorobanDataBuilder(existing)
+ *   .setReadOnly(someLedgerKeys)
+ *   .setRefundableFee("1000")
+ *   .build();
+ *
+ * // You want an instance from scratch
+ * const newData = new SorobanDataBuilder()
+ *   .setFootprint([someLedgerKey], [])
+ *   .setRefundableFee("1000")
+ *   .build();
+ */
+var SorobanDataBuilder = exports.SorobanDataBuilder = /*#__PURE__*/function () {
+  function SorobanDataBuilder(sorobanData) {
+    _classCallCheck(this, SorobanDataBuilder);
+    _defineProperty(this, "_data", void 0);
+    var data;
+    if (!sorobanData) {
+      data = new _xdr["default"].SorobanTransactionData({
+        resources: new _xdr["default"].SorobanResources({
+          footprint: new _xdr["default"].LedgerFootprint({
+            readOnly: [],
+            readWrite: []
+          }),
+          instructions: 0,
+          readBytes: 0,
+          writeBytes: 0
+        }),
+        ext: new _xdr["default"].ExtensionPoint(0),
+        resourceFee: new _xdr["default"].Int64(0)
+      });
+    } else if (typeof sorobanData === 'string' || ArrayBuffer.isView(sorobanData)) {
+      data = SorobanDataBuilder.fromXDR(sorobanData);
+    } else {
+      data = SorobanDataBuilder.fromXDR(sorobanData.toXDR()); // copy
+    }
+    this._data = data;
+  }
+
+  /**
+   * Decodes and builds a {@link xdr.SorobanTransactionData} instance.
+   * @param {Uint8Array|Buffer|string} data   raw input to decode
+   * @returns {xdr.SorobanTransactionData}
+   */
+  _createClass(SorobanDataBuilder, [{
+    key: "setResourceFee",
+    value:
+    /**
+     * Sets the resource fee portion of the Soroban data.
+     * @param {number | bigint | string} fee  the resource fee to set (int64)
+     * @returns {SorobanDataBuilder}
+     */
+    function setResourceFee(fee) {
+      this._data.resourceFee(new _xdr["default"].Int64(fee));
+      return this;
+    }
+
+    /**
+     * Sets up the resource metrics.
+     *
+     * You should almost NEVER need this, as its often generated / provided to you
+     * by transaction simulation/preflight from a Soroban RPC server.
+     *
+     * @param {number} cpuInstrs      number of CPU instructions
+     * @param {number} readBytes      number of bytes being read
+     * @param {number} writeBytes     number of bytes being written
+     *
+     * @returns {SorobanDataBuilder}
+     */
+  }, {
+    key: "setResources",
+    value: function setResources(cpuInstrs, readBytes, writeBytes) {
+      this._data.resources().instructions(cpuInstrs);
+      this._data.resources().readBytes(readBytes);
+      this._data.resources().writeBytes(writeBytes);
+      return this;
+    }
+
+    /**
+     * Appends the given ledger keys to the existing storage access footprint.
+     * @param {xdr.LedgerKey[]} readOnly   read-only keys to add
+     * @param {xdr.LedgerKey[]} readWrite  read-write keys to add
+     * @returns {SorobanDataBuilder} this builder instance
+     */
+  }, {
+    key: "appendFootprint",
+    value: function appendFootprint(readOnly, readWrite) {
+      return this.setFootprint(this.getReadOnly().concat(readOnly), this.getReadWrite().concat(readWrite));
+    }
+
+    /**
+     * Sets the storage access footprint to be a certain set of ledger keys.
+     *
+     * You can also set each field explicitly via
+     * {@link SorobanDataBuilder.setReadOnly} and
+     * {@link SorobanDataBuilder.setReadWrite} or add to the existing footprint
+     * via {@link SorobanDataBuilder.appendFootprint}.
+     *
+     * Passing `null|undefined` to either parameter will IGNORE the existing
+     * values. If you want to clear them, pass `[]`, instead.
+     *
+     * @param {xdr.LedgerKey[]|null} [readOnly]   the set of ledger keys to set in
+     *    the read-only portion of the transaction's `sorobanData`, or `null |
+     *    undefined` to keep the existing keys
+     * @param {xdr.LedgerKey[]|null} [readWrite]  the set of ledger keys to set in
+     *    the read-write portion of the transaction's `sorobanData`, or `null |
+     *    undefined` to keep the existing keys
+     * @returns {SorobanDataBuilder} this builder instance
+     */
+  }, {
+    key: "setFootprint",
+    value: function setFootprint(readOnly, readWrite) {
+      if (readOnly !== null) {
+        // null means "leave me alone"
+        this.setReadOnly(readOnly);
+      }
+      if (readWrite !== null) {
+        this.setReadWrite(readWrite);
+      }
+      return this;
+    }
+
+    /**
+     * @param {xdr.LedgerKey[]} readOnly  read-only keys in the access footprint
+     * @returns {SorobanDataBuilder}
+     */
+  }, {
+    key: "setReadOnly",
+    value: function setReadOnly(readOnly) {
+      this._data.resources().footprint().readOnly(readOnly !== null && readOnly !== void 0 ? readOnly : []);
+      return this;
+    }
+
+    /**
+     * @param {xdr.LedgerKey[]} readWrite  read-write keys in the access footprint
+     * @returns {SorobanDataBuilder}
+     */
+  }, {
+    key: "setReadWrite",
+    value: function setReadWrite(readWrite) {
+      this._data.resources().footprint().readWrite(readWrite !== null && readWrite !== void 0 ? readWrite : []);
+      return this;
+    }
+
+    /**
+     * @returns {xdr.SorobanTransactionData} a copy of the final data structure
+     */
+  }, {
+    key: "build",
+    value: function build() {
+      return _xdr["default"].SorobanTransactionData.fromXDR(this._data.toXDR()); // clone
+    }
+
+    //
+    // getters follow
+    //
+
+    /** @returns {xdr.LedgerKey[]} the read-only storage access pattern */
+  }, {
+    key: "getReadOnly",
+    value: function getReadOnly() {
+      return this.getFootprint().readOnly();
+    }
+
+    /** @returns {xdr.LedgerKey[]} the read-write storage access pattern */
+  }, {
+    key: "getReadWrite",
+    value: function getReadWrite() {
+      return this.getFootprint().readWrite();
+    }
+
+    /** @returns {xdr.LedgerFootprint} the storage access pattern */
+  }, {
+    key: "getFootprint",
+    value: function getFootprint() {
+      return this._data.resources().footprint();
+    }
+  }], [{
+    key: "fromXDR",
+    value: function fromXDR(data) {
+      return _xdr["default"].SorobanTransactionData.fromXDR(data, typeof data === 'string' ? 'base64' : 'raw');
+    }
+  }]);
+  return SorobanDataBuilder;
+}();