@subwallet/extension-dapp 0.3.6-0

package/build/bundle.js

@@ -0,0 +1,222 @@
+// Copyright 2019-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { u8aEq } from '@polkadot/util';
+import { decodeAddress, encodeAddress } from '@polkadot/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)
+
+const win = window; // don't clobber the existing object, but ensure non-undefined
+
+win.injectedWeb3 = win.injectedWeb3 || {}; // true when anything has been injected and is available
+
+function web3IsInjected() {
+  return Object.keys(win.injectedWeb3).length !== 0;
+} // helper to throw a consistent error when not enabled
+
+
+function throwError(method) {
+  throw new Error(`${method}: web3Enable(originName) needs to be called before ${method}`);
+} // internal helper to map from Array<InjectedAccount> -> Array<InjectedAccountWithMeta>
+
+
+function mapAccounts(source, list, ss58Format) {
+  return list.map(({
+    address,
+    genesisHash,
+    name,
+    type
+  }) => {
+    const encodedAddress = address.length === 42 ? address : encodeAddress(decodeAddress(address), ss58Format);
+    return {
+      address: encodedAddress,
+      meta: {
+        genesisHash,
+        name,
+        source
+      },
+      type
+    };
+  });
+} // have we found a properly constructed window.injectedWeb3
+
+
+let isWeb3Injected = web3IsInjected(); // we keep the last promise created around (for queries)
+
+let web3EnablePromise = null;
+export { isWeb3Injected, web3EnablePromise };
+
+function getWindowExtensions(originName) {
+  return Promise.all(Object.entries(win.injectedWeb3).map(([name, {
+    enable,
+    version
+  }]) => Promise.all([Promise.resolve({
+    name,
+    version
+  }), enable(originName).catch(error => {
+    console.error(`Error initializing ${name}: ${error.message}`);
+  })])));
+} // enables all the providers found on the injected window interface
+
+
+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.filter(value => !!value[1]).map(([info, ext]) => {
+    // if we don't have an accounts subscriber, add a single-shot version
+    if (!ext.accounts.subscribe) {
+      ext.accounts.subscribe = cb => {
+        ext.accounts.get().then(cb).catch(console.error);
+        return () => {// no ubsubscribe needed, this is a single-shot
+        };
+      };
+    }
+
+    return { ...info,
+      ...ext
+    };
+  })).catch(() => []).then(values => {
+    const names = values.map(({
+      name,
+      version
+    }) => `${name}/${version}`);
+    isWeb3Injected = web3IsInjected();
+    console.log(`web3Enable: Enabled ${values.length} extension${values.length !== 1 ? 's' : ''}: ${names.join(', ')}`);
+    return values;
+  })));
+  return web3EnablePromise;
+} // retrieve all the accounts across all providers
+
+export async function web3Accounts({
+  accountType,
+  ss58Format
+} = {}) {
+  if (!web3EnablePromise) {
+    return throwError('web3Accounts');
+  }
+
+  const accounts = [];
+  const injected = await web3EnablePromise;
+  const retrieved = await Promise.all(injected.map(async ({
+    accounts,
+    name: source
+  }) => {
+    try {
+      const list = await accounts.get();
+      return mapAccounts(source, list.filter(({
+        type
+      }) => type && accountType ? accountType.includes(type) : true), ss58Format);
+    } catch (error) {
+      // cannot handle this one
+      return [];
+    }
+  }));
+  retrieved.forEach(result => {
+    accounts.push(...result);
+  });
+  const addresses = accounts.map(({
+    address
+  }) => address);
+  console.log(`web3Accounts: Found ${accounts.length} address${accounts.length !== 1 ? 'es' : ''}: ${addresses.join(', ')}`);
+  return accounts;
+}
+export async function web3AccountsSubscribe(cb, {
+  ss58Format
+} = {}) {
+  if (!web3EnablePromise) {
+    return throwError('web3AccountsSubscribe');
+  }
+
+  const accounts = {};
+
+  const triggerUpdate = () => cb(Object.entries(accounts).reduce((result, [source, list]) => {
+    result.push(...mapAccounts(source, list, ss58Format));
+    return result;
+  }, []));
+
+  const unsubs = (await web3EnablePromise).map(({
+    accounts: {
+      subscribe
+    },
+    name: source
+  }) => subscribe(result => {
+    accounts[source] = result; // eslint-disable-next-line @typescript-eslint/no-floating-promises
+
+    triggerUpdate();
+  }));
+  return () => {
+    unsubs.forEach(unsub => {
+      unsub();
+    });
+  };
+} // find a specific provider based on the name
+
+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;
+} // find a specific provider based on an address
+
+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);
+} // retrieve all providers exposed by one source
+
+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();
+} // retrieve all providers exposed by one 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.js

