@pezkuwi/extension-dapp 0.62.6

package/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,3 @@
+# @polkadot/extension-dapp
+
+Documentation available [in the pezkuwi doc](https://polkadot.js.org/docs/extension).

package/bundle-polkadot-extension-dapp.js

@@ -0,0 +1,205 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@polkadot/util'), require('@polkadot/util-crypto')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@polkadot/util', '@polkadot/util-crypto'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.polkadotExtensionDapp = {}, global.polkadotUtil, global.polkadotUtilCrypto));
+})(this, (function (exports, util, utilCrypto) { 'use strict';
+
+    const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;
+
+    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+    function documentReadyPromise(creator) {
+        return new Promise((resolve) => {
+            if (document.readyState === 'complete') {
+                resolve(creator());
+            }
+            else {
+                window.addEventListener('load', () => resolve(creator()));
+            }
+        });
+    }
+
+    const packageInfo = { name: '@polkadot/extension-dapp', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-polkadot-extension-dapp.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-polkadot-extension-dapp.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-polkadot-extension-dapp.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('bundle-polkadot-extension-dapp.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '0.62.6' };
+
+    const unwrapBytes = util.u8aUnwrapBytes;
+    const wrapBytes = util.u8aWrapBytes;
+
+    const win = window;
+    win.injectedWeb3 = win.injectedWeb3 || {};
+    exports.isWeb3Injected = web3IsInjected();
+    exports.web3EnablePromise = null;
+    function web3IsInjected() {
+        return Object
+            .values(win.injectedWeb3)
+            .filter(({ connect, enable }) => !!(connect || enable))
+            .length !== 0;
+    }
+    function throwError(method) {
+        throw new Error(`${method}: web3Enable(originName) needs to be called before ${method}`);
+    }
+    function mapAccounts(source, list, ss58Format) {
+        return list.map(({ address, genesisHash, name, type }) => ({
+            address: address.length === 42
+                ? address
+                : utilCrypto.encodeAddress(utilCrypto.decodeAddress(address), ss58Format),
+            meta: { genesisHash, name, source },
+            type
+        }));
+    }
+    function filterAccounts(list, genesisHash, type) {
+        return list.filter((a) => (!a.type || !type || type.includes(a.type)) &&
+            (!a.genesisHash || !genesisHash || a.genesisHash === genesisHash));
+    }
+    function getWindowExtensions(originName) {
+        return Promise
+            .all(Object
+            .entries(win.injectedWeb3)
+            .map(([nameOrHash, { connect, enable, version }]) => Promise
+            .resolve()
+            .then(() => connect
+            ? connect(originName)
+            : enable
+                ? enable(originName).then((e) => util.objectSpread({ name: nameOrHash, version: version || 'unknown' }, e))
+                : Promise.reject(new Error('No connect(..) or enable(...) hook found')))
+            .catch(({ message }) => {
+            console.error(`Error initializing ${nameOrHash}: ${message}`);
+        })))
+            .then((exts) => exts.filter((e) => !!e));
+    }
+    async function filterEnable(caller, extensions) {
+        if (!exports.web3EnablePromise) {
+            return throwError(caller);
+        }
+        const sources = await exports.web3EnablePromise;
+        return sources.filter(({ name }) => !extensions ||
+            extensions.includes(name));
+    }
+    function web3Enable(originName, compatInits = []) {
+        if (!originName) {
+            throw new Error('You must pass a name for your app to the web3Enable function');
+        }
+        const initCompat = compatInits.length
+            ? Promise.all(compatInits.map((c) => c().catch(() => false)))
+            : Promise.resolve([true]);
+        exports.web3EnablePromise = documentReadyPromise(() => initCompat.then(() => getWindowExtensions(originName)
+            .then((values) => values.map((e) => {
+            if (!e.accounts.subscribe) {
+                e.accounts.subscribe = (cb) => {
+                    e.accounts
+                        .get()
+                        .then(cb)
+                        .catch(console.error);
+                    return () => {
+                    };
+                };
+            }
+            return e;
+        }))
+            .catch(() => [])
+            .then((values) => {
+            const names = values.map(({ name, version }) => `${name}/${version}`);
+            exports.isWeb3Injected = web3IsInjected();
+            console.info(`web3Enable: Enabled ${values.length} extension${values.length !== 1 ? 's' : ''}: ${names.join(', ')}`);
+            return values;
+        })));
+        return exports.web3EnablePromise;
+    }
+    async function web3Accounts({ accountType, extensions, genesisHash, ss58Format } = {}) {
+        const accounts = [];
+        const sources = await filterEnable('web3Accounts', extensions);
+        const retrieved = await Promise.all(sources.map(async ({ accounts, name: source }) => {
+            try {
+                const list = await accounts.get();
+                return mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format);
+            }
+            catch {
+                return [];
+            }
+        }));
+        retrieved.forEach((result) => {
+            accounts.push(...result);
+        });
+        console.info(`web3Accounts: Found ${accounts.length} address${accounts.length !== 1 ? 'es' : ''}`);
+        return accounts;
+    }
+    async function web3AccountsSubscribe(cb, { accountType, extensions, genesisHash, ss58Format } = {}) {
+        const sources = await filterEnable('web3AccountsSubscribe', extensions);
+        const accounts = {};
+        const triggerUpdate = () => cb(Object
+            .entries(accounts)
+            .reduce((result, [source, list]) => {
+            result.push(...mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format));
+            return result;
+        }, []));
+        const unsubs = sources.map(({ accounts: { subscribe }, name: source }) => subscribe((result) => {
+            accounts[source] = result;
+            try {
+                const result = triggerUpdate();
+                if (result && util.isPromise(result)) {
+                    result.catch(console.error);
+                }
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }));
+        return () => {
+            unsubs.forEach((unsub) => {
+                unsub();
+            });
+        };
+    }
+    async function web3FromSource(source) {
+        if (!exports.web3EnablePromise) {
+            return throwError('web3FromSource');
+        }
+        const sources = await exports.web3EnablePromise;
+        const found = source && sources.find(({ name }) => name === source);
+        if (!found) {
+            throw new Error(`web3FromSource: Unable to find an injected ${source}`);
+        }
+        return found;
+    }
+    async function web3FromAddress(address) {
+        if (!exports.web3EnablePromise) {
+            return throwError('web3FromAddress');
+        }
+        const accounts = await web3Accounts();
+        let found;
+        if (address) {
+            const accountU8a = utilCrypto.decodeAddress(address);
+            found = accounts.find((account) => util.u8aEq(utilCrypto.decodeAddress(account.address), accountU8a));
+        }
+        if (!found) {
+            throw new Error(`web3FromAddress: Unable to find injected ${address}`);
+        }
+        return web3FromSource(found.meta.source);
+    }
+    async function web3ListRpcProviders(source) {
+        const { provider } = await web3FromSource(source);
+        if (!provider) {
+            console.warn(`Extension ${source} does not expose any provider`);
+            return null;
+        }
+        return provider.listProviders();
+    }
+    async function web3UseRpcProvider(source, key) {
+        const { provider } = await web3FromSource(source);
+        if (!provider) {
+            throw new Error(`Extension ${source} does not expose any provider`);
+        }
+        const meta = await provider.startProvider(key);
+        return { meta, provider };
+    }
+
+    exports.packageInfo = packageInfo;
+    exports.unwrapBytes = unwrapBytes;
+    exports.web3Accounts = web3Accounts;
+    exports.web3AccountsSubscribe = web3AccountsSubscribe;
+    exports.web3Enable = web3Enable;
+    exports.web3FromAddress = web3FromAddress;
+    exports.web3FromSource = web3FromSource;
+    exports.web3ListRpcProviders = web3ListRpcProviders;
+    exports.web3UseRpcProvider = web3UseRpcProvider;
+    exports.wrapBytes = wrapBytes;
+
+}));

package/bundle.d.ts

@@ -0,0 +1,61 @@
+import type { InjectedAccountWithMeta, InjectedExtension, InjectedProviderWithMeta, ProviderList, Unsubcall, Web3AccountsOptions } from '@polkadot/extension-inject/types';
+export { packageInfo } from './packageInfo.js';
+export { unwrapBytes, wrapBytes } from './wrapBytes.js';
+declare let isWeb3Injected: boolean;
+declare let web3EnablePromise: Promise<InjectedExtension[]> | null;
+export { isWeb3Injected, web3EnablePromise };
+/**
+ * @summary Enables all the providers found on the injected window interface
+ * @description
+ * Enables all injected extensions that has been found on the page. This
+ * should be called before making use of any other web3* functions.
+ */
+export declare function web3Enable(originName: string, compatInits?: (() => Promise<boolean>)[]): Promise<InjectedExtension[]>;
+/**
+ * @summary Retrieves all the accounts across all providers
+ * @description
+ * This returns the full list of account available (across all extensions) to
+ * the page. Filtering options are available of a per-extension, per type and
+ * per-genesisHash basis. Optionally the accounts can be encoded with the provided
+ * ss58Format
+ */
+export declare function web3Accounts({ accountType, extensions, genesisHash, ss58Format }?: Web3AccountsOptions): Promise<InjectedAccountWithMeta[]>;
+/**
+ * @summary Subscribes to all the accounts across all providers
+ * @description
+ * This is the subscription version of the web3Accounts interface with
+ * updates as to when new accounts do become available. The list of filtering
+ * options are the same as for the web3Accounts interface.
+ */
+export declare function web3AccountsSubscribe(cb: (accounts: InjectedAccountWithMeta[]) => void | Promise<void>, { accountType, extensions, genesisHash, ss58Format }?: Web3AccountsOptions): Promise<Unsubcall>;
+/**
+ * @summary Finds a specific provider based on the name
+ * @description
+ * This retrieves a specific source (extension) based on the name. In most
+ * cases it should not be needed to call it directly (e.g. it is used internally
+ * by calls such as web3FromAddress) but would allow operation on a specific
+ * known extension.
+ */
+export declare function web3FromSource(source: string): Promise<InjectedExtension>;
+/**
+ * @summary Find a specific provider that provides a specific address
+ * @description
+ * Based on an address, return the provider that has makes this address
+ * available to the page.
+ */
+export declare function web3FromAddress(address: string): Promise<InjectedExtension>;
+/**
+ * @summary List all providers exposed by one source
+ * @description
+ * For extensions that supply RPC providers, this call would return the list
+ * of RPC providers that any extension may supply.
+ */
+export declare function web3ListRpcProviders(source: string): Promise<ProviderList | null>;
+/**
+ * @summary Start an RPC provider provider by a specific source
+ * @description
+ * For extensions that supply RPC providers, this call would return an
+ * enabled provider (initialized with the specific key) from the
+ * specified extension source.
+ */
+export declare function web3UseRpcProvider(source: string, key: string): Promise<InjectedProviderWithMeta>;

package/bundle.js

@@ -0,0 +1,232 @@
+import { isPromise, objectSpread, u8aEq } from '@polkadot/util';
+import { decodeAddress, encodeAddress } from '@polkadot/util-crypto';
+import { documentReadyPromise } from './util.js';
+export { packageInfo } from './packageInfo.js';
+export { unwrapBytes, wrapBytes } from './wrapBytes.js';
+const win = window;
+win.injectedWeb3 = win.injectedWeb3 || {};
+let isWeb3Injected = web3IsInjected();
+let web3EnablePromise = null;
+export { isWeb3Injected, web3EnablePromise };
+/** @internal true when anything has been injected and is available */
+function web3IsInjected() {
+    return Object
+        .values(win.injectedWeb3)
+        .filter(({ connect, enable }) => !!(connect || enable))
+        .length !== 0;
+}
+/** @internal throw a consistent error when not extensions have not been enabled */
+function throwError(method) {
+    throw new Error(`${method}: web3Enable(originName) needs to be called before ${method}`);
+}
+/** @internal map from Array<InjectedAccount> to Array<InjectedAccountWithMeta> */
+function mapAccounts(source, list, ss58Format) {
+    return list.map(({ address, genesisHash, name, type }) => ({
+        address: address.length === 42
+            ? address
+            : encodeAddress(decodeAddress(address), ss58Format),
+        meta: { genesisHash, name, source },
+        type
+    }));
+}
+/** @internal filter accounts based on genesisHash and type of account */
+function filterAccounts(list, genesisHash, type) {
+    return list.filter((a) => (!a.type || !type || type.includes(a.type)) &&
+        (!a.genesisHash || !genesisHash || a.genesisHash === genesisHash));
+}
+/** @internal retrieves all the extensions available on the window */
+function getWindowExtensions(originName) {
+    return Promise
+        .all(Object
+        .entries(win.injectedWeb3)
+        .map(([nameOrHash, { connect, enable, version }]) => Promise
+        .resolve()
+        .then(() => connect
+        // new style, returning all info
+        ? connect(originName)
+        : enable
+            // previous interface, leakages on name/version
+            ? enable(originName).then((e) => objectSpread({ name: nameOrHash, version: version || 'unknown' }, e))
+            : Promise.reject(new Error('No connect(..) or enable(...) hook found')))
+        .catch(({ message }) => {
+        console.error(`Error initializing ${nameOrHash}: ${message}`);
+    })))
+        .then((exts) => exts.filter((e) => !!e));
+}
+/** @internal Ensure the enable promise is resolved and filter by extensions */
+async function filterEnable(caller, extensions) {
+    if (!web3EnablePromise) {
+        return throwError(caller);
+    }
+    const sources = await web3EnablePromise;
+    return sources.filter(({ name }) => !extensions ||
+        extensions.includes(name));
+}
+/**
+ * @summary Enables all the providers found on the injected window interface
+ * @description
+ * Enables all injected extensions that has been found on the page. This
+ * should be called before making use of any other web3* functions.
+ */
+export function web3Enable(originName, compatInits = []) {
+    if (!originName) {
+        throw new Error('You must pass a name for your app to the web3Enable function');
+    }
+    const initCompat = compatInits.length
+        ? Promise.all(compatInits.map((c) => c().catch(() => false)))
+        : Promise.resolve([true]);
+    web3EnablePromise = documentReadyPromise(() => initCompat.then(() => getWindowExtensions(originName)
+        .then((values) => values.map((e) => {
+        // if we don't have an accounts subscriber, add a single-shot version
+        if (!e.accounts.subscribe) {
+            e.accounts.subscribe = (cb) => {
+                e.accounts
+                    .get()
+                    .then(cb)
+                    .catch(console.error);
+                return () => {
+                    // no ubsubscribe needed, this is a single-shot
+                };
+            };
+        }
+        return e;
+    }))
+        .catch(() => [])
+        .then((values) => {
+        const names = values.map(({ name, version }) => `${name}/${version}`);
+        isWeb3Injected = web3IsInjected();
+        console.info(`web3Enable: Enabled ${values.length} extension${values.length !== 1 ? 's' : ''}: ${names.join(', ')}`);
+        return values;
+    })));
+    return web3EnablePromise;
+}
+/**
+ * @summary Retrieves all the accounts across all providers
+ * @description
+ * This returns the full list of account available (across all extensions) to
+ * the page. Filtering options are available of a per-extension, per type and
+ * per-genesisHash basis. Optionally the accounts can be encoded with the provided
+ * ss58Format
+ */
+export async function web3Accounts({ accountType, extensions, genesisHash, ss58Format } = {}) {
+    const accounts = [];
+    const sources = await filterEnable('web3Accounts', extensions);
+    const retrieved = await Promise.all(sources.map(async ({ accounts, name: source }) => {
+        try {
+            const list = await accounts.get();
+            return mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format);
+        }
+        catch {
+            // cannot handle this one
+            return [];
+        }
+    }));
+    retrieved.forEach((result) => {
+        accounts.push(...result);
+    });
+    console.info(`web3Accounts: Found ${accounts.length} address${accounts.length !== 1 ? 'es' : ''}`);
+    return accounts;
+}
+/**
+ * @summary Subscribes to all the accounts across all providers
+ * @description
+ * This is the subscription version of the web3Accounts interface with
+ * updates as to when new accounts do become available. The list of filtering
+ * options are the same as for the web3Accounts interface.
+ */
+export async function web3AccountsSubscribe(cb, { accountType, extensions, genesisHash, ss58Format } = {}) {
+    const sources = await filterEnable('web3AccountsSubscribe', extensions);
+    const accounts = {};
+    const triggerUpdate = () => cb(Object
+        .entries(accounts)
+        .reduce((result, [source, list]) => {
+        result.push(...mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format));
+        return result;
+    }, []));
+    const unsubs = sources.map(({ accounts: { subscribe }, name: source }) => subscribe((result) => {
+        accounts[source] = result;
+        try {
+            const result = triggerUpdate();
+            if (result && isPromise(result)) {
+                result.catch(console.error);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }));
+    return () => {
+        unsubs.forEach((unsub) => {
+            unsub();
+        });
+    };
+}
+/**
+ * @summary Finds a specific provider based on the name
+ * @description
+ * This retrieves a specific source (extension) based on the name. In most
+ * cases it should not be needed to call it directly (e.g. it is used internally
+ * by calls such as web3FromAddress) but would allow operation on a specific
+ * known extension.
+ */
+export async function web3FromSource(source) {
+    if (!web3EnablePromise) {
+        return throwError('web3FromSource');
+    }
+    const sources = await web3EnablePromise;
+    const found = source && sources.find(({ name }) => name === source);
+    if (!found) {
+        throw new Error(`web3FromSource: Unable to find an injected ${source}`);
+    }
+    return found;
+}
+/**
+ * @summary Find a specific provider that provides a specific address
+ * @description
+ * Based on an address, return the provider that has makes this address
+ * available to the page.
+ */
+export async function web3FromAddress(address) {
+    if (!web3EnablePromise) {
+        return throwError('web3FromAddress');
+    }
+    const accounts = await web3Accounts();
+    let found;
+    if (address) {
+        const accountU8a = decodeAddress(address);
+        found = accounts.find((account) => u8aEq(decodeAddress(account.address), accountU8a));
+    }
+    if (!found) {
+        throw new Error(`web3FromAddress: Unable to find injected ${address}`);
+    }
+    return web3FromSource(found.meta.source);
+}
+/**
+ * @summary List all providers exposed by one source
+ * @description
+ * For extensions that supply RPC providers, this call would return the list
+ * of RPC providers that any extension may supply.
+ */
+export async function web3ListRpcProviders(source) {
+    const { provider } = await web3FromSource(source);
+    if (!provider) {
+        console.warn(`Extension ${source} does not expose any provider`);
+        return null;
+    }
+    return provider.listProviders();
+}
+/**
+ * @summary Start an RPC provider provider by a specific source
+ * @description
+ * For extensions that supply RPC providers, this call would return an
+ * enabled provider (initialized with the specific key) from the
+ * specified extension source.
+ */
+export async function web3UseRpcProvider(source, key) {
+    const { provider } = await web3FromSource(source);
+    if (!provider) {
+        throw new Error(`Extension ${source} does not expose any provider`);
+    }
+    const meta = await provider.startProvider(key);
+    return { meta, provider };
+}

package/cjs/bundle.d.ts

@@ -0,0 +1,61 @@
+import type { InjectedAccountWithMeta, InjectedExtension, InjectedProviderWithMeta, ProviderList, Unsubcall, Web3AccountsOptions } from '@polkadot/extension-inject/types';
+export { packageInfo } from './packageInfo.js';
+export { unwrapBytes, wrapBytes } from './wrapBytes.js';
+declare let isWeb3Injected: boolean;
+declare let web3EnablePromise: Promise<InjectedExtension[]> | null;
+export { isWeb3Injected, web3EnablePromise };
+/**
+ * @summary Enables all the providers found on the injected window interface
+ * @description
+ * Enables all injected extensions that has been found on the page. This
+ * should be called before making use of any other web3* functions.
+ */
+export declare function web3Enable(originName: string, compatInits?: (() => Promise<boolean>)[]): Promise<InjectedExtension[]>;
+/**
+ * @summary Retrieves all the accounts across all providers
+ * @description
+ * This returns the full list of account available (across all extensions) to
+ * the page. Filtering options are available of a per-extension, per type and
+ * per-genesisHash basis. Optionally the accounts can be encoded with the provided
+ * ss58Format
+ */
+export declare function web3Accounts({ accountType, extensions, genesisHash, ss58Format }?: Web3AccountsOptions): Promise<InjectedAccountWithMeta[]>;
+/**
+ * @summary Subscribes to all the accounts across all providers
+ * @description
+ * This is the subscription version of the web3Accounts interface with
+ * updates as to when new accounts do become available. The list of filtering
+ * options are the same as for the web3Accounts interface.
+ */
+export declare function web3AccountsSubscribe(cb: (accounts: InjectedAccountWithMeta[]) => void | Promise<void>, { accountType, extensions, genesisHash, ss58Format }?: Web3AccountsOptions): Promise<Unsubcall>;
+/**
+ * @summary Finds a specific provider based on the name
+ * @description
+ * This retrieves a specific source (extension) based on the name. In most
+ * cases it should not be needed to call it directly (e.g. it is used internally
+ * by calls such as web3FromAddress) but would allow operation on a specific
+ * known extension.
+ */
+export declare function web3FromSource(source: string): Promise<InjectedExtension>;
+/**
+ * @summary Find a specific provider that provides a specific address
+ * @description
+ * Based on an address, return the provider that has makes this address
+ * available to the page.
+ */
+export declare function web3FromAddress(address: string): Promise<InjectedExtension>;
+/**
+ * @summary List all providers exposed by one source
+ * @description
+ * For extensions that supply RPC providers, this call would return the list
+ * of RPC providers that any extension may supply.
+ */
+export declare function web3ListRpcProviders(source: string): Promise<ProviderList | null>;
+/**
+ * @summary Start an RPC provider provider by a specific source
+ * @description
+ * For extensions that supply RPC providers, this call would return an
+ * enabled provider (initialized with the specific key) from the
+ * specified extension source.
+ */
+export declare function web3UseRpcProvider(source: string, key: string): Promise<InjectedProviderWithMeta>;

package/cjs/bundle.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.web3EnablePromise = exports.isWeb3Injected = exports.wrapBytes = exports.unwrapBytes = exports.packageInfo = void 0;
+exports.web3Enable = web3Enable;
+exports.web3Accounts = web3Accounts;
+exports.web3AccountsSubscribe = web3AccountsSubscribe;
+exports.web3FromSource = web3FromSource;
+exports.web3FromAddress = web3FromAddress;
+exports.web3ListRpcProviders = web3ListRpcProviders;
+exports.web3UseRpcProvider = web3UseRpcProvider;
+const util_1 = require("@polkadot/util");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_js_1 = require("./util.js");
+var packageInfo_js_1 = require("./packageInfo.js");
+Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+var wrapBytes_js_1 = require("./wrapBytes.js");
+Object.defineProperty(exports, "unwrapBytes", { enumerable: true, get: function () { return wrapBytes_js_1.unwrapBytes; } });
+Object.defineProperty(exports, "wrapBytes", { enumerable: true, get: function () { return wrapBytes_js_1.wrapBytes; } });
+const win = window;
+win.injectedWeb3 = win.injectedWeb3 || {};
+let isWeb3Injected = web3IsInjected();
+exports.isWeb3Injected = isWeb3Injected;
+let web3EnablePromise = null;
+exports.web3EnablePromise = web3EnablePromise;
+/** @internal true when anything has been injected and is available */
+function web3IsInjected() {
+    return Object
+        .values(win.injectedWeb3)
+        .filter(({ connect, enable }) => !!(connect || enable))
+        .length !== 0;
+}
+/** @internal throw a consistent error when not extensions have not been enabled */
+function throwError(method) {
+    throw new Error(`${method}: web3Enable(originName) needs to be called before ${method}`);
+}
+/** @internal map from Array<InjectedAccount> to Array<InjectedAccountWithMeta> */
+function mapAccounts(source, list, ss58Format) {
+    return list.map(({ address, genesisHash, name, type }) => ({
+        address: address.length === 42
+            ? address
+            : (0, util_crypto_1.encodeAddress)((0, util_crypto_1.decodeAddress)(address), ss58Format),
+        meta: { genesisHash, name, source },
+        type
+    }));
+}
+/** @internal filter accounts based on genesisHash and type of account */
+function filterAccounts(list, genesisHash, type) {
+    return list.filter((a) => (!a.type || !type || type.includes(a.type)) &&
+        (!a.genesisHash || !genesisHash || a.genesisHash === genesisHash));
+}
+/** @internal retrieves all the extensions available on the window */
+function getWindowExtensions(originName) {
+    return Promise
+        .all(Object
+        .entries(win.injectedWeb3)
+        .map(([nameOrHash, { connect, enable, version }]) => Promise
+        .resolve()
+        .then(() => connect
+        // new style, returning all info
+        ? connect(originName)
+        : enable
+            // previous interface, leakages on name/version
+            ? enable(originName).then((e) => (0, util_1.objectSpread)({ name: nameOrHash, version: version || 'unknown' }, e))
+            : Promise.reject(new Error('No connect(..) or enable(...) hook found')))
+        .catch(({ message }) => {
+        console.error(`Error initializing ${nameOrHash}: ${message}`);
+    })))
+        .then((exts) => exts.filter((e) => !!e));
+}
+/** @internal Ensure the enable promise is resolved and filter by extensions */
+async function filterEnable(caller, extensions) {
+    if (!web3EnablePromise) {
+        return throwError(caller);
+    }
+    const sources = await web3EnablePromise;
+    return sources.filter(({ name }) => !extensions ||
+        extensions.includes(name));
+}
+/**
+ * @summary Enables all the providers found on the injected window interface
+ * @description
+ * Enables all injected extensions that has been found on the page. This
+ * should be called before making use of any other web3* functions.
+ */
+function web3Enable(originName, compatInits = []) {
+    if (!originName) {
+        throw new Error('You must pass a name for your app to the web3Enable function');
+    }
+    const initCompat = compatInits.length
+        ? Promise.all(compatInits.map((c) => c().catch(() => false)))
+        : Promise.resolve([true]);
+    exports.web3EnablePromise = web3EnablePromise = (0, util_js_1.documentReadyPromise)(() => initCompat.then(() => getWindowExtensions(originName)
+        .then((values) => values.map((e) => {
+        // if we don't have an accounts subscriber, add a single-shot version
+        if (!e.accounts.subscribe) {
+            e.accounts.subscribe = (cb) => {
+                e.accounts
+                    .get()
+                    .then(cb)
+                    .catch(console.error);
+                return () => {
+                    // no ubsubscribe needed, this is a single-shot
+                };
+            };
+        }
+        return e;
+    }))
+        .catch(() => [])
+        .then((values) => {
+        const names = values.map(({ name, version }) => `${name}/${version}`);
+        exports.isWeb3Injected = isWeb3Injected = web3IsInjected();
+        console.info(`web3Enable: Enabled ${values.length} extension${values.length !== 1 ? 's' : ''}: ${names.join(', ')}`);
+        return values;
+    })));
+    return web3EnablePromise;
+}
+/**
+ * @summary Retrieves all the accounts across all providers
+ * @description
+ * This returns the full list of account available (across all extensions) to
+ * the page. Filtering options are available of a per-extension, per type and
+ * per-genesisHash basis. Optionally the accounts can be encoded with the provided
+ * ss58Format
+ */
+async function web3Accounts({ accountType, extensions, genesisHash, ss58Format } = {}) {
+    const accounts = [];
+    const sources = await filterEnable('web3Accounts', extensions);
+    const retrieved = await Promise.all(sources.map(async ({ accounts, name: source }) => {
+        try {
+            const list = await accounts.get();
+            return mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format);
+        }
+        catch {
+            // cannot handle this one
+            return [];
+        }
+    }));
+    retrieved.forEach((result) => {
+        accounts.push(...result);
+    });
+    console.info(`web3Accounts: Found ${accounts.length} address${accounts.length !== 1 ? 'es' : ''}`);
+    return accounts;
+}
+/**
+ * @summary Subscribes to all the accounts across all providers
+ * @description
+ * This is the subscription version of the web3Accounts interface with
+ * updates as to when new accounts do become available. The list of filtering
+ * options are the same as for the web3Accounts interface.
+ */
+async function web3AccountsSubscribe(cb, { accountType, extensions, genesisHash, ss58Format } = {}) {
+    const sources = await filterEnable('web3AccountsSubscribe', extensions);
+    const accounts = {};
+    const triggerUpdate = () => cb(Object
+        .entries(accounts)
+        .reduce((result, [source, list]) => {
+        result.push(...mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format));
+        return result;
+    }, []));
+    const unsubs = sources.map(({ accounts: { subscribe }, name: source }) => subscribe((result) => {
+        accounts[source] = result;
+        try {
+            const result = triggerUpdate();
+            if (result && (0, util_1.isPromise)(result)) {
+                result.catch(console.error);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }));
+    return () => {
+        unsubs.forEach((unsub) => {
+            unsub();
+        });
+    };
+}
+/**
+ * @summary Finds a specific provider based on the name
+ * @description
+ * This retrieves a specific source (extension) based on the name. In most
+ * cases it should not be needed to call it directly (e.g. it is used internally
+ * by calls such as web3FromAddress) but would allow operation on a specific
+ * known extension.
+ */
+async function web3FromSource(source) {
+    if (!web3EnablePromise) {
+        return throwError('web3FromSource');
+    }
+    const sources = await web3EnablePromise;
+    const found = source && sources.find(({ name }) => name === source);
+    if (!found) {
+        throw new Error(`web3FromSource: Unable to find an injected ${source}`);
+    }
+    return found;
+}
+/**
+ * @summary Find a specific provider that provides a specific address
+ * @description
+ * Based on an address, return the provider that has makes this address
+ * available to the page.
+ */
+async function web3FromAddress(address) {
+    if (!web3EnablePromise) {
+        return throwError('web3FromAddress');
+    }
+    const accounts = await web3Accounts();
+    let found;
+    if (address) {
+        const accountU8a = (0, util_crypto_1.decodeAddress)(address);
+        found = accounts.find((account) => (0, util_1.u8aEq)((0, util_crypto_1.decodeAddress)(account.address), accountU8a));
+    }
+    if (!found) {
+        throw new Error(`web3FromAddress: Unable to find injected ${address}`);
+    }
+    return web3FromSource(found.meta.source);
+}
+/**
+ * @summary List all providers exposed by one source
+ * @description
+ * For extensions that supply RPC providers, this call would return the list
+ * of RPC providers that any extension may supply.
+ */
+async function web3ListRpcProviders(source) {
+    const { provider } = await web3FromSource(source);
+    if (!provider) {
+        console.warn(`Extension ${source} does not expose any provider`);
+        return null;
+    }
+    return provider.listProviders();
+}
+/**
+ * @summary Start an RPC provider provider by a specific source
+ * @description
+ * For extensions that supply RPC providers, this call would return an
+ * enabled provider (initialized with the specific key) from the
+ * specified extension source.
+ */
+async function web3UseRpcProvider(source, key) {
+    const { provider } = await web3FromSource(source);
+    if (!provider) {
+        throw new Error(`Extension ${source} does not expose any provider`);
+    }
+    const meta = await provider.startProvider(key);
+    return { meta, provider };
+}

package/cjs/index.d.ts

@@ -0,0 +1 @@
+export * from './bundle.js';

package/cjs/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./bundle.js"), exports);

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/cjs/packageDetect.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@polkadot/extension-inject/cjs/packageInfo");
+const util_1 = require("@polkadot/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo]);

package/cjs/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@polkadot/extension-dapp', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '0.62.6' };

package/cjs/util.d.ts

@@ -0,0 +1 @@
+export declare function documentReadyPromise<T>(creator: () => Promise<T>): Promise<T>;

package/cjs/util.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.documentReadyPromise = documentReadyPromise;
+function documentReadyPromise(creator) {
+    return new Promise((resolve) => {
+        if (document.readyState === 'complete') {
+            resolve(creator());
+        }
+        else {
+            window.addEventListener('load', () => resolve(creator()));
+        }
+    });
+}

package/cjs/wrapBytes.d.ts

@@ -0,0 +1,7 @@
+import { u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
+export declare const ETHEREUM: Uint8Array<ArrayBufferLike>;
+export declare const POSTFIX: Uint8Array<ArrayBufferLike>;
+export declare const PREFIX: Uint8Array<ArrayBufferLike>;
+export declare const isWrapped: typeof u8aIsWrapped;
+export declare const unwrapBytes: typeof u8aUnwrapBytes;
+export declare const wrapBytes: typeof u8aWrapBytes;

package/cjs/wrapBytes.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapBytes = exports.unwrapBytes = exports.isWrapped = exports.PREFIX = exports.POSTFIX = exports.ETHEREUM = void 0;
+const util_1 = require("@polkadot/util");
+exports.ETHEREUM = util_1.U8A_WRAP_ETHEREUM;
+exports.POSTFIX = util_1.U8A_WRAP_POSTFIX;
+exports.PREFIX = util_1.U8A_WRAP_PREFIX;
+exports.isWrapped = util_1.u8aIsWrapped;
+exports.unwrapBytes = util_1.u8aUnwrapBytes;
+exports.wrapBytes = util_1.u8aWrapBytes;

package/index.d.ts

@@ -0,0 +1 @@
+export * from './bundle.js';

package/index.js

@@ -0,0 +1 @@
+export * from './bundle.js';

package/package.json

@@ -0,0 +1,142 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-extension/issues",
+  "description": "Provides an interfaces around the injected globals for ease of access by dapp developers.",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-extension/tree/master/packages/extension-dapp#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/extension-dapp",
+  "repository": {
+    "directory": "packages/extension-dapp",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-extension.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./cjs/packageDetect.js"
+  ],
+  "type": "module",
+  "version": "0.62.6",
+  "main": "./cjs/index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    "./cjs/package.json": "./cjs/package.json",
+    "./cjs/*": "./cjs/*.js",
+    ".": {
+      "module": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "require": {
+        "types": "./cjs/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "default": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      }
+    },
+    "./bundle": {
+      "module": {
+        "types": "./bundle.d.ts",
+        "default": "./bundle.js"
+      },
+      "require": {
+        "types": "./cjs/bundle.d.ts",
+        "default": "./cjs/bundle.js"
+      },
+      "default": {
+        "types": "./bundle.d.ts",
+        "default": "./bundle.js"
+      }
+    },
+    "./package.json": {
+      "require": "./cjs/package.json",
+      "default": "./package.json"
+    },
+    "./packageDetect": {
+      "module": {
+        "types": "./packageDetect.d.ts",
+        "default": "./packageDetect.js"
+      },
+      "require": {
+        "types": "./cjs/packageDetect.d.ts",
+        "default": "./cjs/packageDetect.js"
+      },
+      "default": {
+        "types": "./packageDetect.d.ts",
+        "default": "./packageDetect.js"
+      }
+    },
+    "./packageInfo.js": {
+      "module": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      },
+      "require": {
+        "types": "./cjs/packageInfo.d.ts",
+        "default": "./cjs/packageInfo.js"
+      },
+      "default": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      }
+    },
+    "./packageInfo": {
+      "module": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      },
+      "require": {
+        "types": "./cjs/packageInfo.d.ts",
+        "default": "./cjs/packageInfo.js"
+      },
+      "default": {
+        "types": "./packageInfo.d.ts",
+        "default": "./packageInfo.js"
+      }
+    },
+    "./util": {
+      "module": {
+        "types": "./util.d.ts",
+        "default": "./util.js"
+      },
+      "require": {
+        "types": "./cjs/util.d.ts",
+        "default": "./cjs/util.js"
+      },
+      "default": {
+        "types": "./util.d.ts",
+        "default": "./util.js"
+      }
+    },
+    "./wrapBytes": {
+      "module": {
+        "types": "./wrapBytes.d.ts",
+        "default": "./wrapBytes.js"
+      },
+      "require": {
+        "types": "./cjs/wrapBytes.d.ts",
+        "default": "./cjs/wrapBytes.js"
+      },
+      "default": {
+        "types": "./wrapBytes.d.ts",
+        "default": "./wrapBytes.js"
+      }
+    }
+  },
+  "dependencies": {
+    "@pezkuwi/extension-inject": "0.62.6",
+    "@pezkuwi/util": "^14.0.5",
+    "@pezkuwi/util-crypto": "^14.0.5",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "@pezkuwi/api": "*",
+    "@pezkuwi/util": "*",
+    "@pezkuwi/util-crypto": "*"
+  }
+}

