@subwallet/extension-base 0.3.6-0

package/build/background/handlers/Tabs.js

@@ -0,0 +1,230 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { PHISHING_PAGE_REDIRECT } from '@subwallet/extension-base/defaults';
+import { canDerive } from '@subwallet/extension-base/utils';
+import { checkIfDenied } from '@polkadot/phishing';
+import keyring from '@polkadot/ui-keyring';
+import { accounts as accountsObservable } from '@polkadot/ui-keyring/observable/accounts';
+import { assert, isNumber } from '@polkadot/util';
+import RequestBytesSign from "../RequestBytesSign.js";
+import RequestExtrinsicSign from "../RequestExtrinsicSign.js";
+import { withErrorLog } from "./helpers.js";
+import { createSubscription, unsubscribe } from "./subscriptions.js";
+
+function transformAccounts(accounts, anyType = false) {
+  return Object.values(accounts).filter(({
+    json: {
+      meta: {
+        isHidden
+      }
+    }
+  }) => !isHidden).filter(({
+    type
+  }) => anyType ? true : canDerive(type)).filter(({
+    type
+  }) => type !== 'ethereum') // Quick fix DApp not allow EVM
+  .sort((a, b) => (a.json.meta.whenCreated || 0) - (b.json.meta.whenCreated || 0)).map(({
+    json: {
+      address,
+      meta: {
+        genesisHash,
+        name
+      }
+    },
+    type
+  }) => ({
+    address,
+    genesisHash,
+    name,
+    type
+  }));
+}
+
+export default class Tabs {
+  #state;
+
+  constructor(state) {
+    this.#state = state;
+  }
+
+  authorize(url, request) {
+    return this.#state.authorizeUrl(url, request);
+  } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+  accountsList(url, {
+    anyType
+  }) {
+    return transformAccounts(accountsObservable.subject.getValue(), anyType);
+  } // FIXME This looks very much like what we have in Extension
+
+
+  accountsSubscribe(url, id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = accountsObservable.subject.subscribe(accounts => cb(transformAccounts(accounts)));
+    port.onDisconnect.addListener(() => {
+      unsubscribe(id);
+      subscription.unsubscribe();
+    });
+    return true;
+  }
+
+  getSigningPair(address) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find keypair');
+    return pair;
+  }
+
+  bytesSign(url, request) {
+    const address = request.address;
+    const pair = this.getSigningPair(address);
+    return this.#state.sign(url, new RequestBytesSign(request), {
+      address,
+      ...pair.meta
+    });
+  }
+
+  extrinsicSign(url, request) {
+    const address = request.address;
+    const pair = this.getSigningPair(address);
+    return this.#state.sign(url, new RequestExtrinsicSign(request), {
+      address,
+      ...pair.meta
+    });
+  }
+
+  metadataProvide(url, request) {
+    return this.#state.injectMetadata(url, request);
+  } // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
+
+  metadataList(url) {
+    return this.#state.knownMetadata.map(({
+      genesisHash,
+      specVersion
+    }) => ({
+      genesisHash,
+      specVersion
+    }));
+  }
+
+  rpcListProviders() {
+    return this.#state.rpcListProviders();
+  }
+
+  rpcSend(request, port) {
+    return this.#state.rpcSend(request, port);
+  }
+
+  rpcStartProvider(key, port) {
+    return this.#state.rpcStartProvider(key, port);
+  }
+
+  async rpcSubscribe(request, id, port) {
+    const innerCb = createSubscription(id, port);
+
+    const cb = (_error, data) => innerCb(data);
+
+    const subscriptionId = await this.#state.rpcSubscribe(request, cb, port);
+    port.onDisconnect.addListener(() => {
+      unsubscribe(id);
+      withErrorLog(() => this.rpcUnsubscribe({ ...request,
+        subscriptionId
+      }, port));
+    });
+    return true;
+  }
+
+  rpcSubscribeConnected(request, id, port) {
+    const innerCb = createSubscription(id, port);
+
+    const cb = (_error, data) => innerCb(data);
+
+    this.#state.rpcSubscribeConnected(request, cb, port);
+    port.onDisconnect.addListener(() => {
+      unsubscribe(id);
+    });
+    return Promise.resolve(true);
+  }
+
+  async rpcUnsubscribe(request, port) {
+    return this.#state.rpcUnsubscribe(request, port);
+  }
+
+  redirectPhishingLanding(phishingWebsite) {
+    const nonFragment = phishingWebsite.split('#')[0];
+    const encodedWebsite = encodeURIComponent(nonFragment);
+    const url = `${chrome.extension.getURL('index.html')}#${PHISHING_PAGE_REDIRECT}/${encodedWebsite}`;
+    chrome.tabs.query({
+      url: nonFragment
+    }, tabs => {
+      tabs.map(({
+        id
+      }) => id).filter(id => isNumber(id)).forEach(id => withErrorLog(() => chrome.tabs.update(id, {
+        url
+      })));
+    });
+  }
+
+  async redirectIfPhishing(url) {
+    const isInDenyList = await checkIfDenied(url);
+
+    if (isInDenyList) {
+      this.redirectPhishingLanding(url);
+      return true;
+    }
+
+    return false;
+  }
+
+  async handle(id, type, request, url, port) {
+    if (type === 'pub(phishing.redirectIfDenied)') {
+      return this.redirectIfPhishing(url);
+    }
+
+    switch (type) {
+      case 'pub(authorize.tab)':
+        return this.authorize(url, request);
+
+      case 'pub(accounts.list)':
+        return this.accountsList(url, request);
+
+      case 'pub(accounts.subscribe)':
+        return this.accountsSubscribe(url, id, port);
+
+      case 'pub(bytes.sign)':
+        return this.bytesSign(url, request);
+
+      case 'pub(extrinsic.sign)':
+        return this.extrinsicSign(url, request);
+
+      case 'pub(metadata.list)':
+        return this.metadataList(url);
+
+      case 'pub(metadata.provide)':
+        return this.metadataProvide(url, request);
+
+      case 'pub(rpc.listProviders)':
+        return this.rpcListProviders();
+
+      case 'pub(rpc.send)':
+        return this.rpcSend(request, port);
+
+      case 'pub(rpc.startProvider)':
+        return this.rpcStartProvider(request, port);
+
+      case 'pub(rpc.subscribe)':
+        return this.rpcSubscribe(request, id, port);
+
+      case 'pub(rpc.subscribeConnected)':
+        return this.rpcSubscribeConnected(request, id, port);
+
+      case 'pub(rpc.unsubscribe)':
+        return this.rpcUnsubscribe(request, port);
+
+      default:
+        throw new Error(`Unable to handle message of type ${type}`);
+    }
+  }
+
+}

