@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,13 @@
+/// <reference types="chrome" />
+import { MessageTypes, TransportRequestMessage } from '@subwallet/extension-base/background/types';
+import { NftHandler } from '@subwallet/extension-base/koni/api/nft';
+import KoniExtension from '@subwallet/extension-base/koni/background/handlers/Extension';
+import Mobile from '@subwallet/extension-base/koni/background/handlers/Mobile';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import KoniTabs from '@subwallet/extension-base/koni/background/handlers/Tabs';
+export declare const state: KoniState;
+export declare const extension: KoniExtension;
+export declare const tabs: KoniTabs;
+export declare const mobile: Mobile;
+export declare const nftHandler: NftHandler;
+export default function handlers<TMessageType extends MessageTypes>({ id, message, request }: TransportRequestMessage<TMessageType>, port: chrome.runtime.Port, extensionPortName?: string): void;

package/koni/background/handlers/index.js

@@ -0,0 +1,76 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { PORT_EXTENSION, PORT_MOBILE } from '@subwallet/extension-base/defaults';
+import { NftHandler } from '@subwallet/extension-base/koni/api/nft';
+import KoniExtension from '@subwallet/extension-base/koni/background/handlers/Extension';
+import Mobile from '@subwallet/extension-base/koni/background/handlers/Mobile';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import KoniTabs from '@subwallet/extension-base/koni/background/handlers/Tabs';
+
+// import Migration from '@subwallet/extension-base/koni/migration';
+import { assert } from '@polkadot/util';
+export const state = new KoniState();
+export const extension = new KoniExtension(state);
+export const tabs = new KoniTabs(state);
+export const mobile = new Mobile(state);
+export const nftHandler = new NftHandler();
+
+// Migration
+// async function makeSureStateReady () {
+//   const poll = (resolve: (value: unknown) => void) => {
+//     if (state.isReady()) {
+//       resolve(true);
+//     } else {
+//       console.log('Waiting for State is ready...');
+//       setTimeout(() => poll(resolve), 400);
+//     }
+//   };
+//
+//   return new Promise(poll);
+// }
+
+// makeSureStateReady().then(() => {
+//   const migration = new Migration(state);
+//
+//   migration.run().catch((err) => console.warn(err));
+// }).catch((e) => console.warn(e));
+
+export default function handlers({
+  id,
+  message,
+  request
+}, port, extensionPortName = PORT_EXTENSION) {
+  const isMobile = port.name === PORT_MOBILE;
+  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 = isMobile ? mobile.handle(id, message, request, port) : 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.error(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,
+        errorCode: error.code,
+        errorData: error.data,
+        id
+      });
+    }
+  });
+}

package/koni/background/subscription.d.ts

