@pezkuwi/extension-dapp 0.62.7 → 0.62.8

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/{cjs → build}/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/build/bundle.js

@@ -0,0 +1,395 @@
+// 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
+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;
+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);
+    })
+        .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));
+}
+/** @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
+        });
+    });
+}
+/** @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);
+    });
+}
+/** @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; }); });
+}
+/** @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);
+                        })];
+            }
+        });
+    });
+}
+/**
+ * @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 (compatInits === void 0) { 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; }); }))
+        : 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;
+            });
+        });
+    });
+    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 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];
+            }
+        });
+    });
+}
+/**
+ * @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 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();
+                            });
+                        }];
+            }
+        });
+    });
+}
+/**
+ * @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 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
+ * @description
+ * 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)];
+            }
+        });
+    });
+}
+/**
+ * @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 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
+ * @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 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/build/index.js

@@ -0,0 +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';

package/build/packageDetect.js

@@ -0,0 +1,8 @@
+// Copyright 2017-2025 @pezkuwi/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @pezkuwi/dev
+// (packageInfo imports will be kept as-is, user-editable)
+import { packageInfo as injectInfo } from '@pezkuwi/extension-inject/packageInfo';
+import { detectPackage } from '@pezkuwi/util';
+import { packageInfo } from './packageInfo.js';
+detectPackage(packageInfo, null, [injectInfo]);

package/build/packageInfo.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2025 @pezkuwi/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @pezkuwi/dev
+export var packageInfo = { name: '@pezkuwi/extension-dapp', path: 'auto', type: 'auto', version: '0.62.6' };

package/build/util.js

@@ -0,0 +1,12 @@
+// Copyright 2019-2025 @pezkuwi/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export function documentReadyPromise(creator) {
+    return new Promise(function (resolve) {
+        if (document.readyState === 'complete') {
+            resolve(creator());
+        }
+        else {
+            window.addEventListener('load', function () { return resolve(creator()); });
+        }
+    });
+}

package/{cjs → build}/wrapBytes.d.ts

@@ -1,4 +1,4 @@
-import { u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from '@polkadot/util';
+import { u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from '@pezkuwi/util';
 export declare const ETHEREUM: Uint8Array<ArrayBufferLike>;
 export declare const POSTFIX: Uint8Array<ArrayBufferLike>;
 export declare const PREFIX: Uint8Array<ArrayBufferLike>;

package/build/wrapBytes.js

@@ -0,0 +1,9 @@
+// Copyright 2019-2025 @pezkuwi/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { U8A_WRAP_ETHEREUM, U8A_WRAP_POSTFIX, U8A_WRAP_PREFIX, u8aIsWrapped, u8aUnwrapBytes, u8aWrapBytes } from '@pezkuwi/util';
+export var ETHEREUM = U8A_WRAP_ETHEREUM;
+export var POSTFIX = U8A_WRAP_POSTFIX;
+export var PREFIX = U8A_WRAP_PREFIX;
+export var isWrapped = u8aIsWrapped;
+export var unwrapBytes = u8aUnwrapBytes;
+export var wrapBytes = u8aWrapBytes;

package/package.json

@@ -15,125 +15,20 @@
   },
   "sideEffects": [
     "./packageDetect.js",
-    "./cjs/packageDetect.js"
+    "./packageDetect.cjs"
   ],
   "type": "module",
-  "version": "0.62.7",
-  "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"
-      }
-    }
-  },
+  "version": "0.62.8",
+  "main": "index.js",
   "dependencies": {
-    "@pezkuwi/extension-inject": "0.62.7",
+    "@pezkuwi/extension-inject": "0.62.6",
     "@pezkuwi/util": "^14.0.5",
     "@pezkuwi/util-crypto": "^14.0.5",
     "tslib": "^2.8.1"
   },
+  "devDependencies": {
+    "@pezkuwi/dev-test": "^0.84.3"
+  },
   "peerDependencies": {
     "@pezkuwi/api": "*",
     "@pezkuwi/util": "*",