package/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/packageDetect.js

@@ -0,0 +1,4 @@
+import { packageInfo as injectInfo } from '@polkadot/extension-inject/packageInfo';
+import { detectPackage } from '@polkadot/util';
+import { packageInfo } from './packageInfo.js';
+detectPackage(packageInfo, null, [injectInfo]);

package/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/packageInfo.js

@@ -0,0 +1 @@
+export const packageInfo = { name: '@polkadot/extension-dapp', path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '0.62.6' };

package/util.d.ts

@@ -0,0 +1 @@
+export declare function documentReadyPromise<T>(creator: () => Promise<T>): Promise<T>;

package/util.js

@@ -0,0 +1,10 @@
+export function documentReadyPromise(creator) {
+    return new Promise((resolve) => {
+        if (document.readyState === 'complete') {
+            resolve(creator());
+        }
+        else {
+            window.addEventListener('load', () => resolve(creator()));
+        }
+    });
+}

package/wrapBytes.d.ts

@@ -0,0 +1,7 @@
+import { u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
+export declare const ETHEREUM: Uint8Array<ArrayBufferLike>;
+export declare const POSTFIX: Uint8Array<ArrayBufferLike>;
+export declare const PREFIX: Uint8Array<ArrayBufferLike>;
+export declare const isWrapped: typeof u8aIsWrapped;
+export declare const unwrapBytes: typeof u8aUnwrapBytes;
+export declare const wrapBytes: typeof u8aWrapBytes;

package/wrapBytes.js

@@ -0,0 +1,7 @@
+import { U8A_WRAP_ETHEREUM, U8A_WRAP_POSTFIX, U8A_WRAP_PREFIX, u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
+export const ETHEREUM = U8A_WRAP_ETHEREUM;
+export const POSTFIX = U8A_WRAP_POSTFIX;
+export const PREFIX = U8A_WRAP_PREFIX;
+export const isWrapped = u8aIsWrapped;
+export const unwrapBytes = u8aUnwrapBytes;
+export const wrapBytes = u8aWrapBytes;