@pezkuwi/extension-dapp 0.62.11 → 0.62.12

package/bundle.js

@@ -1,138 +1,66 @@
-// Copyright 2019-2025 @pezkuwi/extension-dapp authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-var __awaiter = (this && this.__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 __generator = (this && this.__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 };
-    }
-};
 import { isPromise, objectSpread, u8aEq } from '@pezkuwi/util';
 import { decodeAddress, encodeAddress } from '@pezkuwi/util-crypto';
 import { documentReadyPromise } from './util.js';
-// expose utility functions
 export { packageInfo } from './packageInfo.js';
 export { unwrapBytes, wrapBytes } from './wrapBytes.js';
-// just a helper (otherwise we cast all-over, so shorter and more readable)
-var win = window;
-// don't clobber the existing object, but ensure non-undefined
+const win = window;
 win.injectedWeb3 = win.injectedWeb3 || {};
-// have we found a properly constructed window.injectedWeb3
-var isWeb3Injected = web3IsInjected();
-// we keep the last promise created around (for queries)
-var web3EnablePromise = null;
+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(function (_a) {
-        var connect = _a.connect, enable = _a.enable;
-        return !!(connect || enable);
-    })
+        .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("".concat(method, ": web3Enable(originName) needs to be called before ").concat(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(function (_a) {
-        var address = _a.address, genesisHash = _a.genesisHash, name = _a.name, type = _a.type;
-        return ({
-            address: address.length === 42
-                ? address
-                : encodeAddress(decodeAddress(address), ss58Format),
-            meta: { genesisHash: genesisHash, name: name, source: source },
-            type: type
-        });
-    });
+    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(function (a) {
-        return (!a.type || !type || type.includes(a.type)) &&
-            (!a.genesisHash || !genesisHash || a.genesisHash === genesisHash);
-    });
+    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(function (_a) {
-        var nameOrHash = _a[0], _b = _a[1], connect = _b.connect, enable = _b.enable, version = _b.version;
-        return Promise
-            .resolve()
-            .then(function () {
-            return connect
-                // new style, returning all info
-                ? connect(originName)
-                : enable
-                    // previous interface, leakages on name/version
-                    ? enable(originName).then(function (e) {
-                        return objectSpread({ name: nameOrHash, version: version || 'unknown' }, e);
-                    })
-                    : Promise.reject(new Error('No connect(..) or enable(...) hook found'));
-        })
-            .catch(function (_a) {
-            var message = _a.message;
-            console.error("Error initializing ".concat(nameOrHash, ": ").concat(message));
-        });
-    }))
-        .then(function (exts) { return exts.filter(function (e) { return !!e; }); });
+        .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 */
-function filterEnable(caller, extensions) {
-    return __awaiter(this, void 0, void 0, function () {
-        var sources;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!web3EnablePromise) {
-                        return [2 /*return*/, throwError(caller)];
-                    }
-                    return [4 /*yield*/, web3EnablePromise];
-                case 1:
-                    sources = _a.sent();
-                    return [2 /*return*/, sources.filter(function (_a) {
-                            var name = _a.name;
-                            return !extensions ||
-                                extensions.includes(name);
-                        })];
-            }
-        });
-    });
+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
@@ -140,46 +68,36 @@ function filterEnable(caller, extensions) {
  * 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 (compatInits === void 0) { compatInits = []; }
+export function web3Enable(originName, compatInits = []) {
     if (!originName) {
         throw new Error('You must pass a name for your app to the web3Enable function');
     }
-    var initCompat = compatInits.length
-        ? Promise.all(compatInits.map(function (c) { return c().catch(function () { return false; }); }))
+    const initCompat = compatInits.length
+        ? Promise.all(compatInits.map((c) => c().catch(() => false)))
         : Promise.resolve([true]);
-    web3EnablePromise = documentReadyPromise(function () {
-        return initCompat.then(function () {
-            return getWindowExtensions(originName)
-                .then(function (values) {
-                return values.map(function (e) {
-                    // if we don't have an accounts subscriber, add a single-shot version
-                    if (!e.accounts.subscribe) {
-                        e.accounts.subscribe = function (cb) {
-                            e.accounts
-                                .get()
-                                .then(cb)
-                                .catch(console.error);
-                            return function () {
-                                // no ubsubscribe needed, this is a single-shot
-                            };
-                        };
-                    }
-                    return e;
-                });
-            })
-                .catch(function () { return []; })
-                .then(function (values) {
-                var names = values.map(function (_a) {
-                    var name = _a.name, version = _a.version;
-                    return "".concat(name, "/").concat(version);
-                });
-                isWeb3Injected = web3IsInjected();
-                console.info("web3Enable: Enabled ".concat(values.length, " extension").concat(values.length !== 1 ? 's' : '', ": ").concat(names.join(', ')));
-                return values;
-            });
-        });
-    });
+    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;
 }
 /**
@@ -190,47 +108,24 @@ export function web3Enable(originName, compatInits) {
  * per-genesisHash basis. Optionally the accounts can be encoded with the provided
  * ss58Format
  */
-export function web3Accounts() {
-    return __awaiter(this, arguments, void 0, function (_a) {
-        var accounts, sources, retrieved;
-        var _this = this;
-        var _b = _a === void 0 ? {} : _a, accountType = _b.accountType, extensions = _b.extensions, genesisHash = _b.genesisHash, ss58Format = _b.ss58Format;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    accounts = [];
-                    return [4 /*yield*/, filterEnable('web3Accounts', extensions)];
-                case 1:
-                    sources = _c.sent();
-                    return [4 /*yield*/, Promise.all(sources.map(function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
-                            var list, _c;
-                            var accounts = _b.accounts, source = _b.name;
-                            return __generator(this, function (_d) {
-                                switch (_d.label) {
-                                    case 0:
-                                        _d.trys.push([0, 2, , 3]);
-                                        return [4 /*yield*/, accounts.get()];
-                                    case 1:
-                                        list = _d.sent();
-                                        return [2 /*return*/, mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format)];
-                                    case 2:
-                                        _c = _d.sent();
-                                        // cannot handle this one
-                                        return [2 /*return*/, []];
-                                    case 3: return [2 /*return*/];
-                                }
-                            });
-                        }); }))];
-                case 2:
-                    retrieved = _c.sent();
-                    retrieved.forEach(function (result) {
-                        accounts.push.apply(accounts, result);
-                    });
-                    console.info("web3Accounts: Found ".concat(accounts.length, " address").concat(accounts.length !== 1 ? 'es' : ''));
-                    return [2 /*return*/, accounts];
-            }
-        });
+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
@@ -239,48 +134,32 @@ export function web3Accounts() {
  * updates as to when new accounts do become available. The list of filtering
  * options are the same as for the web3Accounts interface.
  */
-export function web3AccountsSubscribe(cb_1) {
-    return __awaiter(this, arguments, void 0, function (cb, _a) {
-        var sources, accounts, triggerUpdate, unsubs;
-        var _b = _a === void 0 ? {} : _a, accountType = _b.accountType, extensions = _b.extensions, genesisHash = _b.genesisHash, ss58Format = _b.ss58Format;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0: return [4 /*yield*/, filterEnable('web3AccountsSubscribe', extensions)];
-                case 1:
-                    sources = _c.sent();
-                    accounts = {};
-                    triggerUpdate = function () {
-                        return cb(Object
-                            .entries(accounts)
-                            .reduce(function (result, _a) {
-                            var source = _a[0], list = _a[1];
-                            result.push.apply(result, mapAccounts(source, filterAccounts(list, genesisHash, accountType), ss58Format));
-                            return result;
-                        }, []));
-                    };
-                    unsubs = sources.map(function (_a) {
-                        var subscribe = _a.accounts.subscribe, source = _a.name;
-                        return subscribe(function (result) {
-                            accounts[source] = result;
-                            try {
-                                var result_1 = triggerUpdate();
-                                if (result_1 && isPromise(result_1)) {
-                                    result_1.catch(console.error);
-                                }
-                            }
-                            catch (error) {
-                                console.error(error);
-                            }
-                        });
-                    });
-                    return [2 /*return*/, function () {
-                            unsubs.forEach(function (unsub) {
-                                unsub();
-                            });
-                        }];
+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
@@ -290,29 +169,16 @@ export function web3AccountsSubscribe(cb_1) {
  * by calls such as web3FromAddress) but would allow operation on a specific
  * known extension.
  */
-export function web3FromSource(source) {
-    return __awaiter(this, void 0, void 0, function () {
-        var sources, found;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!web3EnablePromise) {
-                        return [2 /*return*/, throwError('web3FromSource')];
-                    }
-                    return [4 /*yield*/, web3EnablePromise];
-                case 1:
-                    sources = _a.sent();
-                    found = source && sources.find(function (_a) {
-                        var name = _a.name;
-                        return name === source;
-                    });
-                    if (!found) {
-                        throw new Error("web3FromSource: Unable to find an injected ".concat(source));
-                    }
-                    return [2 /*return*/, found];
-            }
-        });
-    });
+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
@@ -320,29 +186,20 @@ export function web3FromSource(source) {
  * Based on an address, return the provider that has makes this address
  * available to the page.
  */
-export function web3FromAddress(address) {
-    return __awaiter(this, void 0, void 0, function () {
-        var accounts, found, accountU8a_1;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!web3EnablePromise) {
-                        return [2 /*return*/, throwError('web3FromAddress')];
-                    }
-                    return [4 /*yield*/, web3Accounts()];
-                case 1:
-                    accounts = _a.sent();
-                    if (address) {
-                        accountU8a_1 = decodeAddress(address);
-                        found = accounts.find(function (account) { return u8aEq(decodeAddress(account.address), accountU8a_1); });
-                    }
-                    if (!found) {
-                        throw new Error("web3FromAddress: Unable to find injected ".concat(address));
-                    }
-                    return [2 /*return*/, web3FromSource(found.meta.source)];
-            }
-        });
-    });
+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
@@ -350,22 +207,13 @@ export function web3FromAddress(address) {
  * For extensions that supply RPC providers, this call would return the list
  * of RPC providers that any extension may supply.
  */
-export function web3ListRpcProviders(source) {
-    return __awaiter(this, void 0, void 0, function () {
-        var provider;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, web3FromSource(source)];
-                case 1:
-                    provider = (_a.sent()).provider;
-                    if (!provider) {
-                        console.warn("Extension ".concat(source, " does not expose any provider"));
-                        return [2 /*return*/, null];
-                    }
-                    return [2 /*return*/, provider.listProviders()];
-            }
-        });
-    });
+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
@@ -374,22 +222,11 @@ export function web3ListRpcProviders(source) {
  * enabled provider (initialized with the specific key) from the
  * specified extension source.
  */
-export function web3UseRpcProvider(source, key) {
-    return __awaiter(this, void 0, void 0, function () {
-        var provider, meta;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, web3FromSource(source)];
-                case 1:
-                    provider = (_a.sent()).provider;
-                    if (!provider) {
-                        throw new Error("Extension ".concat(source, " does not expose any provider"));
-                    }
-                    return [4 /*yield*/, provider.startProvider(key)];
-                case 2:
-                    meta = _a.sent();
-                    return [2 /*return*/, { meta: meta, provider: provider }];
-            }
-        });
-    });
+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 '@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>;