@subwallet/extension-base 1.0.11-2 → 1.0.13-0

package/services/wallet-connect-service/constants.js

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EIP155_SIGNING_METHODS, POLKADOT_SIGNING_METHODS } from '@subwallet/extension-base/services/wallet-connect-service/types';
+export const PROJECT_ID = '6da34c0b48164d27681924dd9a46d6be';
+export const RELAY_URL = 'wss://relay.walletconnect.com';
+export const DEFAULT_WALLET_CONNECT_OPTIONS = {
+  logger: 'debug',
+  projectId: PROJECT_ID,
+  relayUrl: RELAY_URL,
+  metadata: {
+    name: 'SubWallet',
+    description: 'React Wallet for WalletConnect',
+    url: 'https://www.subwallet.app/',
+    icons: ['https://1570604715-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-Lh39Kwxa1xxZM9WX_Bs%2Ficon%2FiETEgi1ykXUQRW63vPnL%2FLogo%3DWhite%2C%20Background%3DGradient.jpg?alt=media&token=46c5dafa-ce09-4576-bcd9-a5c796786f1a']
+  }
+};
+export const ALL_WALLET_CONNECT_EVENT = ['session_proposal', 'session_update', 'session_extend', 'session_ping', 'session_delete', 'session_expire', 'session_request', 'session_request_sent', 'session_event', 'proposal_expire'];
+export const WALLET_CONNECT_SUPPORTED_METHODS = [POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_MESSAGE, POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_TRANSACTION, EIP155_SIGNING_METHODS.ETH_SEND_TRANSACTION, EIP155_SIGNING_METHODS.PERSONAL_SIGN, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V1, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V3, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4];
+export const WALLET_CONNECT_REQUEST_KEY = 'wallet-connect';
+export const WALLET_CONNECT_EIP155_NAMESPACE = 'eip155';
+export const WALLET_CONNECT_POLKADOT_NAMESPACE = 'polkadot';
+export const WALLET_CONNECT_SUPPORT_NAMESPACES = [WALLET_CONNECT_EIP155_NAMESPACE, WALLET_CONNECT_POLKADOT_NAMESPACE];

package/services/wallet-connect-service/handler/Eip155RequestHandler.d.ts

@@ -0,0 +1,8 @@
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
+import { SignClientTypes } from '@walletconnect/types';
+export default class Eip155RequestHandler {
+    #private;
+    constructor(koniState: KoniState, walletConnectService: WalletConnectService);
+    handleRequest(requestEvent: SignClientTypes.EventArguments['session_request']): void;
+}

package/services/wallet-connect-service/handler/Eip155RequestHandler.js