package/build/background/handlers/helpers.d.ts

@@ -0,0 +1 @@
+export declare function withErrorLog(fn: () => unknown): void;

package/build/background/handlers/helpers.js

@@ -0,0 +1,13 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export function withErrorLog(fn) {
+  try {
+    const p = fn();
+
+    if (p && typeof p === 'object' && typeof p.catch === 'function') {
+      p.catch(console.error);
+    }
+  } catch (e) {
+    console.error(e);
+  }
+}

package/build/background/handlers/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="chrome" />
+import type { MessageTypes, TransportRequestMessage } from '../types';
+export default function handler<TMessageType extends MessageTypes>({ id, message, request }: TransportRequestMessage<TMessageType>, port: chrome.runtime.Port, extensionPortName?: string): void;

package/build/background/handlers/index.js

@@ -0,0 +1,43 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+import { assert } from '@polkadot/util';
+import { PORT_EXTENSION } from "../../defaults.js";
+import Extension from "./Extension.js";
+import State from "./State.js";
+import Tabs from "./Tabs.js";
+const state = new State();
+const extension = new Extension(state);
+const tabs = new Tabs(state);
+export default function handler({
+  id,
+  message,
+  request
+}, port, extensionPortName = PORT_EXTENSION) {
+  const isExtension = port.name === extensionPortName;
+  const sender = port.sender;
+  const from = isExtension ? 'extension' : sender.tab && sender.tab.url || sender.url || '<unknown>';
+  const source = `${from}: ${id}: ${message}`;
+  console.log(` [in] ${source}`); // :: ${JSON.stringify(request)}`);
+
+  const promise = isExtension ? extension.handle(id, message, request, port) : tabs.handle(id, message, request, from, port);
+  promise.then(response => {
+    console.log(`[out] ${source}`); // :: ${JSON.stringify(response)}`);
+    // between the start and the end of the promise, the user may have closed
+    // the tab, in which case port will be undefined
+
+    assert(port, 'Port has been disconnected');
+    port.postMessage({
+      id,
+      response
+    });
+  }).catch(error => {
+    console.log(`[err] ${source}:: ${error.message}`); // only send message back to port if it's still connected
+
+    if (port) {
+      port.postMessage({
+        error: error.message,
+        id
+      });
+    }
+  });
+}

