truffle
Version:
Truffle - Simple development framework for Ethereum
1,361 lines (1,151 loc) • 39.6 kB
JavaScript
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 51788:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = {
run: __webpack_require__(7847),
meta: __webpack_require__(22674)
};
/***/ }),
/***/ 22674:
/***/ ((module) => {
module.exports = {
command: "call",
description: "Call read-only contract function with arguments",
builder: {
"url": {
describe: "Connect to a specified provider given via URL",
type: "string"
},
"network": {
describe: "The network name to connect to as specified in the config",
type: "string"
},
"from": {
describe: "The address to perform the call from",
type: "string"
},
"_": {
type: "string"
},
"fetch-external": {
describe: "Fetch referenced verified contracts as needed",
alias: "x",
type: "boolean",
default: false
},
"block-number": {
describe: "Specify the block for the function to be called in.",
alias: "b",
type: "string",
default: "latest"
}
},
help: {
usage:
"truffle call <contract-address>|<contract-name> <function-name>|<function-signature>\n" +
" " + // spacing to align with previous line
"<arg1> ... <argN> [--fetch-external|-x] [--network <network>|--url <provider_url>]\n" +
" " + // spacing to align with previous line
"[--block-number|-b <block_number>]",
options: [
{
option: "<contract-name>",
description: "The name of the contract to be called."
},
{
option: "<contract-address>",
description: "The address of the contract to be called."
},
{
option: "<function-name>",
description: "The name of the function to be called."
},
{
option: "<function-signature>",
description:
"The full function ABI signature (not selector) to be called."
},
{
option: "<arg1> ... <argN>",
description: "List of arguments to be passed to the function."
},
{
option: "--fetch-external|-x",
description:
"Allows Truffle to fetch verified source for the contract being called;\n" +
" note this is useful only when the contract is supplied by address."
},
{
option: "--url",
description:
"Connects to a specified provider given via URL, ignoring networks in config."
},
{
option: "--network",
description:
"The network to connect to, as specified in the Truffle config."
},
{
option: "--block-number|-b",
description: "Specifies the block for the function to be called in."
}
],
allowedGlobalOptions: ["from", "config"]
}
};
/***/ }),
/***/ 7847:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = async function (options) {
const debug = __webpack_require__(15158)("core:commands:call");
const fs = __webpack_require__(57147);
const util = __webpack_require__(73837);
const { Environment } = __webpack_require__(76765);
const OS = __webpack_require__(22037);
const Codec = __webpack_require__(20102);
const Encoder = __webpack_require__(15967);
const Decoder = __webpack_require__(18852);
const TruffleError = __webpack_require__(73321);
const { fetchAndCompile } = __webpack_require__(5523);
const loadConfig = __webpack_require__(932);
const DebugUtils = __webpack_require__(93293);
const web3Utils = __webpack_require__(18269);
if (options.url && options.network) {
const message =
"" +
"Mutually exclusive options, --url and --network detected!" +
OS.EOL +
"Please use either --url or --network and try again." +
OS.EOL +
"See: https://trufflesuite.com/docs/truffle/reference/truffle-commands/#call" +
OS.EOL;
throw new TruffleError(message);
}
let config = loadConfig(options);
await Environment.detect(config);
const [contractNameOrAddress, functionNameOrSignature, ...args] = config._;
let functionEntry, transaction;
const fromAddress =
options.from ??
config.networks[config.network]?.from ??
Codec.Evm.Utils.ZERO_ADDRESS;
if (!web3Utils.isAddress(fromAddress)) {
throw new TruffleError(
`Error: Address ${fromAddress} is not a valid Ethereum address.` +
OS.EOL +
"Please check the address and try again."
);
}
let blockNumber = options.block ?? "latest";
if (!Number.isNaN(Number(blockNumber))) {
blockNumber = Number(blockNumber);
}
if (
!(Number.isSafeInteger(blockNumber) && blockNumber >= 0) &&
!["latest", "pending", "genesis", "earliest"].includes(blockNumber)
) {
throw new TruffleError(
"Error: Invalid block number. Block number must be nonnegative integer or one of 'latest', 'pending', 'genesis', or 'earliest'."
);
}
const { encoder, decoder } = config.fetchExternal
? await sourceFromExternal(contractNameOrAddress, config)
: await sourceFromLocal(contractNameOrAddress, config);
try {
({ abi: functionEntry, tx: transaction } = await encoder.encodeTransaction(
functionNameOrSignature,
args,
{
allowJson: true,
strictBooleans: true
}
));
} catch (error) {
const expectedErrors = [
Encoder.NoFunctionByThatNameError,
Codec.Wrap.NoOverloadsMatchedError,
Codec.Wrap.NoUniqueBestOverloadError,
Codec.Wrap.TypeMismatchError
];
debug("expectedErrors: %O", expectedErrors);
if (expectedErrors.some(errorClass => error instanceof errorClass)) {
//if it was an expected error, turn it into a TruffleError so that it
//displays nicely
throw new TruffleError("Error: " + error.message);
} else {
//unexpected error, rethrow
throw error;
}
}
if (!["pure", "view"].includes(functionEntry.stateMutability)) {
console.log(
"WARNING: Making read-only call to non-view function." +
OS.EOL +
"Any changes this function attempts to make will not be saved to the blockchain."
);
}
const adapter = new Encoder.ProviderAdapter(config.provider);
let result;
let status = undefined;
try {
result = await adapter.call(
fromAddress,
transaction.to,
transaction.data,
blockNumber
);
//note we don't set status to true... a revert need not cause an
//error, depending on client
if (typeof result !== "string") {
//if we couldn't extract a return value, something's gone badly wrong;
//let's just throw
throw new Error("Malformed response from call");
}
} catch (error) {
status = false;
result = extractResult(error);
if (result === undefined) {
//if we couldn't extract a return value, something's gone badly wrong;
//let's just rethrow the error in that case
throw error;
}
}
debug("result: %O", result);
const decodings = await decoder.decodeReturnValue(functionEntry, result, {
status
});
if (decodings.length === 0) {
throw new TruffleError("Error: Could not decode result.");
}
const decoding = decodings[0];
if (decoding.status) {
//successful return
config.logger.log(
util.inspect(new Codec.Export.ReturndataDecodingInspector(decoding), {
colors: true,
depth: null,
maxArrayLength: null,
breakLength: 79
})
);
} else {
//revert case
if (
decoding.kind === "revert" &&
Codec.AbiData.Utils.abiSignature(decoding.abi) === "Panic(uint256)"
) {
// for panics specifically, we'll want a bit more interpretation
// (shouldn't this be a proper interpretation? yes, but there's no
// time to refactor that right now)
const panicCode = decoding.arguments[0].value.value.asBN;
throw new TruffleError(
`The call resulted in a panic: ${DebugUtils.panicString(panicCode)}`
);
}
//usual revert case
throw new TruffleError(
util.inspect(new Codec.Export.ReturndataDecodingInspector(decoding), {
colors: false, //don't want colors in an error message
depth: null,
maxArrayLength: null,
breakLength: 79
})
);
}
return;
//Note: This is the end of the function. After this point is just inner
//function declarations. These declarations are made as inner functions
//so they can use the imports above.
async function sourceFromLocal(contractNameOrAddress, config) {
if (
contractNameOrAddress.startsWith("0x") &&
!web3Utils.isAddress(contractNameOrAddress)
) {
throw new TruffleError(
`Error: Address ${contractNameOrAddress} is not a valid Ethereum address.` +
OS.EOL +
"Please check the address and try again."
);
}
const contractNames = fs
.readdirSync(config.contracts_build_directory)
.filter(filename => filename.endsWith(".json"))
.map(filename => filename.slice(0, -".json".length));
const contracts = contractNames
.map(contractName => ({
[contractName]: config.resolver.require(contractName)
}))
.reduce((a, b) => ({ ...a, ...b }), {});
if (Object.keys(contracts).length === 0) {
throw new TruffleError(
"Error: No artifacts found; please run `truffle compile` first to compile your contracts."
);
}
if (contractNameOrAddress.startsWith("0x")) {
//note in this case we already performed validation above
const contractAddress = contractNameOrAddress;
const projectInfo = {
artifacts: Object.values(contracts)
};
return await getEncoderDecoderForContractAddress(
contractAddress,
projectInfo
);
} else {
// contract name case
const contractName = contractNameOrAddress;
const settings = {
provider: config.provider,
projectInfo: {
artifacts: Object.values(contracts)
}
};
const contract = contracts[contractName];
if (!contract) {
throw new TruffleError(
`Error: No artifacts found for contract named ${contractName} found. Check the name and make sure you have compiled your contracts.`
);
}
let instance;
try {
instance = await contract.deployed();
} catch (error) {
throw new TruffleError(
"Error: This contract has not been deployed to the detected network." +
OS.EOL +
"Please run `truffle migrate` to deploy the contract."
);
}
const encoder = await Encoder.forContractInstance(instance, settings);
const decoder = await Decoder.forContractInstance(instance, settings);
return { encoder, decoder };
}
}
async function sourceFromExternal(contractAddress, config) {
if (!web3Utils.isAddress(contractAddress)) {
throw new TruffleError(
`Error: Address ${contractAddress} is not a valid Ethereum address.` +
OS.EOL +
"Please check the address and try again, or remove `-x` if you are supplying a contract name."
);
}
const { compileResult } = await fetchAndCompile(contractAddress, config);
const projectInfo = {
commonCompilations: compileResult.compilations
};
return await getEncoderDecoderForContractAddress(
contractAddress,
projectInfo
);
}
async function getEncoderDecoderForContractAddress(
contractAddress,
projectInfo
) {
const projectEncoder = await Encoder.forProject({
provider: config.provider,
projectInfo
});
const encoder = await projectEncoder.forAddress(
contractAddress,
blockNumber
);
const projectDecoder = await Decoder.forProject({
provider: config.provider,
projectInfo
});
const decoder = await projectDecoder.forAddress(
contractAddress,
blockNumber
);
return { encoder, decoder };
}
};
function extractResult(error) {
//CODE DUPLICATION WARNING!!
//the following code is copied (w/slight adaptations) from contract/lib/reason.js
//it should really be factored!! but there may not be time to do that right now
if (!error || !error.data) {
return undefined;
}
// NOTE that Ganache >=2 returns the reason string when
// vmErrorsOnRPCResponse === true, which this code could
// be updated to respect (instead of computing here)
const { data } = error;
if (typeof data === "string") {
return data; // geth, Ganache >7.0.0
} else if ("result" in data) {
// there is a single result (Ganache 7.0.0)
return data.result;
} else {
// handle `evm_mine`, `miner_start`, batch payloads, and ganache 2.0
// NOTE this only works for a single failed transaction at a time.
const hash = Object.keys(data)[0];
const errorDetails = data[hash];
return errorDetails.return /* ganache 2.0 */;
}
}
/***/ }),
/***/ 932:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
module.exports = function (options) {
const Config = __webpack_require__(20553);
const TruffleError = __webpack_require__(73321);
const mergeConfigNetwork = __webpack_require__(22173);
let config;
try {
config = Config.detect(options);
config = mergeConfigNetwork(config, options);
} catch (error) {
if (error instanceof TruffleError && options.url) {
config = Config.default();
config = mergeConfigNetwork(config, options);
// in case config file is not detected (exception thrown) AND url is provided in the options,
// We use default config and set compileNone to true. Since there are is no config files and url is provided,
// It is assumed that truffle debug/console is being used for analysis and debugging and that there is nothing to compile.
// E.g. analysing/debugging a single transaction of an external project
config.compileNone = true;
config.configFileSkipped = true;
} else {
throw error;
}
}
return config;
};
/***/ }),
/***/ 22173:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const { URL } = __webpack_require__(57310);
module.exports = function (config, options) {
if (options.url) {
const url = new URL(options.url);
config.networks[url.host] = {
url: options.url,
network_id: "*"
};
config.network = url.host;
}
config.merge(options);
return config;
};
/***/ }),
/***/ 86927:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const { IPC } = __webpack_require__(39813);
const path = __webpack_require__(71017);
const { spawn } = __webpack_require__(32081);
const debug = __webpack_require__(15158);
const chalk = __webpack_require__(34061);
const Develop = {
start: async function (ipcNetwork, ganacheOptions = {}) {
let chainPath;
// The path to the dev env process depends on whether or not
// we're running in the bundled version. If not, use chain.js
// directly, otherwise let the bundle point at the bundled version.
if (true) {
// Remember: In the bundled version, __dirname refers to the
// build directory where cli.bundled.js and cli.chain.js live.
chainPath = path.join(__dirname, "chain.bundled.js");
} else {}
const logger = ganacheOptions.logger || console;
//check that genesis-time config option passed through the
//truffle-config.js file is a valid time.
if (ganacheOptions.time && isNaN(Date.parse(ganacheOptions.time))) {
ganacheOptions.time = Date.now();
logger.log(
"\x1b[31m%s\x1b[0m",
"Invalid Date passed to genesis-time, using current Date instead",
"\x1b[0m"
);
}
const stringifiedOptions = JSON.stringify(ganacheOptions);
const optionsBuffer = Buffer.from(stringifiedOptions);
const base64OptionsString = optionsBuffer.toString("base64");
return spawn("node", [chainPath, ipcNetwork, base64OptionsString], {
detached: true,
stdio: "ignore"
});
},
/**
* Connect to an existing Ganache server or start a new one.
* @param {object} options
* @param {object} options.ipcOptions - options for IPC connection
* @param {boolean} options.ipcOptions.log - whether to log IPC messages. Defaults to false.
* @param {string} options.ipcOptions.network - network name. Defaults to "develop".
* @param {boolean} options.ipcOptions.retry - whether to retry connection. Defaults to false.
* @param {string} options.solidityLogDisplayPrefix - prefix to display before solidity log messages. Defaults to "".
* @returns {Promise<(): void>} - IPC disconnection function.
*/
connect: function ({ ipcOptions, solidityLogDisplayPrefix }) {
const debugServer = debug("develop:ipc:server");
const debugClient = debug("develop:ipc:client");
const debugRPC = debug("develop:ganache");
const ganacheColor = {
hex: "#ffaf5f", // ganache's color in hex
xterm: 215 // Xterm's number equivalent
};
debugRPC.color = ganacheColor.xterm;
ipcOptions.retry = ipcOptions.retry || false;
ipcOptions.log = ipcOptions.log || false;
ipcOptions.network = ipcOptions.network || "develop";
solidityLogDisplayPrefix = solidityLogDisplayPrefix || "";
var ipcNetwork = ipcOptions.network;
var ipc = new IPC();
ipc.config.appspace = "truffle.";
// set connectPath explicitly
var dirname = ipc.config.socketRoot;
var basename = `${ipc.config.appspace}${ipcNetwork}`;
var connectPath = path.join(dirname, basename);
var loggers = {};
ipc.config.silent = !debugClient.enabled;
ipc.config.logger = debugClient;
const sanitizeAndCallFn =
fn =>
(...args) => {
// HACK-y: replace `{}` that is getting logged instead of ""
if (
args.length === 1 &&
typeof args[0] === "object" &&
Object.keys(args[0]).length === 0
) {
args[0] = "";
}
fn.apply(undefined, args);
};
if (debugServer.enabled) {
loggers.ipc = debugServer;
}
// create a logger to present Ganache's console log messages
const createSolidityLogger = prefix => {
return maybeMultipleLines =>
maybeMultipleLines.split("\n").forEach(
// decorate each line's prefix.
line => console.log(chalk.hex(ganacheColor.hex)(` ${prefix}`), line)
);
};
// enable output/logger for solidity console.log
loggers.solidity = sanitizeAndCallFn(
createSolidityLogger(solidityLogDisplayPrefix)
);
if (ipcOptions.log) {
debugRPC.enabled = true;
loggers.ganache = sanitizeAndCallFn(debugRPC);
}
if (!ipcOptions.retry) {
ipc.config.maxRetries = 0;
}
var disconnect = function () {
ipc.disconnect(ipcNetwork);
};
return new Promise((resolve, reject) => {
ipc.connectTo(ipcNetwork, connectPath, function () {
ipc.of[ipcNetwork].on("destroy", function () {
reject(new Error("IPC connection destroyed"));
});
ipc.of[ipcNetwork].on("truffle.ready", function () {
resolve(disconnect);
});
Object.keys(loggers).forEach(function (key) {
var log = loggers[key];
if (log) {
var message = `truffle.${key}.log`;
ipc.of[ipcNetwork].on(message, log);
}
});
});
});
},
/**
* Connect to a managed Ganache service. This will connect to an existing
* Ganache service if one exists, or, create a new one to connect to.
*
* @param {Object} ipcOptions - IPC connection options.
* @param {string} ipcOptions.network - the network name.
* @param {Object} ganacheOptions - Ganache options if service is necessary.
* @param {string} solidityLogDisplayPrefix - solidity log messages prefix.
* @returns {Promise<Object>} - object with `disconnect` function and
* `started` boolean. The `disconnect` function is used to disconnect
* from the Ganache service. The `started` boolean is true if a new
* Ganache service was started, false otherwise.
*/
connectOrStart: async function (
ipcOptions,
ganacheOptions,
solidityLogDisplayPrefix = ""
) {
ipcOptions.retry = false;
const ipcNetwork = ipcOptions.network || "develop";
let started = false;
let disconnect;
try {
disconnect = await this.connect({ ipcOptions, solidityLogDisplayPrefix });
} catch (_error) {
await this.start(ipcNetwork, ganacheOptions);
ipcOptions.retry = true;
disconnect = await this.connect({ ipcOptions, solidityLogDisplayPrefix });
started = true;
} finally {
return {
disconnect,
started
};
}
}
};
module.exports = Develop;
/***/ }),
/***/ 53234:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const Web3 = __webpack_require__(3283);
const { createInterfaceAdapter } = __webpack_require__(36339);
const expect = __webpack_require__(14096);
const TruffleError = __webpack_require__(73321);
const { Resolver } = __webpack_require__(48511);
const Artifactor = __webpack_require__(29463);
const Ganache = __webpack_require__(11651);
const Provider = __webpack_require__(509);
const Environment = {
// It's important config is a Config object and not a vanilla object
detect: async function (config) {
expect.options(config, ["networks"]);
helpers.setUpConfig(config);
helpers.validateNetworkConfig(config);
const interfaceAdapter = createInterfaceAdapter({
provider: config.provider,
networkType: config.network_config.type
});
await Provider.testConnection(config);
await helpers.detectAndSetNetworkId(config, interfaceAdapter);
await helpers.setFromOnConfig(config, interfaceAdapter);
},
// Ensure you call Environment.detect() first.
fork: async function (config, ganacheOptions) {
expect.options(config, ["from", "provider", "networks", "network"]);
const interfaceAdapter = createInterfaceAdapter({
provider: config.provider,
networkType: config.network_config.type
});
let accounts;
try {
accounts = await interfaceAdapter.getAccounts();
} catch {
// don't prevent Truffle from working if user doesn't provide some way
// to sign transactions (e.g. no reason to disallow debugging)
accounts = [];
}
const block = await interfaceAdapter.getBlock("latest");
const upstreamNetwork = config.network;
const upstreamConfig = config.networks[upstreamNetwork];
const forkedNetwork = config.network + "-fork";
ganacheOptions = {
...ganacheOptions,
fork: config.provider,
miner: {
...ganacheOptions.miner,
blockGasLimit: block.gasLimit
}
};
if (accounts.length > 0) ganacheOptions.unlocked_accounts = accounts;
config.networks[forkedNetwork] = {
network_id: config.network_id,
provider: Ganache.provider(ganacheOptions),
from: config.from,
gas: upstreamConfig.gas,
gasPrice: upstreamConfig.gasPrice
};
config.network = forkedNetwork;
},
develop: async (config, ganacheOptions) => {
expect.options(config, ["networks"]);
const network = config.network || "develop";
const url = `http://${ganacheOptions.host}:${ganacheOptions.port}/`;
config.networks[network] = {
...config.networks[network],
network_id: ganacheOptions.network_id,
provider: function () {
return new Web3.providers.HttpProvider(url, { keepAlive: false });
}
};
config.network = network;
return await Environment.detect(config);
}
};
const helpers = {
setFromOnConfig: async (config, interfaceAdapter) => {
if (config.from) return;
try {
const accounts = await interfaceAdapter.getAccounts();
config.networks[config.network].from = accounts[0];
} catch {
// don't prevent Truffle from working if user doesn't provide some way
// to sign transactions (e.g. no reason to disallow debugging)
}
},
detectAndSetNetworkId: async (config, interfaceAdapter) => {
const configNetworkId = config.networks[config.network].network_id;
const providerNetworkId = await interfaceAdapter.getNetworkId();
if (configNetworkId !== "*") {
// Ensure the network id matches the one in the config for safety
if (providerNetworkId.toString() !== configNetworkId.toString()) {
const error =
`The network id specified in the truffle config ` +
`(${configNetworkId}) does not match the one returned by the network ` +
`(${providerNetworkId}). Ensure that both the network and the ` +
`provider are properly configured.`;
throw new Error(error);
}
} else {
// We have a "*" network. Get the current network and replace it with the real one.
// TODO: Should we replace this with the blockchain uri?
config.networks[config.network].network_id = providerNetworkId;
}
},
validateNetworkConfig: config => {
const networkConfig = config.network_config;
if (!networkConfig) {
throw new TruffleError(
`Unknown network "${config.network}` +
`". See your Truffle configuration file for available networks.`
);
}
const configNetworkId = config.network_config.network_id;
if (configNetworkId == null) {
throw new Error(
`You must specify a network_id in your '` +
`${config.network}' configuration in order to use this network.`
);
}
},
setUpConfig: config => {
if (!config.resolver) {
config.resolver = new Resolver(config);
}
if (!config.artifactor) {
config.artifactor = new Artifactor(config.contracts_build_directory);
}
if (!config.network) {
if (config.networks["development"]) {
config.network = "development";
} else {
config.network = "ganache";
config.networks[config.network] = {
host: "127.0.0.1",
port: 7545,
network_id: 5777
};
}
}
const currentNetworkSettings = config.networks[config.network];
if (
currentNetworkSettings &&
currentNetworkSettings.ens &&
currentNetworkSettings.ens.registry
) {
config.ens.registryAddress = currentNetworkSettings.ens.registry.address;
}
}
};
module.exports = Environment;
/***/ }),
/***/ 76765:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
const Environment = __webpack_require__(53234);
const Develop = __webpack_require__(86927);
module.exports = { Environment, Develop };
/***/ }),
/***/ 48511:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
;
Object.defineProperty(exports, "__esModule", ({ value: true }));
exports.Resolver = void 0;
const resolver_1 = __webpack_require__(43563);
Object.defineProperty(exports, "Resolver", ({ enumerable: true, get: function () { return resolver_1.Resolver; } }));
exports["default"] = resolver_1.Resolver;
//# sourceMappingURL=index.js.map
/***/ }),
/***/ 11651:
/***/ ((module) => {
;
module.exports = require("ganache");
/***/ }),
/***/ 44516:
/***/ ((module) => {
;
module.exports = require("original-require");
/***/ }),
/***/ 39491:
/***/ ((module) => {
;
module.exports = require("assert");
/***/ }),
/***/ 50852:
/***/ ((module) => {
;
module.exports = require("async_hooks");
/***/ }),
/***/ 14300:
/***/ ((module) => {
;
module.exports = require("buffer");
/***/ }),
/***/ 32081:
/***/ ((module) => {
;
module.exports = require("child_process");
/***/ }),
/***/ 22057:
/***/ ((module) => {
;
module.exports = require("constants");
/***/ }),
/***/ 6113:
/***/ ((module) => {
;
module.exports = require("crypto");
/***/ }),
/***/ 71891:
/***/ ((module) => {
;
module.exports = require("dgram");
/***/ }),
/***/ 82361:
/***/ ((module) => {
;
module.exports = require("events");
/***/ }),
/***/ 57147:
/***/ ((module) => {
;
module.exports = require("fs");
/***/ }),
/***/ 73292:
/***/ ((module) => {
;
module.exports = require("fs/promises");
/***/ }),
/***/ 13685:
/***/ ((module) => {
;
module.exports = require("http");
/***/ }),
/***/ 95687:
/***/ ((module) => {
;
module.exports = require("https");
/***/ }),
/***/ 98188:
/***/ ((module) => {
;
module.exports = require("module");
/***/ }),
/***/ 41808:
/***/ ((module) => {
;
module.exports = require("net");
/***/ }),
/***/ 22037:
/***/ ((module) => {
;
module.exports = require("os");
/***/ }),
/***/ 71017:
/***/ ((module) => {
;
module.exports = require("path");
/***/ }),
/***/ 85477:
/***/ ((module) => {
;
module.exports = require("punycode");
/***/ }),
/***/ 63477:
/***/ ((module) => {
;
module.exports = require("querystring");
/***/ }),
/***/ 14521:
/***/ ((module) => {
;
module.exports = require("readline");
/***/ }),
/***/ 12781:
/***/ ((module) => {
;
module.exports = require("stream");
/***/ }),
/***/ 71576:
/***/ ((module) => {
;
module.exports = require("string_decoder");
/***/ }),
/***/ 39512:
/***/ ((module) => {
;
module.exports = require("timers");
/***/ }),
/***/ 24404:
/***/ ((module) => {
;
module.exports = require("tls");
/***/ }),
/***/ 76224:
/***/ ((module) => {
;
module.exports = require("tty");
/***/ }),
/***/ 57310:
/***/ ((module) => {
;
module.exports = require("url");
/***/ }),
/***/ 73837:
/***/ ((module) => {
;
module.exports = require("util");
/***/ }),
/***/ 59796:
/***/ ((module) => {
;
module.exports = require("zlib");
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ id: moduleId,
/******/ loaded: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = __webpack_modules__;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = __webpack_module_cache__;
/******/
/******/ // the startup function
/******/ __webpack_require__.x = () => {
/******/ // Load entry module and return exports
/******/ var __webpack_exports__ = __webpack_require__.O(undefined, [5158,9129,6127,5674,6674,439,406,7657,6434,1503,1698,1833,1071,9612,3613,8834,8100,9813,5498,553,4273,102,3077,5523,8852], () => (__webpack_require__(51788)))
/******/ __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
/******/ return __webpack_exports__;
/******/ };
/******/
/************************************************************************/
/******/ /* webpack/runtime/amd options */
/******/ (() => {
/******/ __webpack_require__.amdO = {};
/******/ })();
/******/
/******/ /* webpack/runtime/chunk loaded */
/******/ (() => {
/******/ var deferred = [];
/******/ __webpack_require__.O = (result, chunkIds, fn, priority) => {
/******/ if(chunkIds) {
/******/ priority = priority || 0;
/******/ for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
/******/ deferred[i] = [chunkIds, fn, priority];
/******/ return;
/******/ }
/******/ var notFulfilled = Infinity;
/******/ for (var i = 0; i < deferred.length; i++) {
/******/ var [chunkIds, fn, priority] = deferred[i];
/******/ var fulfilled = true;
/******/ for (var j = 0; j < chunkIds.length; j++) {
/******/ if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
/******/ chunkIds.splice(j--, 1);
/******/ } else {
/******/ fulfilled = false;
/******/ if(priority < notFulfilled) notFulfilled = priority;
/******/ }
/******/ }
/******/ if(fulfilled) {
/******/ deferred.splice(i--, 1)
/******/ var r = fn();
/******/ if (r !== undefined) result = r;
/******/ }
/******/ }
/******/ return result;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/ensure chunk */
/******/ (() => {
/******/ __webpack_require__.f = {};
/******/ // This file contains only the entry chunk.
/******/ // The chunk loading function for additional chunks
/******/ __webpack_require__.e = (chunkId) => {
/******/ return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
/******/ __webpack_require__.f[key](chunkId, promises);
/******/ return promises;
/******/ }, []));
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/get javascript chunk filename */
/******/ (() => {
/******/ // This function allow to reference async chunks and sibling chunks for the entrypoint
/******/ __webpack_require__.u = (chunkId) => {
/******/ // return url for filenames based on template
/******/ return "" + chunkId + ".bundled.js";
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/node module decorator */
/******/ (() => {
/******/ __webpack_require__.nmd = (module) => {
/******/ module.paths = [];
/******/ if (!module.children) module.children = [];
/******/ return module;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/require chunk loading */
/******/ (() => {
/******/ // no baseURI
/******/
/******/ // object to store loaded chunks
/******/ // "1" means "loaded", otherwise not loaded yet
/******/ var installedChunks = {
/******/ 879: 1
/******/ };
/******/
/******/ __webpack_require__.O.require = (chunkId) => (installedChunks[chunkId]);
/******/
/******/ var installChunk = (chunk) => {
/******/ var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
/******/ for(var moduleId in moreModules) {
/******/ if(__webpack_require__.o(moreModules, moduleId)) {
/******/ __webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(runtime) runtime(__webpack_require__);
/******/ for(var i = 0; i < chunkIds.length; i++)
/******/ installedChunks[chunkIds[i]] = 1;
/******/ __webpack_require__.O();
/******/ };
/******/
/******/ // require() chunk loading for javascript
/******/ __webpack_require__.f.require = (chunkId, promises) => {
/******/ // "1" is the signal for "already loaded"
/******/ if(!installedChunks[chunkId]) {
/******/ if(true) { // all chunks have JS
/******/ installChunk(require("./" + __webpack_require__.u(chunkId)));
/******/ } else installedChunks[chunkId] = 1;
/******/ }
/******/ };
/******/
/******/ // no external install chunk
/******/
/******/ // no HMR
/******/
/******/ // no HMR manifest
/******/ })();
/******/
/******/ /* webpack/runtime/startup chunk dependencies */
/******/ (() => {
/******/ var next = __webpack_require__.x;
/******/ __webpack_require__.x = () => {
/******/ __webpack_require__.e(5158);
/******/ __webpack_require__.e(9129);
/******/ __webpack_require__.e(6127);
/******/ __webpack_require__.e(5674);
/******/ __webpack_require__.e(6674);
/******/ __webpack_require__.e(439);
/******/ __webpack_require__.e(406);
/******/ __webpack_require__.e(7657);
/******/ __webpack_require__.e(6434);
/******/ __webpack_require__.e(1503);
/******/ __webpack_require__.e(1698);
/******/ __webpack_require__.e(1833);
/******/ __webpack_require__.e(1071);
/******/ __webpack_require__.e(9612);
/******/ __webpack_require__.e(3613);
/******/ __webpack_require__.e(8834);
/******/ __webpack_require__.e(8100);
/******/ __webpack_require__.e(9813);
/******/ __webpack_require__.e(5498);
/******/ __webpack_require__.e(553);
/******/ __webpack_require__.e(4273);
/******/ __webpack_require__.e(102);
/******/ __webpack_require__.e(3077);
/******/ __webpack_require__.e(5523);
/******/ __webpack_require__.e(8852);
/******/ return next();
/******/ };
/******/ })();
/******/
/************************************************************************/
/******/
/******/ // module cache are used so entry inlining is disabled
/******/ // run startup
/******/ var __webpack_exports__ = __webpack_require__.x();
/******/ var __webpack_export_target__ = exports;
/******/ for(var i in __webpack_exports__) __webpack_export_target__[i] = __webpack_exports__[i];
/******/ if(__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });
/******/
/******/ })()
;
//# sourceMappingURL=call.bundled.js.map