@@ -0,0 +1,106 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { formatJsonRpcError, formatJsonRpcResult } from '@json-rpc-tools/utils';
+import { getEip155MessageAddress, getWCId, parseRequestParams } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
+import { EIP155_SIGNING_METHODS } from '@subwallet/extension-base/services/wallet-connect-service/types';
+import { isSameAddress } from '@subwallet/extension-base/utils';
+import { getSdkError } from '@walletconnect/utils';
+var _walletConnectService = /*#__PURE__*/_classPrivateFieldLooseKey("walletConnectService");
+var _koniState = /*#__PURE__*/_classPrivateFieldLooseKey("koniState");
+var _checkAccount = /*#__PURE__*/_classPrivateFieldLooseKey("checkAccount");
+var _handleError = /*#__PURE__*/_classPrivateFieldLooseKey("handleError");
+export default class Eip155RequestHandler {
+  constructor(koniState, walletConnectService) {
+    Object.defineProperty(this, _handleError, {
+      value: _handleError2
+    });
+    Object.defineProperty(this, _checkAccount, {
+      value: _checkAccount2
+    });
+    Object.defineProperty(this, _walletConnectService, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _koniState, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _koniState)[_koniState] = koniState;
+    _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService] = walletConnectService;
+  }
+  handleRequest(requestEvent) {
+    const {
+      id,
+      params,
+      topic
+    } = requestEvent;
+    const {
+      chainId: _chainId,
+      request
+    } = params;
+    const method = request.method;
+    const requestSession = _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].getSession(topic);
+    const url = requestSession.peer.metadata.url;
+    const sessionAccounts = requestSession.namespaces.eip155.accounts.map(account => account.split(':')[2]);
+    if ([EIP155_SIGNING_METHODS.PERSONAL_SIGN, EIP155_SIGNING_METHODS.ETH_SIGN, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V3, EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4].includes(method)) {
+      const address = getEip155MessageAddress(method, request.params);
+      _classPrivateFieldLooseBase(this, _checkAccount)[_checkAccount](address, sessionAccounts);
+      _classPrivateFieldLooseBase(this, _koniState)[_koniState].evmSign(getWCId(id), url, method === EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA ? EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4 : method, request.params, sessionAccounts).then(async signature => {
+        await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+          topic: topic,
+          response: formatJsonRpcResult(id, signature)
+        });
+      }).catch(e => {
+        _classPrivateFieldLooseBase(this, _handleError)[_handleError](topic, id, e);
+      });
+    } else if (method === EIP155_SIGNING_METHODS.ETH_SEND_TRANSACTION) {
+      const [tx] = parseRequestParams(request.params);
+      const address = tx.from;
+      _classPrivateFieldLooseBase(this, _checkAccount)[_checkAccount](address, sessionAccounts);
+      const chainId = parseInt(_chainId.split(':')[1]);
+      const [networkKey, chainInfo] = _classPrivateFieldLooseBase(this, _koniState)[_koniState].findNetworkKeyByChainId(chainId);
+      if (!networkKey || !chainInfo) {
+        throw new Error(getSdkError('UNSUPPORTED_CHAINS').message + ' ' + address);
+      }
+      const chainState = _classPrivateFieldLooseBase(this, _koniState)[_koniState].getChainStateByKey(networkKey);
+      const createRequest = () => {
+        _classPrivateFieldLooseBase(this, _koniState)[_koniState].evmSendTransaction(getWCId(id), url, networkKey, sessionAccounts, tx).then(async signature => {
+          await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+            topic: topic,
+            response: formatJsonRpcResult(id, signature)
+          });
+        }).catch(e => {
+          _classPrivateFieldLooseBase(this, _handleError)[_handleError](topic, id, e);
+        });
+      };
+      if (!chainState.active) {
+        _classPrivateFieldLooseBase(this, _koniState)[_koniState].chainService.enableChain(networkKey).then(createRequest).catch(() => {
+          throw new Error(getSdkError('USER_REJECTED').message + ' Can not active chain: ' + chainInfo.name);
+        });
+      } else {
+        createRequest();
+      }
+    } else {
+      throw Error(getSdkError('INVALID_METHOD').message + ' ' + method);
+    }
+  }
+}
+function _checkAccount2(address, accounts) {
+  if (!accounts.find(account => isSameAddress(account, address))) {
+    throw new Error(getSdkError('UNSUPPORTED_ACCOUNTS').message + ' ' + address);
+  }
+}
+function _handleError2(topic, id, e) {
+  console.log(e);
+  let message = e.message;
+  if (message.includes('User Rejected Request')) {
+    message = getSdkError('USER_REJECTED').message;
+  }
+  _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+    topic: topic,
+    response: formatJsonRpcError(id, message)
+  }).catch(console.error);
+}

package/services/wallet-connect-service/handler/PolkadotRequestHandler.d.ts

@@ -0,0 +1,8 @@
+import RequestService from '@subwallet/extension-base/services/request-service';
+import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
+import { SignClientTypes } from '@walletconnect/types';
+export default class PolkadotRequestHandler {
+    #private;
+    constructor(walletConnectService: WalletConnectService, requestService: RequestService);
+    handleRequest(requestEvent: SignClientTypes.EventArguments['session_request']): void;
+}

package/services/wallet-connect-service/handler/PolkadotRequestHandler.js