@@ -0,0 +1,32 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
+import { _ChainState, _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import KoniState from './handlers/State';
+declare type SubscriptionName = 'balance' | 'crowdloan' | 'stakingOnChain';
+export declare class KoniSubscription {
+    private serviceSubscription;
+    private subscriptionMap;
+    dbService: DatabaseService;
+    private state;
+    private logger;
+    constructor(state: KoniState, dbService: DatabaseService);
+    getSubscriptionMap(): Record<SubscriptionName, (() => void) | undefined>;
+    getSubscription(name: SubscriptionName): (() => void) | undefined;
+    updateSubscription(name: SubscriptionName, func: (() => void) | undefined): void;
+    stopAllSubscription(): void;
+    start(): void;
+    stop(): void;
+    init(): void;
+    subscribeBalancesAndCrowdloans(address: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, web3ApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): void;
+    subscribeStakingOnChain(address: string, substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): void;
+    initStakingOnChainSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
+    initBalanceSubscription(addresses: string[], chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
+    initCrowdloanSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, onlyRunOnFirstTime?: boolean): (() => void) | undefined;
+    subscribeNft(address: string, substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
+    initNftSubscription(addresses: string[], substrateApiMap: Record<string, _SubstrateApi>, evmApiMap: Record<string, _EvmApi>, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>): void;
+    subscribeStakingReward(address: string): Promise<void>;
+    subscribeStakingRewardFastInterval(address: string): Promise<void>;
+    fetchChainStakingMetadata(chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>): Promise<void>;
+    fetchNominatorMetadata(currentAddress: string, chainInfoMap: Record<string, _ChainInfo>, chainStateMap: Record<string, _ChainState>, substrateApiMap: Record<string, _SubstrateApi>): Promise<void>;
+}
+export {};

package/koni/background/subscription.js

@@ -0,0 +1,267 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { subscribeBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
+import { subscribeCrowdloan } from '@subwallet/extension-base/koni/api/dotsama/crowdloan';
+import { getNominationStakingRewardData, getPoolingStakingRewardData, stakingOnChainApi } from '@subwallet/extension-base/koni/api/staking';
+import { getChainStakingMetadata, getNominatorMetadata } from '@subwallet/extension-base/koni/api/staking/bonding';
+import { getRelayChainPoolMemberMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
+import { getAmplitudeUnclaimedStakingReward } from '@subwallet/extension-base/koni/api/staking/paraChain';
+import { nftHandler } from '@subwallet/extension-base/koni/background/handlers';
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _isChainEnabled, _isChainSupportSubstrateStaking, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { logger as createLogger } from '@polkadot/util';
+export class KoniSubscription {
+  subscriptionMap = {
+    crowdloan: undefined,
+    balance: undefined,
+    stakingOnChain: undefined
+  };
+  constructor(state, dbService) {
+    this.dbService = dbService;
+    this.state = state;
+    this.logger = createLogger('Subscription');
+    this.init();
+  }
+  getSubscriptionMap() {
+    return this.subscriptionMap;
+  }
+  getSubscription(name) {
+    return this.subscriptionMap[name];
+  }
+  updateSubscription(name, func) {
+    const oldFunc = this.subscriptionMap[name];
+    oldFunc && oldFunc();
+    func && (this.subscriptionMap[name] = func);
+  }
+  stopAllSubscription() {
+    if (this.subscriptionMap.balance) {
+      this.subscriptionMap.balance();
+      delete this.subscriptionMap.balance;
+    }
+    if (this.subscriptionMap.crowdloan) {
+      this.subscriptionMap.crowdloan();
+      delete this.subscriptionMap.crowdloan;
+    }
+    if (this.subscriptionMap.stakingOnChain) {
+      this.subscriptionMap.stakingOnChain();
+      delete this.subscriptionMap.stakingOnChain;
+    }
+  }
+  start() {
+    this.logger.log('Starting subscription');
+    this.state.getCurrentAccount(currentAccountInfo => {
+      if (currentAccountInfo) {
+        const {
+          address
+        } = currentAccountInfo;
+        this.subscribeBalancesAndCrowdloans(address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+        this.subscribeStakingOnChain(address, this.state.getSubstrateApiMap());
+      }
+    });
+    !this.serviceSubscription && (this.serviceSubscription = this.state.subscribeServiceInfo().subscribe({
+      next: serviceInfo => {
+        var _serviceInfo$currentA;
+        this.logger.log('ServiceInfo updated, restarting...');
+        const address = (_serviceInfo$currentA = serviceInfo.currentAccountInfo) === null || _serviceInfo$currentA === void 0 ? void 0 : _serviceInfo$currentA.address;
+        if (!address) {
+          return;
+        }
+        this.subscribeBalancesAndCrowdloans(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm);
+        this.subscribeStakingOnChain(address, serviceInfo.chainApiMap.substrate);
+      }
+    }));
+  }
+  stop() {
+    this.logger.log('Stopping subscription');
+    if (this.serviceSubscription) {
+      this.serviceSubscription.unsubscribe();
+      this.serviceSubscription = undefined;
+    }
+    this.stopAllSubscription();
+  }
+  init() {
+    this.state.getAuthorize(value => {
+      const authString = localStorage.getItem('authUrls') || '{}';
+      const previousAuth = JSON.parse(authString);
+      if (previousAuth && Object.keys(previousAuth).length) {
+        Object.keys(previousAuth).forEach(url => {
+          if (previousAuth[url].isAllowed) {
+            previousAuth[url].isAllowedMap = this.state.getAddressList(true);
+          } else {
+            previousAuth[url].isAllowedMap = this.state.getAddressList();
+          }
+        });
+      }
+      const migrateValue = {
+        ...previousAuth,
+        ...value
+      };
+      this.state.setAuthorize(migrateValue);
+      localStorage.setItem('authUrls', '{}');
+    });
+  }
+  subscribeBalancesAndCrowdloans(address, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime) {
+    this.state.switchAccount(address).then(() => {
+      this.state.getDecodedAddresses(address).then(addresses => {
+        if (!addresses.length) {
+          return;
+        }
+        this.updateSubscription('balance', this.initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime));
+        this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+      }).catch(this.logger.error);
+    }).catch(err => this.logger.warn(err));
+  }
+  subscribeStakingOnChain(address, substrateApiMap, onlyRunOnFirstTime) {
+    this.state.resetStaking(address).then(() => {
+      this.state.getDecodedAddresses(address).then(addresses => {
+        if (!addresses.length) {
+          return;
+        }
+        this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+      }).catch(this.logger.error);
+    }).catch(err => this.logger.warn(err));
+  }
+  initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const unsub = stakingOnChainApi(addresses, substrateApiMap, (networkKey, rs) => {
+      this.state.setStakingItem(networkKey, rs);
+    }, this.state.getActiveChainInfoMap());
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, evmApiMap, onlyRunOnFirstTime) {
+    const filteredChainInfoMap = {};
+    Object.values(chainInfoMap).forEach(chainInfo => {
+      if (chainStateMap[chainInfo.slug].active) {
+        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+      }
+    });
+    const unsub = subscribeBalance(addresses, filteredChainInfoMap, substrateApiMap, evmApiMap, result => {
+      this.state.setBalanceItem(result.tokenSlug, result);
+    });
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
+    const subscriptionPromise = subscribeCrowdloan(addresses, substrateApiMap, (networkKey, rs) => {
+      this.state.setCrowdloanItem(networkKey, rs);
+    }, this.state.getChainInfoMap());
+    if (onlyRunOnFirstTime) {
+      subscriptionPromise.then(unsub => unsub()).catch(this.logger.warn);
+      return;
+    }
+    return () => {
+      subscriptionPromise.then(unsub => unsub()).catch(this.logger.warn);
+    };
+  }
+  subscribeNft(address, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
+    this.state.getDecodedAddresses(address).then(addresses => {
+      if (!addresses.length) {
+        return;
+      }
+      this.initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap);
+    }).catch(this.logger.error);
+  }
+  initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
+    nftHandler.setChainInfoMap(chainInfoMap);
+    nftHandler.setDotSamaApiMap(substrateApiMap);
+    nftHandler.setWeb3ApiMap(evmApiMap);
+    nftHandler.setAddresses(addresses);
+    nftHandler.handleNfts(smartContractNfts, (...args) => this.state.updateNftData(...args), (...args) => this.state.setNftCollection(...args)).then(() => {
+      this.logger.log('nft state updated');
+    }).catch(this.logger.log);
+  }
+  async subscribeStakingReward(address) {
+    const addresses = await this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetNetworkMap = {};
+    Object.entries(chainInfoMap).forEach(([key, network]) => {
+      const chainState = this.state.getChainStateByKey(key);
+      if (_isChainEnabled(chainState) && _isChainSupportSubstrateStaking(network)) {
+        targetNetworkMap[key] = network;
+      }
+    });
+    const result = await getNominationStakingRewardData(addresses, targetNetworkMap);
+    this.state.updateStakingReward(result, 'slowInterval');
+    this.logger.log('Set staking reward state done', result);
+  }
+  async subscribeStakingRewardFastInterval(address) {
+    const addresses = await this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    const pooledStakingItems = await this.state.getPooledStakingRecordsByAddress(addresses);
+    const pooledAddresses = [];
+    pooledStakingItems.forEach(pooledItem => {
+      if (!pooledAddresses.includes(pooledItem.address)) {
+        pooledAddresses.push(pooledItem.address);
+      }
+    });
+    const chainInfoMap = this.state.getChainInfoMap();
+    const targetChainMap = {};
+    Object.entries(chainInfoMap).forEach(([key, network]) => {
+      const chainState = this.state.getChainStateByKey(key);
+      if (_isChainEnabled(chainState) && _isChainSupportSubstrateStaking(network)) {
+        targetChainMap[key] = network;
+      }
+    });
+    const activeNetworks = [];
+    Object.keys(targetChainMap).forEach(key => {
+      activeNetworks.push(key);
+    });
+    const [poolingStakingRewards, amplitudeUnclaimedStakingRewards] = await Promise.all([getPoolingStakingRewardData(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap()), getAmplitudeUnclaimedStakingReward(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks)]);
+    const result = [...poolingStakingRewards, ...amplitudeUnclaimedStakingRewards];
+    this.state.updateStakingReward(result, 'fastInterval');
+    this.logger.log('Set staking reward state with fast interval done', result);
+  }
+  async fetchChainStakingMetadata(chainInfoMap, chainStateMap, substrateApiMap) {
+    await Promise.all(Object.values(chainInfoMap).map(async chainInfo => {
+      const chainState = chainStateMap[chainInfo.slug];
+      if (chainState !== null && chainState !== void 0 && chainState.active && _isChainSupportSubstrateStaking(chainInfo)) {
+        const chainStakingMetadata = await getChainStakingMetadata(chainInfo.slug, substrateApiMap[chainInfo.slug]);
+        this.state.updateChainStakingMetadata(chainStakingMetadata);
+      }
+    }));
+  }
+  async fetchNominatorMetadata(currentAddress, chainInfoMap, chainStateMap, substrateApiMap) {
+    const filteredChainInfoMap = {};
+    Object.values(chainInfoMap).forEach(chainInfo => {
+      const chainState = chainStateMap[chainInfo.slug];
+      if (chainState !== null && chainState !== void 0 && chainState.active && _isChainSupportSubstrateStaking(chainInfo)) {
+        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+      }
+    });
+    let addresses = [currentAddress];
+    if (currentAddress === ALL_ACCOUNT_KEY) {
+      addresses = await this.state.getStakingOwnersByChains(Object.keys(filteredChainInfoMap));
+    }
+    await Promise.all(addresses.map(async address => {
+      await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
+        if (_isSubstrateRelayChain(chainInfo) && _STAKING_CHAIN_GROUP.nominationPool.includes(chainInfo.slug)) {
+          const poolMemberMetadata = await getRelayChainPoolMemberMetadata(chainInfo, address, substrateApiMap[chainInfo.slug]);
+          if (poolMemberMetadata) {
+            this.state.updateStakingNominatorMetadata(poolMemberMetadata);
+          }
+        }
+        const nominatorMetadata = await getNominatorMetadata(chainInfo, address, substrateApiMap[chainInfo.slug]);
+        if (nominatorMetadata) {
+          this.state.updateStakingNominatorMetadata(nominatorMetadata);
+        }
+      }));
+    }));
+  }
+}

