alchemy-sdk
Version:
Extended Ethers.js SDK for Alchemy APIs
1,334 lines (1,319 loc) • 195 kB
JavaScript
import { formatUnits, isHexString, hexStripZeros, hexValue } from './api/utils';
import { BigNumber } from '@ethersproject/bignumber';
import axios from 'axios';
import { Provider } from '@ethersproject/abstract-provider';
import { Wallet as Wallet$1 } from '@ethersproject/wallet';
import { Contract as Contract$1, ContractFactory as ContractFactory$1 } from '@ethersproject/contracts';
/**
* The supported networks by Alchemy. Note that some functions are not available
* on all networks. Please refer to the Alchemy documentation for which APIs are
* available on which networks
* {@link https://docs.alchemy.com/alchemy/apis/feature-support-by-chain}
*
* @public
*/
var Network;
(function (Network) {
Network["ETH_MAINNET"] = "eth-mainnet";
/** @deprecated */
Network["ETH_GOERLI"] = "eth-goerli";
Network["ETH_SEPOLIA"] = "eth-sepolia";
Network["ETH_HOLESKY"] = "eth-holesky";
Network["OPT_MAINNET"] = "opt-mainnet";
/** @deprecated */
Network["OPT_GOERLI"] = "opt-goerli";
Network["OPT_SEPOLIA"] = "opt-sepolia";
Network["ARB_MAINNET"] = "arb-mainnet";
/** @deprecated */
Network["ARB_GOERLI"] = "arb-goerli";
Network["ARB_SEPOLIA"] = "arb-sepolia";
Network["MATIC_MAINNET"] = "polygon-mainnet";
/** @deprecated */
Network["MATIC_MUMBAI"] = "polygon-mumbai";
Network["MATIC_AMOY"] = "polygon-amoy";
Network["ASTAR_MAINNET"] = "astar-mainnet";
Network["POLYGONZKEVM_MAINNET"] = "polygonzkevm-mainnet";
/** @deprecated */
Network["POLYGONZKEVM_TESTNET"] = "polygonzkevm-testnet";
Network["POLYGONZKEVM_CARDONA"] = "polygonzkevm-cardona";
Network["BASE_MAINNET"] = "base-mainnet";
/** @deprecated */
Network["BASE_GOERLI"] = "base-goerli";
Network["BASE_SEPOLIA"] = "base-sepolia";
Network["ZKSYNC_MAINNET"] = "zksync-mainnet";
Network["ZKSYNC_SEPOLIA"] = "zksync-sepolia";
Network["SHAPE_MAINNET"] = "shape-mainnet";
Network["SHAPE_SEPOLIA"] = "shape-sepolia";
Network["LINEA_MAINNET"] = "linea-mainnet";
Network["LINEA_SEPOLIA"] = "linea-sepolia";
Network["FANTOM_MAINNET"] = "fantom-mainnet";
Network["FANTOM_TESTNET"] = "fantom-testnet";
Network["ZETACHAIN_MAINNET"] = "zetachain-mainnet";
Network["ZETACHAIN_TESTNET"] = "zetachain-testnet";
Network["ARBNOVA_MAINNET"] = "arbnova-mainnet";
Network["BLAST_MAINNET"] = "blast-mainnet";
Network["BLAST_SEPOLIA"] = "blast-sepolia";
Network["MANTLE_MAINNET"] = "mantle-mainnet";
Network["MANTLE_SEPOLIA"] = "mantle-sepolia";
Network["SCROLL_MAINNET"] = "scroll-mainnet";
Network["SCROLL_SEPOLIA"] = "scroll-sepolia";
Network["GNOSIS_MAINNET"] = "gnosis-mainnet";
Network["GNOSIS_CHIADO"] = "gnosis-chiado";
Network["BNB_MAINNET"] = "bnb-mainnet";
Network["BNB_TESTNET"] = "bnb-testnet";
Network["AVAX_MAINNET"] = "avax-mainnet";
Network["AVAX_FUJI"] = "avax-fuji";
Network["CELO_MAINNET"] = "celo-mainnet";
Network["CELO_ALFAJORES"] = "celo-alfajores";
Network["METIS_MAINNET"] = "metis-mainnet";
Network["OPBNB_MAINNET"] = "opbnb-mainnet";
Network["OPBNB_TESTNET"] = "opbnb-testnet";
Network["BERACHAIN_BARTIO"] = "berachain-bartio";
Network["SONEIUM_MAINNET"] = "soneium-mainnet";
Network["SONEIUM_MINATO"] = "soneium-minato";
Network["WORLDCHAIN_MAINNET"] = "worldchain-mainnet";
Network["WORLDCHAIN_SEPOLIA"] = "worldchain-sepolia";
Network["ROOTSTOCK_MAINNET"] = "rootstock-mainnet";
Network["ROOTSTOCK_TESTNET"] = "rootstock-testnet";
Network["FLOW_MAINNET"] = "flow-mainnet";
Network["FLOW_TESTNET"] = "flow-testnet";
Network["ZORA_MAINNET"] = "zora-mainnet";
Network["ZORA_SEPOLIA"] = "zora-sepolia";
Network["FRAX_MAINNET"] = "frax-mainnet";
Network["FRAX_SEPOLIA"] = "frax-sepolia";
Network["POLYNOMIAL_MAINNET"] = "polynomial-mainnet";
Network["POLYNOMIAL_SEPOLIA"] = "polynomial-sepolia";
Network["CROSSFI_MAINNET"] = "crossfi-mainnet";
Network["CROSSFI_TESTNET"] = "crossfi-testnet";
Network["APECHAIN_MAINNET"] = "apechain-mainnet";
Network["APECHAIN_CURTIS"] = "apechain-curtis";
Network["LENS_SEPOLIA"] = "lens-sepolia";
Network["GEIST_MAINNET"] = "geist-mainnet";
Network["GEIST_POLTER"] = "geist-polter";
Network["LUMIA_PRISM"] = "lumia-prism";
Network["LUMIA_TESTNET"] = "lumia-testnet";
Network["UNICHAIN_SEPOLIA"] = "unichain-sepolia";
Network["SONIC_MAINNET"] = "sonic-mainnet";
Network["SONIC_BLAZE"] = "sonic-blaze";
Network["XMTP_TESTNET"] = "xmtp-testnet";
Network["ABSTRACT_TESTNET"] = "abstract-testnet";
Network["DEGEN_MAINNET"] = "degen-mainnet";
Network["INK_MAINNET"] = "ink-mainnet";
Network["INK_SEPOLIA"] = "ink-sepolia";
})(Network || (Network = {}));
/** Token Types for the `getTokenBalances()` endpoint. */
var TokenBalanceType;
(function (TokenBalanceType) {
/**
* Option to fetch the top 100 tokens by 24-hour volume. This option is only
* available on Mainnet in Ethereum, Polygon, and Arbitrum.
*/
TokenBalanceType["DEFAULT_TOKENS"] = "DEFAULT_TOKENS";
/**
* Option to fetch the set of ERC-20 tokens that the address as ever held. his
* list is produced by an address's historical transfer activity and includes
* all tokens that the address has ever received.
*/
TokenBalanceType["ERC20"] = "erc20";
})(TokenBalanceType || (TokenBalanceType = {}));
/**
* Categories of transfers to use with the {@link AssetTransfersParams} request
* object when using {@link CoreNamespace.getAssetTransfers}.
*
* @public
*/
var AssetTransfersCategory;
(function (AssetTransfersCategory) {
/**
* Top level ETH transactions that occur where the `fromAddress` is an
* external user-created address. External addresses have private keys and are
* accessed by users.
*/
AssetTransfersCategory["EXTERNAL"] = "external";
/**
* Top level ETH transactions that occur where the `fromAddress` is an
* internal, smart contract address. For example, a smart contract calling
* another smart contract or sending
*/
AssetTransfersCategory["INTERNAL"] = "internal";
/** ERC20 transfers. */
AssetTransfersCategory["ERC20"] = "erc20";
/** ERC721 transfers. */
AssetTransfersCategory["ERC721"] = "erc721";
/** ERC1155 transfers. */
AssetTransfersCategory["ERC1155"] = "erc1155";
/** Special contracts that don't follow ERC 721/1155, (ex: CryptoKitties). */
AssetTransfersCategory["SPECIALNFT"] = "specialnft";
})(AssetTransfersCategory || (AssetTransfersCategory = {}));
/**
* The type of transfer for the request. Note that using `TO` will also include
* NFTs that were minted by the owner.
*/
var GetTransfersForOwnerTransferType;
(function (GetTransfersForOwnerTransferType) {
GetTransfersForOwnerTransferType["TO"] = "TO";
GetTransfersForOwnerTransferType["FROM"] = "FROM";
})(GetTransfersForOwnerTransferType || (GetTransfersForOwnerTransferType = {}));
/**
* Enum for representing the supported sorting orders of the API.
*
* @public
*/
var SortingOrder;
(function (SortingOrder) {
SortingOrder["ASCENDING"] = "asc";
SortingOrder["DESCENDING"] = "desc";
})(SortingOrder || (SortingOrder = {}));
/** An OpenSea collection's approval status. */
var OpenSeaSafelistRequestStatus;
(function (OpenSeaSafelistRequestStatus) {
/** Verified collection. */
OpenSeaSafelistRequestStatus["VERIFIED"] = "verified";
/** Collections that are approved on open sea and can be found in search results. */
OpenSeaSafelistRequestStatus["APPROVED"] = "approved";
/** Collections that requested safelisting on OpenSea. */
OpenSeaSafelistRequestStatus["REQUESTED"] = "requested";
/** Brand new collections. */
OpenSeaSafelistRequestStatus["NOT_REQUESTED"] = "not_requested";
})(OpenSeaSafelistRequestStatus || (OpenSeaSafelistRequestStatus = {}));
/**
* Method names for Alchemy's custom Subscription API endpoints.
*
* This value is provided in the `method` field when creating an event filter on
* the Websocket Namespace.
*/
var AlchemySubscription;
(function (AlchemySubscription) {
AlchemySubscription["PENDING_TRANSACTIONS"] = "alchemy_pendingTransactions";
AlchemySubscription["MINED_TRANSACTIONS"] = "alchemy_minedTransactions";
})(AlchemySubscription || (AlchemySubscription = {}));
/**
* Asset type returned when calling {@link TransactNamespace.simulateAssetChanges}.
* Allows you to determine if the assets approved or / and transferred are
* native, tokens or NFTs.
*/
var SimulateAssetType;
(function (SimulateAssetType) {
/**
* Native transfers that involve the currency of the chain the simulation is
* run on (ex: ETH for Ethereum, MATIC for Polygon, ETH for Arbitrum).
*/
SimulateAssetType["NATIVE"] = "NATIVE";
/** ERC20 approval or transfers. */
SimulateAssetType["ERC20"] = "ERC20";
/** ERC721 approval or transfers. */
SimulateAssetType["ERC721"] = "ERC721";
/** ERC1155 approval or transfers. */
SimulateAssetType["ERC1155"] = "ERC1155";
/**
* Special contracts that don't follow ERC 721/1155.Currently limited to
* CryptoKitties and CryptoPunks.
*/
SimulateAssetType["SPECIAL_NFT"] = "SPECIAL_NFT";
})(SimulateAssetType || (SimulateAssetType = {}));
/**
* Change type returned when calling {@link TransactNamespace.simulateAssetChanges}.
*/
var SimulateChangeType;
(function (SimulateChangeType) {
/**
* Represents a transaction that approved or disapproved permissions for a
* contract.
*
* APPROVE without token ID → approve all tokens
* APPROVE without amount → approve all amount
* APPROVE with zero amount → approval being cleared
*/
SimulateChangeType["APPROVE"] = "APPROVE";
/**
* Represents a transaction that transferred tokens from one address to another.
*/
SimulateChangeType["TRANSFER"] = "TRANSFER";
})(SimulateChangeType || (SimulateChangeType = {}));
/**
* Authority used to decode calls and logs when using the
* {@link TransactNamespace.simulateExecution} method.
*/
var DecodingAuthority;
(function (DecodingAuthority) {
DecodingAuthority["ETHERSCAN"] = "ETHERSCAN";
})(DecodingAuthority || (DecodingAuthority = {}));
/** The type of call in a debug call trace. */
var DebugCallType;
(function (DebugCallType) {
DebugCallType["CREATE"] = "CREATE";
DebugCallType["CALL"] = "CALL";
DebugCallType["STATICCALL"] = "STATICCALL";
DebugCallType["DELEGATECALL"] = "DELEGATECALL";
})(DebugCallType || (DebugCallType = {}));
/**
* Potential transaction job statuses for a {@link GasOptimizedTransactionResponse}
*
* @internal
*/
// TODO(txjob): Remove internal tag once this feature is released.
var GasOptimizedTransactionStatus;
(function (GasOptimizedTransactionStatus) {
GasOptimizedTransactionStatus["UNSPECIFIED"] = "TRANSACTION_JOB_STATUS_UNSPECIFIED";
GasOptimizedTransactionStatus["IN_PROGRESS"] = "IN_PROGRESS";
GasOptimizedTransactionStatus["COMPLETE"] = "COMPLETE";
GasOptimizedTransactionStatus["ABANDONED"] = "ABANDONED";
})(GasOptimizedTransactionStatus || (GasOptimizedTransactionStatus = {}));
/** The version of the webhook. All newly created webhooks default to V2. */
var WebhookVersion;
(function (WebhookVersion) {
WebhookVersion["V1"] = "V1";
WebhookVersion["V2"] = "V2";
})(WebhookVersion || (WebhookVersion = {}));
/** The type of {@link Webhook}. */
var WebhookType;
(function (WebhookType) {
WebhookType["MINED_TRANSACTION"] = "MINED_TRANSACTION";
WebhookType["DROPPED_TRANSACTION"] = "DROPPED_TRANSACTION";
WebhookType["ADDRESS_ACTIVITY"] = "ADDRESS_ACTIVITY";
WebhookType["NFT_ACTIVITY"] = "NFT_ACTIVITY";
WebhookType["NFT_METADATA_UPDATE"] = "NFT_METADATA_UPDATE";
WebhookType["GRAPHQL"] = "GRAPHQL";
})(WebhookType || (WebhookType = {}));
/**
* Commitment level of the target block with using methods in the
* {@link DebugNamespace}
*/
var CommitmentLevel;
(function (CommitmentLevel) {
/**
* Sample next block inferred by Alchemy built on top of the latest block.
* This contains the set of transactions taken from the local mempool and
* is a proxy for blocks that have not been mined yet.
*/
CommitmentLevel["PENDING"] = "pending";
/**
* The most recent block in the canonical chain observed by Alchemy. Note that
* this block may be re-orged out of the canonical chain.
*/
CommitmentLevel["LATEST"] = "latest";
/**
* The most recent crypto-economically secure block that cannot be re-orged
* outside of manual intervention driven by community coordination. This is
* only available on {@link Network.ETH_GOERLI} and {@link Network.ETH_SEPOLIA}.
*/
CommitmentLevel["SAFE"] = "safe";
/**
* The most recent secure block that has been accepted by >2/3 of validators.
* This block is very unlikely to be re-orged. This is only available on
* {@link Network.ETH_GOERLI} and {@link Network.ETH_SEPOLIA}.
*/
CommitmentLevel["FINALIZED"] = "finalized";
/**
* The lowest numbered block available that is usually the first block created.
*/
CommitmentLevel["EARLIEST"] = "earliest";
})(CommitmentLevel || (CommitmentLevel = {}));
/**
* The type of tracer to use when running debug methods in the
* {@link DebugNamespace}.
*/
var DebugTracerType;
(function (DebugTracerType) {
DebugTracerType["CALL_TRACER"] = "callTracer";
DebugTracerType["PRESTATE_TRACER"] = "prestateTracer";
})(DebugTracerType || (DebugTracerType = {}));
/**
* An enum for specifying the token type on NFTs.
*
* @public
*/
var NftTokenType;
(function (NftTokenType) {
NftTokenType["ERC721"] = "ERC721";
NftTokenType["ERC1155"] = "ERC1155";
NftTokenType["NO_SUPPORTED_NFT_STANDARD"] = "NO_SUPPORTED_NFT_STANDARD";
NftTokenType["NOT_A_CONTRACT"] = "NOT_A_CONTRACT";
NftTokenType["UNKNOWN"] = "UNKNOWN";
})(NftTokenType || (NftTokenType = {}));
/** Potential reasons why an NFT contract was classified as spam. */
var NftSpamClassification;
(function (NftSpamClassification) {
NftSpamClassification["Erc721TooManyOwners"] = "Erc721TooManyOwners";
NftSpamClassification["Erc721TooManyTokens"] = "Erc721TooManyTokens";
NftSpamClassification["Erc721DishonestTotalSupply"] = "Erc721DishonestTotalSupply";
NftSpamClassification["MostlyHoneyPotOwners"] = "MostlyHoneyPotOwners";
NftSpamClassification["OwnedByMostHoneyPots"] = "OwnedByMostHoneyPots";
NftSpamClassification["LowDistinctOwnersPercent"] = "LowDistinctOwnersPercent";
NftSpamClassification["HighHoneyPotOwnerPercent"] = "HighHoneyPotOwnerPercent";
NftSpamClassification["HighHoneyPotPercent"] = "HighHoneyPotPercent";
NftSpamClassification["HoneyPotsOwnMultipleTokens"] = "HoneyPotsOwnMultipleTokens";
NftSpamClassification["NoSalesActivity"] = "NoSalesActivity";
NftSpamClassification["HighAirdropPercent"] = "HighAirdropPercent";
NftSpamClassification["Unknown"] = "Unknown";
})(NftSpamClassification || (NftSpamClassification = {}));
/**
* Enum of NFT filters that can be applied to a {@link getNftsForOwner} or a
* {@link getContractsForOwner} request.
*
* @beta
*/
var NftFilters;
(function (NftFilters) {
/** NFTs that have been classified as spam. */
NftFilters["SPAM"] = "SPAM";
/** NFTs that have been airdropped to a user. */
NftFilters["AIRDROPS"] = "AIRDROPS";
})(NftFilters || (NftFilters = {}));
/**
* Enum of ordering that can be applied to a {@link getNftsForOwner} or a
* {@link getContractsForOwner} response.
*
* @beta
*/
var NftOrdering;
(function (NftOrdering) {
NftOrdering["TRANSFERTIME"] = "TRANSFERTIME";
})(NftOrdering || (NftOrdering = {}));
/**
* Enum representing the supported NFT marketplaces by the
* {@link NftNamespace.getNftSales} method.
*
* @public
*/
var NftSaleMarketplace;
(function (NftSaleMarketplace) {
NftSaleMarketplace["SEAPORT"] = "seaport";
NftSaleMarketplace["LOOKSRARE"] = "looksrare";
NftSaleMarketplace["X2Y2"] = "x2y2";
NftSaleMarketplace["WYVERN"] = "wyvern";
NftSaleMarketplace["CRYPTOPUNKS"] = "cryptopunks";
NftSaleMarketplace["BLUR"] = "blur";
NftSaleMarketplace["UNKNOWN"] = "unknown";
})(NftSaleMarketplace || (NftSaleMarketplace = {}));
/**
* Enum for specifying the taker type for the {@link NftNamespace.getNftSales}
* method.
*
* @public
*/
var NftSaleTakerType;
(function (NftSaleTakerType) {
NftSaleTakerType["BUYER"] = "buyer";
NftSaleTakerType["SELLER"] = "seller";
})(NftSaleTakerType || (NftSaleTakerType = {}));
/** The current state of the NFT contract refresh process. */
var NftRefreshState;
(function (NftRefreshState) {
/** The provided contract is not an NFT or does not contain metadata. */
NftRefreshState["DOES_NOT_EXIST"] = "does_not_exist";
/** The contract has already been queued for refresh. */
NftRefreshState["ALREADY_QUEUED"] = "already_queued";
/** The contract is currently being refreshed. */
NftRefreshState["IN_PROGRESS"] = "in_progress";
/** The contract refresh is complete. */
NftRefreshState["FINISHED"] = "finished";
/** The contract refresh has been queued and await execution. */
NftRefreshState["QUEUED"] = "queued";
/** The contract was unable to be queued due to an internal error. */
NftRefreshState["QUEUE_FAILED"] = "queue_failed";
})(NftRefreshState || (NftRefreshState = {}));
/**
* Enum representing the supported NFT marketplaces on a
* {@link NftCollectionFloorPrice} object.
*/
var NftCollectionMarketplace;
(function (NftCollectionMarketplace) {
NftCollectionMarketplace["OPENSEA"] = "OpenSea";
})(NftCollectionMarketplace || (NftCollectionMarketplace = {}));
/**
* Valid time intervals for historical price data.
*
* @public
*/
var HistoricalPriceInterval;
(function (HistoricalPriceInterval) {
/** 5-minute intervals */
HistoricalPriceInterval["FIVE_MINUTE"] = "5m";
/** 1-hour intervals */
HistoricalPriceInterval["ONE_HOUR"] = "1h";
/** 1-day intervals */
HistoricalPriceInterval["ONE_DAY"] = "1d";
})(HistoricalPriceInterval || (HistoricalPriceInterval = {}));
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter$1(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
const DEFAULT_ALCHEMY_API_KEY = 'demo';
const DEFAULT_NETWORK = Network.ETH_MAINNET;
const DEFAULT_MAX_RETRIES = 5;
const DEFAULT_REQUEST_TIMEOUT = 0; // 0 = no timeout
/**
* Returns the base URL for making Alchemy API requests. The `alchemy.com`
* endpoints only work with non eth json-rpc requests.
*
* @internal
*/
function getAlchemyHttpUrl(network, apiKey) {
return `https://${network}.g.alchemy.com/v2/${apiKey}`;
}
function getAlchemyNftHttpUrl(network, apiKey) {
return `https://${network}.g.alchemy.com/nft/v3/${apiKey}`;
}
function getAlchemyWsUrl(network, apiKey) {
return `wss://${network}.g.alchemy.com/v2/${apiKey}`;
}
function getAlchemyWebhookHttpUrl() {
return 'https://dashboard.alchemy.com/api';
}
function getPricesBaseUrl(apiKey) {
return `https://api.g.alchemy.com/prices/v1/${apiKey}`;
}
var AlchemyApiType;
(function (AlchemyApiType) {
AlchemyApiType[AlchemyApiType["BASE"] = 0] = "BASE";
AlchemyApiType[AlchemyApiType["NFT"] = 1] = "NFT";
AlchemyApiType[AlchemyApiType["WEBHOOK"] = 2] = "WEBHOOK";
AlchemyApiType[AlchemyApiType["PRICES"] = 3] = "PRICES";
})(AlchemyApiType || (AlchemyApiType = {}));
/**
* Mapping of network names to their corresponding Network strings used to
* create an Ethers.js Provider instance.
*/
const EthersNetwork = {
[Network.ETH_MAINNET]: 'mainnet',
[Network.ETH_GOERLI]: 'goerli',
[Network.ETH_SEPOLIA]: 'sepolia',
[Network.ETH_HOLESKY]: 'holesky',
[Network.OPT_MAINNET]: 'optimism',
[Network.OPT_GOERLI]: 'optimism-goerli',
[Network.OPT_SEPOLIA]: 'optimism-sepolia',
[Network.ARB_MAINNET]: 'arbitrum',
[Network.ARB_GOERLI]: 'arbitrum-goerli',
[Network.ARB_SEPOLIA]: 'arbitrum-sepolia',
[Network.MATIC_MAINNET]: 'matic',
[Network.MATIC_MUMBAI]: 'maticmum',
[Network.MATIC_AMOY]: 'maticamoy',
[Network.ASTAR_MAINNET]: 'astar-mainnet',
[Network.POLYGONZKEVM_MAINNET]: 'polygonzkevm-mainnet',
[Network.POLYGONZKEVM_TESTNET]: 'polygonzkevm-testnet',
[Network.POLYGONZKEVM_CARDONA]: 'polygonzkevm-cardona',
[Network.BASE_MAINNET]: 'base-mainnet',
[Network.BASE_GOERLI]: 'base-goerli',
[Network.BASE_SEPOLIA]: 'base-sepolia',
[Network.ZKSYNC_MAINNET]: 'zksync-mainnet',
[Network.ZKSYNC_SEPOLIA]: 'zksync-sepolia',
[Network.SHAPE_MAINNET]: 'shape-mainnet',
[Network.SHAPE_SEPOLIA]: 'shape-sepolia',
[Network.LINEA_MAINNET]: 'linea-mainnet',
[Network.LINEA_SEPOLIA]: 'linea-sepolia',
[Network.FANTOM_MAINNET]: 'fantom-mainnet',
[Network.FANTOM_TESTNET]: 'fantom-testnet',
[Network.ZETACHAIN_MAINNET]: 'zetachain-mainnet',
[Network.ZETACHAIN_TESTNET]: 'zetachain-testnet',
[Network.ARBNOVA_MAINNET]: 'arbnova-mainnet',
[Network.BLAST_MAINNET]: 'blast-mainnet',
[Network.BLAST_SEPOLIA]: 'blast-sepolia',
[Network.MANTLE_MAINNET]: 'mantle-mainnet',
[Network.MANTLE_SEPOLIA]: 'mantle-sepolia',
[Network.SCROLL_MAINNET]: 'scroll-mainnet',
[Network.SCROLL_SEPOLIA]: 'scroll-sepolia',
[Network.GNOSIS_MAINNET]: 'gnosis-mainnet',
[Network.GNOSIS_CHIADO]: 'gnosis-chiado',
[Network.BNB_MAINNET]: 'bnb-mainnet',
[Network.BNB_TESTNET]: 'bnb-testnet',
[Network.AVAX_MAINNET]: 'avax-mainnet',
[Network.AVAX_FUJI]: 'avax-fuji',
[Network.CELO_MAINNET]: 'celo-mainnet',
[Network.CELO_ALFAJORES]: 'celo-alfajores',
[Network.METIS_MAINNET]: 'metis-mainnet',
[Network.OPBNB_MAINNET]: 'opbnb-mainnet',
[Network.OPBNB_TESTNET]: 'opbnb-testnet',
[Network.BERACHAIN_BARTIO]: 'berachain-bartio',
[Network.SONEIUM_MAINNET]: 'soneium-mainnet',
[Network.SONEIUM_MINATO]: 'soneium-minato',
[Network.WORLDCHAIN_MAINNET]: 'worldchain-mainnet',
[Network.WORLDCHAIN_SEPOLIA]: 'worldchain-sepolia',
[Network.ROOTSTOCK_MAINNET]: 'rootstock-mainnet',
[Network.ROOTSTOCK_TESTNET]: 'rootstock-testnet',
[Network.FLOW_MAINNET]: 'flow-mainnet',
[Network.FLOW_TESTNET]: 'flow-testnet',
[Network.ZORA_MAINNET]: 'zora-mainnet',
[Network.ZORA_SEPOLIA]: 'zora-sepolia',
[Network.FRAX_MAINNET]: 'frax-mainnet',
[Network.FRAX_SEPOLIA]: 'frax-sepolia',
[Network.POLYNOMIAL_MAINNET]: 'polynomial-mainnet',
[Network.POLYNOMIAL_SEPOLIA]: 'polynomial-sepolia',
[Network.CROSSFI_MAINNET]: 'crossfi-mainnet',
[Network.CROSSFI_TESTNET]: 'crossfi-testnet',
[Network.APECHAIN_MAINNET]: 'apechain-mainnet',
[Network.APECHAIN_CURTIS]: 'apechain-curtis',
[Network.LENS_SEPOLIA]: 'lens-sepolia',
[Network.GEIST_MAINNET]: 'geist-mainnet',
[Network.GEIST_POLTER]: 'geist-polter',
[Network.LUMIA_PRISM]: 'lumia-prism',
[Network.LUMIA_TESTNET]: 'lumia-testnet',
[Network.UNICHAIN_SEPOLIA]: 'unichain-sepolia',
[Network.SONIC_MAINNET]: 'sonic-mainnet',
[Network.SONIC_BLAZE]: 'sonic-blaze',
[Network.XMTP_TESTNET]: 'xmtp-testnet',
[Network.ABSTRACT_TESTNET]: 'abstract-testnet',
[Network.DEGEN_MAINNET]: 'degen-mainnet',
[Network.INK_MAINNET]: 'ink-mainnet',
[Network.INK_SEPOLIA]: 'ink-sepolia'
};
/**
* Mapping of network names to their corresponding Ethers Network objects. These
* networks are not yet supported by Ethers and are listed here to be overriden
* in the provider.
*/
const CustomNetworks = {
'arbitrum-goerli': {
chainId: 421613,
name: 'arbitrum-goerli'
},
'arbitrum-sepolia': {
chainId: 421614,
name: 'arbitrum-sepolia'
},
'astar-mainnet': {
chainId: 592,
name: 'astar-mainnet'
},
sepolia: {
chainId: 11155111,
name: 'sepolia'
},
holesky: {
chainId: 17000,
name: 'holesky'
},
'optimism-sepolia': {
chainId: 11155420,
name: 'optimism-sepolia'
},
'polygonzkevm-mainnet': {
chainId: 1101,
name: 'polygonzkevm-mainnet'
},
'polygonzkevm-testnet': {
chainId: 1442,
name: 'polygonzkevm-testnet'
},
'polygonzkevm-cardona': {
chainId: 2442,
name: 'polygonzkevm-cardona'
},
'base-mainnet': {
chainId: 8453,
name: 'base-mainnet'
},
'base-goerli': {
chainId: 84531,
name: 'base-goerli'
},
'base-sepolia': {
chainId: 84532,
name: 'base-sepolia'
},
maticamoy: {
chainId: 80002,
name: 'maticamoy'
},
'zksync-mainnet': {
chainId: 324,
name: 'zksync-mainnet'
},
'zksync-sepolia': {
chainId: 300,
name: 'zksync-sepolia'
},
'shape-mainnet': {
chainId: 360,
name: 'shape-mainnet'
},
'shape-sepolia': {
chainId: 11011,
name: 'shape-sepolia'
},
'linea-mainnet': {
chainId: 59144,
name: 'linea-mainnet'
},
'linea-sepolia': {
chainId: 59141,
name: 'linea-sepolia'
},
'fantom-mainnet': {
chainId: 250,
name: 'fantom-mainnet'
},
'fantom-testnet': {
chainId: 4002,
name: 'fantom-testnet'
},
'zetachain-mainnet': {
chainId: 7000,
name: 'zetachain-mainnet'
},
'zetachain-testnet': {
chainId: 7001,
name: 'zetachain-testnet'
},
'arbnova-mainnet': {
chainId: 42170,
name: 'arbnova-mainnet'
},
'blast-mainnet': {
chainId: 81457,
name: 'blast-mainnet'
},
'blast-sepolia': {
chainId: 168587773,
name: 'blast-sepolia'
},
'mantle-mainnet': {
chainId: 5000,
name: 'mantle-mainnet'
},
'mantle-sepolia': {
chainId: 5003,
name: 'mantle-sepolia'
},
'scroll-mainnet': {
chainId: 534352,
name: 'scroll-mainnet'
},
'scroll-sepolia': {
chainId: 534351,
name: 'scroll-sepolia'
},
'gnosis-mainnet': {
chainId: 100,
name: 'gnosis-mainnet'
},
'gnosis-chiado': {
chainId: 10200,
name: 'gnosis-chiado'
},
'bnb-mainnet': {
chainId: 56,
name: 'bnb-mainnet'
},
'bnb-testnet': {
chainId: 97,
name: 'bnb-testnet'
},
'avax-mainnet': {
chainId: 43114,
name: 'avax-mainnet'
},
'avax-fuji': {
chainId: 43113,
name: 'avax-fuji'
},
'celo-mainnet': {
chainId: 42220,
name: 'celo-mainnet'
},
'celo-alfajores': {
chainId: 44787,
name: 'celo-alfajores'
},
'metis-mainnet': {
chainId: 1088,
name: 'metis-mainnet'
},
'opbnb-mainnet': {
chainId: 204,
name: 'opbnb-mainnet'
},
'opbnb-testnet': {
chainId: 5611,
name: 'opbnb-testnet'
},
'berachain-bartio': {
chainId: 80084,
name: 'berachain-bartio'
},
'soneium-mainnet': {
chainId: 1868,
name: 'soneium-mainnet'
},
'soneium-minato': {
chainId: 0x79a,
name: 'soneium-minato'
},
'worldchain-mainnet': {
chainId: 0x1e0,
name: 'worldchain-mainnet'
},
'worldchain-sepolia': {
chainId: 0x12c1,
name: 'worldchain-sepolia'
},
'rootstock-mainnet': {
chainId: 0x1e,
name: 'rootstock-mainnet'
},
'rootstock-testnet': {
chainId: 0x1f,
name: 'rootstock-testnet'
},
'flow-mainnet': {
chainId: 747,
name: 'flow-mainnet'
},
'flow-testnet': {
chainId: 545,
name: 'flow-testnet'
},
'zora-mainnet': {
chainId: 7777777,
name: 'zora-mainnet'
},
'zora-sepolia': {
chainId: 999999999,
name: 'zora-sepolia'
},
'frax-mainnet': {
chainId: 252,
name: 'frax-mainnet'
},
'frax-sepolia': {
chainId: 2522,
name: 'frax-sepolia'
},
'polynomial-mainnet': {
chainId: 8008,
name: 'polynomial-mainnet'
},
'polynomial-sepolia': {
chainId: 8009,
name: 'polynomial-sepolia'
},
'crossfi-mainnet': {
chainId: 4158,
name: 'crossfi-mainnet'
},
'crossfi-testnet': {
chainId: 4157,
name: 'crossfi-testnet'
},
'apechain-mainnet': {
chainId: 33139,
name: 'apechain-mainnet'
},
'apechain-curtis': {
chainId: 33111,
name: 'apechain-curtis'
},
'lens-sepolia': {
chainId: 0x90f7,
name: 'lens-sepolia'
},
'geist-mainnet': {
chainId: 63157,
name: 'geist-mainnet'
},
'geist-polter': {
chainId: 631571,
name: 'geist-polter'
},
'lumia-prism': {
chainId: 0x3b4c8eb9,
name: 'lumia-prism'
},
'lumia-testnet': {
chainId: 0x7467cbf8,
name: 'lumia-testnet'
},
'unichain-sepolia': {
chainId: 0x515,
name: 'unichain-sepolia'
},
'sonic-mainnet': {
chainId: 0x92,
name: 'sonic-mainnet'
},
'sonic-blaze': {
chainId: 0xdede,
name: 'sonic-blaze'
},
'xmtp-testnet': {
chainId: 241320161,
name: 'xmtp-testnet'
},
'abstract-testnet': {
chainId: 11124,
name: 'abstract-testnet'
},
'degen-mainnet': {
chainId: 0x27bc86aa,
name: 'degen-mainnet'
},
'ink-mainnet': {
chainId: 0xdef1,
name: 'ink-mainnet'
},
'ink-sepolia': {
chainId: 0xba5ed,
name: 'ink-sepolia'
}
};
function noop() {
// It's a no-op
}
const ETH_NULL_VALUE = '0x';
const ETH_NULL_ADDRESS = '0x0000000000000000000000000000000000000000';
/**
* This class holds the config information for the SDK client instance and
* exposes the underlying providers for more advanced use cases.
*
* @public
*/
class AlchemyConfig {
constructor(config) {
this.apiKey = (config === null || config === void 0 ? void 0 : config.apiKey) || DEFAULT_ALCHEMY_API_KEY;
this.network = (config === null || config === void 0 ? void 0 : config.network) || DEFAULT_NETWORK;
this.maxRetries = (config === null || config === void 0 ? void 0 : config.maxRetries) || DEFAULT_MAX_RETRIES;
this.url = config === null || config === void 0 ? void 0 : config.url;
this.authToken = config === null || config === void 0 ? void 0 : config.authToken;
this.batchRequests = (config === null || config === void 0 ? void 0 : config.batchRequests) || false;
this.requestTimeout = (config === null || config === void 0 ? void 0 : config.requestTimeout) || DEFAULT_REQUEST_TIMEOUT;
this.connectionInfoOverrides = config === null || config === void 0 ? void 0 : config.connectionInfoOverrides;
}
/**
* Returns the URL endpoint to send the HTTP request to. If a custom URL was
* provided in the config, that URL is returned. Otherwise, the default URL is
* from the network and API key.
*
* @param apiType - The type of API to get the URL for.
* @internal
*/
_getRequestUrl(apiType) {
if (this.url !== undefined) {
return this.url;
}
else if (apiType === AlchemyApiType.NFT) {
return getAlchemyNftHttpUrl(this.network, this.apiKey);
}
else if (apiType === AlchemyApiType.WEBHOOK) {
return getAlchemyWebhookHttpUrl();
}
else if (apiType === AlchemyApiType.PRICES) {
return getPricesBaseUrl(this.apiKey);
}
else {
return getAlchemyHttpUrl(this.network, this.apiKey);
}
}
/**
* Returns an AlchemyProvider instance. Only one provider is created per
* Alchemy instance.
*
* The AlchemyProvider is a wrapper around ether's `AlchemyProvider` class and
* has been expanded to support Alchemy's Enhanced APIs.
*
* Most common methods on the provider are available as top-level methods on
* the {@link Alchemy} instance, but the provider is exposed here to access
* other less-common methods.
*
* @public
*/
getProvider() {
if (!this._baseAlchemyProvider) {
this._baseAlchemyProvider = (() => __awaiter$1(this, void 0, void 0, function* () {
const { AlchemyProvider } = yield import('./alchemy-provider-8b0c3e20.js');
return new AlchemyProvider(this);
}))();
}
return this._baseAlchemyProvider;
}
/**
* Returns an AlchemyWebsocketProvider instance. Only one provider is created
* per Alchemy instance.
*
* The AlchemyWebSocketProvider is a wrapper around ether's
* `AlchemyWebSocketProvider` class and has been expanded to support Alchemy's
* Subscription APIs, automatic backfilling, and other performance improvements.
*
* Most common methods on the provider are available as top-level methods on
* the {@link Alchemy} instance, but the provider is exposed here to access
* other less-common methods.
*/
getWebSocketProvider() {
if (!this._baseAlchemyWssProvider) {
this._baseAlchemyWssProvider = (() => __awaiter$1(this, void 0, void 0, function* () {
const { AlchemyWebSocketProvider } = yield import('./alchemy-websocket-provider-948c1ea8.js');
return new AlchemyWebSocketProvider(this);
}))();
}
return this._baseAlchemyWssProvider;
}
}
const version$1 = "logger/5.7.0";
let _permanentCensorErrors = false;
let _censorErrors = false;
const LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
let _logLevel = LogLevels["default"];
let _globalLogger = null;
function _checkNormalize() {
try {
const missing = [];
// Make sure all forms of normalization are supported
["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
try {
if ("test".normalize(form) !== "test") {
throw new Error("bad normalize");
}
;
}
catch (error) {
missing.push(form);
}
});
if (missing.length) {
throw new Error("missing " + missing.join(", "));
}
if (String.fromCharCode(0xe9).normalize("NFD") !== String.fromCharCode(0x65, 0x0301)) {
throw new Error("broken implementation");
}
}
catch (error) {
return error.message;
}
return null;
}
const _normalizeError = _checkNormalize();
var LogLevel$1;
(function (LogLevel) {
LogLevel["DEBUG"] = "DEBUG";
LogLevel["INFO"] = "INFO";
LogLevel["WARNING"] = "WARNING";
LogLevel["ERROR"] = "ERROR";
LogLevel["OFF"] = "OFF";
})(LogLevel$1 || (LogLevel$1 = {}));
var ErrorCode;
(function (ErrorCode) {
///////////////////
// Generic Errors
// Unknown Error
ErrorCode["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
// Not Implemented
ErrorCode["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
// Unsupported Operation
// - operation
ErrorCode["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
// Network Error (i.e. Ethereum Network, such as an invalid chain ID)
// - event ("noNetwork" is not re-thrown in provider.ready; otherwise thrown)
ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
// Some sort of bad response from the server
ErrorCode["SERVER_ERROR"] = "SERVER_ERROR";
// Timeout
ErrorCode["TIMEOUT"] = "TIMEOUT";
///////////////////
// Operational Errors
// Buffer Overrun
ErrorCode["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
// Numeric Fault
// - operation: the operation being executed
// - fault: the reason this faulted
ErrorCode["NUMERIC_FAULT"] = "NUMERIC_FAULT";
///////////////////
// Argument Errors
// Missing new operator to an object
// - name: The name of the class
ErrorCode["MISSING_NEW"] = "MISSING_NEW";
// Invalid argument (e.g. value is incompatible with type) to a function:
// - argument: The argument name that was invalid
// - value: The value of the argument
ErrorCode["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
// Missing argument to a function:
// - count: The number of arguments received
// - expectedCount: The number of arguments expected
ErrorCode["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
// Too many arguments
// - count: The number of arguments received
// - expectedCount: The number of arguments expected
ErrorCode["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
///////////////////
// Blockchain Errors
// Call exception
// - transaction: the transaction
// - address?: the contract address
// - args?: The arguments passed into the function
// - method?: The Solidity method signature
// - errorSignature?: The EIP848 error signature
// - errorArgs?: The EIP848 error parameters
// - reason: The reason (only for EIP848 "Error(string)")
ErrorCode["CALL_EXCEPTION"] = "CALL_EXCEPTION";
// Insufficient funds (< value + gasLimit * gasPrice)
// - transaction: the transaction attempted
ErrorCode["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
// Nonce has already been used
// - transaction: the transaction attempted
ErrorCode["NONCE_EXPIRED"] = "NONCE_EXPIRED";
// The replacement fee for the transaction is too low
// - transaction: the transaction attempted
ErrorCode["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
// The gas limit could not be estimated
// - transaction: the transaction passed to estimateGas
ErrorCode["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
// The transaction was replaced by one with a higher gas price
// - reason: "cancelled", "replaced" or "repriced"
// - cancelled: true if reason == "cancelled" or reason == "replaced")
// - hash: original transaction hash
// - replacement: the full TransactionsResponse for the replacement
// - receipt: the receipt of the replacement
ErrorCode["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
///////////////////
// Interaction Errors
// The user rejected the action, such as signing a message or sending
// a transaction
ErrorCode["ACTION_REJECTED"] = "ACTION_REJECTED";
})(ErrorCode || (ErrorCode = {}));
const HEX = "0123456789abcdef";
class Logger$1 {
constructor(version) {
Object.defineProperty(this, "version", {
enumerable: true,
value: version,
writable: false
});
}
_log(logLevel, args) {
const level = logLevel.toLowerCase();
if (LogLevels[level] == null) {
this.throwArgumentError("invalid log level name", "logLevel", logLevel);
}
if (_logLevel > LogLevels[level]) {
return;
}
console.log.apply(console, args);
}
debug(...args) {
this._log(Logger$1.levels.DEBUG, args);
}
info(...args) {
this._log(Logger$1.levels.INFO, args);
}
warn(...args) {
this._log(Logger$1.levels.WARNING, args);
}
makeError(message, code, params) {
// Errors are being censored
if (_censorErrors) {
return this.makeError("censored error", code, {});
}
if (!code) {
code = Logger$1.errors.UNKNOWN_ERROR;
}
if (!params) {
params = {};
}
const messageDetails = [];
Object.keys(params).forEach((key) => {
const value = params[key];
try {
if (value instanceof Uint8Array) {
let hex = "";
for (let i = 0; i < value.length; i++) {
hex += HEX[value[i] >> 4];
hex += HEX[value[i] & 0x0f];
}
messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
}
else {
messageDetails.push(key + "=" + JSON.stringify(value));
}
}
catch (error) {
messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
}
});
messageDetails.push(`code=${code}`);
messageDetails.push(`version=${this.version}`);
const reason = message;
let url = "";
switch (code) {
case ErrorCode.NUMERIC_FAULT: {
url = "NUMERIC_FAULT";
const fault = message;
switch (fault) {
case "overflow":
case "underflow":
case "division-by-zero":
url += "-" + fault;
break;
case "negative-power":
case "negative-width":
url += "-unsupported";
break;
case "unbound-bitwise-result":
url += "-unbound-result";
break;
}
break;
}
case ErrorCode.CALL_EXCEPTION:
case ErrorCode.INSUFFICIENT_FUNDS:
case ErrorCode.MISSING_NEW:
case ErrorCode.NONCE_EXPIRED:
case ErrorCode.REPLACEMENT_UNDERPRICED:
case ErrorCode.TRANSACTION_REPLACED:
case ErrorCode.UNPREDICTABLE_GAS_LIMIT:
url = code;
break;
}
if (url) {
message += " [ See: https:/\/links.ethers.org/v5-errors-" + url + " ]";
}
if (messageDetails.length) {
message += " (" + messageDetails.join(", ") + ")";
}
// @TODO: Any??
const error = new Error(message);
error.reason = reason;
error.code = code;
Object.keys(params).forEach(function (key) {
error[key] = params[key];
});
return error;
}
throwError(message, code, params) {
throw this.makeError(message, code, params);
}
throwArgumentError(message, name, value) {
return this.throwError(message, Logger$1.errors.INVALID_ARGUMENT, {
argument: name,
value: value
});
}
assert(condition, message, code, params) {
if (!!condition) {
return;
}
this.throwError(message, code, params);
}
assertArgument(condition, message, name, value) {
if (!!condition) {
return;
}
this.throwArgumentError(message, name, value);
}
checkNormalize(message) {
if (_normalizeError) {
this.throwError("platform missing String.prototype.normalize", Logger$1.errors.UNSUPPORTED_OPERATION, {
operation: "String.prototype.normalize", form: _normalizeError
});
}
}
checkSafeUint53(value, message) {
if (typeof (value) !== "number") {
return;
}
if (message == null) {
message = "value not safe";
}
if (value < 0 || value >= 0x1fffffffffffff) {
this.throwError(message, Logger$1.errors.NUMERIC_FAULT, {
operation: "checkSafeInteger",
fault: "out-of-safe-range",
value: value
});
}
if (value % 1) {
this.throwError(message, Logger$1.errors.NUMERIC_FAULT, {
operation: "checkSafeInteger",
fault: "non-integer",
value: value
});
}
}
checkArgumentCount(count, expectedCount, message) {
if (message) {
message = ": " + message;
}
else {
message = "";
}
if (count < expectedCount) {
this.throwError("missing argument" + message, Logger$1.errors.MISSING_ARGUMENT, {
count: count,
expectedCount: expectedCount
});
}
if (count > expectedCount) {
this.throwError("too many arguments" + message, Logger$1.errors.UNEXPECTED_ARGUMENT, {
count: count,
expectedCount: expectedCount
});
}
}
checkNew(target, kind) {
if (target === Object || target == null) {
this.throwError("missing new", Logger$1.errors.MISSING_NEW, { name: kind.name });
}
}
checkAbstract(target, kind) {
if (target === kind) {
this.throwError("cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class", Logger$1.errors.UNSUPPORTED_OPERATION, { name: target.name, operation: "new" });
}
else if (target === Object || target == null) {
this.throwError("missing new", Logger$1.errors.MISSING_NEW, { name: kind.name });
}
}
static globalLogger() {
if (!_globalLogger) {
_globalLogger = new Logger$1(version$1);
}
return _globalLogger;
}
static setCensorship(censorship, permanent) {
if (!censorship && permanent) {
this.globalLogger().throwError("cannot per