@stellar/stellar-base 10.0.0

package/lib/operations/set_options.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setOptions = setOptions;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _keypair = require("../keypair");
+var _strkey = require("../strkey");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+/* eslint-disable no-param-reassign */
+
+function weightCheckFunction(value, name) {
+  if (value >= 0 && value <= 255) {
+    return true;
+  }
+  throw new Error("".concat(name, " value must be between 0 and 255"));
+}
+
+/**
+ * Returns an XDR SetOptionsOp. A "set options" operations set or clear account flags,
+ * set the account's inflation destination, and/or add new signers to the account.
+ * The flags used in `opts.clearFlags` and `opts.setFlags` can be the following:
+ *   - `{@link AuthRequiredFlag}`
+ *   - `{@link AuthRevocableFlag}`
+ *   - `{@link AuthImmutableFlag}`
+ *   - `{@link AuthClawbackEnabledFlag}`
+ *
+ * It's possible to set/clear multiple flags at once using logical or.
+ *
+ * @function
+ * @alias Operation.setOptions
+ *
+ * @param {object} opts Options object
+ * @param {string} [opts.inflationDest] - Set this account ID as the account's inflation destination.
+ * @param {(number|string)} [opts.clearFlags] - Bitmap integer for which account flags to clear.
+ * @param {(number|string)} [opts.setFlags] - Bitmap integer for which account flags to set.
+ * @param {number|string} [opts.masterWeight] - The master key weight.
+ * @param {number|string} [opts.lowThreshold] - The sum weight for the low threshold.
+ * @param {number|string} [opts.medThreshold] - The sum weight for the medium threshold.
+ * @param {number|string} [opts.highThreshold] - The sum weight for the high threshold.
+ * @param {object} [opts.signer] - Add or remove a signer from the account. The signer is
+ *                                 deleted if the weight is 0. Only one of `ed25519PublicKey`, `sha256Hash`, `preAuthTx` should be defined.
+ * @param {string} [opts.signer.ed25519PublicKey] - The ed25519 public key of the signer.
+ * @param {Buffer|string} [opts.signer.sha256Hash] - sha256 hash (Buffer or hex string) of preimage that will unlock funds. Preimage should be used as signature of future transaction.
+ * @param {Buffer|string} [opts.signer.preAuthTx] - Hash (Buffer or hex string) of transaction that will unlock funds.
+ * @param {string} [opts.signer.ed25519SignedPayload] - Signed payload signer (ed25519 public key + raw payload) for atomic transaction signature disclosure.
+ * @param {number|string} [opts.signer.weight] - The weight of the new signer (0 to delete or 1-255)
+ * @param {string} [opts.homeDomain] - sets the home domain used for reverse federation lookup.
+ * @param {string} [opts.source] - The source account (defaults to transaction source).
+ *
+ * @returns {xdr.SetOptionsOp}  XDR operation
+ * @see [Account flags](https://developers.stellar.org/docs/glossary/accounts/#flags)
+ */
+function setOptions(opts) {
+  var attributes = {};
+  if (opts.inflationDest) {
+    if (!_strkey.StrKey.isValidEd25519PublicKey(opts.inflationDest)) {
+      throw new Error('inflationDest is invalid');
+    }
+    attributes.inflationDest = _keypair.Keypair.fromPublicKey(opts.inflationDest).xdrAccountId();
+  }
+  attributes.clearFlags = this._checkUnsignedIntValue('clearFlags', opts.clearFlags);
+  attributes.setFlags = this._checkUnsignedIntValue('setFlags', opts.setFlags);
+  attributes.masterWeight = this._checkUnsignedIntValue('masterWeight', opts.masterWeight, weightCheckFunction);
+  attributes.lowThreshold = this._checkUnsignedIntValue('lowThreshold', opts.lowThreshold, weightCheckFunction);
+  attributes.medThreshold = this._checkUnsignedIntValue('medThreshold', opts.medThreshold, weightCheckFunction);
+  attributes.highThreshold = this._checkUnsignedIntValue('highThreshold', opts.highThreshold, weightCheckFunction);
+  if (opts.homeDomain !== undefined && typeof opts.homeDomain !== 'string') {
+    throw new TypeError('homeDomain argument must be of type String');
+  }
+  attributes.homeDomain = opts.homeDomain;
+  if (opts.signer) {
+    var weight = this._checkUnsignedIntValue('signer.weight', opts.signer.weight, weightCheckFunction);
+    var key;
+    var setValues = 0;
+    if (opts.signer.ed25519PublicKey) {
+      if (!_strkey.StrKey.isValidEd25519PublicKey(opts.signer.ed25519PublicKey)) {
+        throw new Error('signer.ed25519PublicKey is invalid.');
+      }
+      var rawKey = _strkey.StrKey.decodeEd25519PublicKey(opts.signer.ed25519PublicKey);
+
+      // eslint-disable-next-line new-cap
+      key = new _xdr["default"].SignerKey.signerKeyTypeEd25519(rawKey);
+      setValues += 1;
+    }
+    if (opts.signer.preAuthTx) {
+      if (typeof opts.signer.preAuthTx === 'string') {
+        opts.signer.preAuthTx = Buffer.from(opts.signer.preAuthTx, 'hex');
+      }
+      if (!(Buffer.isBuffer(opts.signer.preAuthTx) && opts.signer.preAuthTx.length === 32)) {
+        throw new Error('signer.preAuthTx must be 32 bytes Buffer.');
+      }
+
+      // eslint-disable-next-line new-cap
+      key = new _xdr["default"].SignerKey.signerKeyTypePreAuthTx(opts.signer.preAuthTx);
+      setValues += 1;
+    }
+    if (opts.signer.sha256Hash) {
+      if (typeof opts.signer.sha256Hash === 'string') {
+        opts.signer.sha256Hash = Buffer.from(opts.signer.sha256Hash, 'hex');
+      }
+      if (!(Buffer.isBuffer(opts.signer.sha256Hash) && opts.signer.sha256Hash.length === 32)) {
+        throw new Error('signer.sha256Hash must be 32 bytes Buffer.');
+      }
+
+      // eslint-disable-next-line new-cap
+      key = new _xdr["default"].SignerKey.signerKeyTypeHashX(opts.signer.sha256Hash);
+      setValues += 1;
+    }
+    if (opts.signer.ed25519SignedPayload) {
+      if (!_strkey.StrKey.isValidSignedPayload(opts.signer.ed25519SignedPayload)) {
+        throw new Error('signer.ed25519SignedPayload is invalid.');
+      }
+      var _rawKey = _strkey.StrKey.decodeSignedPayload(opts.signer.ed25519SignedPayload);
+      var signedPayloadXdr = _xdr["default"].SignerKeyEd25519SignedPayload.fromXDR(_rawKey);
+
+      // eslint-disable-next-line new-cap
+      key = _xdr["default"].SignerKey.signerKeyTypeEd25519SignedPayload(signedPayloadXdr);
+      setValues += 1;
+    }
+    if (setValues !== 1) {
+      throw new Error('Signer object must contain exactly one of signer.ed25519PublicKey, signer.sha256Hash, signer.preAuthTx.');
+    }
+    attributes.signer = new _xdr["default"].Signer({
+      key: key,
+      weight: weight
+    });
+  }
+  var setOptionsOp = new _xdr["default"].SetOptionsOp(attributes);
+  var opAttributes = {};
+  opAttributes.body = _xdr["default"].OperationBody.setOptions(setOptionsOp);
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/operations/set_trustline_flags.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setTrustLineFlags = setTrustLineFlags;
+var _xdr = _interopRequireDefault(require("../xdr"));
+var _keypair = require("../keypair");
+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); }
+/**
+ * Creates a trustline flag configuring operation.
+ *
+ * For the flags, set them to true to enable them and false to disable them. Any
+ * unmodified operations will be marked `undefined` in the result.
+ *
+ * Note that you can only **clear** the clawbackEnabled flag set; it must be set
+ * account-wide via operations.SetOptions (setting
+ * xdr.AccountFlags.clawbackEnabled).
+ *
+ * @function
+ * @alias Operation.setTrustLineFlags
+ *
+ * @param {object} opts - Options object
+ * @param {string} opts.trustor     - the account whose trustline this is
+ * @param {Asset}  opts.asset       - the asset on the trustline
+ * @param {object} opts.flags       - the set of flags to modify
+ *
+ * @param {bool}   [opts.flags.authorized]  - authorize account to perform
+ *     transactions with its credit
+ * @param {bool}   [opts.flags.authorizedToMaintainLiabilities] - authorize
+ *     account to maintain and reduce liabilities for its credit
+ * @param {bool}   [opts.flags.clawbackEnabled] - stop claimable balances on
+ *     this trustlines from having clawbacks enabled (this flag can only be set
+ *     to false!)
+ * @param {string} [opts.source] - The source account for the operation.
+ *                                 Defaults to the transaction's source account.
+ *
+ * @note You must include at least one flag.
+ *
+ * @return {xdr.SetTrustLineFlagsOp}
+ *
+ * @link xdr.AccountFlags
+ * @link xdr.TrustLineFlags
+ * @see https://github.com/stellar/stellar-protocol/blob/master/core/cap-0035.md#set-trustline-flags-operation
+ * @see https://developers.stellar.org/docs/start/list-of-operations/#set-options
+ */
+function setTrustLineFlags() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var attributes = {};
+  if (_typeof(opts.flags) !== 'object' || Object.keys(opts.flags).length === 0) {
+    throw new Error('opts.flags must be a map of boolean flags to modify');
+  }
+  var mapping = {
+    authorized: _xdr["default"].TrustLineFlags.authorizedFlag(),
+    authorizedToMaintainLiabilities: _xdr["default"].TrustLineFlags.authorizedToMaintainLiabilitiesFlag(),
+    clawbackEnabled: _xdr["default"].TrustLineFlags.trustlineClawbackEnabledFlag()
+  };
+
+  /* eslint no-bitwise: "off" */
+  var clearFlag = 0;
+  var setFlag = 0;
+  Object.keys(opts.flags).forEach(function (flagName) {
+    if (!Object.prototype.hasOwnProperty.call(mapping, flagName)) {
+      throw new Error("unsupported flag name specified: ".concat(flagName));
+    }
+    var flagValue = opts.flags[flagName];
+    var bit = mapping[flagName].value;
+    if (flagValue === true) {
+      setFlag |= bit;
+    } else if (flagValue === false) {
+      clearFlag |= bit;
+    }
+  });
+  attributes.trustor = _keypair.Keypair.fromPublicKey(opts.trustor).xdrAccountId();
+  attributes.asset = opts.asset.toXDRObject();
+  attributes.clearFlags = clearFlag;
+  attributes.setFlags = setFlag;
+  var opAttributes = {
+    body: _xdr["default"].OperationBody.setTrustLineFlags(new _xdr["default"].SetTrustLineFlagsOp(attributes))
+  };
+  this.setSourceAccount(opAttributes, opts);
+  return new _xdr["default"].Operation(opAttributes);
+}