@@ -0,0 +1,297 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWeb3Injected = void 0;
+Object.defineProperty(exports, "packageInfo", {
+  enumerable: true,
+  get: function () {
+    return _packageInfo.packageInfo;
+  }
+});
+Object.defineProperty(exports, "unwrapBytes", {
+  enumerable: true,
+  get: function () {
+    return _wrapBytes.unwrapBytes;
+  }
+});
+exports.web3Accounts = web3Accounts;
+exports.web3AccountsSubscribe = web3AccountsSubscribe;
+exports.web3Enable = web3Enable;
+exports.web3EnablePromise = void 0;
+exports.web3FromAddress = web3FromAddress;
+exports.web3FromSource = web3FromSource;
+exports.web3ListRpcProviders = web3ListRpcProviders;
+exports.web3UseRpcProvider = web3UseRpcProvider;
+Object.defineProperty(exports, "wrapBytes", {
+  enumerable: true,
+  get: function () {
+    return _wrapBytes.wrapBytes;
+  }
+});
+
+var _util = require("@polkadot/util");
+
+var _utilCrypto = require("@polkadot/util-crypto");
+
+var _util2 = require("./util");
+
+var _packageInfo = require("./packageInfo");
+
+var _wrapBytes = require("./wrapBytes");
+
+// Copyright 2019-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// expose utility functions
+// just a helper (otherwise we cast all-over, so shorter and more readable)
+const win = window; // don't clobber the existing object, but ensure non-undefined
+
+win.injectedWeb3 = win.injectedWeb3 || {}; // true when anything has been injected and is available
+
+function web3IsInjected() {
+  return Object.keys(win.injectedWeb3).length !== 0;
+} // helper to throw a consistent error when not enabled
+
+
+function throwError(method) {
+  throw new Error(`${method}: web3Enable(originName) needs to be called before ${method}`);
+} // internal helper to map from Array<InjectedAccount> -> Array<InjectedAccountWithMeta>
+
+
+function mapAccounts(source, list, ss58Format) {
+  return list.map(_ref => {
+    let {
+      address,
+      genesisHash,
+      name,
+      type
+    } = _ref;
+    const encodedAddress = address.length === 42 ? address : (0, _utilCrypto.encodeAddress)((0, _utilCrypto.decodeAddress)(address), ss58Format);
+    return {
+      address: encodedAddress,
+      meta: {
+        genesisHash,
+        name,
+        source
+      },
+      type
+    };
+  });
+} // have we found a properly constructed window.injectedWeb3
+
+
+let isWeb3Injected = web3IsInjected(); // we keep the last promise created around (for queries)
+
+exports.isWeb3Injected = isWeb3Injected;
+let web3EnablePromise = null;
+exports.web3EnablePromise = web3EnablePromise;
+
+function getWindowExtensions(originName) {
+  return Promise.all(Object.entries(win.injectedWeb3).map(_ref2 => {
+    let [name, {
+      enable,
+      version
+    }] = _ref2;
+    return Promise.all([Promise.resolve({
+      name,
+      version
+    }), enable(originName).catch(error => {
+      console.error(`Error initializing ${name}: ${error.message}`);
+    })]);
+  }));
+} // enables all the providers found on the injected window interface
+
+
+function web3Enable(originName) {
+  let compatInits = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
+  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, _util2.documentReadyPromise)(() => initCompat.then(() => getWindowExtensions(originName).then(values => values.filter(value => !!value[1]).map(_ref3 => {
+    let [info, ext] = _ref3;
+
+    // if we don't have an accounts subscriber, add a single-shot version
+    if (!ext.accounts.subscribe) {
+      ext.accounts.subscribe = cb => {
+        ext.accounts.get().then(cb).catch(console.error);
+        return () => {// no ubsubscribe needed, this is a single-shot
+        };
+      };
+    }
+
+    return { ...info,
+      ...ext
+    };
+  })).catch(() => []).then(values => {
+    const names = values.map(_ref4 => {
+      let {
+        name,
+        version
+      } = _ref4;
+      return `${name}/${version}`;
+    });
+    exports.isWeb3Injected = isWeb3Injected = web3IsInjected();
+    console.log(`web3Enable: Enabled ${values.length} extension${values.length !== 1 ? 's' : ''}: ${names.join(', ')}`);
+    return values;
+  })));
+  return web3EnablePromise;
+} // retrieve all the accounts across all providers
+
+
+async function web3Accounts() {
+  let {
+    accountType,
+    ss58Format
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  if (!web3EnablePromise) {
+    return throwError('web3Accounts');
+  }
+
+  const accounts = [];
+  const injected = await web3EnablePromise;
+  const retrieved = await Promise.all(injected.map(async _ref5 => {
+    let {
+      accounts,
+      name: source
+    } = _ref5;
+
+    try {
+      const list = await accounts.get();
+      return mapAccounts(source, list.filter(_ref6 => {
+        let {
+          type
+        } = _ref6;
+        return type && accountType ? accountType.includes(type) : true;
+      }), ss58Format);
+    } catch (error) {
+      // cannot handle this one
+      return [];
+    }
+  }));
+  retrieved.forEach(result => {
+    accounts.push(...result);
+  });
+  const addresses = accounts.map(_ref7 => {
+    let {
+      address
+    } = _ref7;
+    return address;
+  });
+  console.log(`web3Accounts: Found ${accounts.length} address${accounts.length !== 1 ? 'es' : ''}: ${addresses.join(', ')}`);
+  return accounts;
+}
+
+async function web3AccountsSubscribe(cb) {
+  let {
+    ss58Format
+  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+  if (!web3EnablePromise) {
+    return throwError('web3AccountsSubscribe');
+  }
+
+  const accounts = {};
+
+  const triggerUpdate = () => cb(Object.entries(accounts).reduce((result, _ref8) => {
+    let [source, list] = _ref8;
+    result.push(...mapAccounts(source, list, ss58Format));
+    return result;
+  }, []));
+
+  const unsubs = (await web3EnablePromise).map(_ref9 => {
+    let {
+      accounts: {
+        subscribe
+      },
+      name: source
+    } = _ref9;
+    return subscribe(result => {
+      accounts[source] = result; // eslint-disable-next-line @typescript-eslint/no-floating-promises
+
+      triggerUpdate();
+    });
+  });
+  return () => {
+    unsubs.forEach(unsub => {
+      unsub();
+    });
+  };
+} // find a specific provider based on the name
+
+
+async function web3FromSource(source) {
+  if (!web3EnablePromise) {
+    return throwError('web3FromSource');
+  }
+
+  const sources = await web3EnablePromise;
+  const found = source && sources.find(_ref10 => {
+    let {
+      name
+    } = _ref10;
+    return name === source;
+  });
+
+  if (!found) {
+    throw new Error(`web3FromSource: Unable to find an injected ${source}`);
+  }
+
+  return found;
+} // find a specific provider based on an address
+
+
+async function web3FromAddress(address) {
+  if (!web3EnablePromise) {
+    return throwError('web3FromAddress');
+  }
+
+  const accounts = await web3Accounts();
+  let found;
+
+  if (address) {
+    const accountU8a = (0, _utilCrypto.decodeAddress)(address);
+    found = accounts.find(account => (0, _util.u8aEq)((0, _utilCrypto.decodeAddress)(account.address), accountU8a));
+  }
+
+  if (!found) {
+    throw new Error(`web3FromAddress: Unable to find injected ${address}`);
+  }
+
+  return web3FromSource(found.meta.source);
+} // retrieve all providers exposed by one source
+
+
+async function web3ListRpcProviders(source) {
+  const {
+    provider
+  } = await web3FromSource(source);
+
+  if (!provider) {
+    console.warn(`Extension ${source} does not expose any provider`);
+    return null;
+  }
+
+  return provider.listProviders();
+} // retrieve all providers exposed by one 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/detectOther.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _packageInfo = require("@subwallet/extension-inject/cjs/packageInfo");
+
+// Copyright 2017-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+var _default = [_packageInfo.packageInfo];
+exports.default = _default;

package/build/cjs/detectPackage.js

@@ -0,0 +1,14 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _util = require("@polkadot/util");
+
+var _detectOther = _interopRequireDefault(require("./detectOther"));
+
+var _packageInfo = require("./packageInfo");
+
+// Copyright 2017-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @polkadot/dev
+(0, _util.detectPackage)(_packageInfo.packageInfo, null, _detectOther.default);

package/build/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _bundle = require("./bundle");
+
+Object.keys(_bundle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bundle[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _bundle[key];
+    }
+  });
+});