@@ -0,0 +1,114 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { formatJsonRpcError, formatJsonRpcResult } from '@json-rpc-tools/utils';
+import RequestBytesSign from '@subwallet/extension-base/background/RequestBytesSign';
+import RequestExtrinsicSign from '@subwallet/extension-base/background/RequestExtrinsicSign';
+import { getWCId, parseRequestParams } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
+import { POLKADOT_SIGNING_METHODS } from '@subwallet/extension-base/services/wallet-connect-service/types';
+import { isSameAddress } from '@subwallet/extension-base/utils';
+import keyring from '@subwallet/ui-keyring';
+import { getSdkError } from '@walletconnect/utils';
+var _walletConnectService = /*#__PURE__*/_classPrivateFieldLooseKey("walletConnectService");
+var _requestService = /*#__PURE__*/_classPrivateFieldLooseKey("requestService");
+var _checkAccount = /*#__PURE__*/_classPrivateFieldLooseKey("checkAccount");
+var _handleError = /*#__PURE__*/_classPrivateFieldLooseKey("handleError");
+export default class PolkadotRequestHandler {
+  constructor(walletConnectService, requestService) {
+    Object.defineProperty(this, _handleError, {
+      value: _handleError2
+    });
+    Object.defineProperty(this, _checkAccount, {
+      value: _checkAccount2
+    });
+    Object.defineProperty(this, _walletConnectService, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _requestService, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService] = walletConnectService;
+    _classPrivateFieldLooseBase(this, _requestService)[_requestService] = requestService;
+  }
+  handleRequest(requestEvent) {
+    const {
+      id,
+      params,
+      topic
+    } = requestEvent;
+    const {
+      request
+    } = params;
+    const method = request.method;
+    const requestSession = _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].getSession(topic);
+    const url = requestSession.peer.metadata.url;
+    const sessionAccounts = requestSession.namespaces.polkadot.accounts.map(account => account.split(':')[2]);
+    if (method === POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_MESSAGE) {
+      const param = parseRequestParams(request.params);
+      _classPrivateFieldLooseBase(this, _checkAccount)[_checkAccount](param.address, sessionAccounts);
+      const pair = keyring.getPair(param.address);
+      const address = pair.address;
+      _classPrivateFieldLooseBase(this, _requestService)[_requestService].sign(url, new RequestBytesSign({
+        address: address,
+        data: param.message,
+        type: 'bytes'
+      }), {
+        address,
+        ...pair.meta
+      }, getWCId(id)).then(async ({
+        signature
+      }) => {
+        await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+          topic: topic,
+          response: formatJsonRpcResult(id, {
+            signature
+          })
+        });
+      }).catch(e => {
+        _classPrivateFieldLooseBase(this, _handleError)[_handleError](topic, id, e);
+      });
+    } else if (method === POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_TRANSACTION) {
+      const param = parseRequestParams(request.params);
+      _classPrivateFieldLooseBase(this, _checkAccount)[_checkAccount](param.address, sessionAccounts);
+      const pair = keyring.getPair(param.address);
+      const address = pair.address;
+      _classPrivateFieldLooseBase(this, _requestService)[_requestService].sign(url, new RequestExtrinsicSign(param.transactionPayload), {
+        address,
+        ...pair.meta
+      }, getWCId(id)).then(async ({
+        signature
+      }) => {
+        await _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+          topic: topic,
+          response: formatJsonRpcResult(id, {
+            signature
+          })
+        });
+      }).catch(e => {
+        _classPrivateFieldLooseBase(this, _handleError)[_handleError](topic, id, e);
+      });
+    } else {
+      throw Error(`${getSdkError('INVALID_METHOD').message} ${method}`);
+    }
+  }
+}
+function _checkAccount2(address, accounts) {
+  if (!accounts.find(account => isSameAddress(account, address))) {
+    throw new Error(getSdkError('UNSUPPORTED_ACCOUNTS').message + ' ' + address);
+  }
+}
+function _handleError2(topic, id, e) {
+  console.log(e);
+  let message = e.message;
+  if (message.includes('User Rejected Request')) {
+    message = getSdkError('USER_REJECTED').message;
+  }
+  _classPrivateFieldLooseBase(this, _walletConnectService)[_walletConnectService].responseRequest({
+    topic: topic,
+    response: formatJsonRpcError(id, message)
+  }).catch(console.error);
+}