package/lib/scval.js

@@ -0,0 +1,369 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nativeToScVal = nativeToScVal;
+exports.scValToNative = scValToNative;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _address = require("./address");
+var _contract = require("./contract");
+var _index = require("./numbers/index");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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 _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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); }
+/**
+ * Attempts to convert native types into smart contract values
+ * ({@link xdr.ScVal}).
+ *
+ * Provides conversions from smart contract XDR values ({@link xdr.ScVal}) to
+ * native JavaScript types.
+ *
+ * The conversions are as follows:
+ *
+ *  - xdr.ScVal -> passthrough
+ *  - null/undefined -> scvVoid
+ *  - string -> scvString (a copy is made)
+ *  - UintArray8 -> scvBytes (a copy is made)
+ *  - boolean -> scvBool
+ *
+ *  - number/bigint -> the smallest possible XDR integer type that will fit the
+ *    input value (if you want a specific type, use {@link ScInt})
+ *
+ *  - {@link Address} or {@link Contract} -> scvAddress (for contracts and
+ *    public keys)
+ *
+ *  - Array<T> -> scvVec after attempting to convert each item of type `T` to an
+ *    xdr.ScVal (recursively). note that all values must be the same type!
+ *
+ *  - object -> scvMap after attempting to convert each key and value to an
+ *    xdr.ScVal (recursively). note that there is no restriction on types
+ *    matching anywhere (unlike arrays)
+ *
+ * When passing an integer-like native value, you can also optionally specify a
+ * type which will force a particular interpretation of that value.
+ *
+ * Note that not all type specifications are compatible with all `ScVal`s, e.g.
+ * `toScVal("a string", {type: "i256"})` will throw.
+ *
+ * @param {any} val -       a native (or convertible) input value to wrap
+ * @param {object} [opts] - an optional set of hints around the type of
+ *    conversion you'd like to see
+ * @param {string} [opts.type] - there is different behavior for different input
+ *    types for `val`:
+ *
+ *     - when `val` is an integer-like type (i.e. number|bigint), this will be
+ *       forwarded to {@link ScInt} or forced to be u32/i32.
+ *
+ *     - when `val` is an array type, this is forwarded to the recursion
+ *
+ *     - when `val` is an object type (key-value entries), this should be an
+ *       object in which each key has a pair of types (to represent forced types
+ *       for the key and the value), where `null` (or a missing entry) indicates
+ *       the default interpretation(s) (refer to the examples, below)
+ *
+ *     - when `val` is a string type, this can be 'string' or 'symbol' to force
+ *       a particular interpretation of `val`.
+ *
+ *     - when `val` is a bytes-like type, this can be 'string', 'symbol', or
+ *       'bytes' to force a particular interpretation
+ *
+ *    As a simple example, `nativeToScVal("hello", {type: 'symbol'})` will
+ *    return an `scvSymbol`, whereas without the type it would have been an
+ *    `scvString`.
+ *
+ * @returns {xdr.ScVal} a wrapped, smart, XDR version of the input value
+ * @throws {TypeError} if...
+ *  - there are arrays with more than one type in them
+ *  - there are values that do not have a sensible conversion (e.g. random XDR
+ *    types, custom classes)
+ *  - the type of the input object (or some inner value of said object) cannot
+ *    be determined (via `typeof`)
+ *  - the type you specified (via `opts.type`) is incompatible with the value
+ *    you passed in (`val`), e.g. `nativeToScVal("a string", { type: 'i128' })`,
+ *    though this does not apply for types that ignore `opts` (e.g. addresses).
+ * @see scValToNative
+ *
+ * @example
+ * nativeToScVal(1000);                   // gives ScValType === scvU64
+ * nativeToScVal(1000n);                  // gives ScValType === scvU64
+ * nativeToScVal(1n << 100n);             // gives ScValType === scvU128
+ * nativeToScVal(1000, { type: 'u32' });  // gives ScValType === scvU32
+ * nativeToScVal(1000, { type: 'i125' }); // gives ScValType === scvI256
+ * nativeToScVal("a string");                     // gives ScValType === scvString
+ * nativeToScVal("a string", { type: 'symbol' }); // gives scvSymbol
+ * nativeToScVal(new Uint8Array(5));                      // scvBytes
+ * nativeToScVal(new Uint8Array(5), { type: 'symbol' });  // scvSymbol
+ * nativeToScVal(null); // scvVoid
+ * nativeToScVal(true); // scvBool
+ * nativeToScVal([1, 2, 3]);                    // gives scvVec with each element as scvU64
+ * nativeToScVal([1, 2, 3], { type: 'i128' });  // scvVec<scvI128>
+ * nativeToScVal({ 'hello': 1, 'world': [ true, false ] }, {
+ *   type: {
+ *     'hello': [ 'symbol', 'i128' ],
+ *   }
+ * })
+ * // gives scvMap with entries: [
+ * //     [ scvSymbol, scvI128 ],
+ * //     [ scvString, scvArray<scvBool> ]
+ * // ]
+ *
+ * @example
+ * import { nativeToScVal, scValToNative, ScInt, xdr } from 'stellar-base';
+ *
+ * let gigaMap = {
+ *   bool: true,
+ *   void: null,
+ *   u32: xdr.ScVal.scvU32(1),
+ *   i32: xdr.ScVal.scvI32(1),
+ *   u64: 1n,
+ *   i64: -1n,
+ *   u128: new ScInt(1).toU128(),
+ *   i128: new ScInt(1).toI128(),
+ *   u256: new ScInt(1).toU256(),
+ *   i256: new ScInt(1).toI256(),
+ *   map: {
+ *     arbitrary: 1n,
+ *     nested: 'values',
+ *     etc: false
+ *   },
+ *   vec: ['same', 'type', 'list'],
+ * };
+ *
+ * // then, simply:
+ * let scv = nativeToScVal(gigaMap);    // scv.switch() == xdr.ScValType.scvMap()
+ *
+ * // then...
+ * someContract.call("method", scv);
+ *
+ * // Similarly, the inverse should work:
+ * scValToNative(scv) == gigaMap;       // true
+ */
+function nativeToScVal(val) {
+  var _val$constructor$name, _val$constructor;
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  switch (_typeof(val)) {
+    case 'object':
+      if (val === null) {
+        return _xdr["default"].ScVal.scvVoid();
+      }
+      if (val instanceof _xdr["default"].ScVal) {
+        return val; // should we copy?
+      }
+      if (val instanceof _address.Address) {
+        return val.toScVal();
+      }
+      if (val instanceof _contract.Contract) {
+        return val.address().toScVal();
+      }
+      if (val instanceof Uint8Array || Buffer.isBuffer(val)) {
+        var _opts$type;
+        var copy = Uint8Array.from(val);
+        switch ((_opts$type = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type !== void 0 ? _opts$type : 'bytes') {
+          case 'bytes':
+            return _xdr["default"].ScVal.scvBytes(copy);
+          case 'symbol':
+            return _xdr["default"].ScVal.scvSymbol(copy);
+          case 'string':
+            return _xdr["default"].ScVal.scvString(copy);
+          default:
+            throw new TypeError("invalid type (".concat(opts.type, ") specified for bytes-like value"));
+        }
+      }
+      if (Array.isArray(val)) {
+        if (val.length > 0 && val.some(function (v) {
+          return _typeof(v) !== _typeof(val[0]);
+        })) {
+          throw new TypeError("array values (".concat(val, ") must have the same type (types: ").concat(val.map(function (v) {
+            return _typeof(v);
+          }).join(','), ")"));
+        }
+        return _xdr["default"].ScVal.scvVec(val.map(function (v) {
+          return nativeToScVal(v, opts);
+        }));
+      }
+      if (((_val$constructor$name = (_val$constructor = val.constructor) === null || _val$constructor === void 0 ? void 0 : _val$constructor.name) !== null && _val$constructor$name !== void 0 ? _val$constructor$name : '') !== 'Object') {
+        var _val$constructor2;
+        throw new TypeError("cannot interpret ".concat((_val$constructor2 = val.constructor) === null || _val$constructor2 === void 0 ? void 0 : _val$constructor2.name, " value as ScVal (").concat(JSON.stringify(val), ")"));
+      }
+      return _xdr["default"].ScVal.scvMap(Object.entries(val).map(function (_ref) {
+        var _k, _opts$type2;
+        var _ref2 = _slicedToArray(_ref, 2),
+          k = _ref2[0],
+          v = _ref2[1];
+        // the type can be specified with an entry for the key and the value,
+        // e.g. val = { 'hello': 1 } and opts.type = { hello: [ 'symbol',
+        // 'u128' ]} or you can use `null` for the default interpretation
+        var _ref3 = (_k = ((_opts$type2 = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type2 !== void 0 ? _opts$type2 : {})[k]) !== null && _k !== void 0 ? _k : [null, null],
+          _ref4 = _slicedToArray(_ref3, 2),
+          keyType = _ref4[0],
+          valType = _ref4[1];
+        var keyOpts = keyType ? {
+          type: keyType
+        } : {};
+        var valOpts = valType ? {
+          type: valType
+        } : {};
+        return new _xdr["default"].ScMapEntry({
+          key: nativeToScVal(k, keyOpts),
+          val: nativeToScVal(v, valOpts)
+        });
+      }));
+    case 'number':
+    case 'bigint':
+      switch (opts === null || opts === void 0 ? void 0 : opts.type) {
+        case 'u32':
+          return _xdr["default"].ScVal.scvU32(val);
+        case 'i32':
+          return _xdr["default"].ScVal.scvI32(val);
+        default:
+          break;
+      }
+      return new _index.ScInt(val, {
+        type: opts === null || opts === void 0 ? void 0 : opts.type
+      }).toScVal();
+    case 'string':
+      {
+        var _opts$type3;
+        var optType = (_opts$type3 = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type3 !== void 0 ? _opts$type3 : 'string';
+        switch (optType) {
+          case 'string':
+            return _xdr["default"].ScVal.scvString(val);
+          case 'symbol':
+            return _xdr["default"].ScVal.scvSymbol(val);
+          case 'address':
+            return new _address.Address(val).toScVal();
+          default:
+            if (_index.XdrLargeInt.isType(optType)) {
+              return new _index.XdrLargeInt(optType, val).toScVal();
+            }
+            throw new TypeError("invalid type (".concat(opts.type, ") specified for string value"));
+        }
+      }
+    case 'boolean':
+      return _xdr["default"].ScVal.scvBool(val);
+    case 'undefined':
+      return _xdr["default"].ScVal.scvVoid();
+    case 'function':
+      // FIXME: Is this too helpful?
+      return nativeToScVal(val());
+    default:
+      throw new TypeError("failed to convert typeof ".concat(_typeof(val), " (").concat(val, ")"));
+  }
+}
+
+/**
+ * Given a smart contract value, attempt to convert it to a native type.
+ * Possible conversions include:
+ *
+ *  - void -> `null`
+ *  - u32, i32 -> `number`
+ *  - u64, i64, u128, i128, u256, i256 -> `bigint`
+ *  - vec -> `Array` of any of the above (via recursion)
+ *  - map -> key-value object of any of the above (via recursion)
+ *  - bool -> `boolean`
+ *  - bytes -> `Uint8Array`
+ *  - symbol -> `string`
+ *  - string -> `string` IF the underlying buffer can be decoded as ascii/utf8,
+ *              `Uint8Array` of the raw contents in any error case
+ *
+ * If no viable conversion can be determined, this just "unwraps" the smart
+ * value to return its underlying XDR value.
+ *
+ * @param {xdr.ScVal} scv - the input smart contract value
+ *
+ * @returns {any}
+ * @see nativeToScVal
+ */
+function scValToNative(scv) {
+  var _scv$vec, _scv$map;
+  // we use the verbose xdr.ScValType.<type>.value form here because it's faster
+  // than string comparisons and the underlying constants never need to be
+  // updated
+  switch (scv["switch"]().value) {
+    case _xdr["default"].ScValType.scvVoid().value:
+      return null;
+
+    // these can be converted to bigints directly
+    case _xdr["default"].ScValType.scvU64().value:
+    case _xdr["default"].ScValType.scvI64().value:
+      return scv.value().toBigInt();
+
+    // these can be parsed by internal abstractions note that this can also
+    // handle the above two cases, but it's not as efficient (another
+    // type-check, parsing, etc.)
+    case _xdr["default"].ScValType.scvU128().value:
+    case _xdr["default"].ScValType.scvI128().value:
+    case _xdr["default"].ScValType.scvU256().value:
+    case _xdr["default"].ScValType.scvI256().value:
+      return (0, _index.scValToBigInt)(scv);
+    case _xdr["default"].ScValType.scvVec().value:
+      return ((_scv$vec = scv.vec()) !== null && _scv$vec !== void 0 ? _scv$vec : []).map(scValToNative);
+    case _xdr["default"].ScValType.scvAddress().value:
+      return _address.Address.fromScVal(scv).toString();
+    case _xdr["default"].ScValType.scvMap().value:
+      return Object.fromEntries(((_scv$map = scv.map()) !== null && _scv$map !== void 0 ? _scv$map : []).map(function (entry) {
+        return [scValToNative(entry.key()), scValToNative(entry.val())];
+      }));
+
+    // these return the primitive type directly
+    case _xdr["default"].ScValType.scvBool().value:
+    case _xdr["default"].ScValType.scvU32().value:
+    case _xdr["default"].ScValType.scvI32().value:
+    case _xdr["default"].ScValType.scvBytes().value:
+      return scv.value();
+
+    // Symbols are limited to [a-zA-Z0-9_]+, so we can safely make ascii strings
+    //
+    // Strings, however, are "presented" as strings and we treat them as such
+    // (in other words, string = bytes with a hint that it's text). If the user
+    // encoded non-printable bytes in their string value, that's on them.
+    //
+    // Note that we assume a utf8 encoding (ascii-compatible). For other
+    // encodings, you should probably use bytes anyway. If it cannot be decoded,
+    // the raw bytes are returned.
+    case _xdr["default"].ScValType.scvSymbol().value:
+    case _xdr["default"].ScValType.scvString().value:
+      {
+        var v = scv.value(); // string|Buffer
+        if (Buffer.isBuffer(v) || ArrayBuffer.isView(v)) {
+          try {
+            return new TextDecoder().decode(v);
+          } catch (e) {
+            return new Uint8Array(v.buffer); // copy of bytes
+          }
+        }
+        return v; // string already
+      }
+
+    // these can be converted to bigint
+    case _xdr["default"].ScValType.scvTimepoint().value:
+    case _xdr["default"].ScValType.scvDuration().value:
+      return new _xdr["default"].Uint64(scv.value()).toBigInt();
+    case _xdr["default"].ScValType.scvStatus().value:
+      // TODO: Convert each status type into a human-readable error string?
+      switch (scv.value()["switch"]()) {
+        case _xdr["default"].ScStatusType.sstOk().value:
+        case _xdr["default"].ScStatusType.sstUnknownError().value:
+        case _xdr["default"].ScStatusType.sstHostValueError().value:
+        case _xdr["default"].ScStatusType.sstHostObjectError().value:
+        case _xdr["default"].ScStatusType.sstHostFunctionError().value:
+        case _xdr["default"].ScStatusType.sstHostStorageError().value:
+        case _xdr["default"].ScStatusType.sstHostContextError().value:
+        case _xdr["default"].ScStatusType.sstVmError().value:
+        case _xdr["default"].ScStatusType.sstContractError().value:
+        case _xdr["default"].ScStatusType.sstHostAuthError().value:
+        default:
+          break;
+      }
+
+    // in the fallthrough case, just return the underlying value directly
+    default:
+      return scv.value();
+  }
+}