@subwallet/extension-dapp 0.3.6-0

package/src/bundle.ts

@@ -0,0 +1,244 @@
+// Copyright 2019-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Injected, InjectedAccount, InjectedAccountWithMeta, InjectedExtension, InjectedExtensionInfo, InjectedProviderWithMeta, InjectedWindow, ProviderList, Unsubcall, Web3AccountsOptions } from '@subwallet/extension-inject/types';
+
+import { u8aEq } from '@polkadot/util';
+import { decodeAddress, encodeAddress } from '@polkadot/util-crypto';
+
+import { documentReadyPromise } from './util';
+
+// expose utility functions
+export { packageInfo } from './packageInfo';
+export { unwrapBytes, wrapBytes } from './wrapBytes';
+
+// just a helper (otherwise we cast all-over, so shorter and more readable)
+const win = window as Window & InjectedWindow;
+
+// 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 (): boolean {
+  return Object.keys(win.injectedWeb3).length !== 0;
+}
+
+// helper to throw a consistent error when not enabled
+function throwError (method: string): never {
+  throw new Error(`${method}: web3Enable(originName) needs to be called before ${method}`);
+}
+
+// internal helper to map from Array<InjectedAccount> -> Array<InjectedAccountWithMeta>
+function mapAccounts (source: string, list: InjectedAccount[], ss58Format?: number): InjectedAccountWithMeta[] {
+  return list.map(({ address, genesisHash, name, type }): InjectedAccountWithMeta => {
+    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: Promise<InjectedExtension[]> | null = null;
+
+export { isWeb3Injected, web3EnablePromise };
+
+function getWindowExtensions (originName: string): Promise<[InjectedExtensionInfo, Injected | void][]> {
+  return Promise.all(
+    Object.entries(win.injectedWeb3).map(
+      ([name, { enable, version }]): Promise<[InjectedExtensionInfo, Injected | void]> =>
+        Promise.all([
+          Promise.resolve({ name, version }),
+          enable(originName).catch((error: Error): void => {
+            console.error(`Error initializing ${name}: ${error.message}`);
+          })
+        ])
+    )
+  );
+}
+
+// enables all the providers found on the injected window interface
+export function web3Enable (originName: string, compatInits: (() => Promise<boolean>)[] = []): Promise<InjectedExtension[]> {
+  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(
+    (): Promise<InjectedExtension[]> =>
+      initCompat.then(() =>
+        getWindowExtensions(originName)
+          .then((values): InjectedExtension[] =>
+            values
+              .filter((value): value is [InjectedExtensionInfo, Injected] => !!value[1])
+              .map(([info, ext]): InjectedExtension => {
+                // if we don't have an accounts subscriber, add a single-shot version
+                if (!ext.accounts.subscribe) {
+                  ext.accounts.subscribe = (cb: (accounts: InjectedAccount[]) => void | Promise<void>): Unsubcall => {
+                    ext.accounts.get().then(cb).catch(console.error);
+
+                    return (): void => {
+                      // no ubsubscribe needed, this is a single-shot
+                    };
+                  };
+                }
+
+                return { ...info, ...ext };
+              })
+          )
+          .catch((): InjectedExtension[] => [])
+          .then((values): InjectedExtension[] => {
+            const names = values.map(({ name, version }): string => `${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 }: Web3AccountsOptions = {}): Promise<InjectedAccountWithMeta[]> {
+  if (!web3EnablePromise) {
+    return throwError('web3Accounts');
+  }
+
+  const accounts: InjectedAccountWithMeta[] = [];
+  const injected = await web3EnablePromise;
+
+  const retrieved = await Promise.all(
+    injected.map(async ({ accounts, name: source }): Promise<InjectedAccountWithMeta[]> => {
+      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): void => {
+    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: (accounts: InjectedAccountWithMeta[]) => void | Promise<void>, { ss58Format }: Web3AccountsOptions = {}): Promise<Unsubcall> {
+  if (!web3EnablePromise) {
+    return throwError('web3AccountsSubscribe');
+  }
+
+  const accounts: Record<string, InjectedAccount[]> = {};
+
+  const triggerUpdate = (): void | Promise<void> =>
+    cb(
+      Object.entries(accounts).reduce(
+        (result: InjectedAccountWithMeta[], [source, list]): InjectedAccountWithMeta[] => {
+          result.push(...mapAccounts(source, list, ss58Format));
+
+          return result;
+        },
+        []
+      )
+    );
+
+  const unsubs = (await web3EnablePromise).map(
+    ({ accounts: { subscribe }, name: source }): Unsubcall =>
+      subscribe((result): void => {
+        accounts[source] = result;
+
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        triggerUpdate();
+      })
+  );
+
+  return (): void => {
+    unsubs.forEach((unsub): void => {
+      unsub();
+    });
+  };
+}
+
+// find a specific provider based on the name
+export async function web3FromSource (source: string): Promise<InjectedExtension> {
+  if (!web3EnablePromise) {
+    return throwError('web3FromSource');
+  }
+
+  const sources = await web3EnablePromise;
+  const found = source && sources.find(({ name }): boolean => 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: string): Promise<InjectedExtension> {
+  if (!web3EnablePromise) {
+    return throwError('web3FromAddress');
+  }
+
+  const accounts = await web3Accounts();
+  let found: InjectedAccountWithMeta | undefined;
+
+  if (address) {
+    const accountU8a = decodeAddress(address);
+
+    found = accounts.find((account): boolean => 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: string): Promise<ProviderList | null> {
+  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: string, key: string): Promise<InjectedProviderWithMeta> {
+  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/src/detectOther.ts

@@ -0,0 +1,6 @@
+// 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/src/detectPackage.ts

@@ -0,0 +1,11 @@
+// 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';
+import { packageInfo } from './packageInfo';
+
+detectPackage(packageInfo, null, others);

package/src/index.ts

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

package/src/packageInfo.ts

@@ -0,0 +1,6 @@
+// Copyright 2017-2022 @subwallet/extension-dapp authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Do not edit, auto-generated by @polkadot/dev
+
+export const packageInfo = { name: '@subwallet/extension-dapp', path: 'auto', type: 'auto', version: '0.3.6-0' };

package/src/util.ts

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

package/src/wrapBytes.spec.ts

@@ -0,0 +1,135 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { u8aConcat, u8aEq, u8aToString } from '@polkadot/util';
+
+import { ETHEREUM, POSTFIX, PREFIX, unwrapBytes, wrapBytes } from './wrapBytes';
+
+const TEST_DATA = 'this is just some random message that we expect to be wrapped along the way';
+const TEST_ETH = u8aConcat(ETHEREUM, TEST_DATA);
+const TEST_WRAP_EMPTY = `${u8aToString(PREFIX)}${u8aToString(POSTFIX)}`;
+const TEST_WRAP_FULL = `${u8aToString(PREFIX)}${TEST_DATA}${u8aToString(POSTFIX)}`;
+const TEST_WARP_HALF_PRE = `${u8aToString(PREFIX)}${TEST_DATA}`;
+const TEST_WRAP_HALF_POST = `${TEST_DATA}${u8aToString(POSTFIX)}`;
+
+describe('wrapBytes', (): void => {
+  it('wraps empty bytes', (): void => {
+    expect(
+      u8aEq(
+        wrapBytes(new Uint8Array()),
+        u8aConcat(PREFIX, POSTFIX)
+      )
+    ).toBe(true);
+  });
+
+  it('wraps when no wrapping is detected', (): void => {
+    expect(
+      u8aToString(
+        wrapBytes(TEST_DATA)
+      )
+    ).toEqual(TEST_WRAP_FULL);
+  });
+
+  it('wraps when only start wrap is detected', (): void => {
+    expect(
+      u8aToString(
+        wrapBytes(TEST_WARP_HALF_PRE)
+      )
+    ).toEqual(`${u8aToString(PREFIX)}${TEST_WARP_HALF_PRE}${u8aToString(POSTFIX)}`);
+  });
+
+  it('wraps when only end wrap is detected', (): void => {
+    expect(
+      u8aToString(
+        wrapBytes(TEST_WRAP_HALF_POST)
+      )
+    ).toEqual(`${u8aToString(PREFIX)}${TEST_WRAP_HALF_POST}${u8aToString(POSTFIX)}`);
+  });
+
+  it('does not re-wrap when a wrap is already present', (): void => {
+    expect(
+      u8aToString(
+        wrapBytes(TEST_WRAP_FULL)
+      )
+    ).toEqual(TEST_WRAP_FULL);
+  });
+
+  it('does not re-wrap when a wrap (empty data) is already present', (): void => {
+    expect(
+      u8aToString(
+        wrapBytes(TEST_WRAP_EMPTY)
+      )
+    ).toEqual(TEST_WRAP_EMPTY);
+  });
+});
+
+describe('unwrapBytes', (): void => {
+  it('unwraps empty bytes', (): void => {
+    expect(
+      u8aEq(
+        unwrapBytes(new Uint8Array()),
+        new Uint8Array()
+      )
+    ).toBe(true);
+  });
+
+  it('unwraps when no wrapping is detected', (): void => {
+    expect(
+      u8aToString(
+        unwrapBytes(TEST_DATA)
+      )
+    ).toEqual(TEST_DATA);
+  });
+
+  it('unwraps when no wrapping is detected (only start)', (): void => {
+    expect(
+      u8aToString(
+        unwrapBytes(TEST_WARP_HALF_PRE)
+      )
+    ).toEqual(TEST_WARP_HALF_PRE);
+  });
+
+  it('unwraps when no wrapping is detected (only end)', (): void => {
+    expect(
+      u8aToString(
+        unwrapBytes(TEST_WRAP_HALF_POST)
+      )
+    ).toEqual(TEST_WRAP_HALF_POST);
+  });
+
+  it('unwraps when a wrap is present', (): void => {
+    expect(
+      u8aToString(
+        unwrapBytes(TEST_WRAP_FULL)
+      )
+    ).toEqual(TEST_DATA);
+  });
+
+  it('unwraps when a an empty wrap is present', (): void => {
+    expect(
+      u8aToString(
+        unwrapBytes(TEST_WRAP_EMPTY)
+      )
+    ).toEqual('');
+  });
+
+  describe('Ethereum-style', (): void => {
+    it('does not wrap an Ethereum wrap', (): void => {
+      expect(
+        u8aEq(
+          wrapBytes(TEST_ETH),
+          TEST_ETH
+        )
+      ).toBe(true);
+    });
+
+    it('does not unwrap an Ethereum wrap', (): void => {
+      expect(
+        u8aEq(
+          unwrapBytes(TEST_ETH),
+          TEST_ETH
+        )
+      ).toBe(true);
+    });
+  });
+});

package/src/wrapBytes.ts

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

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": "..",
+    "outDir": "./build",
+    "rootDir": "./src"
+  },
+  "references": [
+    { "path": "../extension-inject/tsconfig.build.json"
+    }
+  ]
+}