package/services/wallet-connect-service/helpers.d.ts

@@ -0,0 +1,12 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { SignClientTypes } from '@walletconnect/types';
+import { ProposalTypes } from '@walletconnect/types/dist/types/sign-client/proposal';
+import { EIP155_SIGNING_METHODS, WalletConnectParamMap, WalletConnectSessionRequest, WalletConnectSigningMethod } from './types';
+export declare const getWCId: (id: number) => string;
+export declare const convertConnectRequest: (request: SignClientTypes.EventArguments['session_proposal']) => WalletConnectSessionRequest;
+export declare const parseRequestParams: <T extends WalletConnectSigningMethod>(params: unknown) => WalletConnectParamMap[T];
+export declare const getEip155MessageAddress: (method: EIP155_SIGNING_METHODS, param: unknown) => string;
+export declare const isWalletConnectRequest: (id?: string) => boolean;
+export declare const isProposalExpired: (params: ProposalTypes.Struct) => boolean;
+export declare const isSupportWalletConnectNamespace: (namespace: string) => boolean;
+export declare const isSupportWalletConnectChain: (chain: string, chainInfoMap: Record<string, _ChainInfo>) => boolean;

package/services/wallet-connect-service/helpers.js

@@ -0,0 +1,67 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { findChainInfoByChainId, findChainInfoByHalfGenesisHash } from '@subwallet/extension-base/services/chain-service/utils';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+import { WALLET_CONNECT_EIP155_NAMESPACE, WALLET_CONNECT_POLKADOT_NAMESPACE, WALLET_CONNECT_REQUEST_KEY, WALLET_CONNECT_SUPPORT_NAMESPACES } from "./constants.js";
+import { EIP155_SIGNING_METHODS } from "./types.js";
+export const getWCId = id => {
+  return [WALLET_CONNECT_REQUEST_KEY, Date.now(), id].join('.');
+};
+export const convertConnectRequest = request => {
+  return {
+    id: getWCId(request.id),
+    isInternal: false,
+    request: request,
+    url: request.params.proposer.metadata.url
+  };
+};
+export const parseRequestParams = params => {
+  // @ts-ignore
+  return params;
+};
+export const getEip155MessageAddress = (method, param) => {
+  switch (method) {
+    case EIP155_SIGNING_METHODS.PERSONAL_SIGN:
+    case EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA:
+    case EIP155_SIGNING_METHODS.ETH_SIGN:
+    case EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V3:
+    case EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4:
+      // eslint-disable-next-line no-case-declarations
+      const [p1, p2] = parseRequestParams(param);
+      if (typeof p1 === 'string' && isEthereumAddress(p1)) {
+        return p1;
+      } else if (typeof p2 === 'string' && isEthereumAddress(p2)) {
+        return p2;
+      }
+      return '';
+    default:
+      return '';
+  }
+};
+export const isWalletConnectRequest = id => {
+  if (!id) {
+    return false;
+  }
+  const [prefix] = id.split('.');
+  return prefix === WALLET_CONNECT_REQUEST_KEY;
+};
+export const isProposalExpired = params => {
+  const timeNum = params.expiry;
+  const expireTime = new Date(timeNum > 10 ** 12 ? timeNum : timeNum * 1000);
+  const now = new Date();
+  return now.getTime() >= expireTime.getTime();
+};
+export const isSupportWalletConnectNamespace = namespace => {
+  return WALLET_CONNECT_SUPPORT_NAMESPACES.includes(namespace);
+};
+export const isSupportWalletConnectChain = (chain, chainInfoMap) => {
+  const [namespace, info] = chain.split(':');
+  if (namespace === WALLET_CONNECT_POLKADOT_NAMESPACE) {
+    return !!findChainInfoByHalfGenesisHash(chainInfoMap, info);
+  } else if (namespace === WALLET_CONNECT_EIP155_NAMESPACE) {
+    return !!findChainInfoByChainId(chainInfoMap, parseInt(info));
+  } else {
+    return false;
+  }
+};