package/build/cjs/package.json

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

package/build/cjs/packageInfo.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.packageInfo = void 0;
+// Copyright 2017-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @polkadot/dev
+const packageInfo = {
+  name: '@subwallet/extension-dapp',
+  path: typeof __dirname === 'string' ? __dirname : 'auto',
+  type: 'cjs',
+  version: '0.3.6-0'
+};
+exports.packageInfo = packageInfo;

package/build/cjs/util.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.documentReadyPromise = documentReadyPromise;
+
+// Copyright 2019-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+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,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapBytes = exports.unwrapBytes = exports.isWrapped = exports.PREFIX = exports.POSTFIX = exports.ETHEREUM = void 0;
+
+var _util = require("@polkadot/util");
+
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const ETHEREUM = _util.U8A_WRAP_ETHEREUM;
+exports.ETHEREUM = ETHEREUM;
+const POSTFIX = _util.U8A_WRAP_POSTFIX;
+exports.POSTFIX = POSTFIX;
+const PREFIX = _util.U8A_WRAP_PREFIX;
+exports.PREFIX = PREFIX;
+const isWrapped = _util.u8aIsWrapped;
+exports.isWrapped = isWrapped;
+const unwrapBytes = _util.u8aUnwrapBytes;
+exports.unwrapBytes = unwrapBytes;
+const wrapBytes = _util.u8aWrapBytes;
+exports.wrapBytes = wrapBytes;

package/build/detectOther.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+}[];
+export default _default;

package/build/detectOther.js

@@ -0,0 +1,4 @@
+// Copyright 2017-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { packageInfo as injectInfo } from '@subwallet/extension-inject/packageInfo';
+export default [injectInfo];

package/build/detectPackage.d.ts

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

package/build/detectPackage.js

@@ -0,0 +1,7 @@
+// Copyright 2017-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+// Do not edit, auto-generated by @polkadot/dev
+import { detectPackage } from '@polkadot/util';
+import others from "./detectOther.js";
+import { packageInfo } from "./packageInfo.js";
+detectPackage(packageInfo, null, others);

package/build/index.d.ts

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

package/build/index.js

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