package/build/background/handlers/subscriptions.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="chrome" />
+import type { MessageTypesWithSubscriptions, SubscriptionMessageTypes } from '../types';
+export declare function createSubscription<TMessageType extends MessageTypesWithSubscriptions>(id: string, port: chrome.runtime.Port): (data: SubscriptionMessageTypes[TMessageType]) => void;
+export declare function unsubscribe(id: string): void;

package/build/background/handlers/subscriptions.js

@@ -0,0 +1,24 @@
+// Copyright 2019-2022 @subwallet/extension authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+const subscriptions = {}; // return a subscription callback, that will send the data to the caller via the port
+
+export function createSubscription(id, port) {
+  subscriptions[id] = port;
+  return subscription => {
+    if (subscriptions[id]) {
+      port.postMessage({
+        id,
+        subscription
+      });
+    }
+  };
+} // clear a previous subscriber
+
+export function unsubscribe(id) {
+  if (subscriptions[id]) {
+    console.log(`Unsubscribing from ${id}`);
+    delete subscriptions[id];
+  } else {
+    console.error(`Unable to unsubscribe from ${id}`);
+  }
+}

package/build/background/types.d.ts

@@ -0,0 +1,345 @@
+import type { InjectedAccount, InjectedMetadataKnown, MetadataDef, ProviderList, ProviderMeta } from '@subwallet/extension-inject/types';
+import type { KeyringPair, KeyringPair$Json, KeyringPair$Meta } from '@polkadot/keyring/types';
+import type { JsonRpcResponse } from '@polkadot/rpc-provider/types';
+import type { SignerPayloadJSON, SignerPayloadRaw } from '@polkadot/types/types';
+import type { KeyringPairs$Json } from '@polkadot/ui-keyring/types';
+import type { HexString } from '@polkadot/util/types';
+import type { KeypairType } from '@polkadot/util-crypto/types';
+import { CurrentNetworkInfo, KoniRequestSignatures } from '@subwallet/extension-base/background/KoniTypes';
+import { TypeRegistry } from '@polkadot/types';
+import { ALLOWED_PATH } from '../defaults';
+import { AuthUrls } from './handlers/State';
+declare type KeysWithDefinedValues<T> = {
+    [K in keyof T]: T[K] extends undefined ? never : K;
+}[keyof T];
+declare type NoUndefinedValues<T> = {
+    [K in KeysWithDefinedValues<T>]: T[K];
+};
+declare type IsNull<T, K extends keyof T> = {
+    [K1 in Exclude<keyof T, K>]: T[K1];
+} & T[K] extends null ? K : never;
+declare type NullKeys<T> = {
+    [K in keyof T]: IsNull<T, K>;
+}[keyof T];
+export declare type SeedLengths = 12 | 24;
+export interface AccountJson extends KeyringPair$Meta {
+    address: string;
+    genesisHash?: string | null;
+    isExternal?: boolean;
+    isHardware?: boolean;
+    isHidden?: boolean;
+    name?: string;
+    parentAddress?: string;
+    suri?: string;
+    type?: KeypairType;
+    whenCreated?: number;
+}
+export interface AccountsWithCurrentAddress {
+    accounts: AccountJson[];
+    currentAddress?: string;
+}
+export interface CurrentAccountInfo {
+    address: string;
+}
+export declare type AccountWithChildren = AccountJson & {
+    children?: AccountWithChildren[];
+};
+export declare type AccountsContext = {
+    accounts: AccountJson[];
+    hierarchy: AccountWithChildren[];
+    master?: AccountJson;
+};
+export declare type CurrentAccContext = {
+    currentAccount: AccountJson | null;
+    setCurrentAccount: (account: AccountJson | null) => void;
+};
+export declare type AccNetworkContext = {
+    network: CurrentNetworkInfo;
+    setNetwork: (network: CurrentNetworkInfo) => void;
+};
+export interface AuthorizeRequest {
+    id: string;
+    request: RequestAuthorizeTab;
+    url: string;
+}
+export interface MetadataRequest {
+    id: string;
+    request: MetadataDef;
+    url: string;
+}
+export interface SigningRequest {
+    account: AccountJson;
+    id: string;
+    request: RequestSign;
+    url: string;
+}
+export interface RequestSignatures extends KoniRequestSignatures {
+    'pri(accounts.create.external)': [RequestAccountCreateExternal, boolean];
+    'pri(accounts.create.hardware)': [RequestAccountCreateHardware, boolean];
+    'pri(accounts.create.suri)': [RequestAccountCreateSuri, boolean];
+    'pri(accounts.edit)': [RequestAccountEdit, boolean];
+    'pri(accounts.export)': [RequestAccountExport, ResponseAccountExport];
+    'pri(accounts.batchExport)': [RequestAccountBatchExport, ResponseAccountsExport];
+    'pri(accounts.forget)': [RequestAccountForget, boolean];
+    'pri(accounts.show)': [RequestAccountShow, boolean];
+    'pri(accounts.tie)': [RequestAccountTie, boolean];
+    'pri(accounts.subscribe)': [RequestAccountSubscribe, boolean, AccountJson[]];
+    'pri(accounts.validate)': [RequestAccountValidate, boolean];
+    'pri(accounts.changePassword)': [RequestAccountChangePassword, boolean];
+    'pri(authorize.approve)': [RequestAuthorizeApprove, boolean];
+    'pri(authorize.list)': [null, ResponseAuthorizeList];
+    'pri(authorize.reject)': [RequestAuthorizeReject, boolean];
+    'pri(authorize.requests)': [RequestAuthorizeSubscribe, boolean, AuthorizeRequest[]];
+    'pri(authorize.toggle)': [string, ResponseAuthorizeList];
+    'pri(derivation.create)': [RequestDeriveCreate, boolean];
+    'pri(derivation.validate)': [RequestDeriveValidate, ResponseDeriveValidate];
+    'pri(json.restore)': [RequestJsonRestore, void];
+    'pri(json.batchRestore)': [RequestBatchRestore, void];
+    'pri(json.validate.password)': [];
+    'pri(json.account.info)': [KeyringPair$Json, ResponseJsonGetAccountInfo];
+    'pri(metadata.approve)': [RequestMetadataApprove, boolean];
+    'pri(metadata.get)': [string | null, MetadataDef | null];
+    'pri(metadata.reject)': [RequestMetadataReject, boolean];
+    'pri(metadata.requests)': [RequestMetadataSubscribe, boolean, MetadataRequest[]];
+    'pri(metadata.list)': [null, MetadataDef[]];
+    'pri(seed.create)': [RequestSeedCreate, ResponseSeedCreate];
+    'pri(seed.validate)': [RequestSeedValidate, ResponseSeedValidate];
+    'pri(settings.notification)': [string, boolean];
+    'pri(signing.approve.password)': [RequestSigningApprovePassword, boolean];
+    'pri(signing.approve.signature)': [RequestSigningApproveSignature, boolean];
+    'pri(signing.cancel)': [RequestSigningCancel, boolean];
+    'pri(signing.isLocked)': [RequestSigningIsLocked, ResponseSigningIsLocked];
+    'pri(signing.requests)': [RequestSigningSubscribe, boolean, SigningRequest[]];
+    'pri(window.open)': [AllowedPath, boolean];
+    'pub(accounts.list)': [RequestAccountList, InjectedAccount[]];
+    'pub(accounts.subscribe)': [RequestAccountSubscribe, boolean, InjectedAccount[]];
+    'pub(authorize.tab)': [RequestAuthorizeTab, null];
+    'pub(authorize.tabV2)': [RequestAuthorizeTab, null];
+    'pub(bytes.sign)': [SignerPayloadRaw, ResponseSigning];
+    'pub(extrinsic.sign)': [SignerPayloadJSON, ResponseSigning];
+    'pub(metadata.list)': [null, InjectedMetadataKnown[]];
+    'pub(metadata.provide)': [MetadataDef, boolean];
+    'pub(phishing.redirectIfDenied)': [null, boolean];
+    'pub(rpc.listProviders)': [void, ResponseRpcListProviders];
+    'pub(rpc.send)': [RequestRpcSend, JsonRpcResponse];
+    'pub(rpc.startProvider)': [string, ProviderMeta];
+    'pub(rpc.subscribe)': [RequestRpcSubscribe, number, JsonRpcResponse];
+    'pub(rpc.subscribeConnected)': [null, boolean, boolean];
+    'pub(rpc.unsubscribe)': [RequestRpcUnsubscribe, boolean];
+}
+export declare type MessageTypes = keyof RequestSignatures;
+export declare type RequestTypes = {
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][0];
+};
+export declare type MessageTypesWithNullRequest = NullKeys<RequestTypes>;
+export interface TransportRequestMessage<TMessageType extends MessageTypes> {
+    id: string;
+    message: TMessageType;
+    origin: 'page' | 'extension' | string;
+    request: RequestTypes[TMessageType];
+}
+export interface RequestAuthorizeTab {
+    origin: string;
+}
+export interface RequestAuthorizeApprove {
+    id: string;
+}
+export interface RequestAuthorizeReject {
+    id: string;
+}
+export declare type RequestAuthorizeSubscribe = null;
+export interface RequestMetadataApprove {
+    id: string;
+}
+export interface RequestCurrentAccountAddress {
+    address: string;
+}
+export interface RequestMetadataReject {
+    id: string;
+}
+export declare type RequestMetadataSubscribe = null;
+export interface RequestAccountCreateExternal {
+    address: string;
+    genesisHash?: string | null;
+    name: string;
+}
+export interface RequestAccountCreateSuri {
+    name: string;
+    genesisHash?: string | null;
+    password: string;
+    suri: string;
+    type?: KeypairType;
+}
+export interface RequestAccountCreateHardware {
+    accountIndex: number;
+    address: string;
+    addressOffset: number;
+    genesisHash: string;
+    hardwareType: string;
+    name: string;
+}
+export interface RequestAccountChangePassword {
+    address: string;
+    oldPass: string;
+    newPass: string;
+}
+export interface RequestAccountEdit {
+    address: string;
+    genesisHash?: string | null;
+    name: string;
+}
+export interface RequestAccountForget {
+    address: string;
+}
+export interface RequestAccountShow {
+    address: string;
+    isShowing: boolean;
+}
+export interface RequestAccountTie {
+    address: string;
+    genesisHash: string | null;
+}
+export interface RequestAccountValidate {
+    address: string;
+    password: string;
+}
+export interface RequestDeriveCreate {
+    name: string;
+    genesisHash?: string | null;
+    suri: string;
+    parentAddress: string;
+    parentPassword: string;
+    password: string;
+}
+export interface RequestDeriveValidate {
+    suri: string;
+    parentAddress: string;
+    parentPassword: string;
+}
+export interface RequestAccountExport {
+    address: string;
+    password: string;
+}
+export interface RequestAccountBatchExport {
+    addresses: string[];
+    password: string;
+}
+export interface RequestAccountList {
+    anyType?: boolean;
+}
+export declare type RequestAccountSubscribe = null;
+export interface RequestRpcSend {
+    method: string;
+    params: unknown[];
+}
+export interface RequestRpcSubscribe extends RequestRpcSend {
+    type: string;
+}
+export interface RequestRpcUnsubscribe {
+    method: string;
+    subscriptionId: number | string;
+    type: string;
+}
+export interface RequestSigningApprovePassword {
+    id: string;
+    password?: string;
+    savePass: boolean;
+}
+export interface RequestSigningApproveSignature {
+    id: string;
+    signature: HexString;
+}
+export interface RequestSigningCancel {
+    id: string;
+}
+export interface RequestSigningIsLocked {
+    id: string;
+}
+export interface ResponseSigningIsLocked {
+    isLocked: boolean;
+    remainingTime: number;
+}
+export declare type RequestSigningSubscribe = null;
+export interface RequestSeedCreate {
+    length?: SeedLengths;
+    seed?: string;
+    type?: KeypairType;
+}
+export interface RequestSeedValidate {
+    suri: string;
+    type?: KeypairType;
+}
+export declare type ResponseTypes = {
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][1];
+};
+export declare type ResponseType<TMessageType extends keyof RequestSignatures> = RequestSignatures[TMessageType][1];
+interface TransportResponseMessageSub<TMessageType extends MessageTypesWithSubscriptions> {
+    error?: string;
+    id: string;
+    response?: ResponseTypes[TMessageType];
+    subscription?: SubscriptionMessageTypes[TMessageType];
+}
+interface TransportResponseMessageNoSub<TMessageType extends MessageTypesWithNoSubscriptions> {
+    error?: string;
+    id: string;
+    response?: ResponseTypes[TMessageType];
+}
+export declare type TransportResponseMessage<TMessageType extends MessageTypes> = TMessageType extends MessageTypesWithNoSubscriptions ? TransportResponseMessageNoSub<TMessageType> : TMessageType extends MessageTypesWithSubscriptions ? TransportResponseMessageSub<TMessageType> : never;
+export interface ResponseSigning {
+    id: string;
+    signature: HexString;
+}
+export interface ResponseDeriveValidate {
+    address: string;
+    suri: string;
+}
+export interface ResponseSeedCreate {
+    address: string;
+    seed: string;
+}
+export interface ResponseSeedValidate {
+    address: string;
+    suri: string;
+}
+export interface ResponseAccountExport {
+    exportedJson: KeyringPair$Json;
+}
+export interface ResponseAccountsExport {
+    exportedJson: KeyringPairs$Json;
+}
+export declare type ResponseRpcListProviders = ProviderList;
+export declare type SubscriptionMessageTypes = NoUndefinedValues<{
+    [MessageType in keyof RequestSignatures]: RequestSignatures[MessageType][2];
+}>;
+export declare type MessageTypesWithSubscriptions = keyof SubscriptionMessageTypes;
+export declare type MessageTypesWithNoSubscriptions = Exclude<MessageTypes, keyof SubscriptionMessageTypes>;
+export interface RequestSign {
+    readonly payload: SignerPayloadJSON | SignerPayloadRaw;
+    sign(registry: TypeRegistry, pair: KeyringPair): {
+        signature: HexString;
+    };
+}
+export interface RequestJsonRestore {
+    file: KeyringPair$Json;
+    password: string;
+    address: string;
+}
+export interface RequestBatchRestore {
+    file: KeyringPairs$Json;
+    password: string;
+    address: string;
+}
+export interface ResponseJsonRestore {
+    error: string | null;
+}
+export declare type AllowedPath = typeof ALLOWED_PATH[number];
+export interface ResponseJsonGetAccountInfo {
+    address: string;
+    name: string;
+    genesisHash: string;
+    type: KeypairType;
+}
+export interface ResponseAuthorizeList {
+    list: AuthUrls;
+}
+export {};

package/build/background/types.js

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

package/build/bundle.d.ts

@@ -0,0 +1 @@
+export { packageInfo } from './packageInfo';

package/build/bundle.js

@@ -0,0 +1,3 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+export { packageInfo } from "./packageInfo.js";