@subwallet/extension-base 1.0.12-0 → 1.0.13-0

package/page/Metadata.js

@@ -13,4 +13,7 @@ export default class Metadata {
   provide(definition) {
     return sendRequest('pub(metadata.provide)', definition);
   }
+  addToken(request) {
+    return sendRequest('pub(token.add)', request);
+  }
 }

package/services/chain-service/utils.d.ts

@@ -63,3 +63,5 @@ export declare function _isAssetFungibleToken(chainAsset: _ChainAsset): boolean;
 export declare function _getCrowdloanUrlFromChain(chainInfo: _ChainInfo): string;
 export declare function _isCustomProvider(providerKey: string): boolean;
 export declare function _generateCustomProviderKey(index: number): string;
+export declare const findChainInfoByHalfGenesisHash: (chainMap: Record<string, _ChainInfo>, halfGenesisHash?: string) => _ChainInfo | null;
+export declare const findChainInfoByChainId: (chainMap: Record<string, _ChainInfo>, chainId?: number) => _ChainInfo | null;

package/services/chain-service/utils.js

@@ -330,4 +330,28 @@ export function _isCustomProvider(providerKey) {
 }
 export function _generateCustomProviderKey(index) {
   return `${_CUSTOM_PREFIX}provider-${index}`;
-}
+}
+export const findChainInfoByHalfGenesisHash = (chainMap, halfGenesisHash) => {
+  if (!halfGenesisHash) {
+    return null;
+  }
+  for (const chainInfo of Object.values(chainMap)) {
+    var _getSubstrateGenesisH;
+    if (((_getSubstrateGenesisH = _getSubstrateGenesisHash(chainInfo)) === null || _getSubstrateGenesisH === void 0 ? void 0 : _getSubstrateGenesisH.toLowerCase().substring(2, 2 + 32)) === halfGenesisHash.toLowerCase()) {
+      return chainInfo;
+    }
+  }
+  return null;
+};
+export const findChainInfoByChainId = (chainMap, chainId) => {
+  if (!chainId) {
+    return null;
+  }
+  for (const chainInfo of Object.values(chainMap)) {
+    var _chainInfo$evmInfo5;
+    if (((_chainInfo$evmInfo5 = chainInfo.evmInfo) === null || _chainInfo$evmInfo5 === void 0 ? void 0 : _chainInfo$evmInfo5.evmChainId) === chainId) {
+      return chainInfo;
+    }
+  }
+  return null;
+};

package/services/request-service/handler/AuthRequestHandler.d.ts