package/services/wallet-connect-service/index.d.ts

@@ -0,0 +1,20 @@
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { EngineTypes, SessionTypes, SignClientTypes } from '@walletconnect/types';
+import { BehaviorSubject } from 'rxjs';
+import { ResultApproveWalletConnectSession } from './types';
+export default class WalletConnectService {
+    #private;
+    readonly sessionSubject: BehaviorSubject<SessionTypes.Struct[]>;
+    constructor(koniState: KoniState, requestService: RequestService, option?: SignClientTypes.Options);
+    get sessions(): SessionTypes.Struct[];
+    getSession(topic: string): SessionTypes.Struct;
+    changeOption(newOption: Omit<SignClientTypes.Options, 'projectId'>): Promise<void>;
+    getSessions(): void;
+    connect(uri: string): Promise<void>;
+    approveSession(result: ResultApproveWalletConnectSession): Promise<void>;
+    rejectSession(id: number): Promise<void>;
+    responseRequest(response: EngineTypes.RespondParams): Promise<void>;
+    resetWallet(resetAll: boolean): Promise<void>;
+    disconnect(topic: string): Promise<void>;
+}

package/services/wallet-connect-service/index.js

@@ -0,0 +1,265 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/esm/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/esm/classPrivateFieldLooseKey";
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { formatJsonRpcError } from '@json-rpc-tools/utils';
+import Eip155RequestHandler from '@subwallet/extension-base/services/wallet-connect-service/handler/Eip155RequestHandler';
+import SignClient from '@walletconnect/sign-client';
+import { getInternalError, getSdkError } from '@walletconnect/utils';
+import { BehaviorSubject } from 'rxjs';
+import PolkadotRequestHandler from "./handler/PolkadotRequestHandler.js";
+import { ALL_WALLET_CONNECT_EVENT, DEFAULT_WALLET_CONNECT_OPTIONS, WALLET_CONNECT_SUPPORTED_METHODS } from "./constants.js";
+import { convertConnectRequest, isSupportWalletConnectChain } from "./helpers.js";
+import { EIP155_SIGNING_METHODS, POLKADOT_SIGNING_METHODS } from "./types.js";
+var _requestService = /*#__PURE__*/_classPrivateFieldLooseKey("requestService");
+var _polkadotRequestHandler = /*#__PURE__*/_classPrivateFieldLooseKey("polkadotRequestHandler");
+var _eip155RequestHandler = /*#__PURE__*/_classPrivateFieldLooseKey("eip155RequestHandler");
+var _koniState = /*#__PURE__*/_classPrivateFieldLooseKey("koniState");
+var _client = /*#__PURE__*/_classPrivateFieldLooseKey("client");
+var _option = /*#__PURE__*/_classPrivateFieldLooseKey("option");
+var _initClient = /*#__PURE__*/_classPrivateFieldLooseKey("initClient");
+var _updateSessions = /*#__PURE__*/_classPrivateFieldLooseKey("updateSessions");
+var _onSessionProposal = /*#__PURE__*/_classPrivateFieldLooseKey("onSessionProposal");
+var _onSessionRequest = /*#__PURE__*/_classPrivateFieldLooseKey("onSessionRequest");
+var _createListener = /*#__PURE__*/_classPrivateFieldLooseKey("createListener");
+var _removeListener = /*#__PURE__*/_classPrivateFieldLooseKey("removeListener");
+var _checkClient = /*#__PURE__*/_classPrivateFieldLooseKey("checkClient");
+export default class WalletConnectService {
+  constructor(koniState, requestService, option = DEFAULT_WALLET_CONNECT_OPTIONS) {
+    Object.defineProperty(this, _checkClient, {
+      value: _checkClient2
+    });
+    Object.defineProperty(this, _removeListener, {
+      value: _removeListener2
+    });
+    Object.defineProperty(this, _createListener, {
+      value: _createListener2
+    });
+    Object.defineProperty(this, _onSessionRequest, {
+      value: _onSessionRequest2
+    });
+    Object.defineProperty(this, _onSessionProposal, {
+      value: _onSessionProposal2
+    });
+    Object.defineProperty(this, _updateSessions, {
+      value: _updateSessions2
+    });
+    Object.defineProperty(this, _initClient, {
+      value: _initClient2
+    });
+    Object.defineProperty(this, _requestService, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _polkadotRequestHandler, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _eip155RequestHandler, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _koniState, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _client, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _option, {
+      writable: true,
+      value: void 0
+    });
+    this.sessionSubject = new BehaviorSubject([]);
+    _classPrivateFieldLooseBase(this, _koniState)[_koniState] = koniState;
+    _classPrivateFieldLooseBase(this, _requestService)[_requestService] = requestService;
+    _classPrivateFieldLooseBase(this, _option)[_option] = option;
+    _classPrivateFieldLooseBase(this, _polkadotRequestHandler)[_polkadotRequestHandler] = new PolkadotRequestHandler(this, requestService);
+    _classPrivateFieldLooseBase(this, _eip155RequestHandler)[_eip155RequestHandler] = new Eip155RequestHandler(_classPrivateFieldLooseBase(this, _koniState)[_koniState], this);
+    _classPrivateFieldLooseBase(this, _initClient)[_initClient]().catch(console.error);
+  }
+  get sessions() {
+    var _classPrivateFieldLoo;
+    return ((_classPrivateFieldLoo = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo === void 0 ? void 0 : _classPrivateFieldLoo.session.values) || [];
+  }
+  getSession(topic) {
+    var _classPrivateFieldLoo2;
+    const session = (_classPrivateFieldLoo2 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo2 === void 0 ? void 0 : _classPrivateFieldLoo2.session.get(topic);
+    if (!session) {
+      throw new Error(getInternalError('MISMATCHED_TOPIC').message);
+    } else {
+      return session;
+    }
+  }
+  async changeOption(newOption) {
+    _classPrivateFieldLooseBase(this, _option)[_option] = Object.assign({}, _classPrivateFieldLooseBase(this, _option)[_option], newOption);
+    await _classPrivateFieldLooseBase(this, _initClient)[_initClient]();
+  }
+  getSessions() {
+    var _classPrivateFieldLoo3;
+    _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+    console.log((_classPrivateFieldLoo3 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo3 === void 0 ? void 0 : _classPrivateFieldLoo3.session.values);
+  }
+  async connect(uri) {
+    var _classPrivateFieldLoo4;
+    _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+    await ((_classPrivateFieldLoo4 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo4 === void 0 ? void 0 : _classPrivateFieldLoo4.pair({
+      uri
+    }));
+  }
+  async approveSession(result) {
+    var _classPrivateFieldLoo5;
+    _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+    await ((_classPrivateFieldLoo5 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo5 === void 0 ? void 0 : _classPrivateFieldLoo5.approve(result));
+    _classPrivateFieldLooseBase(this, _updateSessions)[_updateSessions]();
+  }
+  async rejectSession(id) {
+    var _classPrivateFieldLoo6;
+    _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+    await ((_classPrivateFieldLoo6 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo6 === void 0 ? void 0 : _classPrivateFieldLoo6.reject({
+      id: id,
+      reason: getSdkError('USER_REJECTED')
+    }));
+  }
+  async responseRequest(response) {
+    var _classPrivateFieldLoo7;
+    _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+    await ((_classPrivateFieldLoo7 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo7 === void 0 ? void 0 : _classPrivateFieldLoo7.respond(response));
+  }
+  async resetWallet(resetAll) {
+    var _classPrivateFieldLoo8, _classPrivateFieldLoo10, _classPrivateFieldLoo12;
+    _classPrivateFieldLooseBase(this, _removeListener)[_removeListener]();
+
+    // Disconnect session
+    const sessions = ((_classPrivateFieldLoo8 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo8 === void 0 ? void 0 : _classPrivateFieldLoo8.session.values) || [];
+    for (const session of sessions) {
+      var _classPrivateFieldLoo9;
+      (_classPrivateFieldLoo9 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo9 === void 0 ? void 0 : _classPrivateFieldLoo9.disconnect({
+        topic: session.topic,
+        reason: getSdkError('USER_DISCONNECTED')
+      }).catch(console.error);
+    }
+
+    // Disconnect pair
+    const pairs = ((_classPrivateFieldLoo10 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo10 === void 0 ? void 0 : _classPrivateFieldLoo10.pairing.values) || [];
+    for (const pair of pairs) {
+      var _classPrivateFieldLoo11;
+      (_classPrivateFieldLoo11 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo11 === void 0 ? void 0 : _classPrivateFieldLoo11.disconnect({
+        topic: pair.topic,
+        reason: getSdkError('USER_DISCONNECTED')
+      }).catch(console.error);
+    }
+    const keys = (await ((_classPrivateFieldLoo12 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo12 === void 0 ? void 0 : _classPrivateFieldLoo12.core.storage.getKeys())) || [];
+    const deleteKeys = resetAll ? keys : keys.filter(key => key.startsWith('wc@'));
+    for (const key of deleteKeys) {
+      try {
+        var _classPrivateFieldLoo13;
+        await ((_classPrivateFieldLoo13 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo13 === void 0 ? void 0 : _classPrivateFieldLoo13.core.storage.removeItem(key));
+      } catch (e) {
+        console.error(e);
+      }
+    }
+    await _classPrivateFieldLooseBase(this, _initClient)[_initClient]();
+  }
+  async disconnect(topic) {
+    var _classPrivateFieldLoo14;
+    await ((_classPrivateFieldLoo14 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo14 === void 0 ? void 0 : _classPrivateFieldLoo14.disconnect({
+      topic: topic,
+      reason: getSdkError('USER_DISCONNECTED')
+    }));
+    _classPrivateFieldLooseBase(this, _updateSessions)[_updateSessions]();
+  }
+}
+async function _initClient2() {
+  _classPrivateFieldLooseBase(this, _removeListener)[_removeListener]();
+  _classPrivateFieldLooseBase(this, _client)[_client] = await SignClient.init(_classPrivateFieldLooseBase(this, _option)[_option]);
+  _classPrivateFieldLooseBase(this, _updateSessions)[_updateSessions]();
+  _classPrivateFieldLooseBase(this, _createListener)[_createListener]();
+}
+function _updateSessions2() {
+  this.sessionSubject.next(this.sessions);
+}
+function _onSessionProposal2(proposal) {
+  _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+  _classPrivateFieldLooseBase(this, _requestService)[_requestService].addConnectWCRequest(convertConnectRequest(proposal));
+}
+function _onSessionRequest2(requestEvent) {
+  _classPrivateFieldLooseBase(this, _checkClient)[_checkClient]();
+  const {
+    id,
+    params,
+    topic
+  } = requestEvent;
+  const {
+    chainId,
+    request
+  } = params;
+  const method = request.method;
+  try {
+    const requestSession = this.getSession(topic);
+    const namespaces = Object.keys(requestSession.namespaces);
+    const chains = Object.values(requestSession.namespaces).map(namespace => namespace.chains).flat();
+    const methods = Object.values(requestSession.namespaces).map(namespace => namespace.methods).flat();
+    const chainInfoMap = _classPrivateFieldLooseBase(this, _koniState)[_koniState].getChainInfoMap();
+    const [requestNamespace] = chainId.split(':');
+    if (!namespaces.includes(requestNamespace)) {
+      throw Error(getSdkError('UNSUPPORTED_NAMESPACE_KEY').message);
+    }
+    if (!chains.includes(chainId)) {
+      throw Error(getSdkError('UNSUPPORTED_CHAINS').message + ' ' + chainId);
+    }
+    if (!isSupportWalletConnectChain(chainId, chainInfoMap)) {
+      throw Error(getSdkError('UNSUPPORTED_CHAINS').message + ' ' + chainId);
+    }
+    if (!methods.includes(method)) {
+      throw Error(getSdkError('UNAUTHORIZED_METHOD').message + ' ' + method);
+    }
+    if (!WALLET_CONNECT_SUPPORTED_METHODS.includes(method)) {
+      throw Error(getSdkError('UNSUPPORTED_METHODS').message + ' ' + method);
+    }
+    switch (method) {
+      case POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_MESSAGE:
+      case POLKADOT_SIGNING_METHODS.POLKADOT_SIGN_TRANSACTION:
+        _classPrivateFieldLooseBase(this, _polkadotRequestHandler)[_polkadotRequestHandler].handleRequest(requestEvent);
+        break;
+      case EIP155_SIGNING_METHODS.ETH_SEND_TRANSACTION:
+      case EIP155_SIGNING_METHODS.PERSONAL_SIGN:
+      case EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA:
+      case EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V3:
+      case EIP155_SIGNING_METHODS.ETH_SIGN_TYPED_DATA_V4:
+      case EIP155_SIGNING_METHODS.ETH_SIGN:
+        _classPrivateFieldLooseBase(this, _eip155RequestHandler)[_eip155RequestHandler].handleRequest(requestEvent);
+        break;
+      default:
+        throw Error(getSdkError('INVALID_METHOD').message + ' ' + method);
+    }
+  } catch (e) {
+    console.log(e);
+    this.responseRequest({
+      topic: topic,
+      response: formatJsonRpcError(id, e.message)
+    }).catch(console.error);
+  }
+}
+function _createListener2() {
+  var _classPrivateFieldLoo15, _classPrivateFieldLoo16, _classPrivateFieldLoo17, _classPrivateFieldLoo18, _classPrivateFieldLoo19, _classPrivateFieldLoo20;
+  (_classPrivateFieldLoo15 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo15 === void 0 ? void 0 : _classPrivateFieldLoo15.on('session_proposal', _classPrivateFieldLooseBase(this, _onSessionProposal)[_onSessionProposal].bind(this));
+  (_classPrivateFieldLoo16 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo16 === void 0 ? void 0 : _classPrivateFieldLoo16.on('session_request', _classPrivateFieldLooseBase(this, _onSessionRequest)[_onSessionRequest].bind(this));
+  (_classPrivateFieldLoo17 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo17 === void 0 ? void 0 : _classPrivateFieldLoo17.on('session_ping', data => console.log('ping', data));
+  (_classPrivateFieldLoo18 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo18 === void 0 ? void 0 : _classPrivateFieldLoo18.on('session_event', data => console.log('event', data));
+  (_classPrivateFieldLoo19 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo19 === void 0 ? void 0 : _classPrivateFieldLoo19.on('session_update', data => console.log('update', data));
+  (_classPrivateFieldLoo20 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo20 === void 0 ? void 0 : _classPrivateFieldLoo20.on('session_delete', _classPrivateFieldLooseBase(this, _updateSessions)[_updateSessions].bind(this));
+}
+function _removeListener2() {
+  ALL_WALLET_CONNECT_EVENT.forEach(event => {
+    var _classPrivateFieldLoo21;
+    (_classPrivateFieldLoo21 = _classPrivateFieldLooseBase(this, _client)[_client]) === null || _classPrivateFieldLoo21 === void 0 ? void 0 : _classPrivateFieldLoo21.removeAllListeners(event);
+  });
+}
+function _checkClient2() {
+  if (!_classPrivateFieldLooseBase(this, _client)[_client]) {
+    throw new Error(getInternalError('NOT_INITIALIZED').message);
+  }
+}