package/koni/page/SubWalleEvmProvider.d.ts

@@ -0,0 +1,27 @@
+import type { EvmProvider } from '@subwallet/extension-inject/types';
+import SafeEventEmitter from '@metamask/safe-event-emitter';
+import { SendRequest } from '@subwallet/extension-base/page/types';
+import { JsonRpcRequest, JsonRpcResponse } from 'json-rpc-engine';
+import { RequestArguments } from 'web3-core';
+export interface SendSyncJsonRpcRequest extends JsonRpcRequest<unknown> {
+    method: 'net_version';
+}
+export declare class SubWalletEvmProvider extends SafeEventEmitter implements EvmProvider {
+    readonly isSubWallet = true;
+    readonly isMetaMask = false;
+    readonly version: string;
+    protected sendMessage: SendRequest;
+    protected _connected: boolean;
+    protected _subscribed: boolean;
+    constructor(sendMessage: SendRequest, version: string);
+    get connected(): boolean;
+    isConnected(): boolean;
+    protected subscribeExtensionEvents(): void;
+    enable(): Promise<unknown>;
+    request<T>({ method, params }: RequestArguments): Promise<T>;
+    private _sendSync;
+    send<T>(method: string, params?: T[]): Promise<JsonRpcResponse<T>>;
+    send<T>(payload: JsonRpcRequest<unknown>, callback: (error: Error | null, result?: JsonRpcResponse<T>) => void): void;
+    send<T>(payload: SendSyncJsonRpcRequest): JsonRpcResponse<T>;
+    sendAsync<T>(payload: JsonRpcRequest<T>, callback: (error: (Error | null), result?: JsonRpcResponse<T>) => void): void;
+}

