@stellar/stellar-sdk
Version:
A library for working with the Stellar network, including communication with the Horizon and Soroban RPC servers.
1,493 lines (1,362 loc) • 2.31 MB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define("StellarSdk", [], factory);
else if(typeof exports === 'object')
exports["StellarSdk"] = factory();
else
root["StellarSdk"] = factory();
})(self, () => {
return /******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 15:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
/* provided dependency */ var Buffer = __webpack_require__(8287)["Buffer"];
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 = __webpack_require__(Object(function webpackMissingModule() { var e = new Error("Cannot find module 'sodium-native'"); e.code = 'MODULE_NOT_FOUND'; throw e; }()));
} 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 = __webpack_require__(4940);
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;
}
/***/ }),
/***/ 41:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var $defineProperty = __webpack_require__(655);
var $SyntaxError = __webpack_require__(8068);
var $TypeError = __webpack_require__(9675);
var gopd = __webpack_require__(5795);
/** @type {import('.')} */
module.exports = function defineDataProperty(
obj,
property,
value
) {
if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
throw new $TypeError('`obj` must be an object or a function`');
}
if (typeof property !== 'string' && typeof property !== 'symbol') {
throw new $TypeError('`property` must be a string or a symbol`');
}
if (arguments.length > 3 && typeof arguments[3] !== 'boolean' && arguments[3] !== null) {
throw new $TypeError('`nonEnumerable`, if provided, must be a boolean or null');
}
if (arguments.length > 4 && typeof arguments[4] !== 'boolean' && arguments[4] !== null) {
throw new $TypeError('`nonWritable`, if provided, must be a boolean or null');
}
if (arguments.length > 5 && typeof arguments[5] !== 'boolean' && arguments[5] !== null) {
throw new $TypeError('`nonConfigurable`, if provided, must be a boolean or null');
}
if (arguments.length > 6 && typeof arguments[6] !== 'boolean') {
throw new $TypeError('`loose`, if provided, must be a boolean');
}
var nonEnumerable = arguments.length > 3 ? arguments[3] : null;
var nonWritable = arguments.length > 4 ? arguments[4] : null;
var nonConfigurable = arguments.length > 5 ? arguments[5] : null;
var loose = arguments.length > 6 ? arguments[6] : false;
/* @type {false | TypedPropertyDescriptor<unknown>} */
var desc = !!gopd && gopd(obj, property);
if ($defineProperty) {
$defineProperty(obj, property, {
configurable: nonConfigurable === null && desc ? desc.configurable : !nonConfigurable,
enumerable: nonEnumerable === null && desc ? desc.enumerable : !nonEnumerable,
value: value,
writable: nonWritable === null && desc ? desc.writable : !nonWritable
});
} else if (loose || (!nonEnumerable && !nonWritable && !nonConfigurable)) {
// must fall back to [[Set]], and was not explicitly asked to make non-enumerable, non-writable, or non-configurable
obj[property] = value; // eslint-disable-line no-param-reassign
} else {
throw new $SyntaxError('This environment does not support defining a property as non-configurable, non-writable, or non-enumerable.');
}
};
/***/ }),
/***/ 76:
/***/ ((module) => {
"use strict";
/** @type {import('./functionCall')} */
module.exports = Function.prototype.call;
/***/ }),
/***/ 149:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.restoreFootprint = restoreFootprint;
var _xdr = _interopRequireDefault(__webpack_require__(1918));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
/**
* Builds an operation to restore the archived ledger entries specified
* by the ledger keys.
*
* The ledger keys to restore are specified separately from the operation
* in read-write footprint of the transaction.
*
* It takes no parameters because the relevant footprint is derived from the
* transaction itself. See {@link TransactionBuilder}'s `opts.sorobanData`
* parameter (or {@link TransactionBuilder.setSorobanData} /
* {@link TransactionBuilder.setLedgerKeys}), which is a
* {@link xdr.SorobanTransactionData} instance that contains fee data & resource
* usage as part of {@link xdr.SorobanTransactionData}.
*
* @function
* @alias Operation.restoreFootprint
*
* @param {object} [opts] - an optional set of parameters
* @param {string} [opts.source] - an optional source account
*
* @returns {xdr.Operation} a Bump Footprint Expiration operation
* (xdr.RestoreFootprintOp)
*/
function restoreFootprint() {
var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
var op = new _xdr["default"].RestoreFootprintOp({
ext: new _xdr["default"].ExtensionPoint(0)
});
var opAttributes = {
body: _xdr["default"].OperationBody.restoreFootprint(op)
};
this.setSourceAccount(opAttributes, opts !== null && opts !== void 0 ? opts : {});
return new _xdr["default"].Operation(opAttributes);
}
/***/ }),
/***/ 225:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.SignerKey = void 0;
var _xdr = _interopRequireDefault(__webpack_require__(1918));
var _strkey = __webpack_require__(7120);
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
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(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
/**
* 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);
}
return _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);
}
}]);
}();
/***/ }),
/***/ 251:
/***/ ((__unused_webpack_module, exports) => {
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
exports.read = function (buffer, offset, isLE, mLen, nBytes) {
var e, m
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var nBits = -7
var i = isLE ? (nBytes - 1) : 0
var d = isLE ? -1 : 1
var s = buffer[offset + i]
i += d
e = s & ((1 << (-nBits)) - 1)
s >>= (-nBits)
nBits += eLen
for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
m = e & ((1 << (-nBits)) - 1)
e >>= (-nBits)
nBits += mLen
for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
if (e === 0) {
e = 1 - eBias
} else if (e === eMax) {
return m ? NaN : ((s ? -1 : 1) * Infinity)
} else {
m = m + Math.pow(2, mLen)
e = e - eBias
}
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}
exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
var e, m, c
var eLen = (nBytes * 8) - mLen - 1
var eMax = (1 << eLen) - 1
var eBias = eMax >> 1
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
var i = isLE ? 0 : (nBytes - 1)
var d = isLE ? 1 : -1
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
value = Math.abs(value)
if (isNaN(value) || value === Infinity) {
m = isNaN(value) ? 1 : 0
e = eMax
} else {
e = Math.floor(Math.log(value) / Math.LN2)
if (value * (c = Math.pow(2, -e)) < 1) {
e--
c *= 2
}
if (e + eBias >= 1) {
value += rt / c
} else {
value += rt * Math.pow(2, 1 - eBias)
}
if (value * c >= 2) {
e++
c /= 2
}
if (e + eBias >= eMax) {
m = 0
e = eMax
} else if (e + eBias >= 1) {
m = ((value * c) - 1) * Math.pow(2, mLen)
e = e + eBias
} else {
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
e = 0
}
}
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
e = (e << mLen) | m
eLen += mLen
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
buffer[offset + i - d] |= s * 128
}
/***/ }),
/***/ 345:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = __webpack_require__(7007).EventEmitter;
/***/ }),
/***/ 356:
/***/ ((module, exports, __webpack_require__) => {
"use strict";
Object.defineProperty(exports, "__esModule", ({
value: true
}));
var _exportNames = {
xdr: true,
cereal: true,
hash: true,
sign: true,
verify: true,
FastSigning: true,
getLiquidityPoolId: true,
LiquidityPoolFeeV18: true,
Keypair: true,
UnsignedHyper: true,
Hyper: true,
TransactionBase: true,
Transaction: true,
FeeBumpTransaction: true,
TransactionBuilder: true,
TimeoutInfinite: true,
BASE_FEE: true,
Asset: true,
LiquidityPoolAsset: true,
LiquidityPoolId: true,
Operation: true,
AuthRequiredFlag: true,
AuthRevocableFlag: true,
AuthImmutableFlag: true,
AuthClawbackEnabledFlag: true,
Account: true,
MuxedAccount: true,
Claimant: true,
Networks: true,
StrKey: true,
SignerKey: true,
Soroban: true,
decodeAddressToMuxedAccount: true,
encodeMuxedAccountToAddress: true,
extractBaseAddress: true,
encodeMuxedAccount: true,
Contract: true,
Address: true
};
Object.defineProperty(exports, "Account", ({
enumerable: true,
get: function get() {
return _account.Account;
}
}));
Object.defineProperty(exports, "Address", ({
enumerable: true,
get: function get() {
return _address.Address;
}
}));
Object.defineProperty(exports, "Asset", ({
enumerable: true,
get: function get() {
return _asset.Asset;
}
}));
Object.defineProperty(exports, "AuthClawbackEnabledFlag", ({
enumerable: true,
get: function get() {
return _operation.AuthClawbackEnabledFlag;
}
}));
Object.defineProperty(exports, "AuthImmutableFlag", ({
enumerable: true,
get: function get() {
return _operation.AuthImmutableFlag;
}
}));
Object.defineProperty(exports, "AuthRequiredFlag", ({
enumerable: true,
get: function get() {
return _operation.AuthRequiredFlag;
}
}));
Object.defineProperty(exports, "AuthRevocableFlag", ({
enumerable: true,
get: function get() {
return _operation.AuthRevocableFlag;
}
}));
Object.defineProperty(exports, "BASE_FEE", ({
enumerable: true,
get: function get() {
return _transaction_builder.BASE_FEE;
}
}));
Object.defineProperty(exports, "Claimant", ({
enumerable: true,
get: function get() {
return _claimant.Claimant;
}
}));
Object.defineProperty(exports, "Contract", ({
enumerable: true,
get: function get() {
return _contract.Contract;
}
}));
Object.defineProperty(exports, "FastSigning", ({
enumerable: true,
get: function get() {
return _signing.FastSigning;
}
}));
Object.defineProperty(exports, "FeeBumpTransaction", ({
enumerable: true,
get: function get() {
return _fee_bump_transaction.FeeBumpTransaction;
}
}));
Object.defineProperty(exports, "Hyper", ({
enumerable: true,
get: function get() {
return _jsXdr.Hyper;
}
}));
Object.defineProperty(exports, "Keypair", ({
enumerable: true,
get: function get() {
return _keypair.Keypair;
}
}));
Object.defineProperty(exports, "LiquidityPoolAsset", ({
enumerable: true,
get: function get() {
return _liquidity_pool_asset.LiquidityPoolAsset;
}
}));
Object.defineProperty(exports, "LiquidityPoolFeeV18", ({
enumerable: true,
get: function get() {
return _get_liquidity_pool_id.LiquidityPoolFeeV18;
}
}));
Object.defineProperty(exports, "LiquidityPoolId", ({
enumerable: true,
get: function get() {
return _liquidity_pool_id.LiquidityPoolId;
}
}));
Object.defineProperty(exports, "MuxedAccount", ({
enumerable: true,
get: function get() {
return _muxed_account.MuxedAccount;
}
}));
Object.defineProperty(exports, "Networks", ({
enumerable: true,
get: function get() {
return _network.Networks;
}
}));
Object.defineProperty(exports, "Operation", ({
enumerable: true,
get: function get() {
return _operation.Operation;
}
}));
Object.defineProperty(exports, "SignerKey", ({
enumerable: true,
get: function get() {
return _signerkey.SignerKey;
}
}));
Object.defineProperty(exports, "Soroban", ({
enumerable: true,
get: function get() {
return _soroban.Soroban;
}
}));
Object.defineProperty(exports, "StrKey", ({
enumerable: true,
get: function get() {
return _strkey.StrKey;
}
}));
Object.defineProperty(exports, "TimeoutInfinite", ({
enumerable: true,
get: function get() {
return _transaction_builder.TimeoutInfinite;
}
}));
Object.defineProperty(exports, "Transaction", ({
enumerable: true,
get: function get() {
return _transaction.Transaction;
}
}));
Object.defineProperty(exports, "TransactionBase", ({
enumerable: true,
get: function get() {
return _transaction_base.TransactionBase;
}
}));
Object.defineProperty(exports, "TransactionBuilder", ({
enumerable: true,
get: function get() {
return _transaction_builder.TransactionBuilder;
}
}));
Object.defineProperty(exports, "UnsignedHyper", ({
enumerable: true,
get: function get() {
return _jsXdr.UnsignedHyper;
}
}));
Object.defineProperty(exports, "cereal", ({
enumerable: true,
get: function get() {
return _jsxdr["default"];
}
}));
Object.defineProperty(exports, "decodeAddressToMuxedAccount", ({
enumerable: true,
get: function get() {
return _decode_encode_muxed_account.decodeAddressToMuxedAccount;
}
}));
exports["default"] = void 0;
Object.defineProperty(exports, "encodeMuxedAccount", ({
enumerable: true,
get: function get() {
return _decode_encode_muxed_account.encodeMuxedAccount;
}
}));
Object.defineProperty(exports, "encodeMuxedAccountToAddress", ({
enumerable: true,
get: function get() {
return _decode_encode_muxed_account.encodeMuxedAccountToAddress;
}
}));
Object.defineProperty(exports, "extractBaseAddress", ({
enumerable: true,
get: function get() {
return _decode_encode_muxed_account.extractBaseAddress;
}
}));
Object.defineProperty(exports, "getLiquidityPoolId", ({
enumerable: true,
get: function get() {
return _get_liquidity_pool_id.getLiquidityPoolId;
}
}));
Object.defineProperty(exports, "hash", ({
enumerable: true,
get: function get() {
return _hashing.hash;
}
}));
Object.defineProperty(exports, "sign", ({
enumerable: true,
get: function get() {
return _signing.sign;
}
}));
Object.defineProperty(exports, "verify", ({
enumerable: true,
get: function get() {
return _signing.verify;
}
}));
Object.defineProperty(exports, "xdr", ({
enumerable: true,
get: function get() {
return _xdr["default"];
}
}));
var _xdr = _interopRequireDefault(__webpack_require__(1918));
var _jsxdr = _interopRequireDefault(__webpack_require__(3335));
var _hashing = __webpack_require__(9152);
var _signing = __webpack_require__(15);
var _get_liquidity_pool_id = __webpack_require__(5578);
var _keypair = __webpack_require__(6691);
var _jsXdr = __webpack_require__(3740);
var _transaction_base = __webpack_require__(3758);
var _transaction = __webpack_require__(380);
var _fee_bump_transaction = __webpack_require__(9260);
var _transaction_builder = __webpack_require__(6396);
var _asset = __webpack_require__(1764);
var _liquidity_pool_asset = __webpack_require__(2262);
var _liquidity_pool_id = __webpack_require__(9353);
var _operation = __webpack_require__(7237);
var _memo = __webpack_require__(4172);
Object.keys(_memo).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _memo[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _memo[key];
}
});
});
var _account = __webpack_require__(2135);
var _muxed_account = __webpack_require__(2243);
var _claimant = __webpack_require__(1387);
var _network = __webpack_require__(6202);
var _strkey = __webpack_require__(7120);
var _signerkey = __webpack_require__(225);
var _soroban = __webpack_require__(4062);
var _decode_encode_muxed_account = __webpack_require__(6160);
var _contract = __webpack_require__(7452);
var _address = __webpack_require__(1180);
var _numbers = __webpack_require__(8549);
Object.keys(_numbers).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _numbers[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _numbers[key];
}
});
});
var _scval = __webpack_require__(7177);
Object.keys(_scval).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _scval[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _scval[key];
}
});
});
var _events = __webpack_require__(3919);
Object.keys(_events).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _events[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _events[key];
}
});
});
var _sorobandata_builder = __webpack_require__(4842);
Object.keys(_sorobandata_builder).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _sorobandata_builder[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _sorobandata_builder[key];
}
});
});
var _auth = __webpack_require__(5328);
Object.keys(_auth).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _auth[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _auth[key];
}
});
});
var _invocation = __webpack_require__(3564);
Object.keys(_invocation).forEach(function (key) {
if (key === "default" || key === "__esModule") return;
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
if (key in exports && exports[key] === _invocation[key]) return;
Object.defineProperty(exports, key, {
enumerable: true,
get: function get() {
return _invocation[key];
}
});
});
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
/* eslint-disable import/no-import-module-exports */
//
// Soroban
//
var _default = exports["default"] = module.exports;
/***/ }),
/***/ 380:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
/* provided dependency */ var Buffer = __webpack_require__(8287)["Buffer"];
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); }
Object.defineProperty(exports, "__esModule", ({
value: true
}));
exports.Transaction = void 0;
var _xdr = _interopRequireDefault(__webpack_require__(1918));
var _hashing = __webpack_require__(9152);
var _strkey = __webpack_require__(7120);
var _operation = __webpack_require__(7237);
var _memo = __webpack_require__(4172);
var _transaction_base = __webpack_require__(3758);
var _decode_encode_muxed_account = __webpack_require__(6160);
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
/**
* Use {@link TransactionBuilder} to build a transaction object. If you have an
* object or base64-encoded string of the transaction envelope XDR, use {@link
* TransactionBuilder.fromXDR}.
*
* Once a Transaction has been created, its attributes and operations should not
* be changed. You should only add signatures (using {@link Transaction#sign})
* to a Transaction object before submitting to the network or forwarding on to
* additional signers.
*
* @constructor
*
* @param {string|xdr.TransactionEnvelope} envelope - transaction envelope
* object or base64 encoded string
* @param {string} [networkPassphrase] - passphrase of the target stellar
* network (e.g. "Public Global Stellar Network ; September 2015")
*
* @extends TransactionBase
*/
var Transaction = exports.Transaction = /*#__PURE__*/function (_TransactionBase) {
function Transaction(envelope, networkPassphrase) {
var _this;
_classCallCheck(this, Transaction);
if (typeof envelope === 'string') {
var buffer = Buffer.from(envelope, 'base64');
envelope = _xdr["default"].TransactionEnvelope.fromXDR(buffer);
}
var envelopeType = envelope["switch"]();
if (!(envelopeType === _xdr["default"].EnvelopeType.envelopeTypeTxV0() || envelopeType === _xdr["default"].EnvelopeType.envelopeTypeTx())) {
throw new Error("Invalid TransactionEnvelope: expected an envelopeTypeTxV0 or envelopeTypeTx but received an ".concat(envelopeType.name, "."));
}
var txEnvelope = envelope.value();
var tx = txEnvelope.tx();
var fee = tx.fee().toString();
var signatures = (txEnvelope.signatures() || []).slice();
_this = _callSuper(this, Transaction, [tx, signatures, fee, networkPassphrase]);
_this._envelopeType = envelopeType;
_this._memo = tx.memo();
_this._sequence = tx.seqNum().toString();
switch (_this._envelopeType) {
case _xdr["default"].EnvelopeType.envelopeTypeTxV0():
_this._source = _strkey.StrKey.encodeEd25519PublicKey(_this.tx.sourceAccountEd25519());
break;
default:
_this._source = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(_this.tx.sourceAccount());
break;
}
var cond = null;
var timeBounds = null;
switch (_this._envelopeType) {
case _xdr["default"].EnvelopeType.envelopeTypeTxV0():
timeBounds = tx.timeBounds();
break;
case _xdr["default"].EnvelopeType.envelopeTypeTx():
switch (tx.cond()["switch"]()) {
case _xdr["default"].PreconditionType.precondTime():
timeBounds = tx.cond().timeBounds();
break;
case _xdr["default"].PreconditionType.precondV2():
cond = tx.cond().v2();
timeBounds = cond.timeBounds();
break;
default:
break;
}
break;
default:
break;
}
if (timeBounds) {
_this._timeBounds = {
minTime: timeBounds.minTime().toString(),
maxTime: timeBounds.maxTime().toString()
};
}
if (cond) {
var ledgerBounds = cond.ledgerBounds();
if (ledgerBounds) {
_this._ledgerBounds = {
minLedger: ledgerBounds.minLedger(),
maxLedger: ledgerBounds.maxLedger()
};
}
var minSeq = cond.minSeqNum();
if (minSeq) {
_this._minAccountSequence = minSeq.toString();
}
_this._minAccountSequenceAge = cond.minSeqAge();
_this._minAccountSequenceLedgerGap = cond.minSeqLedgerGap();
_this._extraSigners = cond.extraSigners();
}
var operations = tx.operations() || [];
_this._operations = operations.map(function (op) {
return _operation.Operation.fromXDRObject(op);
});
return _this;
}
/**
* @type {object}
* @property {string} 64 bit unix timestamp
* @property {string} 64 bit unix timestamp
* @readonly
*/
_inherits(Transaction, _TransactionBase);
return _createClass(Transaction, [{
key: "timeBounds",
get: function get() {
return this._timeBounds;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* @type {object}
* @property {number} minLedger - smallest ledger bound (uint32)
* @property {number} maxLedger - largest ledger bound (or 0 for inf)
* @readonly
*/
}, {
key: "ledgerBounds",
get: function get() {
return this._ledgerBounds;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* 64 bit account sequence
* @readonly
* @type {string}
*/
}, {
key: "minAccountSequence",
get: function get() {
return this._minAccountSequence;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* 64 bit number of seconds
* @type {number}
* @readonly
*/
}, {
key: "minAccountSequenceAge",
get: function get() {
return this._minAccountSequenceAge;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* 32 bit number of ledgers
* @type {number}
* @readonly
*/
}, {
key: "minAccountSequenceLedgerGap",
get: function get() {
return this._minAccountSequenceLedgerGap;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* array of extra signers ({@link StrKey}s)
* @type {string[]}
* @readonly
*/
}, {
key: "extraSigners",
get: function get() {
return this._extraSigners;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* @type {string}
* @readonly
*/
}, {
key: "sequence",
get: function get() {
return this._sequence;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* @type {string}
* @readonly
*/
}, {
key: "source",
get: function get() {
return this._source;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* @type {Array.<xdr.Operation>}
* @readonly
*/
}, {
key: "operations",
get: function get() {
return this._operations;
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* @type {string}
* @readonly
*/
}, {
key: "memo",
get: function get() {
return _memo.Memo.fromXDRObject(this._memo);
},
set: function set(value) {
throw new Error('Transaction is immutable');
}
/**
* Returns the "signature base" of this transaction, which is the value
* that, when hashed, should be signed to create a signature that
* validators on the Stellar Network will accept.
*
* It is composed of a 4 prefix bytes followed by the xdr-encoded form
* of this transaction.
* @returns {Buffer}
*/
}, {
key: "signatureBase",
value: function signatureBase() {
var tx = this.tx;
// Backwards Compatibility: Use ENVELOPE_TYPE_TX to sign ENVELOPE_TYPE_TX_V0
// we need a Transaction to generate the signature base
if (this._envelopeType === _xdr["default"].EnvelopeType.envelopeTypeTxV0()) {
tx = _xdr["default"].Transaction.fromXDR(Buffer.concat([
// TransactionV0 is a transaction with the AccountID discriminant
// stripped off, we need to put it back to build a valid transaction
// which we can use to build a TransactionSignaturePayloadTaggedTransaction
_xdr["default"].PublicKeyType.publicKeyTypeEd25519().toXDR(), tx.toXDR()]));
}
var taggedTransaction = new _xdr["default"].TransactionSignaturePayloadTaggedTransaction.envelopeTypeTx(tx);
var txSignature = new _xdr["default"].TransactionSignaturePayload({
networkId: _xdr["default"].Hash.fromXDR((0, _hashing.hash)(this.networkPassphrase)),
taggedTransaction: taggedTransaction
});
return txSignature.toXDR();
}
/**
* To envelope returns a xdr.TransactionEnvelope which can be submitted to the network.
* @returns {xdr.TransactionEnvelope}
*/
}, {
key: "toEnvelope",
value: function toEnvelope() {
var rawTx = this.tx.toXDR();
var signatures = this.signatures.slice(); // make a copy of the signatures
var envelope;
switch (this._envelopeType) {
case _xdr["default"].EnvelopeType.envelopeTypeTxV0():
envelope = new _xdr["default"].TransactionEnvelope.envelopeTypeTxV0(new _xdr["default"].TransactionV0Envelope({
tx: _xdr["default"].TransactionV0.fromXDR(rawTx),
// make a copy of tx
signatures: signatures
}));
break;
case _xdr["default"].EnvelopeType.envelopeTypeTx():
envelope = new _xdr["default"].TransactionEnvelope.envelopeTypeTx(new _xdr["default"].TransactionV1Envelope({
tx: _xdr["default"].Transaction.fromXDR(rawTx),
// make a copy of tx
signatures: signatures
}));
break;
default:
throw new Error("Invalid TransactionEnvelope: expected an envelopeTypeTxV0 or envelopeTypeTx but received an ".concat(this._envelopeType.name, "."));
}
return envelope;
}
/**
* Calculate the claimable balance ID for an operation within the transaction.
*
* @param {integer} opIndex the index of the CreateClaimableBalance op
* @returns {string} a hex string representing the claimable balance ID
*
* @throws {RangeError} for invalid `opIndex` value
* @throws {TypeError} if op at `opIndex` is not `CreateClaimableBalance`
* @throws for general XDR un/marshalling failures
*
* @see https://github.com/stellar/go/blob/d712346e61e288d450b0c08038c158f8848cc3e4/txnbuild/transaction.go#L392-L435
*
*/
}, {
key: "getClaimableBalanceId",
value: function getClaimableBalanceId(opIndex) {
// Validate and then extract the operation from the transaction.
if (!Number.isInteger(opIndex) || opIndex < 0 || opIndex >= this.operations.length) {
throw new RangeError('invalid operation index');
}
var op = this.operations[opIndex];
try {
op = _operation.Operation.createClaimableBalance(op);
} catch (err) {
throw new TypeError("expected createClaimableBalance, got ".concat(op.type, ": ").concat(err));
}
// Always use the transaction's *unmuxed* source.
var account = _strkey.StrKey.decodeEd25519PublicKey((0, _decode_encode_muxed_account.extractBaseAddress)(this.source));
var operationId = _xdr["default"].HashIdPreimage.envelopeTypeOpId(new _xdr["default"].HashIdPreimageOperationId({
sourceAccount: _xdr["default"].AccountId.publicKeyTypeEd25519(account),
seqNum: _xdr["default"].SequenceNumber.fromString(this.sequence),
opNum: opIndex
}));
var opIdHash = (0, _hashing.hash)(operationId.toXDR('raw'));
var balanceId = _xdr["default"].ClaimableBalanceId.claimableBalanceIdTypeV0(opIdHash);
return balanceId.toXDR('hex');
}
}]);
}(_transaction_base.TransactionBase);
/***/ }),
/***/ 392:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
var Buffer = (__webpack_require__(2861).Buffer)
// prototype class for hash functions
function Hash (blockSize, finalSize) {
this._block = Buffer.alloc(blockSize)
this._finalSize = finalSize
this._blockSize = blockSize
this._len = 0
}
Hash.prototype.update = function (data, enc) {
if (typeof data === 'string') {
enc = enc || 'utf8'
data = Buffer.from(data, enc)
}
var block = this._block
var blockSize = this._blockSize
var length = data.length
var accum = this._len
for (var offset = 0; offset < length;) {
var assigned = accum % blockSize
var remainder = Math.min(length - offset, blockSize - assigned)
for (var i = 0; i < remainder; i++) {
block[assigned + i] = data[offset + i]
}
accum += remainder
offset += remainder
if ((accum % blockSize) === 0) {
this._update(block)
}
}
this._len += length
return this
}
Hash.prototype.digest = function (enc) {
var rem = this._len % this._blockSize
this._block[rem] = 0x80
// zero (rem + 1) trailing bits, where (rem + 1) is the smallest
// non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize
this._block.fill(0, rem + 1)
if (rem >= this._finalSize) {
this._update(this._block)
this._block.fill(0)
}
var bits = this._len * 8
// uint32
if (bits <= 0xffffffff) {
this._block.writeUInt32BE(bits, this._blockSize - 4)
// uint64
} else {
var lowBits = (bits & 0xffffffff) >>> 0
var highBits = (bits - lowBits) / 0x100000000
this._block.writeUInt32BE(highBits, this._blockSize - 8)
this._block.writeUInt32BE(lowBits, this._blockSize - 4)
}
this._update(this._block)
var hash = this._hash()
return enc ? hash.toString(enc) : hash
}
Hash.prototype._update = function () {
throw new Error('_update must be implemented by subclass')
}
module.exports = Hash
/***/ }),
/***/ 414:
/***/ ((module) => {
"use strict";
/** @type {import('./round')} */
module.exports = Math.round;
/***/ }),
/***/ 453:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var undefined;
var $Object = __webpack_require__(9612);
var $Error = __webpack_require__(9383);
var $EvalError = __webpack_require__(1237);
var $RangeError = __webpack_require__(9290);
var $ReferenceError = __webpack_require__(9538);
var $SyntaxError = __webpack_require__(8068);
var $TypeError = __webpack_require__(9675);
var $URIError = __webpack_require__(5345);
var abs = __webpack_require__(1514);
var floor = __webpack_require__(8968);
var max = __webpack_require__(6188);
var min = __webpack_require__(8002);
var pow = __webpack_require__(5880);
var round = __webpack_require__(414);
var sign = __webpack_require__(3093);
var $Function = Function;
// eslint-disable-next-line consistent-return
var getEvalledConstructor = function (expressionSyntax) {
try {
return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')();
} catch (e) {}
};
var $gOPD = __webpack_require__(5795);
var $defineProperty = __webpack_require__(655);
var throwTypeError = function () {
throw new $TypeError();
};
var ThrowTypeError = $gOPD
? (function () {
try {
// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties
arguments.callee; // IE 8 does not throw here
return throwTypeError;
} catch (calleeThrows) {
try {
// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')
return $gOPD(arguments, 'callee').get;
} catch (gOPDthrows) {
return throwTypeError;
}
}
}())
: throwTypeError;
var hasSymbols = __webpack_require__(4039)();
var getProto = __webpack_require__(3628);
var $ObjectGPO = __webpack_require__(1064);
var $ReflectGPO = __webpack_require__(8648);
var $apply = __webpack_require__(1002);
var $call = __webpack_require__(76);
var needsEval = {};
var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array);
var INTRINSICS = {
__proto__: null,
'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,
'%Array%': Array,
'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
'%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined,
'%AsyncFromSyncIteratorPrototype%': undefined,
'%AsyncFunction%': needsEval,
'%AsyncGenerator%': needsEval,
'%AsyncGeneratorFunction%': needsEval,
'%AsyncIteratorPrototype%': needsEval,
'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,
'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,
'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,
'%Boolean%': Boolean,
'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,
'%Date%': Date,
'%decodeURI%': decodeURI,
'%decodeURIComponent%': decodeURIComponent,
'%encodeURI%': encodeURI,
'%encodeURIComponent%': encodeURIComponent,
'%Error%': $Error,
'%eval%': eval, // eslint-disable-line no-eval
'%EvalError%': $EvalError,
'%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array,
'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,
'%Function%': $Function,
'%GeneratorFunction%': needsEval,
'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
'%isFinite%': isFinite,
'%isNaN%': isNaN,
'%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined,
'%JSON%': typeof JSON === 'object' ? JSON : undefined,
'%Map%': typeof Map === 'undefined' ? undefined : Map,
'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()),
'%Math%': Math,
'%Number%': Number,
'%Object%': $Object,
'%Object.getOwnPropertyDescriptor%': $gOPD,
'%parseFloat%': parseFloat,
'%parseInt%': parseInt,
'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,
'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
'%RangeError%': $RangeError,
'%ReferenceError%': $ReferenceError,
'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
'%RegExp%': RegExp,
'%Set%': typeof Set === 'undefined' ? undefined : Set,
'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()),
'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
'%String%': String,
'%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined,
'%Symbol%': hasSymbols ? Symbol : undefined,
'%SyntaxError%': $SyntaxError,
'%ThrowTypeError%': ThrowTypeError,
'%TypedArray%': TypedArray,
'%TypeError%': $TypeError,
'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
'%URIError%': $URIError,
'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,
'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,
'%Function.prototype.call%': $call,
'%Function.prototype.apply%': $apply,
'%Object.defineProperty%': $defineProperty,
'%Object.getPrototypeOf%': $ObjectGPO,
'%Math.abs%': abs,
'%Math.floor%': floor,
'%Math.max%': max,
'%Math.min%': min,
'%Math.pow%': pow,
'%Math.round%': round,
'%Math.sign%': sign,
'%Reflect.getPrototypeOf%': $ReflectGPO
};
if (getProto) {
try {
null.error; // eslint-disable-line no-unused-expressions
} catch (e) {
// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229
var errorProto = getProto(getProto(e));
INTRINSICS['%Error.prototype%'] = errorProto;
}
}
var doEval = function doEval(name) {
var value;
if (name === '%AsyncFunction%') {
value = getEvalledConstructor('async function () {}');
} else if (name === '%GeneratorFuncti