@@ -15,7 +15,6 @@ export default class AuthRequestHandler {
     private readonly evmChainSubject;
     readonly authSubjectV2: BehaviorSubject<AuthorizeRequest[]>;
     constructor(requestService: RequestService, chainService: ChainService, keyringService: KeyringService);
-    stripUrl(url: string): string;
     private getAddressList;
     get numAuthRequestsV2(): number;
     private get allAuthRequestsV2();

package/services/request-service/handler/AuthRequestHandler.js

@@ -4,7 +4,7 @@
 import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { PREDEFINED_CHAIN_DAPP_CHAIN_MAP } from '@subwallet/extension-base/services/request-service/constants';
 import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
-import { getDomainFromUrl } from '@subwallet/extension-base/utils';
+import { getDomainFromUrl, stripUrl } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { assert } from '@polkadot/util';
@@ -24,11 +24,6 @@ export default class AuthRequestHandler {
     this.#requestService = requestService;
     this.#chainService = chainService;
   }
-  stripUrl(url) {
-    assert(url && (url.startsWith('http:') || url.startsWith('https:') || url.startsWith('ipfs:') || url.startsWith('ipns:')), `Invalid url ${url}, expected to start with http: or https: or ipfs: or ipns:`);
-    const parts = url.split('/');
-    return parts[2];
-  }
   getAddressList(value = false) {
     const addressList = Object.keys(this.keyringService.accounts);
     return addressList.reduce((addressList, v) => ({
@@ -161,7 +156,7 @@ export default class AuthRequestHandler {
         if (value) {
           authorizeList = value;
         }
-        const existed = authorizeList[this.stripUrl(url)];
+        const existed = authorizeList[stripUrl(url)];
 
         // On cancel don't save anything
         if (isCancelled) {
@@ -170,7 +165,7 @@ export default class AuthRequestHandler {
           cb();
           return;
         }
-        authorizeList[this.stripUrl(url)] = {
+        authorizeList[stripUrl(url)] = {
           count: 0,
           id: idStr,
           isAllowed,
@@ -210,7 +205,7 @@ export default class AuthRequestHandler {
     if (!authList) {
       authList = {};
     }
-    const idStr = this.stripUrl(url);
+    const idStr = stripUrl(url);
     // Do not enqueue duplicate authorization requests.
     const isDuplicate = Object.values(this.#authRequestsV2).some(request => request.idStr === idStr);
     assert(!isDuplicate, `The source ${url} has a pending authorization request`);
@@ -265,7 +260,7 @@ export default class AuthRequestHandler {
     return this.authorizeUrlSubject;
   }
   ensureUrlAuthorizedV2(url) {
-    const idStr = this.stripUrl(url);
+    const idStr = stripUrl(url);
     return new Promise((resolve, reject) => {
       this.getAuthorize(value => {
         if (!value) {

package/services/request-service/handler/SubstrateRequestHandler.d.ts

@@ -12,7 +12,7 @@ export default class SubstrateRequestHandler {
     private updateIconSign;
     private signComplete;
     get numSubstrateRequests(): number;
-    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+    sign(url: string, request: RequestSign, account: AccountJson, _id?: string): Promise<ResponseSigning>;
     signTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON): Promise<ResponseSigning>;
     resetWallet(): void;
 }

package/services/request-service/handler/SubstrateRequestHandler.js

@@ -57,8 +57,8 @@ export default class SubstrateRequestHandler {
   get numSubstrateRequests() {
     return Object.keys(this.#substrateRequests).length;
   }
-  sign(url, request, account) {
-    const id = getId();
+  sign(url, request, account, _id) {
+    const id = _id || getId();
     return new Promise((resolve, reject) => {
       this.#substrateRequests[id] = {
         ...this.signComplete(id, resolve, reject),

package/services/request-service/handler/WalletConnectRequestHandler.d.ts

@@ -0,0 +1,15 @@
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { RequestWalletConnectSession, WalletConnectSessionRequest } from '@subwallet/extension-base/services/wallet-connect-service/types';
+import { BehaviorSubject } from 'rxjs';
+export default class WalletConnectRequestHandler {
+    #private;
+    readonly connectWCSubject: BehaviorSubject<WalletConnectSessionRequest[]>;
+    constructor(requestService: RequestService);
+    get allConnectWCRequests(): WalletConnectSessionRequest[];
+    get numConnectWCRequests(): number;
+    getConnectWCRequest(id: string): RequestWalletConnectSession;
+    private updateIconConnectWC;
+    private connectWCComplete;
+    addConnectWCRequest(request: WalletConnectSessionRequest): void;
+    resetWallet(): void;
+}

package/services/request-service/handler/WalletConnectRequestHandler.js

@@ -0,0 +1,62 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BehaviorSubject } from 'rxjs';
+
+// WC = WalletConnect
+export default class WalletConnectRequestHandler {
+  #requestService;
+  #walletConnectSessionRequests = {};
+  connectWCSubject = new BehaviorSubject([]);
+  constructor(requestService) {
+    this.#requestService = requestService;
+  }
+  get allConnectWCRequests() {
+    return Object.values(this.#walletConnectSessionRequests)
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    .map(({
+      reject,
+      resolve,
+      ...data
+    }) => data);
+  }
+  get numConnectWCRequests() {
+    return Object.keys(this.#walletConnectSessionRequests).length;
+  }
+  getConnectWCRequest(id) {
+    return this.#walletConnectSessionRequests[id];
+  }
+  updateIconConnectWC(shouldClose) {
+    this.connectWCSubject.next(this.allConnectWCRequests);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  connectWCComplete = id => {
+    const complete = shouldClose => {
+      delete this.#walletConnectSessionRequests[id];
+      this.updateIconConnectWC(shouldClose);
+    };
+    return {
+      reject: () => {
+        complete(true);
+      },
+      resolve: () => {
+        complete(true);
+      }
+    };
+  };
+  addConnectWCRequest(request) {
+    const id = request.id;
+    this.#walletConnectSessionRequests[id] = {
+      ...this.connectWCComplete(id),
+      ...request
+    };
+    this.updateIconConnectWC();
+    this.#requestService.popupOpen();
+  }
+  resetWallet() {
+    for (const request of Object.values(this.#walletConnectSessionRequests)) {
+      request.reject(new Error('Reset wallet'));
+    }
+    this.connectWCSubject.next([]);
+  }
+}

package/services/request-service/index.d.ts

@@ -4,6 +4,7 @@ import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import { AuthUrls, MetaRequest } from '@subwallet/extension-base/services/request-service/types';
 import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
+import { WalletConnectSessionRequest } from '@subwallet/extension-base/services/wallet-connect-service/types';
 import { MetadataDef } from '@subwallet/extension-inject/types';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { SignerPayloadJSON } from '@polkadot/types/types/extrinsic';
@@ -14,7 +15,6 @@ export default class RequestService {
     constructor(chainService: ChainService, settingService: SettingService, keyringService: KeyringService);
     get numAllRequests(): number;
     updateIconV2(shouldClose?: boolean): void;
-    stripUrl(url: string): string;
     getAddressList(value?: boolean): Record<string, boolean>;
     get popup(): number[];
     popupClose(): void;
@@ -43,7 +43,7 @@ export default class RequestService {
     ensureUrlAuthorizedV2(url: string): Promise<boolean>;
     get signSubject(): BehaviorSubject<SigningRequest[]>;
     get allSubstrateRequests(): SigningRequest[];
-    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+    sign(url: string, request: RequestSign, account: AccountJson, id?: string): Promise<ResponseSigning>;
     get numSubstrateRequests(): number;
     get numEvmRequests(): number;
     get confirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
@@ -52,6 +52,11 @@ export default class RequestService {
     addConfirmation<CT extends ConfirmationType>(id: string, url: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): Promise<ConfirmationDefinitions[CT][1]>;
     completeConfirmation(request: RequestConfirmationComplete): Promise<boolean>;
     updateConfirmation<CT extends ConfirmationType>(id: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): void;
+    getConnectWCRequest(id: string): import("@subwallet/extension-base/services/wallet-connect-service/types").RequestWalletConnectSession;
+    get connectWCSubject(): BehaviorSubject<WalletConnectSessionRequest[]>;
+    get allConnectWCRequests(): WalletConnectSessionRequest[];
+    get numConnectWCRequests(): number;
+    addConnectWCRequest(request: WalletConnectSessionRequest): void;
     get numRequests(): number;
     resetWallet(): void;
 }

package/services/request-service/index.js

@@ -6,6 +6,7 @@ import EvmRequestHandler from '@subwallet/extension-base/services/request-servic
 import MetadataRequestHandler from '@subwallet/extension-base/services/request-service/handler/MetadataRequestHandler';
 import PopupHandler from '@subwallet/extension-base/services/request-service/handler/PopupHandler';
 import SubstrateRequestHandler from '@subwallet/extension-base/services/request-service/handler/SubstrateRequestHandler';
+import WalletConnectRequestHandler from '@subwallet/extension-base/services/request-service/handler/WalletConnectRequestHandler';
 export default class RequestService {
   // Common
   #chainService;
@@ -14,6 +15,7 @@ export default class RequestService {
   #authRequestHandler;
   #substrateRequestHandler;
   #evmRequestHandler;
+  #walletConnectRequestHandler;
 
   // Common
   constructor(chainService, settingService, keyringService) {
@@ -25,6 +27,7 @@ export default class RequestService {
     this.#authRequestHandler = new AuthRequestHandler(this, this.#chainService, this.keyringService);
     this.#substrateRequestHandler = new SubstrateRequestHandler(this);
     this.#evmRequestHandler = new EvmRequestHandler(this);
+    this.#walletConnectRequestHandler = new WalletConnectRequestHandler(this);
 
     // Reset icon on start service
     this.updateIconV2();
@@ -35,9 +38,6 @@ export default class RequestService {
   updateIconV2(shouldClose) {
     this.#popupHandler.updateIconV2(shouldClose);
   }
-  stripUrl(url) {
-    return this.#authRequestHandler.stripUrl(url);
-  }
   getAddressList(value = false) {
     const addressList = Object.keys(this.keyringService.accounts);
     return addressList.reduce((addressList, v) => ({
@@ -128,8 +128,8 @@ export default class RequestService {
   get allSubstrateRequests() {
     return this.#substrateRequestHandler.allSubstrateRequests;
   }
-  sign(url, request, account) {
-    return this.#substrateRequestHandler.sign(url, request, account);
+  sign(url, request, account, id) {
+    return this.#substrateRequestHandler.sign(url, request, account, id);
   }
   get numSubstrateRequests() {
     return this.#substrateRequestHandler.numSubstrateRequests;
@@ -158,14 +158,32 @@ export default class RequestService {
     return this.#evmRequestHandler.updateConfirmation(id, type, payload, options, validator);
   }
 
+  // Wallet Connect requests
+  getConnectWCRequest(id) {
+    return this.#walletConnectRequestHandler.getConnectWCRequest(id);
+  }
+  get connectWCSubject() {
+    return this.#walletConnectRequestHandler.connectWCSubject;
+  }
+  get allConnectWCRequests() {
+    return this.#walletConnectRequestHandler.allConnectWCRequests;
+  }
+  get numConnectWCRequests() {
+    return this.#walletConnectRequestHandler.numConnectWCRequests;
+  }
+  addConnectWCRequest(request) {
+    return this.#walletConnectRequestHandler.addConnectWCRequest(request);
+  }
+
   // General methods
   get numRequests() {
-    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests;
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests;
   }
   resetWallet() {
     this.#authRequestHandler.resetWallet();
     this.#substrateRequestHandler.resetWallet();
     this.#evmRequestHandler.resetWallet();
     this.#metadataRequestHandler.resetWallet();
+    this.#walletConnectRequestHandler.resetWallet();
   }
 }

package/services/transaction-service/helpers/index.d.ts

@@ -1,7 +1,7 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
-export declare const getTransactionId: (chainType: string, chain: string, isInternal: boolean) => string;
+export declare const getTransactionId: (chainType: string, chain: string, isInternal: boolean, isWalletConnect?: boolean) => string;
 export declare const getValidationId: (chainType: string, chain: string) => string;
 export declare const isSubstrateTransaction: (tx: SWTransaction['transaction']) => tx is SubmittableExtrinsic;
 export declare const getBaseTransactionInfo: (transaction: SWTransaction, chainInfoMap: Record<string, _ChainInfo>) => string;

package/services/transaction-service/helpers/index.js

@@ -4,8 +4,8 @@
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 let transactionCount = 0;
 let validationCount = 0;
-export const getTransactionId = (chainType, chain, isInternal) => {
-  return `${isInternal ? 'internal' : 'external'}.${chainType}.${chain}.${Date.now()}.${++transactionCount}`;
+export const getTransactionId = (chainType, chain, isInternal, isWalletConnect = false) => {
+  return `${isInternal ? 'internal' : !isWalletConnect ? 'external' : 'wallet-connect'}.${chainType}.${chain}.${Date.now()}.${++transactionCount}`;
 };
 export const getValidationId = (chainType, chain) => {
   return `${chainType}.${chain}.${Date.now()}.${++validationCount}`;

package/services/transaction-service/index.js

@@ -13,6 +13,7 @@ import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transact
 import { parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
 import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
+import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { anyNumberToBN } from '@subwallet/extension-base/utils/eth';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
@@ -170,7 +171,7 @@ export default class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
-    const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal);
+    const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal, isWalletConnectRequest(transaction.id));
     return {
       ...transaction,
       createdAt: new Date().getTime(),

package/services/transaction-service/types.d.ts

@@ -23,7 +23,8 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
 }
 export declare type SWTransactionResult = Omit<SWTransaction, 'transaction' | 'additionalValidator' | 'eventsHandler'>;
 declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase {
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransaction, 'estimateFee'>> {
+    id?: string;
     transaction?: SWTransaction['transaction'] | null;
     warnings?: SWTransaction['warnings'];
     errors?: SWTransaction['errors'];

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

@@ -0,0 +1,11 @@
+import { WalletConnectSigningMethod } from '@subwallet/extension-base/services/wallet-connect-service/types';
+import { SignClientTypes } from '@walletconnect/types';
+export declare const PROJECT_ID = "6da34c0b48164d27681924dd9a46d6be";
+export declare const RELAY_URL = "wss://relay.walletconnect.com";
+export declare const DEFAULT_WALLET_CONNECT_OPTIONS: SignClientTypes.Options;
+export declare const ALL_WALLET_CONNECT_EVENT: SignClientTypes.Event[];
+export declare const WALLET_CONNECT_SUPPORTED_METHODS: WalletConnectSigningMethod[];
+export declare const WALLET_CONNECT_REQUEST_KEY = "wallet-connect";
+export declare const WALLET_CONNECT_EIP155_NAMESPACE = "eip155";
+export declare const WALLET_CONNECT_POLKADOT_NAMESPACE = "polkadot";
+export declare const WALLET_CONNECT_SUPPORT_NAMESPACES: string[];

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;
+}