package/koni/page/SubWalleEvmProvider.js

@@ -0,0 +1,132 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import SafeEventEmitter from '@metamask/safe-event-emitter';
+export class SubWalletEvmProvider extends SafeEventEmitter {
+  isSubWallet = true;
+  isMetaMask = false;
+  _connected = false;
+  _subscribed = false;
+  constructor(sendMessage, version) {
+    super();
+    this.version = version;
+    this.sendMessage = sendMessage;
+    this._connected = true;
+  }
+  get connected() {
+    return this._connected;
+  }
+  isConnected() {
+    return this._connected;
+  }
+  subscribeExtensionEvents() {
+    if (this._subscribed) {
+      return;
+    }
+    this.sendMessage('evm(events.subscribe)', null, ({
+      payload,
+      type
+    }) => {
+      if (['connect', 'disconnect', 'accountsChanged', 'chainChanged', 'message', 'data', 'reconnect', 'error'].includes(type)) {
+        if (type === 'connect') {
+          this._connected = true;
+        } else if (type === 'disconnect') {
+          this._connected = false;
+        }
+        const finalType = type === 'data' ? 'message' : type;
+
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+        this.emit(finalType, payload);
+      } else {
+        console.warn('Can not handle event', type, payload);
+      }
+    }).then(done => {
+      this._subscribed = true;
+    }).catch(console.error);
+  }
+  async enable() {
+    return this.request({
+      method: 'eth_requestAccounts'
+    });
+  }
+  request({
+    method,
+    params
+  }) {
+    switch (method) {
+      case 'eth_requestAccounts':
+        return new Promise((resolve, reject) => {
+          const origin = document.title !== '' ? document.title : window.location.hostname;
+          this.sendMessage('pub(authorize.tabV2)', {
+            origin,
+            accountAuthType: 'evm'
+          }).then(() => {
+            // Subscribe event
+            this.subscribeExtensionEvents();
+
+            // Return account list
+            this.request({
+              method: 'eth_accounts'
+            }).then(accounts => {
+              // @ts-ignore
+              resolve(accounts);
+            }).catch(e => {
+              reject(e);
+            });
+          }).catch(e => {
+            reject(e);
+          });
+        });
+      default:
+        return new Promise((resolve, reject) => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          this.sendMessage('evm(request)', {
+            params,
+            method
+          }).then(result => {
+            resolve(result);
+          }).catch(e => {
+            reject(e);
+          });
+        });
+    }
+  }
+  _sendSync(payload) {
+    let result;
+    switch (payload.method) {
+      case 'net_version':
+        result = this.version ? `SubWallet v${this.version}` : null;
+        break;
+      default:
+        throw new Error(`Not support ${payload.method}`);
+    }
+    return {
+      id: payload.id,
+      jsonrpc: payload.jsonrpc,
+      result
+    };
+  }
+  send(methodOrPayload, callbackOrArgs) {
+    if (typeof methodOrPayload === 'string' && (!callbackOrArgs || Array.isArray(callbackOrArgs))) {
+      return this.request({
+        method: methodOrPayload,
+        params: callbackOrArgs
+      });
+    } else if (methodOrPayload && typeof methodOrPayload === 'object' && typeof callbackOrArgs === 'function') {
+      return this.request(methodOrPayload).then(rs => {
+        callbackOrArgs(rs);
+      });
+    }
+    return this._sendSync(methodOrPayload);
+  }
+  sendAsync(payload, callback) {
+    this.request(payload).then(result => {
+      // @ts-ignore
+      callback(null, {
+        result
+      });
+    }).catch(e => {
+      callback(e);
+    });
+  }
+}

package/koni/page/index.d.ts

@@ -0,0 +1,2 @@
+import { EvmProvider } from '@subwallet/extension-inject/types';
+export declare function initEvmProvider(version: string): EvmProvider;

package/koni/page/index.js

@@ -0,0 +1,9 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// the enable function, called by the dapp to allow access
+import { SubWalletEvmProvider } from '@subwallet/extension-base/koni/page/SubWalleEvmProvider';
+import { sendMessage } from '@subwallet/extension-base/page';
+export function initEvmProvider(version) {
+  return new SubWalletEvmProvider(sendMessage, version);
+}