@pezkuwi/extension-dapp 0.62.14 → 0.62.17

package/build/README.md

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

package/build/bundle.js

@@ -0,0 +1,232 @@
+import { isPromise, objectSpread, u8aEq } from '@pezkuwi/util';
+import { decodeAddress, encodeAddress } from '@pezkuwi/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/build/cjs/bundle.d.ts

@@ -0,0 +1,61 @@
+import type { InjectedAccountWithMeta, InjectedExtension, InjectedProviderWithMeta, ProviderList, Unsubcall, Web3AccountsOptions } from '@pezkuwi/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/build/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("@pezkuwi/util");
+const util_crypto_1 = require("@pezkuwi/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/build/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/build/cjs/packageInfo.js

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

package/build/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/build/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("@pezkuwi/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/build/index.d.ts

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

package/build/index.js

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