@pezkuwi/extension-dapp 0.62.7 → 0.62.10

package/README.md

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

package/bundle.d.ts

@@ -1,4 +1,4 @@
-import type { InjectedAccountWithMeta, InjectedExtension, InjectedProviderWithMeta, ProviderList, Unsubcall, Web3AccountsOptions } from '@polkadot/extension-inject/types';
+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;

package/bundle.js

@@ -1,66 +1,138 @@
-import { isPromise, objectSpread, u8aEq } from '@polkadot/util';
-import { decodeAddress, encodeAddress } from '@polkadot/util-crypto';
+// 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';
-const win = window;
+// 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
 win.injectedWeb3 = win.injectedWeb3 || {};
-let isWeb3Injected = web3IsInjected();
-let web3EnablePromise = null;
+// have we found a properly constructed window.injectedWeb3
+var isWeb3Injected = web3IsInjected();
+// we keep the last promise created around (for queries)
+var 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))
+        .filter(function (_a) {
+        var connect = _a.connect, enable = _a.enable;
+        return !!(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}`);
+    throw new Error("".concat(method, ": web3Enable(originName) needs to be called before ").concat(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
-    }));
+    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
+        });
+    });
 }
 /** @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));
+    return list.filter(function (a) {
+        return (!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));
+        .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; }); });
 }
 /** @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));
+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);
+                        })];
+            }
+        });
+    });
 }
 /**
  * @summary Enables all the providers found on the injected window interface
@@ -68,36 +140,46 @@ async 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 = []) {
+export function web3Enable(originName, compatInits) {
+    if (compatInits === void 0) { 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)))
+    var initCompat = compatInits.length
+        ? Promise.all(compatInits.map(function (c) { return c().catch(function () { return 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;
-    })));
+    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;
+            });
+        });
+    });
     return web3EnablePromise;
 }
 /**
@@ -108,24 +190,47 @@ export function web3Enable(originName, compatInits = []) {
  * 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);
+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];
+            }
+        });
     });
-    console.info(`web3Accounts: Found ${accounts.length} address${accounts.length !== 1 ? 'es' : ''}`);
-    return accounts;
 }
 /**
  * @summary Subscribes to all the accounts across all providers
@@ -134,32 +239,48 @@ export async function web3Accounts({ accountType, extensions, genesisHash, ss58F
  * 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);
+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();
+                            });
+                        }];
             }
-        }
-        catch (error) {
-            console.error(error);
-        }
-    }));
-    return () => {
-        unsubs.forEach((unsub) => {
-            unsub();
         });
-    };
+    });
 }
 /**
  * @summary Finds a specific provider based on the name
@@ -169,16 +290,29 @@ export async function web3AccountsSubscribe(cb, { accountType, extensions, genes
  * 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;
+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];
+            }
+        });
+    });
 }
 /**
  * @summary Find a specific provider that provides a specific address
@@ -186,20 +320,29 @@ export async function web3FromSource(source) {
  * 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);
+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)];
+            }
+        });
+    });
 }
 /**
  * @summary List all providers exposed by one source
@@ -207,13 +350,22 @@ export async function web3FromAddress(address) {
  * 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();
+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()];
+            }
+        });
+    });
 }
 /**
  * @summary Start an RPC provider provider by a specific source
@@ -222,11 +374,22 @@ export async function web3ListRpcProviders(source) {
  * 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 };
+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 }];
+            }
+        });
+    });
 }

package/index.js

@@ -1 +1,5 @@
+// Copyright 2019-2025 @pezkuwi/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Since we inject into pages, we skip this
+// import './packageDetect.js';
 export * from './bundle.js';