shogun-core 6.5.3 → 6.5.5

package/dist/browser/shogun-core.js

@@ -58500,7 +58500,7 @@ var __webpack_exports__ = {};
 (() => {
 "use strict";
 /*!************************************!*\
-  !*** ./src/index.ts + 292 modules ***!
+  !*** ./src/index.ts + 278 modules ***!
   \************************************/
 // ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
@@ -58524,7 +58524,6 @@ __webpack_require__.d(__webpack_exports__, {
   SEA: () => (/* reexport */ (sea_default())),
   ShogunCore: () => (/* reexport */ ShogunCore),
   ShogunStorage: () => (/* reexport */ ShogunStorage),
-  SmartWalletPlugin: () => (/* reexport */ SmartWalletPlugin),
   Web3Connector: () => (/* reexport */ Web3Connector),
   Web3ConnectorPlugin: () => (/* reexport */ Web3ConnectorPlugin),
   Webauthn: () => (/* reexport */ Webauthn),
@@ -126905,3438 +126904,6 @@ var ZkCredentials = /** @class */ (function () {
 }());
 
 
-;// ./node_modules/ethers/lib.esm/providers/community.js
-/**
- *  There are many awesome community services that provide Ethereum
- *  nodes both for developers just starting out and for large-scale
- *  communities.
- *
- *  @_section: api/providers/thirdparty: Community Providers  [thirdparty]
- */
-// Show the throttle message only once per service
-const shown = new Set();
-/**
- *  Displays a warning in the console when the community resource is
- *  being used too heavily by the app, recommending the developer
- *  acquire their own credentials instead of using the community
- *  credentials.
- *
- *  The notification will only occur once per service.
- */
-function showThrottleMessage(service) {
-    if (shown.has(service)) {
-        return;
-    }
-    shown.add(service);
-    console.log("========= NOTICE =========");
-    console.log(`Request-Rate Exceeded for ${service} (this message will not be repeated)`);
-    console.log("");
-    console.log("The default API keys for each service are provided as a highly-throttled,");
-    console.log("community resource for low-traffic projects and early prototyping.");
-    console.log("");
-    console.log("While your application will continue to function, we highly recommended");
-    console.log("signing up for your own API keys to improve performance, increase your");
-    console.log("request rate/limit and enable other perks, such as metrics and advanced APIs.");
-    console.log("");
-    console.log("For more details: https:/\/docs.ethers.org/api-keys/");
-    console.log("==========================");
-}
-//# sourceMappingURL=community.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-ankr.js
-/**
- *  [[link-ankr]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Arbitrum (``arbitrum``)
- *  - Base (``base``)
- *  - Base Goerlia Testnet (``base-goerli``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - BNB (``bnb``)
- *  - BNB Testnet (``bnbt``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *
- *  @_subsection: api/providers/thirdparty:Ankr  [providers-ankr]
- */
-
-
-
-
-const defaultApiKey = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972";
-function getHost(name) {
-    switch (name) {
-        case "mainnet":
-            return "rpc.ankr.com/eth";
-        case "goerli":
-            return "rpc.ankr.com/eth_goerli";
-        case "sepolia":
-            return "rpc.ankr.com/eth_sepolia";
-        case "arbitrum":
-            return "rpc.ankr.com/arbitrum";
-        case "base":
-            return "rpc.ankr.com/base";
-        case "base-goerli":
-            return "rpc.ankr.com/base_goerli";
-        case "base-sepolia":
-            return "rpc.ankr.com/base_sepolia";
-        case "bnb":
-            return "rpc.ankr.com/bsc";
-        case "bnbt":
-            return "rpc.ankr.com/bsc_testnet_chapel";
-        case "matic":
-            return "rpc.ankr.com/polygon";
-        case "matic-mumbai":
-            return "rpc.ankr.com/polygon_mumbai";
-        case "optimism":
-            return "rpc.ankr.com/optimism";
-        case "optimism-goerli":
-            return "rpc.ankr.com/optimism_testnet";
-        case "optimism-sepolia":
-            return "rpc.ankr.com/optimism_sepolia";
-    }
-    assertArgument(false, "unsupported network", "network", name);
-}
-/**
- *  The **AnkrProvider** connects to the [[link-ankr]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-ankr-signup).
- */
-class AnkrProvider extends JsonRpcProvider {
-    /**
-     *  The API key for the Ankr connection.
-     */
-    apiKey;
-    /**
-     *  Create a new **AnkrProvider**.
-     *
-     *  By default connecting to ``mainnet`` with a highly throttled
-     *  API key.
-     */
-    constructor(_network, apiKey) {
-        if (_network == null) {
-            _network = "mainnet";
-        }
-        const network = Network.from(_network);
-        if (apiKey == null) {
-            apiKey = defaultApiKey;
-        }
-        // Ankr does not support filterId, so we force polling
-        const options = { polling: true, staticNetwork: network };
-        const request = AnkrProvider.getRequest(network, apiKey);
-        super(request, network, options);
-        defineProperties(this, { apiKey });
-    }
-    _getProvider(chainId) {
-        try {
-            return new AnkrProvider(chainId, this.apiKey);
-        }
-        catch (error) { }
-        return super._getProvider(chainId);
-    }
-    /**
-     *  Returns a prepared request for connecting to %%network%% with
-     *  %%apiKey%%.
-     */
-    static getRequest(network, apiKey) {
-        if (apiKey == null) {
-            apiKey = defaultApiKey;
-        }
-        const request = new FetchRequest(`https:/\/${getHost(network.name)}/${apiKey}`);
-        request.allowGzip = true;
-        if (apiKey === defaultApiKey) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("AnkrProvider");
-                return true;
-            };
-        }
-        return request;
-    }
-    getRpcError(payload, error) {
-        if (payload.method === "eth_sendRawTransaction") {
-            if (error && error.error && error.error.message === "INTERNAL_ERROR: could not replace existing tx") {
-                error.error.message = "replacement transaction underpriced";
-            }
-        }
-        return super.getRpcError(payload, error);
-    }
-    isCommunityResource() {
-        return (this.apiKey === defaultApiKey);
-    }
-}
-//# sourceMappingURL=provider-ankr.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-alchemy.js
-/**
- *  [[link-alchemy]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Arbitrum (``arbitrum``)
- *  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
- *  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
- *  - Base (``base``)
- *  - Base Goerlia Testnet (``base-goerli``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *  - Polygon Amoy Testnet (``matic-amoy``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *
- *  @_subsection: api/providers/thirdparty:Alchemy  [providers-alchemy]
- */
-
-
-
-
-const provider_alchemy_defaultApiKey = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
-function provider_alchemy_getHost(name) {
-    switch (name) {
-        case "mainnet":
-            return "eth-mainnet.alchemyapi.io";
-        case "goerli":
-            return "eth-goerli.g.alchemy.com";
-        case "sepolia":
-            return "eth-sepolia.g.alchemy.com";
-        case "arbitrum":
-            return "arb-mainnet.g.alchemy.com";
-        case "arbitrum-goerli":
-            return "arb-goerli.g.alchemy.com";
-        case "arbitrum-sepolia":
-            return "arb-sepolia.g.alchemy.com";
-        case "base":
-            return "base-mainnet.g.alchemy.com";
-        case "base-goerli":
-            return "base-goerli.g.alchemy.com";
-        case "base-sepolia":
-            return "base-sepolia.g.alchemy.com";
-        case "matic":
-            return "polygon-mainnet.g.alchemy.com";
-        case "matic-amoy":
-            return "polygon-amoy.g.alchemy.com";
-        case "matic-mumbai":
-            return "polygon-mumbai.g.alchemy.com";
-        case "optimism":
-            return "opt-mainnet.g.alchemy.com";
-        case "optimism-goerli":
-            return "opt-goerli.g.alchemy.com";
-        case "optimism-sepolia":
-            return "opt-sepolia.g.alchemy.com";
-    }
-    assertArgument(false, "unsupported network", "network", name);
-}
-/**
- *  The **AlchemyProvider** connects to the [[link-alchemy]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-alchemy-signup).
- *
- *  @_docloc: api/providers/thirdparty
- */
-class AlchemyProvider extends JsonRpcProvider {
-    apiKey;
-    constructor(_network, apiKey) {
-        if (_network == null) {
-            _network = "mainnet";
-        }
-        const network = Network.from(_network);
-        if (apiKey == null) {
-            apiKey = provider_alchemy_defaultApiKey;
-        }
-        const request = AlchemyProvider.getRequest(network, apiKey);
-        super(request, network, { staticNetwork: network });
-        defineProperties(this, { apiKey });
-    }
-    _getProvider(chainId) {
-        try {
-            return new AlchemyProvider(chainId, this.apiKey);
-        }
-        catch (error) { }
-        return super._getProvider(chainId);
-    }
-    async _perform(req) {
-        // https://docs.alchemy.com/reference/trace-transaction
-        if (req.method === "getTransactionResult") {
-            const { trace, tx } = await resolveProperties({
-                trace: this.send("trace_transaction", [req.hash]),
-                tx: this.getTransaction(req.hash)
-            });
-            if (trace == null || tx == null) {
-                return null;
-            }
-            let data;
-            let error = false;
-            try {
-                data = trace[0].result.output;
-                error = (trace[0].error === "Reverted");
-            }
-            catch (error) { }
-            if (data) {
-                assert(!error, "an error occurred during transaction executions", "CALL_EXCEPTION", {
-                    action: "getTransactionResult",
-                    data,
-                    reason: null,
-                    transaction: tx,
-                    invocation: null,
-                    revert: null // @TODO
-                });
-                return data;
-            }
-            assert(false, "could not parse trace result", "BAD_DATA", { value: trace });
-        }
-        return await super._perform(req);
-    }
-    isCommunityResource() {
-        return (this.apiKey === provider_alchemy_defaultApiKey);
-    }
-    static getRequest(network, apiKey) {
-        if (apiKey == null) {
-            apiKey = provider_alchemy_defaultApiKey;
-        }
-        const request = new FetchRequest(`https:/\/${provider_alchemy_getHost(network.name)}/v2/${apiKey}`);
-        request.allowGzip = true;
-        if (apiKey === provider_alchemy_defaultApiKey) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("alchemy");
-                return true;
-            };
-        }
-        return request;
-    }
-}
-//# sourceMappingURL=provider-alchemy.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-chainstack.js
-/**
- *  [[link-chainstack]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Arbitrum (``arbitrum``)
- *  - BNB Smart Chain Mainnet (``bnb``)
- *  - Polygon (``matic``)
- *
- *  @_subsection: api/providers/thirdparty:Chainstack  [providers-chainstack]
- */
-
-
-
-
-function getApiKey(name) {
-    switch (name) {
-        case "mainnet": return "39f1d67cedf8b7831010a665328c9197";
-        case "arbitrum": return "0550c209db33c3abf4cc927e1e18cea1";
-        case "bnb": return "98b5a77e531614387366f6fc5da097f8";
-        case "matic": return "cd9d4d70377471aa7c142ec4a4205249";
-    }
-    assertArgument(false, "unsupported network", "network", name);
-}
-function provider_chainstack_getHost(name) {
-    switch (name) {
-        case "mainnet":
-            return "ethereum-mainnet.core.chainstack.com";
-        case "arbitrum":
-            return "arbitrum-mainnet.core.chainstack.com";
-        case "bnb":
-            return "bsc-mainnet.core.chainstack.com";
-        case "matic":
-            return "polygon-mainnet.core.chainstack.com";
-    }
-    assertArgument(false, "unsupported network", "network", name);
-}
-/**
- *  The **ChainstackProvider** connects to the [[link-chainstack]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-chainstack).
- */
-class ChainstackProvider extends JsonRpcProvider {
-    /**
-     *  The API key for the Chainstack connection.
-     */
-    apiKey;
-    /**
-     *  Creates a new **ChainstackProvider**.
-     */
-    constructor(_network, apiKey) {
-        if (_network == null) {
-            _network = "mainnet";
-        }
-        const network = Network.from(_network);
-        if (apiKey == null) {
-            apiKey = getApiKey(network.name);
-        }
-        const request = ChainstackProvider.getRequest(network, apiKey);
-        super(request, network, { staticNetwork: network });
-        defineProperties(this, { apiKey });
-    }
-    _getProvider(chainId) {
-        try {
-            return new ChainstackProvider(chainId, this.apiKey);
-        }
-        catch (error) { }
-        return super._getProvider(chainId);
-    }
-    isCommunityResource() {
-        return (this.apiKey === getApiKey(this._network.name));
-    }
-    /**
-     *  Returns a prepared request for connecting to %%network%%
-     *  with %%apiKey%% and %%projectSecret%%.
-     */
-    static getRequest(network, apiKey) {
-        if (apiKey == null) {
-            apiKey = getApiKey(network.name);
-        }
-        const request = new FetchRequest(`https:/\/${provider_chainstack_getHost(network.name)}/${apiKey}`);
-        request.allowGzip = true;
-        if (apiKey === getApiKey(network.name)) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("ChainstackProvider");
-                return true;
-            };
-        }
-        return request;
-    }
-}
-//# sourceMappingURL=provider-chainstack.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-cloudflare.js
-/**
- *  About Cloudflare
- *
- *  @_subsection: api/providers/thirdparty:Cloudflare  [providers-cloudflare]
- */
-
-
-
-/**
- *  About Cloudflare...
- */
-class CloudflareProvider extends JsonRpcProvider {
-    constructor(_network) {
-        if (_network == null) {
-            _network = "mainnet";
-        }
-        const network = Network.from(_network);
-        assertArgument(network.name === "mainnet", "unsupported network", "network", _network);
-        super("https:/\/cloudflare-eth.com/", network, { staticNetwork: network });
-    }
-}
-//# sourceMappingURL=provider-cloudflare.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-etherscan.js
-/**
- *  [[link-etherscan]] provides a third-party service for connecting to
- *  various blockchains over a combination of JSON-RPC and custom API
- *  endpoints.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Holesky Testnet (``holesky``)
- *  - Arbitrum (``arbitrum``)
- *  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
- *  - Base (``base``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - BNB Smart Chain Mainnet (``bnb``)
- *  - BNB Smart Chain Testnet (``bnbt``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Polygon (``matic``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *  - Polygon Amoy Testnet (``matic-amoy``)
- *
- *  @_subsection api/providers/thirdparty:Etherscan  [providers-etherscan]
- */
-
-
-
-
-
-
-
-
-const THROTTLE = 2000;
-function provider_etherscan_isPromise(value) {
-    return (value && typeof (value.then) === "function");
-}
-const EtherscanPluginId = "org.ethers.plugins.provider.Etherscan";
-/**
- *  A Network can include an **EtherscanPlugin** to provide
- *  a custom base URL.
- *
- *  @_docloc: api/providers/thirdparty:Etherscan
- */
-class EtherscanPlugin extends NetworkPlugin {
-    /**
-     *  The Etherscan API base URL.
-     */
-    baseUrl;
-    /**
-     *  Creates a new **EtherscanProvider** which will use
-     *  %%baseUrl%%.
-     */
-    constructor(baseUrl) {
-        super(EtherscanPluginId);
-        defineProperties(this, { baseUrl });
-    }
-    clone() {
-        return new EtherscanPlugin(this.baseUrl);
-    }
-}
-const skipKeys = ["enableCcipRead"];
-let nextId = 1;
-/**
- *  The **EtherscanBaseProvider** is the super-class of
- *  [[EtherscanProvider]], which should generally be used instead.
- *
- *  Since the **EtherscanProvider** includes additional code for
- *  [[Contract]] access, in //rare cases// that contracts are not
- *  used, this class can reduce code size.
- *
- *  @_docloc: api/providers/thirdparty:Etherscan
- */
-class EtherscanProvider extends AbstractProvider {
-    /**
-     *  The connected network.
-     */
-    network;
-    /**
-     *  The API key or null if using the community provided bandwidth.
-     */
-    apiKey;
-    #plugin;
-    /**
-     *  Creates a new **EtherscanBaseProvider**.
-     */
-    constructor(_network, _apiKey) {
-        const apiKey = (_apiKey != null) ? _apiKey : null;
-        super();
-        const network = Network.from(_network);
-        this.#plugin = network.getPlugin(EtherscanPluginId);
-        defineProperties(this, { apiKey, network });
-    }
-    /**
-     *  Returns the base URL.
-     *
-     *  If an [[EtherscanPlugin]] is configured on the
-     *  [[EtherscanBaseProvider_network]], returns the plugin's
-     *  baseUrl.
-     *
-     *  Deprecated; for Etherscan v2 the base is no longer a simply
-     *  host, but instead a URL including a chainId parameter. Changing
-     *  this to return a URL prefix could break some libraries, so it
-     *  is left intact but will be removed in the future as it is unused.
-     */
-    getBaseUrl() {
-        if (this.#plugin) {
-            return this.#plugin.baseUrl;
-        }
-        switch (this.network.name) {
-            case "mainnet":
-                return "https:/\/api.etherscan.io";
-            case "goerli":
-                return "https:/\/api-goerli.etherscan.io";
-            case "sepolia":
-                return "https:/\/api-sepolia.etherscan.io";
-            case "holesky":
-                return "https:/\/api-holesky.etherscan.io";
-            case "arbitrum":
-                return "https:/\/api.arbiscan.io";
-            case "arbitrum-goerli":
-                return "https:/\/api-goerli.arbiscan.io";
-            case "base":
-                return "https:/\/api.basescan.org";
-            case "base-sepolia":
-                return "https:/\/api-sepolia.basescan.org";
-            case "bnb":
-                return "https:/\/api.bscscan.com";
-            case "bnbt":
-                return "https:/\/api-testnet.bscscan.com";
-            case "matic":
-                return "https:/\/api.polygonscan.com";
-            case "matic-amoy":
-                return "https:/\/api-amoy.polygonscan.com";
-            case "matic-mumbai":
-                return "https:/\/api-testnet.polygonscan.com";
-            case "optimism":
-                return "https:/\/api-optimistic.etherscan.io";
-            case "optimism-goerli":
-                return "https:/\/api-goerli-optimistic.etherscan.io";
-            default:
-        }
-        assertArgument(false, "unsupported network", "network", this.network);
-    }
-    /**
-     *  Returns the URL for the %%module%% and %%params%%.
-     */
-    getUrl(module, params) {
-        let query = Object.keys(params).reduce((accum, key) => {
-            const value = params[key];
-            if (value != null) {
-                accum += `&${key}=${value}`;
-            }
-            return accum;
-        }, "");
-        if (this.apiKey) {
-            query += `&apikey=${this.apiKey}`;
-        }
-        return `https:/\/api.etherscan.io/v2/api?chainid=${this.network.chainId}&module=${module}${query}`;
-    }
-    /**
-     *  Returns the URL for using POST requests.
-     */
-    getPostUrl() {
-        return `https:/\/api.etherscan.io/v2/api?chainid=${this.network.chainId}`;
-    }
-    /**
-     *  Returns the parameters for using POST requests.
-     */
-    getPostData(module, params) {
-        params.module = module;
-        params.apikey = this.apiKey;
-        params.chainid = this.network.chainId;
-        return params;
-    }
-    async detectNetwork() {
-        return this.network;
-    }
-    /**
-     *  Resolves to the result of calling %%module%% with %%params%%.
-     *
-     *  If %%post%%, the request is made as a POST request.
-     */
-    async fetch(module, params, post) {
-        const id = nextId++;
-        const url = (post ? this.getPostUrl() : this.getUrl(module, params));
-        const payload = (post ? this.getPostData(module, params) : null);
-        this.emit("debug", { action: "sendRequest", id, url, payload: payload });
-        const request = new FetchRequest(url);
-        request.setThrottleParams({ slotInterval: 1000 });
-        request.retryFunc = (req, resp, attempt) => {
-            if (this.isCommunityResource()) {
-                showThrottleMessage("Etherscan");
-            }
-            return Promise.resolve(true);
-        };
-        request.processFunc = async (request, response) => {
-            const result = response.hasBody() ? JSON.parse(toUtf8String(response.body)) : {};
-            const throttle = ((typeof (result.result) === "string") ? result.result : "").toLowerCase().indexOf("rate limit") >= 0;
-            if (module === "proxy") {
-                // This JSON response indicates we are being throttled
-                if (result && result.status == 0 && result.message == "NOTOK" && throttle) {
-                    this.emit("debug", { action: "receiveError", id, reason: "proxy-NOTOK", error: result });
-                    response.throwThrottleError(result.result, THROTTLE);
-                }
-            }
-            else {
-                if (throttle) {
-                    this.emit("debug", { action: "receiveError", id, reason: "null result", error: result.result });
-                    response.throwThrottleError(result.result, THROTTLE);
-                }
-            }
-            return response;
-        };
-        if (payload) {
-            request.setHeader("content-type", "application/x-www-form-urlencoded; charset=UTF-8");
-            request.body = Object.keys(payload).map((k) => `${k}=${payload[k]}`).join("&");
-        }
-        const response = await request.send();
-        try {
-            response.assertOk();
-        }
-        catch (error) {
-            this.emit("debug", { action: "receiveError", id, error, reason: "assertOk" });
-            assert(false, "response error", "SERVER_ERROR", { request, response });
-        }
-        if (!response.hasBody()) {
-            this.emit("debug", { action: "receiveError", id, error: "missing body", reason: "null body" });
-            assert(false, "missing response", "SERVER_ERROR", { request, response });
-        }
-        const result = JSON.parse(toUtf8String(response.body));
-        if (module === "proxy") {
-            if (result.jsonrpc != "2.0") {
-                this.emit("debug", { action: "receiveError", id, result, reason: "invalid JSON-RPC" });
-                assert(false, "invalid JSON-RPC response (missing jsonrpc='2.0')", "SERVER_ERROR", { request, response, info: { result } });
-            }
-            if (result.error) {
-                this.emit("debug", { action: "receiveError", id, result, reason: "JSON-RPC error" });
-                assert(false, "error response", "SERVER_ERROR", { request, response, info: { result } });
-            }
-            this.emit("debug", { action: "receiveRequest", id, result });
-            return result.result;
-        }
-        else {
-            // getLogs, getHistory have weird success responses
-            if (result.status == 0 && (result.message === "No records found" || result.message === "No transactions found")) {
-                this.emit("debug", { action: "receiveRequest", id, result });
-                return result.result;
-            }
-            if (result.status != 1 || (typeof (result.message) === "string" && !result.message.match(/^OK/))) {
-                this.emit("debug", { action: "receiveError", id, result });
-                assert(false, "error response", "SERVER_ERROR", { request, response, info: { result } });
-            }
-            this.emit("debug", { action: "receiveRequest", id, result });
-            return result.result;
-        }
-    }
-    /**
-     *  Returns %%transaction%% normalized for the Etherscan API.
-     */
-    _getTransactionPostData(transaction) {
-        const result = {};
-        for (let key in transaction) {
-            if (skipKeys.indexOf(key) >= 0) {
-                continue;
-            }
-            if (transaction[key] == null) {
-                continue;
-            }
-            let value = transaction[key];
-            if (key === "type" && value === 0) {
-                continue;
-            }
-            if (key === "blockTag" && value === "latest") {
-                continue;
-            }
-            // Quantity-types require no leading zero, unless 0
-            if ({ type: true, gasLimit: true, gasPrice: true, maxFeePerGs: true, maxPriorityFeePerGas: true, nonce: true, value: true }[key]) {
-                value = toQuantity(value);
-            }
-            else if (key === "accessList") {
-                value = "[" + accessListify(value).map((set) => {
-                    return `{address:"${set.address}",storageKeys:["${set.storageKeys.join('","')}"]}`;
-                }).join(",") + "]";
-            }
-            else if (key === "blobVersionedHashes") {
-                if (value.length === 0) {
-                    continue;
-                }
-                // @TODO: update this once the API supports blobs
-                assert(false, "Etherscan API does not support blobVersionedHashes", "UNSUPPORTED_OPERATION", {
-                    operation: "_getTransactionPostData",
-                    info: { transaction }
-                });
-            }
-            else {
-                value = hexlify(value);
-            }
-            result[key] = value;
-        }
-        return result;
-    }
-    /**
-     *  Throws the normalized Etherscan error.
-     */
-    _checkError(req, error, transaction) {
-        // Pull any message out if, possible
-        let message = "";
-        if (isError(error, "SERVER_ERROR")) {
-            // Check for an error emitted by a proxy call
-            try {
-                message = error.info.result.error.message;
-            }
-            catch (e) { }
-            if (!message) {
-                try {
-                    message = error.info.message;
-                }
-                catch (e) { }
-            }
-        }
-        if (req.method === "estimateGas") {
-            if (!message.match(/revert/i) && message.match(/insufficient funds/i)) {
-                assert(false, "insufficient funds", "INSUFFICIENT_FUNDS", {
-                    transaction: req.transaction
-                });
-            }
-        }
-        if (req.method === "call" || req.method === "estimateGas") {
-            if (message.match(/execution reverted/i)) {
-                let data = "";
-                try {
-                    data = error.info.result.error.data;
-                }
-                catch (error) { }
-                const e = AbiCoder.getBuiltinCallException(req.method, req.transaction, data);
-                e.info = { request: req, error };
-                throw e;
-            }
-        }
-        if (message) {
-            if (req.method === "broadcastTransaction") {
-                const transaction = Transaction.from(req.signedTransaction);
-                if (message.match(/replacement/i) && message.match(/underpriced/i)) {
-                    assert(false, "replacement fee too low", "REPLACEMENT_UNDERPRICED", {
-                        transaction
-                    });
-                }
-                if (message.match(/insufficient funds/)) {
-                    assert(false, "insufficient funds for intrinsic transaction cost", "INSUFFICIENT_FUNDS", {
-                        transaction
-                    });
-                }
-                if (message.match(/same hash was already imported|transaction nonce is too low|nonce too low/)) {
-                    assert(false, "nonce has already been used", "NONCE_EXPIRED", {
-                        transaction
-                    });
-                }
-            }
-        }
-        // Something we could not process
-        throw error;
-    }
-    async _detectNetwork() {
-        return this.network;
-    }
-    async _perform(req) {
-        switch (req.method) {
-            case "chainId":
-                return this.network.chainId;
-            case "getBlockNumber":
-                return this.fetch("proxy", { action: "eth_blockNumber" });
-            case "getGasPrice":
-                return this.fetch("proxy", { action: "eth_gasPrice" });
-            case "getPriorityFee":
-                // This is temporary until Etherscan completes support
-                if (this.network.name === "mainnet") {
-                    return "1000000000";
-                }
-                else if (this.network.name === "optimism") {
-                    return "1000000";
-                }
-                else {
-                    throw new Error("fallback onto the AbstractProvider default");
-                }
-            /* Working with Etherscan to get this added:
-            try {
-                const test = await this.fetch("proxy", {
-                    action: "eth_maxPriorityFeePerGas"
-                });
-                console.log(test);
-                return test;
-            } catch (e) {
-                console.log("DEBUG", e);
-                throw e;
-            }
-            */
-            /* This might be safe; but due to rounding neither myself
-               or Etherscan are necessarily comfortable with this. :)
-            try {
-                const result = await this.fetch("gastracker", { action: "gasoracle" });
-                console.log(result);
-                const gasPrice = parseUnits(result.SafeGasPrice, "gwei");
-                const baseFee = parseUnits(result.suggestBaseFee, "gwei");
-                const priorityFee = gasPrice - baseFee;
-                if (priorityFee < 0) { throw new Error("negative priority fee; defer to abstract provider default"); }
-                return priorityFee;
-            } catch (error) {
-                console.log("DEBUG", error);
-                throw error;
-            }
-            */
-            case "getBalance":
-                // Returns base-10 result
-                return this.fetch("account", {
-                    action: "balance",
-                    address: req.address,
-                    tag: req.blockTag
-                });
-            case "getTransactionCount":
-                return this.fetch("proxy", {
-                    action: "eth_getTransactionCount",
-                    address: req.address,
-                    tag: req.blockTag
-                });
-            case "getCode":
-                return this.fetch("proxy", {
-                    action: "eth_getCode",
-                    address: req.address,
-                    tag: req.blockTag
-                });
-            case "getStorage":
-                return this.fetch("proxy", {
-                    action: "eth_getStorageAt",
-                    address: req.address,
-                    position: req.position,
-                    tag: req.blockTag
-                });
-            case "broadcastTransaction":
-                return this.fetch("proxy", {
-                    action: "eth_sendRawTransaction",
-                    hex: req.signedTransaction
-                }, true).catch((error) => {
-                    return this._checkError(req, error, req.signedTransaction);
-                });
-            case "getBlock":
-                if ("blockTag" in req) {
-                    return this.fetch("proxy", {
-                        action: "eth_getBlockByNumber",
-                        tag: req.blockTag,
-                        boolean: (req.includeTransactions ? "true" : "false")
-                    });
-                }
-                assert(false, "getBlock by blockHash not supported by Etherscan", "UNSUPPORTED_OPERATION", {
-                    operation: "getBlock(blockHash)"
-                });
-            case "getTransaction":
-                return this.fetch("proxy", {
-                    action: "eth_getTransactionByHash",
-                    txhash: req.hash
-                });
-            case "getTransactionReceipt":
-                return this.fetch("proxy", {
-                    action: "eth_getTransactionReceipt",
-                    txhash: req.hash
-                });
-            case "call": {
-                if (req.blockTag !== "latest") {
-                    throw new Error("EtherscanProvider does not support blockTag for call");
-                }
-                const postData = this._getTransactionPostData(req.transaction);
-                postData.module = "proxy";
-                postData.action = "eth_call";
-                try {
-                    return await this.fetch("proxy", postData, true);
-                }
-                catch (error) {
-                    return this._checkError(req, error, req.transaction);
-                }
-            }
-            case "estimateGas": {
-                const postData = this._getTransactionPostData(req.transaction);
-                postData.module = "proxy";
-                postData.action = "eth_estimateGas";
-                try {
-                    return await this.fetch("proxy", postData, true);
-                }
-                catch (error) {
-                    return this._checkError(req, error, req.transaction);
-                }
-            }
-            /*
-                        case "getLogs": {
-                            // Needs to complain if more than one address is passed in
-                            const args: Record<string, any> = { action: "getLogs" }
-            
-                            if (params.filter.fromBlock) {
-                                args.fromBlock = checkLogTag(params.filter.fromBlock);
-                            }
-            
-                            if (params.filter.toBlock) {
-                                args.toBlock = checkLogTag(params.filter.toBlock);
-                            }
-            
-                            if (params.filter.address) {
-                                args.address = params.filter.address;
-                            }
-            
-                            // @TODO: We can handle slightly more complicated logs using the logs API
-                            if (params.filter.topics && params.filter.topics.length > 0) {
-                                if (params.filter.topics.length > 1) {
-                                    logger.throwError("unsupported topic count", Logger.Errors.UNSUPPORTED_OPERATION, { topics: params.filter.topics });
-                                }
-                                if (params.filter.topics.length === 1) {
-                                    const topic0 = params.filter.topics[0];
-                                    if (typeof(topic0) !== "string" || topic0.length !== 66) {
-                                        logger.throwError("unsupported topic format", Logger.Errors.UNSUPPORTED_OPERATION, { topic0: topic0 });
-                                    }
-                                    args.topic0 = topic0;
-                                }
-                            }
-            
-                            const logs: Array<any> = await this.fetch("logs", args);
-            
-                            // Cache txHash => blockHash
-                            let blocks: { [tag: string]: string } = {};
-            
-                            // Add any missing blockHash to the logs
-                            for (let i = 0; i < logs.length; i++) {
-                                const log = logs[i];
-                                if (log.blockHash != null) { continue; }
-                                if (blocks[log.blockNumber] == null) {
-                                    const block = await this.getBlock(log.blockNumber);
-                                    if (block) {
-                                        blocks[log.blockNumber] = block.hash;
-                                    }
-                                }
-            
-                                log.blockHash = blocks[log.blockNumber];
-                            }
-            
-                            return logs;
-                        }
-            */
-            default:
-                break;
-        }
-        return super._perform(req);
-    }
-    async getNetwork() {
-        return this.network;
-    }
-    /**
-     *  Resolves to the current price of ether.
-     *
-     *  This returns ``0`` on any network other than ``mainnet``.
-     */
-    async getEtherPrice() {
-        if (this.network.name !== "mainnet") {
-            return 0.0;
-        }
-        return parseFloat((await this.fetch("stats", { action: "ethprice" })).ethusd);
-    }
-    /**
-     *  Resolves to a [Contract]] for %%address%%, using the
-     *  Etherscan API to retreive the Contract ABI.
-     */
-    async getContract(_address) {
-        let address = this._getAddress(_address);
-        if (provider_etherscan_isPromise(address)) {
-            address = await address;
-        }
-        try {
-            const resp = await this.fetch("contract", {
-                action: "getabi", address
-            });
-            const abi = JSON.parse(resp);
-            return new Contract(address, abi, this);
-        }
-        catch (error) {
-            return null;
-        }
-    }
-    isCommunityResource() {
-        return (this.apiKey == null);
-    }
-}
-//# sourceMappingURL=provider-etherscan.js.map
-;// ./node_modules/ethers/lib.esm/providers/ws-browser.js
-function ws_browser_getGlobal() {
-    if (typeof self !== 'undefined') {
-        return self;
-    }
-    if (true) {
-        return window;
-    }
-    // removed by dead control flow
-
-    // removed by dead control flow
-
-}
-;
-const ws_browser_WebSocket = ws_browser_getGlobal().WebSocket;
-
-//# sourceMappingURL=ws-browser.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-socket.js
-/**
- *  Generic long-lived socket provider.
- *
- *  Sub-classing notes
- *  - a sub-class MUST call the `_start()` method once connected
- *  - a sub-class MUST override the `_write(string)` method
- *  - a sub-class MUST call `_processMessage(string)` for each message
- *
- *  @_subsection: api/providers/abstract-provider:Socket Providers  [about-socketProvider]
- */
-
-
-
-/**
- *  A **SocketSubscriber** uses a socket transport to handle events and
- *  should use [[_emit]] to manage the events.
- */
-class SocketSubscriber {
-    #provider;
-    #filter;
-    /**
-     *  The filter.
-     */
-    get filter() { return JSON.parse(this.#filter); }
-    #filterId;
-    #paused;
-    #emitPromise;
-    /**
-     *  Creates a new **SocketSubscriber** attached to %%provider%% listening
-     *  to %%filter%%.
-     */
-    constructor(provider, filter) {
-        this.#provider = provider;
-        this.#filter = JSON.stringify(filter);
-        this.#filterId = null;
-        this.#paused = null;
-        this.#emitPromise = null;
-    }
-    start() {
-        this.#filterId = this.#provider.send("eth_subscribe", this.filter).then((filterId) => {
-            ;
-            this.#provider._register(filterId, this);
-            return filterId;
-        });
-    }
-    stop() {
-        (this.#filterId).then((filterId) => {
-            if (this.#provider.destroyed) {
-                return;
-            }
-            this.#provider.send("eth_unsubscribe", [filterId]);
-        });
-        this.#filterId = null;
-    }
-    // @TODO: pause should trap the current blockNumber, unsub, and on resume use getLogs
-    //        and resume
-    pause(dropWhilePaused) {
-        assert(dropWhilePaused, "preserve logs while paused not supported by SocketSubscriber yet", "UNSUPPORTED_OPERATION", { operation: "pause(false)" });
-        this.#paused = !!dropWhilePaused;
-    }
-    resume() {
-        this.#paused = null;
-    }
-    /**
-     *  @_ignore:
-     */
-    _handleMessage(message) {
-        if (this.#filterId == null) {
-            return;
-        }
-        if (this.#paused === null) {
-            let emitPromise = this.#emitPromise;
-            if (emitPromise == null) {
-                emitPromise = this._emit(this.#provider, message);
-            }
-            else {
-                emitPromise = emitPromise.then(async () => {
-                    await this._emit(this.#provider, message);
-                });
-            }
-            this.#emitPromise = emitPromise.then(() => {
-                if (this.#emitPromise === emitPromise) {
-                    this.#emitPromise = null;
-                }
-            });
-        }
-    }
-    /**
-     *  Sub-classes **must** override this to emit the events on the
-     *  provider.
-     */
-    async _emit(provider, message) {
-        throw new Error("sub-classes must implemente this; _emit");
-    }
-}
-/**
- *  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
- *  ``"block"`` events.
- */
-class SocketBlockSubscriber extends SocketSubscriber {
-    /**
-     *  @_ignore:
-     */
-    constructor(provider) {
-        super(provider, ["newHeads"]);
-    }
-    async _emit(provider, message) {
-        provider.emit("block", parseInt(message.number));
-    }
-}
-/**
- *  A **SocketPendingSubscriber** listens for pending transacitons and emits
- *  ``"pending"`` events.
- */
-class SocketPendingSubscriber extends SocketSubscriber {
-    /**
-     *  @_ignore:
-     */
-    constructor(provider) {
-        super(provider, ["newPendingTransactions"]);
-    }
-    async _emit(provider, message) {
-        provider.emit("pending", message);
-    }
-}
-/**
- *  A **SocketEventSubscriber** listens for event logs.
- */
-class SocketEventSubscriber extends SocketSubscriber {
-    #logFilter;
-    /**
-     *  The filter.
-     */
-    get logFilter() { return JSON.parse(this.#logFilter); }
-    /**
-     *  @_ignore:
-     */
-    constructor(provider, filter) {
-        super(provider, ["logs", filter]);
-        this.#logFilter = JSON.stringify(filter);
-    }
-    async _emit(provider, message) {
-        provider.emit(this.logFilter, provider._wrapLog(message, provider._network));
-    }
-}
-/**
- *  A **SocketProvider** is backed by a long-lived connection over a
- *  socket, which can subscribe and receive real-time messages over
- *  its communication channel.
- */
-class SocketProvider extends JsonRpcApiProvider {
-    #callbacks;
-    // Maps each filterId to its subscriber
-    #subs;
-    // If any events come in before a subscriber has finished
-    // registering, queue them
-    #pending;
-    /**
-     *  Creates a new **SocketProvider** connected to %%network%%.
-     *
-     *  If unspecified, the network will be discovered.
-     */
-    constructor(network, _options) {
-        // Copy the options
-        const options = Object.assign({}, (_options != null) ? _options : {});
-        // Support for batches is generally not supported for
-        // connection-base providers; if this changes in the future
-        // the _send should be updated to reflect this
-        assertArgument(options.batchMaxCount == null || options.batchMaxCount === 1, "sockets-based providers do not support batches", "options.batchMaxCount", _options);
-        options.batchMaxCount = 1;
-        // Socket-based Providers (generally) cannot change their network,
-        // since they have a long-lived connection; but let people override
-        // this if they have just cause.
-        if (options.staticNetwork == null) {
-            options.staticNetwork = true;
-        }
-        super(network, options);
-        this.#callbacks = new Map();
-        this.#subs = new Map();
-        this.#pending = new Map();
-    }
-    // This value is only valid after _start has been called
-    /*
-    get _network(): Network {
-        if (this.#network == null) {
-            throw new Error("this shouldn't happen");
-        }
-        return this.#network.clone();
-    }
-    */
-    _getSubscriber(sub) {
-        switch (sub.type) {
-            case "close":
-                return new UnmanagedSubscriber("close");
-            case "block":
-                return new SocketBlockSubscriber(this);
-            case "pending":
-                return new SocketPendingSubscriber(this);
-            case "event":
-                return new SocketEventSubscriber(this, sub.filter);
-            case "orphan":
-                // Handled auto-matically within AbstractProvider
-                // when the log.removed = true
-                if (sub.filter.orphan === "drop-log") {
-                    return new UnmanagedSubscriber("drop-log");
-                }
-        }
-        return super._getSubscriber(sub);
-    }
-    /**
-     *  Register a new subscriber. This is used internalled by Subscribers
-     *  and generally is unecessary unless extending capabilities.
-     */
-    _register(filterId, subscriber) {
-        this.#subs.set(filterId, subscriber);
-        const pending = this.#pending.get(filterId);
-        if (pending) {
-            for (const message of pending) {
-                subscriber._handleMessage(message);
-            }
-            this.#pending.delete(filterId);
-        }
-    }
-    async _send(payload) {
-        // WebSocket provider doesn't accept batches
-        assertArgument(!Array.isArray(payload), "WebSocket does not support batch send", "payload", payload);
-        // @TODO: stringify payloads here and store to prevent mutations
-        // Prepare a promise to respond to
-        const promise = new Promise((resolve, reject) => {
-            this.#callbacks.set(payload.id, { payload, resolve, reject });
-        });
-        // Wait until the socket is connected before writing to it
-        await this._waitUntilReady();
-        // Write the request to the socket
-        await this._write(JSON.stringify(payload));
-        return [await promise];
-    }
-    // Sub-classes must call this once they are connected
-    /*
-    async _start(): Promise<void> {
-        if (this.#ready) { return; }
-
-        for (const { payload } of this.#callbacks.values()) {
-            await this._write(JSON.stringify(payload));
-        }
-
-        this.#ready = (async function() {
-            await super._start();
-        })();
-    }
-    */
-    /**
-     *  Sub-classes **must** call this with messages received over their
-     *  transport to be processed and dispatched.
-     */
-    async _processMessage(message) {
-        const result = (JSON.parse(message));
-        if (result && typeof (result) === "object" && "id" in result) {
-            const callback = this.#callbacks.get(result.id);
-            if (callback == null) {
-                this.emit("error", makeError("received result for unknown id", "UNKNOWN_ERROR", {
-                    reasonCode: "UNKNOWN_ID",
-                    result
-                }));
-                return;
-            }
-            this.#callbacks.delete(result.id);
-            callback.resolve(result);
-        }
-        else if (result && result.method === "eth_subscription") {
-            const filterId = result.params.subscription;
-            const subscriber = this.#subs.get(filterId);
-            if (subscriber) {
-                subscriber._handleMessage(result.params.result);
-            }
-            else {
-                let pending = this.#pending.get(filterId);
-                if (pending == null) {
-                    pending = [];
-                    this.#pending.set(filterId, pending);
-                }
-                pending.push(result.params.result);
-            }
-        }
-        else {
-            this.emit("error", makeError("received unexpected message", "UNKNOWN_ERROR", {
-                reasonCode: "UNEXPECTED_MESSAGE",
-                result
-            }));
-            return;
-        }
-    }
-    /**
-     *  Sub-classes **must** override this to send %%message%% over their
-     *  transport.
-     */
-    async _write(message) {
-        throw new Error("sub-classes must override this");
-    }
-}
-//# sourceMappingURL=provider-socket.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-websocket.js
- /*-browser*/
-
-/**
- *  A JSON-RPC provider which is backed by a WebSocket.
- *
- *  WebSockets are often preferred because they retain a live connection
- *  to a server, which permits more instant access to events.
- *
- *  However, this incurs higher server infrasturture costs, so additional
- *  resources may be required to host your own WebSocket nodes and many
- *  third-party services charge additional fees for WebSocket endpoints.
- */
-class WebSocketProvider extends SocketProvider {
-    #connect;
-    #websocket;
-    get websocket() {
-        if (this.#websocket == null) {
-            throw new Error("websocket closed");
-        }
-        return this.#websocket;
-    }
-    constructor(url, network, options) {
-        super(network, options);
-        if (typeof (url) === "string") {
-            this.#connect = () => { return new ws_browser_WebSocket(url); };
-            this.#websocket = this.#connect();
-        }
-        else if (typeof (url) === "function") {
-            this.#connect = url;
-            this.#websocket = url();
-        }
-        else {
-            this.#connect = null;
-            this.#websocket = url;
-        }
-        this.websocket.onopen = async () => {
-            try {
-                await this._start();
-                this.resume();
-            }
-            catch (error) {
-                console.log("failed to start WebsocketProvider", error);
-                // @TODO: now what? Attempt reconnect?
-            }
-        };
-        this.websocket.onmessage = (message) => {
-            this._processMessage(message.data);
-        };
-        /*
-                this.websocket.onclose = (event) => {
-                    // @TODO: What event.code should we reconnect on?
-                    const reconnect = false;
-                    if (reconnect) {
-                        this.pause(true);
-                        if (this.#connect) {
-                            this.#websocket = this.#connect();
-                            this.#websocket.onopen = ...
-                            // @TODO: this requires the super class to rebroadcast; move it there
-                        }
-                        this._reconnect();
-                    }
-                };
-        */
-    }
-    async _write(message) {
-        this.websocket.send(message);
-    }
-    async destroy() {
-        if (this.#websocket != null) {
-            this.#websocket.close();
-            this.#websocket = null;
-        }
-        super.destroy();
-    }
-}
-//# sourceMappingURL=provider-websocket.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-infura.js
-/**
- *  [[link-infura]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Arbitrum (``arbitrum``)
- *  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
- *  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
- *  - Base (``base``)
- *  - Base Goerlia Testnet (``base-goerli``)
- *  - Base Sepolia Testnet (``base-sepolia``)
- *  - BNB Smart Chain Mainnet (``bnb``)
- *  - BNB Smart Chain Testnet (``bnbt``)
- *  - Linea (``linea``)
- *  - Linea Goerli Testnet (``linea-goerli``)
- *  - Linea Sepolia Testnet (``linea-sepolia``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *  - Polygon Amoy Testnet (``matic-amoy``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *
- *  @_subsection: api/providers/thirdparty:INFURA  [providers-infura]
- */
-
-
-
-
-
-const defaultProjectId = "84842078b09946638c03157f83405213";
-function provider_infura_getHost(name) {
-    switch (name) {
-        case "mainnet":
-            return "mainnet.infura.io";
-        case "goerli":
-            return "goerli.infura.io";
-        case "sepolia":
-            return "sepolia.infura.io";
-        case "arbitrum":
-            return "arbitrum-mainnet.infura.io";
-        case "arbitrum-goerli":
-            return "arbitrum-goerli.infura.io";
-        case "arbitrum-sepolia":
-            return "arbitrum-sepolia.infura.io";
-        case "base":
-            return "base-mainnet.infura.io";
-        case "base-goerlia": // @TODO: Remove this typo in the future!
-        case "base-goerli":
-            return "base-goerli.infura.io";
-        case "base-sepolia":
-            return "base-sepolia.infura.io";
-        case "bnb":
-            return "bsc-mainnet.infura.io";
-        case "bnbt":
-            return "bsc-testnet.infura.io";
-        case "linea":
-            return "linea-mainnet.infura.io";
-        case "linea-goerli":
-            return "linea-goerli.infura.io";
-        case "linea-sepolia":
-            return "linea-sepolia.infura.io";
-        case "matic":
-            return "polygon-mainnet.infura.io";
-        case "matic-amoy":
-            return "polygon-amoy.infura.io";
-        case "matic-mumbai":
-            return "polygon-mumbai.infura.io";
-        case "optimism":
-            return "optimism-mainnet.infura.io";
-        case "optimism-goerli":
-            return "optimism-goerli.infura.io";
-        case "optimism-sepolia":
-            return "optimism-sepolia.infura.io";
-    }
-    assertArgument(false, "unsupported network", "network", name);
-}
-/**
- *  The **InfuraWebSocketProvider** connects to the [[link-infura]]
- *  WebSocket end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-infura-signup).
- */
-class InfuraWebSocketProvider extends WebSocketProvider {
-    /**
-     *  The Project ID for the INFURA connection.
-     */
-    projectId;
-    /**
-     *  The Project Secret.
-     *
-     *  If null, no authenticated requests are made. This should not
-     *  be used outside of private contexts.
-     */
-    projectSecret;
-    /**
-     *  Creates a new **InfuraWebSocketProvider**.
-     */
-    constructor(network, projectId) {
-        const provider = new InfuraProvider(network, projectId);
-        const req = provider._getConnection();
-        assert(!req.credentials, "INFURA WebSocket project secrets unsupported", "UNSUPPORTED_OPERATION", { operation: "InfuraProvider.getWebSocketProvider()" });
-        const url = req.url.replace(/^http/i, "ws").replace("/v3/", "/ws/v3/");
-        super(url, provider._network);
-        defineProperties(this, {
-            projectId: provider.projectId,
-            projectSecret: provider.projectSecret
-        });
-    }
-    isCommunityResource() {
-        return (this.projectId === defaultProjectId);
-    }
-}
-/**
- *  The **InfuraProvider** connects to the [[link-infura]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API key is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-infura-signup).
- */
-class InfuraProvider extends JsonRpcProvider {
-    /**
-     *  The Project ID for the INFURA connection.
-     */
-    projectId;
-    /**
-     *  The Project Secret.
-     *
-     *  If null, no authenticated requests are made. This should not
-     *  be used outside of private contexts.
-     */
-    projectSecret;
-    /**
-     *  Creates a new **InfuraProvider**.
-     */
-    constructor(_network, projectId, projectSecret) {
-        if (_network == null) {
-            _network = "mainnet";
-        }
-        const network = Network.from(_network);
-        if (projectId == null) {
-            projectId = defaultProjectId;
-        }
-        if (projectSecret == null) {
-            projectSecret = null;
-        }
-        const request = InfuraProvider.getRequest(network, projectId, projectSecret);
-        super(request, network, { staticNetwork: network });
-        defineProperties(this, { projectId, projectSecret });
-    }
-    _getProvider(chainId) {
-        try {
-            return new InfuraProvider(chainId, this.projectId, this.projectSecret);
-        }
-        catch (error) { }
-        return super._getProvider(chainId);
-    }
-    isCommunityResource() {
-        return (this.projectId === defaultProjectId);
-    }
-    /**
-     *  Creates a new **InfuraWebSocketProvider**.
-     */
-    static getWebSocketProvider(network, projectId) {
-        return new InfuraWebSocketProvider(network, projectId);
-    }
-    /**
-     *  Returns a prepared request for connecting to %%network%%
-     *  with %%projectId%% and %%projectSecret%%.
-     */
-    static getRequest(network, projectId, projectSecret) {
-        if (projectId == null) {
-            projectId = defaultProjectId;
-        }
-        if (projectSecret == null) {
-            projectSecret = null;
-        }
-        const request = new FetchRequest(`https:/\/${provider_infura_getHost(network.name)}/v3/${projectId}`);
-        request.allowGzip = true;
-        if (projectSecret) {
-            request.setCredentials("", projectSecret);
-        }
-        if (projectId === defaultProjectId) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("InfuraProvider");
-                return true;
-            };
-        }
-        return request;
-    }
-}
-//# sourceMappingURL=provider-infura.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-quicknode.js
-/**
- *  [[link-quicknode]] provides a third-party service for connecting to
- *  various blockchains over JSON-RPC.
- *
- *  **Supported Networks**
- *
- *  - Ethereum Mainnet (``mainnet``)
- *  - Goerli Testnet (``goerli``)
- *  - Sepolia Testnet (``sepolia``)
- *  - Holesky Testnet (``holesky``)
- *  - Arbitrum (``arbitrum``)
- *  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
- *  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
- *  - Base Mainnet (``base``);
- *  - Base Goerli Testnet (``base-goerli``);
- *  - Base Sepolia Testnet (``base-sepolia``);
- *  - BNB Smart Chain Mainnet (``bnb``)
- *  - BNB Smart Chain Testnet (``bnbt``)
- *  - Optimism (``optimism``)
- *  - Optimism Goerli Testnet (``optimism-goerli``)
- *  - Optimism Sepolia Testnet (``optimism-sepolia``)
- *  - Polygon (``matic``)
- *  - Polygon Mumbai Testnet (``matic-mumbai``)
- *
- *  @_subsection: api/providers/thirdparty:QuickNode  [providers-quicknode]
- */
-
-
-
-
-const defaultToken = "919b412a057b5e9c9b6dce193c5a60242d6efadb";
-function provider_quicknode_getHost(name) {
-    switch (name) {
-        case "mainnet":
-            return "ethers.quiknode.pro";
-        case "goerli":
-            return "ethers.ethereum-goerli.quiknode.pro";
-        case "sepolia":
-            return "ethers.ethereum-sepolia.quiknode.pro";
-        case "holesky":
-            return "ethers.ethereum-holesky.quiknode.pro";
-        case "arbitrum":
-            return "ethers.arbitrum-mainnet.quiknode.pro";
-        case "arbitrum-goerli":
-            return "ethers.arbitrum-goerli.quiknode.pro";
-        case "arbitrum-sepolia":
-            return "ethers.arbitrum-sepolia.quiknode.pro";
-        case "base":
-            return "ethers.base-mainnet.quiknode.pro";
-        case "base-goerli":
-            return "ethers.base-goerli.quiknode.pro";
-        case "base-spolia":
-            return "ethers.base-sepolia.quiknode.pro";
-        case "bnb":
-            return "ethers.bsc.quiknode.pro";
-        case "bnbt":
-            return "ethers.bsc-testnet.quiknode.pro";
-        case "matic":
-            return "ethers.matic.quiknode.pro";
-        case "matic-mumbai":
-            return "ethers.matic-testnet.quiknode.pro";
-        case "optimism":
-            return "ethers.optimism.quiknode.pro";
-        case "optimism-goerli":
-            return "ethers.optimism-goerli.quiknode.pro";
-        case "optimism-sepolia":
-            return "ethers.optimism-sepolia.quiknode.pro";
-        case "xdai":
-            return "ethers.xdai.quiknode.pro";
-    }
-    assertArgument(false, "unsupported network", "network", name);
-}
-/*
-@TODO:
-  These networks are not currently present in the Network
-  default included networks. Research them and ensure they
-  are EVM compatible and work with ethers
-
-  http://ethers.matic-amoy.quiknode.pro
-
-  http://ethers.avalanche-mainnet.quiknode.pro
-  http://ethers.avalanche-testnet.quiknode.pro
-  http://ethers.blast-sepolia.quiknode.pro
-  http://ethers.celo-mainnet.quiknode.pro
-  http://ethers.fantom.quiknode.pro
-  http://ethers.imx-demo.quiknode.pro
-  http://ethers.imx-mainnet.quiknode.pro
-  http://ethers.imx-testnet.quiknode.pro
-  http://ethers.near-mainnet.quiknode.pro
-  http://ethers.near-testnet.quiknode.pro
-  http://ethers.nova-mainnet.quiknode.pro
-  http://ethers.scroll-mainnet.quiknode.pro
-  http://ethers.scroll-testnet.quiknode.pro
-  http://ethers.tron-mainnet.quiknode.pro
-  http://ethers.zkevm-mainnet.quiknode.pro
-  http://ethers.zkevm-testnet.quiknode.pro
-  http://ethers.zksync-mainnet.quiknode.pro
-  http://ethers.zksync-testnet.quiknode.pro
-*/
-/**
- *  The **QuickNodeProvider** connects to the [[link-quicknode]]
- *  JSON-RPC end-points.
- *
- *  By default, a highly-throttled API token is used, which is
- *  appropriate for quick prototypes and simple scripts. To
- *  gain access to an increased rate-limit, it is highly
- *  recommended to [sign up here](link-quicknode).
- */
-class QuickNodeProvider extends JsonRpcProvider {
-    /**
-     *  The API token.
-     */
-    token;
-    /**
-     *  Creates a new **QuickNodeProvider**.
-     */
-    constructor(_network, token) {
-        if (_network == null) {
-            _network = "mainnet";
-        }
-        const network = Network.from(_network);
-        if (token == null) {
-            token = defaultToken;
-        }
-        const request = QuickNodeProvider.getRequest(network, token);
-        super(request, network, { staticNetwork: network });
-        defineProperties(this, { token });
-    }
-    _getProvider(chainId) {
-        try {
-            return new QuickNodeProvider(chainId, this.token);
-        }
-        catch (error) { }
-        return super._getProvider(chainId);
-    }
-    isCommunityResource() {
-        return (this.token === defaultToken);
-    }
-    /**
-     *  Returns a new request prepared for %%network%% and the
-     *  %%token%%.
-     */
-    static getRequest(network, token) {
-        if (token == null) {
-            token = defaultToken;
-        }
-        const request = new FetchRequest(`https:/\/${provider_quicknode_getHost(network.name)}/${token}`);
-        request.allowGzip = true;
-        //if (projectSecret) { request.setCredentials("", projectSecret); }
-        if (token === defaultToken) {
-            request.retryFunc = async (request, response, attempt) => {
-                showThrottleMessage("QuickNodeProvider");
-                return true;
-            };
-        }
-        return request;
-    }
-}
-//# sourceMappingURL=provider-quicknode.js.map
-;// ./node_modules/ethers/lib.esm/providers/provider-fallback.js
-/**
- *  A **FallbackProvider** provides resilience, security and performance
- *  in a way that is customizable and configurable.
- *
- *  @_section: api/providers/fallback-provider:Fallback Provider [about-fallback-provider]
- */
-
-
-
-const provider_fallback_BN_1 = BigInt("1");
-const provider_fallback_BN_2 = BigInt("2");
-function shuffle(array) {
-    for (let i = array.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        const tmp = array[i];
-        array[i] = array[j];
-        array[j] = tmp;
-    }
-}
-function provider_fallback_stall(duration) {
-    return new Promise((resolve) => { setTimeout(resolve, duration); });
-}
-function provider_fallback_getTime() { return (new Date()).getTime(); }
-function provider_fallback_stringify(value) {
-    return JSON.stringify(value, (key, value) => {
-        if (typeof (value) === "bigint") {
-            return { type: "bigint", value: value.toString() };
-        }
-        return value;
-    });
-}
-;
-const defaultConfig = { stallTimeout: 400, priority: 1, weight: 1 };
-const defaultState = {
-    blockNumber: -2, requests: 0, lateResponses: 0, errorResponses: 0,
-    outOfSync: -1, unsupportedEvents: 0, rollingDuration: 0, score: 0,
-    _network: null, _updateNumber: null, _totalTime: 0,
-    _lastFatalError: null, _lastFatalErrorTimestamp: 0
-};
-async function waitForSync(config, blockNumber) {
-    while (config.blockNumber < 0 || config.blockNumber < blockNumber) {
-        if (!config._updateNumber) {
-            config._updateNumber = (async () => {
-                try {
-                    const blockNumber = await config.provider.getBlockNumber();
-                    if (blockNumber > config.blockNumber) {
-                        config.blockNumber = blockNumber;
-                    }
-                }
-                catch (error) {
-                    config.blockNumber = -2;
-                    config._lastFatalError = error;
-                    config._lastFatalErrorTimestamp = provider_fallback_getTime();
-                }
-                config._updateNumber = null;
-            })();
-        }
-        await config._updateNumber;
-        config.outOfSync++;
-        if (config._lastFatalError) {
-            break;
-        }
-    }
-}
-function _normalize(value) {
-    if (value == null) {
-        return "null";
-    }
-    if (Array.isArray(value)) {
-        return "[" + (value.map(_normalize)).join(",") + "]";
-    }
-    if (typeof (value) === "object" && typeof (value.toJSON) === "function") {
-        return _normalize(value.toJSON());
-    }
-    switch (typeof (value)) {
-        case "boolean":
-        case "symbol":
-            return value.toString();
-        case "bigint":
-        case "number":
-            return BigInt(value).toString();
-        case "string":
-            return JSON.stringify(value);
-        case "object": {
-            const keys = Object.keys(value);
-            keys.sort();
-            return "{" + keys.map((k) => `${JSON.stringify(k)}:${_normalize(value[k])}`).join(",") + "}";
-        }
-    }
-    console.log("Could not serialize", value);
-    throw new Error("Hmm...");
-}
-function normalizeResult(method, value) {
-    if ("error" in value) {
-        const error = value.error;
-        let tag;
-        if (isError(error, "CALL_EXCEPTION")) {
-            tag = _normalize(Object.assign({}, error, {
-                shortMessage: undefined, reason: undefined, info: undefined
-            }));
-        }
-        else {
-            tag = _normalize(error);
-        }
-        return { tag, value: error };
-    }
-    const result = value.result;
-    return { tag: _normalize(result), value: result };
-}
-// This strategy picks the highest weight result, as long as the weight is
-// equal to or greater than quorum
-function checkQuorum(quorum, results) {
-    const tally = new Map();
-    for (const { value, tag, weight } of results) {
-        const t = tally.get(tag) || { value, weight: 0 };
-        t.weight += weight;
-        tally.set(tag, t);
-    }
-    let best = null;
-    for (const r of tally.values()) {
-        if (r.weight >= quorum && (!best || r.weight > best.weight)) {
-            best = r;
-        }
-    }
-    if (best) {
-        return best.value;
-    }
-    return undefined;
-}
-function getMedian(quorum, results) {
-    let resultWeight = 0;
-    const errorMap = new Map();
-    let bestError = null;
-    const values = [];
-    for (const { value, tag, weight } of results) {
-        if (value instanceof Error) {
-            const e = errorMap.get(tag) || { value, weight: 0 };
-            e.weight += weight;
-            errorMap.set(tag, e);
-            if (bestError == null || e.weight > bestError.weight) {
-                bestError = e;
-            }
-        }
-        else {
-            values.push(BigInt(value));
-            resultWeight += weight;
-        }
-    }
-    if (resultWeight < quorum) {
-        // We have quorum for an error
-        if (bestError && bestError.weight >= quorum) {
-            return bestError.value;
-        }
-        // We do not have quorum for a result
-        return undefined;
-    }
-    // Get the sorted values
-    values.sort((a, b) => ((a < b) ? -1 : (b > a) ? 1 : 0));
-    const mid = Math.floor(values.length / 2);
-    // Odd-length; take the middle value
-    if (values.length % 2) {
-        return values[mid];
-    }
-    // Even length; take the ceiling of the mean of the center two values
-    return (values[mid - 1] + values[mid] + provider_fallback_BN_1) / provider_fallback_BN_2;
-}
-function getAnyResult(quorum, results) {
-    // If any value or error meets quorum, that is our preferred result
-    const result = checkQuorum(quorum, results);
-    if (result !== undefined) {
-        return result;
-    }
-    // Otherwise, do we have any result?
-    for (const r of results) {
-        if (r.value) {
-            return r.value;
-        }
-    }
-    // Nope!
-    return undefined;
-}
-function getFuzzyMode(quorum, results) {
-    if (quorum === 1) {
-        return getNumber(getMedian(quorum, results), "%internal");
-    }
-    const tally = new Map();
-    const add = (result, weight) => {
-        const t = tally.get(result) || { result, weight: 0 };
-        t.weight += weight;
-        tally.set(result, t);
-    };
-    for (const { weight, value } of results) {
-        const r = getNumber(value);
-        add(r - 1, weight);
-        add(r, weight);
-        add(r + 1, weight);
-    }
-    let bestWeight = 0;
-    let bestResult = undefined;
-    for (const { weight, result } of tally.values()) {
-        // Use this result, if this result meets quorum and has either:
-        // - a better weight
-        // - or equal weight, but the result is larger
-        if (weight >= quorum && (weight > bestWeight || (bestResult != null && weight === bestWeight && result > bestResult))) {
-            bestWeight = weight;
-            bestResult = result;
-        }
-    }
-    return bestResult;
-}
-/**
- *  A **FallbackProvider** manages several [[Providers]] providing
- *  resilience by switching between slow or misbehaving nodes, security
- *  by requiring multiple backends to aggree and performance by allowing
- *  faster backends to respond earlier.
- *
- */
-class FallbackProvider extends AbstractProvider {
-    /**
-     *  The number of backends that must agree on a value before it is
-     *  accpeted.
-     */
-    quorum;
-    /**
-     *  @_ignore:
-     */
-    eventQuorum;
-    /**
-     *  @_ignore:
-     */
-    eventWorkers;
-    #configs;
-    #height;
-    #initialSyncPromise;
-    /**
-     *  Creates a new **FallbackProvider** with %%providers%% connected to
-     *  %%network%%.
-     *
-     *  If a [[Provider]] is included in %%providers%%, defaults are used
-     *  for the configuration.
-     */
-    constructor(providers, network, options) {
-        super(network, options);
-        this.#configs = providers.map((p) => {
-            if (p instanceof AbstractProvider) {
-                return Object.assign({ provider: p }, defaultConfig, defaultState);
-            }
-            else {
-                return Object.assign({}, defaultConfig, p, defaultState);
-            }
-        });
-        this.#height = -2;
-        this.#initialSyncPromise = null;
-        if (options && options.quorum != null) {
-            this.quorum = options.quorum;
-        }
-        else {
-            this.quorum = Math.ceil(this.#configs.reduce((accum, config) => {
-                accum += config.weight;
-                return accum;
-            }, 0) / 2);
-        }
-        this.eventQuorum = 1;
-        this.eventWorkers = 1;
-        assertArgument(this.quorum <= this.#configs.reduce((a, c) => (a + c.weight), 0), "quorum exceed provider weight", "quorum", this.quorum);
-    }
-    get providerConfigs() {
-        return this.#configs.map((c) => {
-            const result = Object.assign({}, c);
-            for (const key in result) {
-                if (key[0] === "_") {
-                    delete result[key];
-                }
-            }
-            return result;
-        });
-    }
-    async _detectNetwork() {
-        return Network.from(getBigInt(await this._perform({ method: "chainId" })));
-    }
-    // @TODO: Add support to select providers to be the event subscriber
-    //_getSubscriber(sub: Subscription): Subscriber {
-    //    throw new Error("@TODO");
-    //}
-    /**
-     *  Transforms a %%req%% into the correct method call on %%provider%%.
-     */
-    async _translatePerform(provider, req) {
-        switch (req.method) {
-            case "broadcastTransaction":
-                return await provider.broadcastTransaction(req.signedTransaction);
-            case "call":
-                return await provider.call(Object.assign({}, req.transaction, { blockTag: req.blockTag }));
-            case "chainId":
-                return (await provider.getNetwork()).chainId;
-            case "estimateGas":
-                return await provider.estimateGas(req.transaction);
-            case "getBalance":
-                return await provider.getBalance(req.address, req.blockTag);
-            case "getBlock": {
-                const block = ("blockHash" in req) ? req.blockHash : req.blockTag;
-                return await provider.getBlock(block, req.includeTransactions);
-            }
-            case "getBlockNumber":
-                return await provider.getBlockNumber();
-            case "getCode":
-                return await provider.getCode(req.address, req.blockTag);
-            case "getGasPrice":
-                return (await provider.getFeeData()).gasPrice;
-            case "getPriorityFee":
-                return (await provider.getFeeData()).maxPriorityFeePerGas;
-            case "getLogs":
-                return await provider.getLogs(req.filter);
-            case "getStorage":
-                return await provider.getStorage(req.address, req.position, req.blockTag);
-            case "getTransaction":
-                return await provider.getTransaction(req.hash);
-            case "getTransactionCount":
-                return await provider.getTransactionCount(req.address, req.blockTag);
-            case "getTransactionReceipt":
-                return await provider.getTransactionReceipt(req.hash);
-            case "getTransactionResult":
-                return await provider.getTransactionResult(req.hash);
-        }
-    }
-    // Grab the next (random) config that is not already part of
-    // the running set
-    #getNextConfig(running) {
-        // @TODO: Maybe do a check here to favour (heavily) providers that
-        //        do not require waitForSync and disfavour providers that
-        //        seem down-ish or are behaving slowly
-        const configs = Array.from(running).map((r) => r.config);
-        // Shuffle the states, sorted by priority
-        const allConfigs = this.#configs.slice();
-        shuffle(allConfigs);
-        allConfigs.sort((a, b) => (a.priority - b.priority));
-        for (const config of allConfigs) {
-            if (config._lastFatalError) {
-                continue;
-            }
-            if (configs.indexOf(config) === -1) {
-                return config;
-            }
-        }
-        return null;
-    }
-    // Adds a new runner (if available) to running.
-    #addRunner(running, req) {
-        const config = this.#getNextConfig(running);
-        // No runners available
-        if (config == null) {
-            return null;
-        }
-        // Create a new runner
-        const runner = {
-            config, result: null, didBump: false,
-            perform: null, staller: null
-        };
-        const now = provider_fallback_getTime();
-        // Start performing this operation
-        runner.perform = (async () => {
-            try {
-                config.requests++;
-                const result = await this._translatePerform(config.provider, req);
-                runner.result = { result };
-            }
-            catch (error) {
-                config.errorResponses++;
-                runner.result = { error };
-            }
-            const dt = (provider_fallback_getTime() - now);
-            config._totalTime += dt;
-            config.rollingDuration = 0.95 * config.rollingDuration + 0.05 * dt;
-            runner.perform = null;
-        })();
-        // Start a staller; when this times out, it's time to force
-        // kicking off another runner because we are taking too long
-        runner.staller = (async () => {
-            await provider_fallback_stall(config.stallTimeout);
-            runner.staller = null;
-        })();
-        running.add(runner);
-        return runner;
-    }
-    // Initializes the blockNumber and network for each runner and
-    // blocks until initialized
-    async #initialSync() {
-        let initialSync = this.#initialSyncPromise;
-        if (!initialSync) {
-            const promises = [];
-            this.#configs.forEach((config) => {
-                promises.push((async () => {
-                    await waitForSync(config, 0);
-                    if (!config._lastFatalError) {
-                        config._network = await config.provider.getNetwork();
-                    }
-                })());
-            });
-            this.#initialSyncPromise = initialSync = (async () => {
-                // Wait for all providers to have a block number and network
-                await Promise.all(promises);
-                // Check all the networks match
-                let chainId = null;
-                for (const config of this.#configs) {
-                    if (config._lastFatalError) {
-                        continue;
-                    }
-                    const network = (config._network);
-                    if (chainId == null) {
-                        chainId = network.chainId;
-                    }
-                    else if (network.chainId !== chainId) {
-                        assert(false, "cannot mix providers on different networks", "UNSUPPORTED_OPERATION", {
-                            operation: "new FallbackProvider"
-                        });
-                    }
-                }
-            })();
-        }
-        await initialSync;
-    }
-    async #checkQuorum(running, req) {
-        // Get all the result objects
-        const results = [];
-        for (const runner of running) {
-            if (runner.result != null) {
-                const { tag, value } = normalizeResult(req.method, runner.result);
-                results.push({ tag, value, weight: runner.config.weight });
-            }
-        }
-        // Are there enough results to event meet quorum?
-        if (results.reduce((a, r) => (a + r.weight), 0) < this.quorum) {
-            return undefined;
-        }
-        switch (req.method) {
-            case "getBlockNumber": {
-                // We need to get the bootstrap block height
-                if (this.#height === -2) {
-                    this.#height = Math.ceil(getNumber(getMedian(this.quorum, this.#configs.filter((c) => (!c._lastFatalError)).map((c) => ({
-                        value: c.blockNumber,
-                        tag: getNumber(c.blockNumber).toString(),
-                        weight: c.weight
-                    })))));
-                }
-                // Find the mode across all the providers, allowing for
-                // a little drift between block heights
-                const mode = getFuzzyMode(this.quorum, results);
-                if (mode === undefined) {
-                    return undefined;
-                }
-                if (mode > this.#height) {
-                    this.#height = mode;
-                }
-                return this.#height;
-            }
-            case "getGasPrice":
-            case "getPriorityFee":
-            case "estimateGas":
-                return getMedian(this.quorum, results);
-            case "getBlock":
-                // Pending blocks are in the mempool and already
-                // quite untrustworthy; just grab anything
-                if ("blockTag" in req && req.blockTag === "pending") {
-                    return getAnyResult(this.quorum, results);
-                }
-                return checkQuorum(this.quorum, results);
-            case "call":
-            case "chainId":
-            case "getBalance":
-            case "getTransactionCount":
-            case "getCode":
-            case "getStorage":
-            case "getTransaction":
-            case "getTransactionReceipt":
-            case "getLogs":
-                return checkQuorum(this.quorum, results);
-            case "broadcastTransaction":
-                return getAnyResult(this.quorum, results);
-        }
-        assert(false, "unsupported method", "UNSUPPORTED_OPERATION", {
-            operation: `_perform(${provider_fallback_stringify(req.method)})`
-        });
-    }
-    async #waitForQuorum(running, req) {
-        if (running.size === 0) {
-            throw new Error("no runners?!");
-        }
-        // Any promises that are interesting to watch for; an expired stall
-        // or a successful perform
-        const interesting = [];
-        let newRunners = 0;
-        for (const runner of running) {
-            // No responses, yet; keep an eye on it
-            if (runner.perform) {
-                interesting.push(runner.perform);
-            }
-            // Still stalling...
-            if (runner.staller) {
-                interesting.push(runner.staller);
-                continue;
-            }
-            // This runner has already triggered another runner
-            if (runner.didBump) {
-                continue;
-            }
-            // Got a response (result or error) or stalled; kick off another runner
-            runner.didBump = true;
-            newRunners++;
-        }
-        // Check if we have reached quorum on a result (or error)
-        const value = await this.#checkQuorum(running, req);
-        if (value !== undefined) {
-            if (value instanceof Error) {
-                throw value;
-            }
-            return value;
-        }
-        // Add any new runners, because a staller timed out or a result
-        // or error response came in.
-        for (let i = 0; i < newRunners; i++) {
-            this.#addRunner(running, req);
-        }
-        // All providers have returned, and we have no result
-        assert(interesting.length > 0, "quorum not met", "SERVER_ERROR", {
-            request: "%sub-requests",
-            info: { request: req, results: Array.from(running).map((r) => provider_fallback_stringify(r.result)) }
-        });
-        // Wait for someone to either complete its perform or stall out
-        await Promise.race(interesting);
-        // This is recursive, but at worst case the depth is 2x the
-        // number of providers (each has a perform and a staller)
-        return await this.#waitForQuorum(running, req);
-    }
-    async _perform(req) {
-        // Broadcasting a transaction is rare (ish) and already incurs
-        // a cost on the user, so spamming is safe-ish. Just send it to
-        // every backend.
-        if (req.method === "broadcastTransaction") {
-            // Once any broadcast provides a positive result, use it. No
-            // need to wait for anyone else
-            const results = this.#configs.map((c) => null);
-            const broadcasts = this.#configs.map(async ({ provider, weight }, index) => {
-                try {
-                    const result = await provider._perform(req);
-                    results[index] = Object.assign(normalizeResult(req.method, { result }), { weight });
-                }
-                catch (error) {
-                    results[index] = Object.assign(normalizeResult(req.method, { error }), { weight });
-                }
-            });
-            // As each promise finishes...
-            while (true) {
-                // Check for a valid broadcast result
-                const done = results.filter((r) => (r != null));
-                for (const { value } of done) {
-                    if (!(value instanceof Error)) {
-                        return value;
-                    }
-                }
-                // Check for a legit broadcast error (one which we cannot
-                // recover from; some nodes may return the following red
-                // herring events:
-                // - alredy seend (UNKNOWN_ERROR)
-                // - NONCE_EXPIRED
-                // - REPLACEMENT_UNDERPRICED
-                const result = checkQuorum(this.quorum, results.filter((r) => (r != null)));
-                if (isError(result, "INSUFFICIENT_FUNDS")) {
-                    throw result;
-                }
-                // Kick off the next provider (if any)
-                const waiting = broadcasts.filter((b, i) => (results[i] == null));
-                if (waiting.length === 0) {
-                    break;
-                }
-                await Promise.race(waiting);
-            }
-            // Use standard quorum results; any result was returned above,
-            // so this will find any error that met quorum if any
-            const result = getAnyResult(this.quorum, results);
-            assert(result !== undefined, "problem multi-broadcasting", "SERVER_ERROR", {
-                request: "%sub-requests",
-                info: { request: req, results: results.map(provider_fallback_stringify) }
-            });
-            if (result instanceof Error) {
-                throw result;
-            }
-            return result;
-        }
-        await this.#initialSync();
-        // Bootstrap enough runners to meet quorum
-        const running = new Set();
-        let inflightQuorum = 0;
-        while (true) {
-            const runner = this.#addRunner(running, req);
-            if (runner == null) {
-                break;
-            }
-            inflightQuorum += runner.config.weight;
-            if (inflightQuorum >= this.quorum) {
-                break;
-            }
-        }
-        const result = await this.#waitForQuorum(running, req);
-        // Track requests sent to a provider that are still
-        // outstanding after quorum has been otherwise found
-        for (const runner of running) {
-            if (runner.perform && runner.result == null) {
-                runner.config.lateResponses++;
-            }
-        }
-        return result;
-    }
-    async destroy() {
-        for (const { provider } of this.#configs) {
-            provider.destroy();
-        }
-        super.destroy();
-    }
-}
-//# sourceMappingURL=provider-fallback.js.map
-;// ./node_modules/ethers/lib.esm/providers/default-provider.js
-
-
-
-//import { BlockscoutProvider } from "./provider-blockscout.js";
-
-
-
-
-//import { PocketProvider } from "./provider-pocket.js";
-
-
-
-
-
-function isWebSocketLike(value) {
-    return (value && typeof (value.send) === "function" &&
-        typeof (value.close) === "function");
-}
-const Testnets = "goerli kovan sepolia classicKotti optimism-goerli arbitrum-goerli matic-mumbai bnbt".split(" ");
-/**
- *  Returns a default provider for %%network%%.
- *
- *  If %%network%% is a [[WebSocketLike]] or string that begins with
- *  ``"ws:"`` or ``"wss:"``, a [[WebSocketProvider]] is returned backed
- *  by that WebSocket or URL.
- *
- *  If %%network%% is a string that begins with ``"HTTP:"`` or ``"HTTPS:"``,
- *  a [[JsonRpcProvider]] is returned connected to that URL.
- *
- *  Otherwise, a default provider is created backed by well-known public
- *  Web3 backends (such as [[link-infura]]) using community-provided API
- *  keys.
- *
- *  The %%options%% allows specifying custom API keys per backend (setting
- *  an API key to ``"-"`` will omit that provider) and ``options.exclusive``
- *  can be set to either a backend name or and array of backend names, which
- *  will whitelist **only** those backends.
- *
- *  Current backend strings supported are:
- *  - ``"alchemy"``
- *  - ``"ankr"``
- *  - ``"cloudflare"``
- *  - ``"chainstack"``
- *  - ``"etherscan"``
- *  - ``"infura"``
- *  - ``"publicPolygon"``
- *  - ``"quicknode"``
- *
- *  @example:
- *    // Connect to a local Geth node
- *    provider = getDefaultProvider("http://localhost:8545/");
- *
- *    // Connect to Ethereum mainnet with any current and future
- *    // third-party services available
- *    provider = getDefaultProvider("mainnet");
- *
- *    // Connect to Polygon, but only allow Etherscan and
- *    // INFURA and use "MY_API_KEY" in calls to Etherscan.
- *    provider = getDefaultProvider("matic", {
- *      etherscan: "MY_API_KEY",
- *      exclusive: [ "etherscan", "infura" ]
- *    });
- */
-function getDefaultProvider(network, options) {
-    if (options == null) {
-        options = {};
-    }
-    const allowService = (name) => {
-        if (options[name] === "-") {
-            return false;
-        }
-        if (typeof (options.exclusive) === "string") {
-            return (name === options.exclusive);
-        }
-        if (Array.isArray(options.exclusive)) {
-            return (options.exclusive.indexOf(name) !== -1);
-        }
-        return true;
-    };
-    if (typeof (network) === "string" && network.match(/^https?:/)) {
-        return new JsonRpcProvider(network);
-    }
-    if (typeof (network) === "string" && network.match(/^wss?:/) || isWebSocketLike(network)) {
-        return new WebSocketProvider(network);
-    }
-    // Get the network and name, if possible
-    let staticNetwork = null;
-    try {
-        staticNetwork = Network.from(network);
-    }
-    catch (error) { }
-    const providers = [];
-    if (allowService("publicPolygon") && staticNetwork) {
-        if (staticNetwork.name === "matic") {
-            providers.push(new JsonRpcProvider("https:/\/polygon-rpc.com/", staticNetwork, { staticNetwork }));
-        }
-        else if (staticNetwork.name === "matic-amoy") {
-            providers.push(new JsonRpcProvider("https:/\/rpc-amoy.polygon.technology/", staticNetwork, { staticNetwork }));
-        }
-    }
-    if (allowService("alchemy")) {
-        try {
-            providers.push(new AlchemyProvider(network, options.alchemy));
-        }
-        catch (error) { }
-    }
-    if (allowService("ankr") && options.ankr != null) {
-        try {
-            providers.push(new AnkrProvider(network, options.ankr));
-        }
-        catch (error) { }
-    }
-    /* Temporarily remove until custom error issue is fixed
-        if (allowService("blockscout")) {
-            try {
-                providers.push(new BlockscoutProvider(network, options.blockscout));
-            } catch (error) { }
-        }
-    */
-    if (allowService("chainstack")) {
-        try {
-            providers.push(new ChainstackProvider(network, options.chainstack));
-        }
-        catch (error) { }
-    }
-    if (allowService("cloudflare")) {
-        try {
-            providers.push(new CloudflareProvider(network));
-        }
-        catch (error) { }
-    }
-    if (allowService("etherscan")) {
-        try {
-            providers.push(new EtherscanProvider(network, options.etherscan));
-        }
-        catch (error) { }
-    }
-    if (allowService("infura")) {
-        try {
-            let projectId = options.infura;
-            let projectSecret = undefined;
-            if (typeof (projectId) === "object") {
-                projectSecret = projectId.projectSecret;
-                projectId = projectId.projectId;
-            }
-            providers.push(new InfuraProvider(network, projectId, projectSecret));
-        }
-        catch (error) { }
-    }
-    /*
-        if (options.pocket !== "-") {
-            try {
-                let appId = options.pocket;
-                let secretKey: undefined | string = undefined;
-                let loadBalancer: undefined | boolean = undefined;
-                if (typeof(appId) === "object") {
-                    loadBalancer = !!appId.loadBalancer;
-                    secretKey = appId.secretKey;
-                    appId = appId.appId;
-                }
-                providers.push(new PocketProvider(network, appId, secretKey, loadBalancer));
-            } catch (error) { console.log(error); }
-        }
-    */
-    if (allowService("quicknode")) {
-        try {
-            let token = options.quicknode;
-            providers.push(new QuickNodeProvider(network, token));
-        }
-        catch (error) { }
-    }
-    assert(providers.length, "unsupported default network", "UNSUPPORTED_OPERATION", {
-        operation: "getDefaultProvider"
-    });
-    // No need for a FallbackProvider
-    if (providers.length === 1) {
-        return providers[0];
-    }
-    // We use the floor because public third-party providers can be unreliable,
-    // so a low number of providers with a large quorum will fail too often
-    let quorum = Math.floor(providers.length / 2);
-    if (quorum > 2) {
-        quorum = 2;
-    }
-    // Testnets don't need as strong a security gaurantee and speed is
-    // more useful during testing
-    if (staticNetwork && Testnets.indexOf(staticNetwork.name) !== -1) {
-        quorum = 1;
-    }
-    // Provided override qorum takes priority
-    if (options && options.quorum) {
-        quorum = options.quorum;
-    }
-    return new FallbackProvider(providers, undefined, { quorum });
-}
-//# sourceMappingURL=default-provider.js.map
-;// ./src/plugins/smartwallet/smartWalletPlugin.ts
-var smartWalletPlugin_extends = (undefined && undefined.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var smartWalletPlugin_assign = (undefined && undefined.__assign) || function () {
-    smartWalletPlugin_assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return smartWalletPlugin_assign.apply(this, arguments);
-};
-var smartWalletPlugin_awaiter = (undefined && undefined.__awaiter) || function (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());
-    });
-};
-var smartWalletPlugin_generator = (undefined && undefined.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var smartWalletPlugin_read = (undefined && undefined.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-
-
-// Smart Wallet ABIs
-var SMART_WALLET_FACTORY_ABI = [
-    "function createWallet(address owner, uint256 requiredSignatures, uint256 requiredGuardians) external returns (address wallet)",
-    "function createWalletWithGuardians(address owner, address[] memory guardians, uint256 requiredSignatures, uint256 requiredGuardians) external returns (address wallet)",
-    "function getOwnerWallets(address owner) external view returns (address[] memory)",
-    "event WalletCreated(address indexed wallet, address indexed owner, uint256 indexed walletIndex)",
-];
-var SMART_WALLET_ABI = [
-    // Signer management
-    "function addSigner(address signer) external",
-    "function removeSigner(address signer) external",
-    "function setRequiredSignatures(uint256 requiredSignatures) external",
-    "function signers(address) external view returns (bool)",
-    "function requiredSignatures() external view returns (uint256)",
-    "function owner() external view returns (address)",
-    // Guardian management
-    "function addGuardian(address guardian) external",
-    "function removeGuardian(address guardian) external",
-    "function setRequiredGuardians(uint256 requiredGuardians) external",
-    "function guardians(address) external view returns (bool)",
-    "function requiredGuardians() external view returns (uint256)",
-    // Execution
-    "function execute(address target, bytes calldata data, uint256 value) external returns (bool success, bytes memory returnData)",
-    "function executeBatch(address[] memory targets, bytes[] memory data, uint256[] memory values) external returns (bool[] memory results)",
-    // Multi-sig
-    "function proposeExecution(address target, bytes calldata data) external returns (uint256 proposalId)",
-    "function approveProposal(uint256 proposalId) external",
-    "function getProposal(uint256 proposalId) external view returns (address target, bytes memory data, address proposer, uint256 approvals, bool executed)",
-    "function hasApprovedProposal(uint256 proposalId, address signer) external view returns (bool)",
-    // Recovery
-    "function initiateRecovery(address newOwner) external",
-    "function approveRecovery() external",
-    "function executeRecovery() external",
-    "function getRecoveryRequest() external view returns (address newOwner, uint256 unlockTime, uint256 approvals)",
-    "function hasApprovedRecovery(address guardian) external view returns (bool)",
-    "event SignerAdded(address indexed signer)",
-    "event GuardianAdded(address indexed guardian)",
-    "event ExecutionExecuted(uint256 indexed proposalId, bool success)",
-    "event RecoveryExecuted(address indexed newOwner)",
-];
-/**
- * Smart Wallet Plugin for Shogun Core
- * Provides integration with Smart Wallet contracts for account abstraction
- */
-var SmartWalletPlugin = /** @class */ (function (_super) {
-    smartWalletPlugin_extends(SmartWalletPlugin, _super);
-    function SmartWalletPlugin(config) {
-        if (config === void 0) { config = {}; }
-        var _this = _super.call(this) || this;
-        _this.name = "smartwallet";
-        _this.version = "1.0.0";
-        _this.description = "Smart Wallet integration for Shogun Core with multi-sig and social recovery";
-        _this.factoryContract = null;
-        _this.signer = null;
-        _this.config = smartWalletPlugin_assign({ enabled: true, defaultRequiredSignatures: 1, defaultRequiredGuardians: 2 }, config);
-        return _this;
-    }
-    /**
-     * Initialize the plugin
-     */
-    SmartWalletPlugin.prototype.initialize = function (core) {
-        _super.prototype.initialize.call(this, core);
-        if (!this.config.enabled) {
-            console.log("[SmartWallet] Plugin disabled");
-            return;
-        }
-        try {
-            // Initialize provider and signer
-            this.initProvider();
-            // Initialize factory contract if address is provided
-            if (this.config.factoryAddress) {
-                this.initFactoryContract();
-            }
-            console.log("[SmartWallet] Plugin initialized successfully");
-        }
-        catch (error) {
-            console.error("[SmartWallet] Initialization failed:", error.message);
-        }
-    };
-    /**
-     * Destroy the plugin and cleanup resources
-     */
-    SmartWalletPlugin.prototype.destroy = function () {
-        this.factoryContract = null;
-        this.signer = null;
-        _super.prototype.destroy.call(this);
-        console.log("[SmartWallet] Plugin destroyed");
-    };
-    /**
-     * Initialize provider and signer
-     */
-    SmartWalletPlugin.prototype.initProvider = function () {
-        if ( true && window.ethereum) {
-            var provider = new BrowserProvider(window.ethereum);
-            // Try to get signer from config, otherwise request from browser
-            if (this.config.privateKey) {
-                this.signer = new Wallet(this.config.privateKey, provider);
-            }
-            else {
-                // Will be set when user connects wallet or provides private key
-                this.signer = null;
-                console.log("[SmartWallet] No private key provided. Use connectWallet() or setSigner() first.");
-            }
-        }
-    };
-    /**
-     * Set signer with private key or wallet instance
-     * This should be called after deriving the EOA from seed phrase
-     */
-    SmartWalletPlugin.prototype.setSigner = function (privateKeyOrAddress) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var provider;
-            var _a;
-            return smartWalletPlugin_generator(this, function (_b) {
-                try {
-                    if (!((_a = this.signer) === null || _a === void 0 ? void 0 : _a.provider)) {
-                        provider = new BrowserProvider(window.ethereum);
-                        this.signer = new Wallet(privateKeyOrAddress, provider);
-                    }
-                    else {
-                        this.signer = new Wallet(privateKeyOrAddress, this.signer.provider);
-                    }
-                    console.log("[SmartWallet] Signer updated");
-                }
-                catch (error) {
-                    console.error("[SmartWallet] Failed to set signer:", error.message);
-                    throw error;
-                }
-                return [2 /*return*/];
-            });
-        });
-    };
-    /**
-     * Connect to MetaMask or other injected provider
-     */
-    SmartWalletPlugin.prototype.connectWallet = function () {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var provider, _a, _b, _c, _d, error_1;
-            return smartWalletPlugin_generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _e.trys.push([0, 6, , 7]);
-                        if (!( true && window.ethereum)) return [3 /*break*/, 4];
-                        provider = new BrowserProvider(window.ethereum);
-                        return [4 /*yield*/, provider.send("eth_requestAccounts", [])];
-                    case 1:
-                        _e.sent();
-                        _a = this;
-                        return [4 /*yield*/, provider.getSigner()];
-                    case 2:
-                        _a.signer = _e.sent();
-                        _c = (_b = console).log;
-                        _d = ["[SmartWallet] Connected to wallet:"];
-                        return [4 /*yield*/, this.signer.getAddress()];
-                    case 3:
-                        _c.apply(_b, _d.concat([_e.sent()]));
-                        return [3 /*break*/, 5];
-                    case 4: throw new Error("No Ethereum provider found");
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        error_1 = _e.sent();
-                        console.error("[SmartWallet] Failed to connect wallet:", error_1.message);
-                        throw error_1;
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Initialize factory contract
-     */
-    SmartWalletPlugin.prototype.initFactoryContract = function () {
-        if (!this.config.factoryAddress || !this.signer) {
-            console.warn("[SmartWallet] Factory address or signer not available");
-            return;
-        }
-        this.factoryContract = new Contract(this.config.factoryAddress, SMART_WALLET_FACTORY_ABI, this.signer);
-    };
-    /**
-     * Ensure signer is available
-     */
-    SmartWalletPlugin.prototype.assertSigner = function () {
-        if (!this.signer) {
-            throw new Error("Signer not available. Please connect a wallet.");
-        }
-        return this.signer;
-    };
-    /**
-     * Ensure factory is initialized
-     */
-    SmartWalletPlugin.prototype.assertFactory = function () {
-        if (!this.factoryContract) {
-            throw new Error("SmartWallet factory not initialized. Please deploy factory first.");
-        }
-        return this.factoryContract;
-    };
-    // ============================================ Wallet Creation ============================================
-    SmartWalletPlugin.prototype.createWallet = function (owner, requiredSignatures, requiredGuardians) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var factory, sig, reqSig, reqGuard, tx, receipt, event_1, walletAddress, error_2;
-            var _a, _b;
-            return smartWalletPlugin_generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _c.trys.push([0, 3, , 4]);
-                        factory = this.assertFactory();
-                        sig = this.assertSigner();
-                        reqSig = (_a = requiredSignatures !== null && requiredSignatures !== void 0 ? requiredSignatures : this.config.defaultRequiredSignatures) !== null && _a !== void 0 ? _a : 1;
-                        reqGuard = (_b = requiredGuardians !== null && requiredGuardians !== void 0 ? requiredGuardians : this.config.defaultRequiredGuardians) !== null && _b !== void 0 ? _b : 2;
-                        return [4 /*yield*/, factory.createWallet(owner, reqSig, reqGuard)];
-                    case 1:
-                        tx = _c.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _c.sent();
-                        event_1 = receipt.logs.find(function (log) {
-                            return log.topics[0] === id("WalletCreated(address,address,uint256)");
-                        });
-                        walletAddress = event_1
-                            ? getAddress("0x" + event_1.topics[1].slice(-40))
-                            : null;
-                        return [2 /*return*/, {
-                                success: true,
-                                walletAddress: walletAddress || undefined,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_2 = _c.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_2.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.createWalletWithGuardians = function (owner, guardians, requiredSignatures, requiredGuardians) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var factory, reqSig, reqGuard, tx, receipt, event_2, walletAddress, error_3;
-            var _a, _b;
-            return smartWalletPlugin_generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _c.trys.push([0, 3, , 4]);
-                        factory = this.assertFactory();
-                        reqSig = (_a = requiredSignatures !== null && requiredSignatures !== void 0 ? requiredSignatures : this.config.defaultRequiredSignatures) !== null && _a !== void 0 ? _a : 1;
-                        reqGuard = (_b = requiredGuardians !== null && requiredGuardians !== void 0 ? requiredGuardians : this.config.defaultRequiredGuardians) !== null && _b !== void 0 ? _b : 2;
-                        return [4 /*yield*/, factory.createWalletWithGuardians(owner, guardians, reqSig, reqGuard)];
-                    case 1:
-                        tx = _c.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _c.sent();
-                        event_2 = receipt.logs.find(function (log) {
-                            return log.topics[0] === id("WalletCreated(address,address,uint256)");
-                        });
-                        walletAddress = event_2
-                            ? getAddress("0x" + event_2.topics[1].slice(-40))
-                            : null;
-                        return [2 /*return*/, {
-                                success: true,
-                                walletAddress: walletAddress || undefined,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_3 = _c.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_3.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // ============================================ Wallet Management ============================================
-    SmartWalletPlugin.prototype.getWalletInfo = function (walletAddress) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, _a, owner, requiredSig, requiredGuard, currentSigner, isSigner, error_4;
-            return smartWalletPlugin_generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, Promise.all([
-                                walletContract.owner(),
-                                walletContract.requiredSignatures(),
-                                walletContract.requiredGuardians(),
-                                this.assertSigner().getAddress(),
-                            ])];
-                    case 1:
-                        _a = smartWalletPlugin_read.apply(void 0, [_b.sent(), 4]), owner = _a[0], requiredSig = _a[1], requiredGuard = _a[2], currentSigner = _a[3];
-                        return [4 /*yield*/, walletContract.signers(currentSigner)];
-                    case 2:
-                        isSigner = _b.sent();
-                        return [2 /*return*/, {
-                                address: walletAddress,
-                                owner: owner,
-                                isSigner: isSigner,
-                                requiredSignatures: Number(requiredSig),
-                                requiredGuardians: Number(requiredGuard),
-                            }];
-                    case 3:
-                        error_4 = _b.sent();
-                        console.error("[SmartWallet] Error getting wallet info:", error_4);
-                        return [2 /*return*/, null];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.getOwnerWallets = function (ownerAddress) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var factory, wallets, error_5;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        factory = this.assertFactory();
-                        return [4 /*yield*/, factory.getOwnerWallets(ownerAddress)];
-                    case 1:
-                        wallets = _a.sent();
-                        return [2 /*return*/, wallets];
-                    case 2:
-                        error_5 = _a.sent();
-                        console.error("[SmartWallet] Error getting owner wallets:", error_5);
-                        return [2 /*return*/, []];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // ============================================ Signer Management ============================================
-    SmartWalletPlugin.prototype.addSigner = function (walletAddress, signer) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_6;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.addSigner(signer)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_6 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_6.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.removeSigner = function (walletAddress, signer) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_7;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.removeSigner(signer)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_7 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_7.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.setRequiredSignatures = function (walletAddress, required) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_8;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.setRequiredSignatures(required)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_8 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_8.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // ============================================ Guardian Management ============================================
-    SmartWalletPlugin.prototype.addGuardian = function (walletAddress, guardian) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_9;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.addGuardian(guardian)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_9 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_9.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.removeGuardian = function (walletAddress, guardian) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_10;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.removeGuardian(guardian)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_10 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_10.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // ============================================ Execution ============================================
-    SmartWalletPlugin.prototype.executeTransaction = function (walletAddress_1, target_1, data_1) {
-        return smartWalletPlugin_awaiter(this, arguments, void 0, function (walletAddress, target, data, value) {
-            var walletContract, tx, receipt, error_11;
-            if (value === void 0) { value = "0"; }
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.execute(target, data, value)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_11 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_11.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.executeBatch = function (walletAddress, targets, dataArray, values) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_12;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.executeBatch(targets, dataArray, values)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_12 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_12.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // ============================================ Multi-Sig ============================================
-    SmartWalletPlugin.prototype.proposeExecution = function (walletAddress, target, data) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_13;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.proposeExecution(target, data)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_13 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_13.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.approveProposal = function (walletAddress, proposalId) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_14;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.approveProposal(proposalId)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_14 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_14.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.getProposalInfo = function (walletAddress, proposalId) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var provider, walletContract, _a, target, data, proposer, approvals, executed, error_15;
-            return smartWalletPlugin_generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        provider = this.assertSigner().provider || getDefaultProvider();
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, provider);
-                        return [4 /*yield*/, walletContract.getProposal(proposalId)];
-                    case 1:
-                        _a = smartWalletPlugin_read.apply(void 0, [_b.sent(), 5]), target = _a[0], data = _a[1], proposer = _a[2], approvals = _a[3], executed = _a[4];
-                        return [2 /*return*/, {
-                                proposalId: proposalId,
-                                target: target,
-                                proposer: proposer,
-                                approvals: Number(approvals),
-                                executed: executed,
-                            }];
-                    case 2:
-                        error_15 = _b.sent();
-                        console.error("[SmartWallet] Error getting proposal info:", error_15);
-                        return [2 /*return*/, null];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    // ============================================ Recovery ============================================
-    SmartWalletPlugin.prototype.initiateRecovery = function (walletAddress, newOwner) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_16;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.initiateRecovery(newOwner)];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_16 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_16.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.approveRecovery = function (walletAddress) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_17;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.approveRecovery()];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_17 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_17.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.executeRecovery = function (walletAddress) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var walletContract, tx, receipt, error_18;
-            return smartWalletPlugin_generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, this.assertSigner());
-                        return [4 /*yield*/, walletContract.executeRecovery()];
-                    case 1:
-                        tx = _a.sent();
-                        return [4 /*yield*/, tx.wait()];
-                    case 2:
-                        receipt = _a.sent();
-                        return [2 /*return*/, {
-                                success: true,
-                                transactionHash: receipt.hash,
-                            }];
-                    case 3:
-                        error_18 = _a.sent();
-                        return [2 /*return*/, {
-                                success: false,
-                                error: error_18.message,
-                            }];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SmartWalletPlugin.prototype.getRecoveryRequest = function (walletAddress) {
-        return smartWalletPlugin_awaiter(this, void 0, void 0, function () {
-            var provider, walletContract, _a, newOwner, unlockTime, approvals, error_19;
-            return smartWalletPlugin_generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        provider = this.assertSigner().provider || getDefaultProvider();
-                        walletContract = new Contract(walletAddress, SMART_WALLET_ABI, provider);
-                        return [4 /*yield*/, walletContract.getRecoveryRequest()];
-                    case 1:
-                        _a = smartWalletPlugin_read.apply(void 0, [_b.sent(), 3]), newOwner = _a[0], unlockTime = _a[1], approvals = _a[2];
-                        return [2 /*return*/, {
-                                newOwner: newOwner,
-                                unlockTime: Number(unlockTime),
-                                approvals: Number(approvals),
-                            }];
-                    case 2:
-                        error_19 = _b.sent();
-                        console.error("[SmartWallet] Error getting recovery request:", error_19);
-                        return [2 /*return*/, null];
-                    case 3: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return SmartWalletPlugin;
-}(BasePlugin));
-
-
 ;// ./src/plugins/index.ts
 // Base plugin interface and types
 
@@ -130353,8 +126920,6 @@ var SmartWalletPlugin = /** @class */ (function (_super) {
 
 
 
-// Smart Wallet plugin exports
-
 
 // EXTERNAL MODULE: external "Gun"
 var external_Gun_ = __webpack_require__("gun");