@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,253 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _isChainEnabled, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import AuthorizeStore from '@subwallet/extension-base/stores/Authorize';
+import { getId } from '@subwallet/extension-base/utils/getId';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { assert } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+const AUTH_URLS_KEY = 'authUrls';
+export default class AuthRequestHandler {
+  #requestService;
+  #chainService;
+  authorizeStore = new AuthorizeStore();
+  #authRequestsV2 = {};
+  authorizeCached = undefined;
+  authorizeUrlSubject = new Subject();
+  evmChainSubject = new Subject();
+  authSubjectV2 = new BehaviorSubject([]);
+  constructor(requestService, chainService) {
+    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(accounts.subject.value);
+    return addressList.reduce((addressList, v) => ({
+      ...addressList,
+      [v]: value
+    }), {});
+  }
+  get numAuthRequestsV2() {
+    return Object.keys(this.#authRequestsV2).length;
+  }
+  get allAuthRequestsV2() {
+    return Object.values(this.#authRequestsV2).map(({
+      id,
+      request,
+      url
+    }) => ({
+      id,
+      request,
+      url
+    }));
+  }
+  updateIconAuthV2(shouldClose) {
+    this.authSubjectV2.next(this.allAuthRequestsV2);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  setAuthorize(data, callback) {
+    this.authorizeStore.set(AUTH_URLS_KEY, data, () => {
+      this.authorizeCached = data;
+      this.evmChainSubject.next(this.authorizeCached);
+      this.authorizeUrlSubject.next(this.authorizeCached);
+      callback && callback();
+    });
+  }
+  getAuthorize(update) {
+    // This action can be use many by DApp interaction => caching it in memory
+    if (this.authorizeCached) {
+      update(this.authorizeCached);
+    } else {
+      this.authorizeStore.get('authUrls', data => {
+        this.authorizeCached = data;
+        update(this.authorizeCached);
+      });
+    }
+  }
+  getAuthList() {
+    return new Promise((resolve, reject) => {
+      this.getAuthorize(rs => {
+        resolve(rs);
+      });
+    });
+  }
+  authCompleteV2 = (id, resolve, reject) => {
+    const isAllowedMap = this.getAddressList();
+    const complete = (result, cb, accounts) => {
+      const isAllowed = result === true;
+      let isCancelled = false;
+      if (!isAllowed && typeof result === 'object' && result.message === 'Cancelled') {
+        isCancelled = true;
+      }
+      if (accounts && accounts.length) {
+        accounts.forEach(acc => {
+          isAllowedMap[acc] = true;
+        });
+      } else {
+        // eslint-disable-next-line no-return-assign
+        Object.keys(isAllowedMap).forEach(address => isAllowedMap[address] = false);
+      }
+      const {
+        accountAuthType,
+        idStr,
+        request: {
+          allowedAccounts,
+          origin
+        },
+        url
+      } = this.#authRequestsV2[id];
+      if (accountAuthType !== 'both') {
+        const isEvmType = accountAuthType === 'evm';
+        const backupAllowed = [...(allowedAccounts || [])].filter(a => {
+          const isEth = isEthereumAddress(a);
+          return isEvmType ? !isEth : isEth;
+        });
+        backupAllowed.forEach(acc => {
+          isAllowedMap[acc] = true;
+        });
+      }
+      let defaultEvmNetworkKey;
+      if (accountAuthType === 'both' || accountAuthType === 'evm') {
+        const defaultChain = Object.values(this.#chainService.getChainInfoMap()).find(chainInfo => {
+          const chainState = this.#chainService.getChainStateByKey(chainInfo.slug);
+          return _isChainEvmCompatible(chainInfo) && _isChainEnabled(chainState);
+        });
+        if (defaultChain) {
+          defaultEvmNetworkKey = defaultChain.slug;
+        }
+      }
+      this.getAuthorize(value => {
+        let authorizeList = {};
+        if (value) {
+          authorizeList = value;
+        }
+        const existed = authorizeList[this.stripUrl(url)];
+
+        // On cancel don't save anything
+        if (isCancelled) {
+          delete this.#authRequestsV2[id];
+          this.updateIconAuthV2(true);
+          cb();
+          return;
+        }
+        authorizeList[this.stripUrl(url)] = {
+          count: 0,
+          id: idStr,
+          isAllowed,
+          isAllowedMap,
+          origin,
+          url,
+          accountAuthType: existed && existed.accountAuthType !== accountAuthType ? 'both' : accountAuthType,
+          currentEvmNetworkKey: existed ? existed.currentEvmNetworkKey : defaultEvmNetworkKey
+        };
+        this.setAuthorize(authorizeList, () => {
+          cb();
+          delete this.#authRequestsV2[id];
+          this.updateIconAuthV2(true);
+        });
+      });
+    };
+    return {
+      reject: error => {
+        complete(error, () => {
+          reject(error);
+        });
+      },
+      resolve: ({
+        accounts,
+        result
+      }) => {
+        complete(result, () => {
+          resolve(result);
+        }, accounts);
+      }
+    };
+  };
+  async authorizeUrlV2(url, request) {
+    let authList = await this.getAuthList();
+    const accountAuthType = request.accountAuthType || 'substrate';
+    request.accountAuthType = accountAuthType;
+    if (!authList) {
+      authList = {};
+    }
+    const idStr = this.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`);
+    const existedAuth = authList[idStr];
+    const existedAccountAuthType = existedAuth === null || existedAuth === void 0 ? void 0 : existedAuth.accountAuthType;
+    const confirmAnotherType = existedAccountAuthType !== 'both' && existedAccountAuthType !== request.accountAuthType;
+    if (request.reConfirm && existedAuth) {
+      request.origin = existedAuth.origin;
+    }
+
+    // Reconfirm if check auth for empty list
+    if (existedAuth) {
+      const inBlackList = existedAuth && !existedAuth.isAllowed;
+      if (inBlackList) {
+        throw new Error(`The source ${url} is not allowed to interact with this extension`);
+      }
+      request.allowedAccounts = Object.entries(existedAuth.isAllowedMap).map(([address, allowed]) => allowed ? address : '').filter(item => item !== '');
+      let allowedListByRequestType = [...request.allowedAccounts];
+      if (accountAuthType === 'evm') {
+        allowedListByRequestType = allowedListByRequestType.filter(a => isEthereumAddress(a));
+      } else if (accountAuthType === 'substrate') {
+        allowedListByRequestType = allowedListByRequestType.filter(a => !isEthereumAddress(a));
+      }
+      if (!confirmAnotherType && !request.reConfirm && allowedListByRequestType.length !== 0) {
+        // Prevent appear confirmation popup
+        return false;
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const id = getId();
+      this.#authRequestsV2[id] = {
+        ...this.authCompleteV2(id, resolve, reject),
+        id,
+        idStr,
+        request,
+        url,
+        accountAuthType: accountAuthType
+      };
+      this.updateIconAuthV2();
+      if (Object.keys(this.#authRequestsV2).length < 2) {
+        this.#requestService.popupOpen();
+      }
+    });
+  }
+  getAuthRequestV2(id) {
+    return this.#authRequestsV2[id];
+  }
+  get subscribeEvmChainChange() {
+    return this.evmChainSubject;
+  }
+  get subscribeAuthorizeUrlSubject() {
+    return this.authorizeUrlSubject;
+  }
+  ensureUrlAuthorizedV2(url) {
+    const idStr = this.stripUrl(url);
+    return new Promise((resolve, reject) => {
+      this.getAuthorize(value => {
+        if (!value) {
+          value = {};
+        }
+        const entry = Object.keys(value).includes(idStr);
+        if (!entry) {
+          reject(new Error(`The source ${url} has not been enabled yet`));
+        }
+        const isConnected = value[idStr] && Object.keys(value[idStr].isAllowedMap).some(address => value[idStr].isAllowedMap[address]);
+        if (!isConnected) {
+          reject(new Error(`The source ${url} is not allowed to interact with this extension`));
+        }
+        resolve(true);
+      });
+    });
+  }
+}

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

@@ -0,0 +1,19 @@
+import { ConfirmationDefinitions, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationType, RequestConfirmationComplete } from '@subwallet/extension-base/background/KoniTypes';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { Transaction } from 'ethereumjs-tx';
+import { BehaviorSubject } from 'rxjs';
+import { TransactionConfig } from 'web3-core';
+export default class EvmRequestHandler {
+    #private;
+    private readonly confirmationsQueueSubject;
+    private readonly confirmationsPromiseMap;
+    constructor(requestService: RequestService);
+    get numEvmRequests(): number;
+    getConfirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
+    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]>;
+    private signMessage;
+    configToTransaction(config: TransactionConfig): Transaction;
+    private signTransaction;
+    private decorateResult;
+    completeConfirmation(request: RequestConfirmationComplete): Promise<boolean>;
+}

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

@@ -0,0 +1,207 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import Common from '@ethereumjs/common';
+import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
+import { EvmProviderErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { anyNumberToBN } from '@subwallet/extension-base/utils/eth';
+import { isInternalRequest } from '@subwallet/extension-base/utils/request';
+import keyring from '@subwallet/ui-keyring';
+import BN from 'bn.js';
+import { Transaction } from 'ethereumjs-tx';
+import { toBuffer } from 'ethereumjs-util';
+import { BehaviorSubject } from 'rxjs';
+import { logger as createLogger } from '@polkadot/util';
+export default class EvmRequestHandler {
+  #requestService;
+  #logger;
+  confirmationsQueueSubject = new BehaviorSubject({
+    addNetworkRequest: {},
+    addTokenRequest: {},
+    switchNetworkRequest: {},
+    evmSignatureRequest: {},
+    evmSendTransactionRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = createLogger('EvmRequestHandler');
+  }
+  get numEvmRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubject.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubject() {
+    return this.confirmationsQueueSubject;
+  }
+  addConfirmation(id, url, type, payload, options = {}, validator) {
+    const confirmations = this.confirmationsQueueSubject.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify(payload);
+    const isInternal = isInternalRequest(url);
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Duplicate request information');
+    }
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubject.next(confirmations);
+    if (!isInternal) {
+      // Not open new popup and use existed
+      const popupList = this.#requestService.popup;
+      if (this.#requestService.popup.length > 0) {
+        // eslint-disable-next-line no-void
+        void chrome.windows.update(popupList[0], {
+          focused: true
+        });
+      } else {
+        this.#requestService.popupOpen();
+      }
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  async signMessage(confirmation) {
+    const {
+      account,
+      payload,
+      type
+    } = confirmation.payload;
+    const address = account.address;
+    const pair = keyring.getPair(address);
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    switch (type) {
+      case 'eth_sign':
+      case 'personal_sign':
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v1':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+        return await pair.evmSigner.signMessage(payload, type);
+      default:
+        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+    }
+  }
+  configToTransaction(config) {
+    function formatField(input) {
+      if (typeof input === 'string') {
+        if (input.startsWith('0x')) {
+          return input;
+        } else {
+          return new BN(input);
+        }
+      }
+      return input;
+    }
+
+    // Convert any string, number to number with BigN exclude hex string
+    const txData = {
+      from: config.from,
+      nonce: formatField(config.nonce),
+      gasPrice: formatField(config.gasPrice),
+      gasLimit: formatField(config.gas),
+      to: config.to,
+      value: formatField(config.value),
+      data: toBuffer(config.data)
+    };
+    const common = Common.custom({
+      chainId: config.chainId
+    });
+
+    // @ts-ignore
+    return new Transaction(txData, {
+      common
+    });
+  }
+  async signTransaction(confirmation) {
+    const transaction = confirmation.payload;
+    const {
+      estimateGas,
+      from,
+      gasPrice
+    } = transaction;
+    const pair = keyring.getPair(from);
+    const params = {
+      ...transaction,
+      gasPrice: anyNumberToBN(gasPrice).toNumber(),
+      gasLimit: anyNumberToBN(estimateGas).toNumber()
+      // nonce: await web3.eth.getTransactionCount(from) // Todo: fill this value from transaction service
+    };
+
+    const tx = this.configToTransaction(params);
+    await Promise.resolve();
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    return pair.evmSigner.signTransaction(tx);
+  }
+  async decorateResult(t, request, result) {
+    if (result.payload === '') {
+      if (t === 'evmSignatureRequest') {
+        result.payload = await this.signMessage(request);
+      } else if (t === 'evmSendTransactionRequest') {
+        result.payload = await this.signTransaction(request);
+      }
+    }
+  }
+  async completeConfirmation(request) {
+    const confirmations = this.confirmationsQueueSubject.getValue();
+    for (const ct in request) {
+      const t = ct;
+      const result = request[t];
+      const {
+        id
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[t][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error('Not found confirmation', t, id);
+        throw new Error('Not found promise for confirmation');
+      }
+
+      // Fill signature for some special type
+      await this.decorateResult(t, confirmation, result);
+
+      // Validate response from confirmation popup some info like password, response format....
+      const error = validator && validator(result);
+      if (error) {
+        resolver.reject(error);
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[t][id];
+      this.confirmationsQueueSubject.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+    return true;
+  }
+}

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

@@ -0,0 +1,18 @@
+import { MetadataRequest } from '@subwallet/extension-base/background/types';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { MetaRequest } from '@subwallet/extension-base/services/request-service/types';
+import { MetadataDef } from '@subwallet/extension-inject/types';
+import { BehaviorSubject } from 'rxjs';
+export default class MetadataRequestHandler {
+    #private;
+    readonly metaSubject: BehaviorSubject<MetadataRequest[]>;
+    constructor(requestService: RequestService);
+    get knownMetadata(): MetadataDef[];
+    get allMetaRequests(): MetadataRequest[];
+    get numMetaRequests(): number;
+    getMetaRequest(id: string): MetaRequest;
+    saveMetadata(meta: MetadataDef): void;
+    private updateIconMeta;
+    private metaComplete;
+    injectMetadata(url: string, request: MetadataDef): Promise<boolean>;
+}

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

@@ -0,0 +1,75 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { extractMetadata } from '@subwallet/extension-base/services/request-service/helper';
+import { MetadataStore } from '@subwallet/extension-base/stores';
+import { getId } from '@subwallet/extension-base/utils/getId';
+import { addMetadata, knownMetadata } from '@subwallet/extension-chains';
+import { BehaviorSubject } from 'rxjs';
+export default class MetadataRequestHandler {
+  #requestService;
+  #metaStore = new MetadataStore();
+  #metaRequests = {};
+  metaSubject = new BehaviorSubject([]);
+  constructor(requestService) {
+    this.#requestService = requestService;
+    extractMetadata(this.#metaStore);
+  }
+  get knownMetadata() {
+    return knownMetadata();
+  }
+  get allMetaRequests() {
+    return Object.values(this.#metaRequests).map(({
+      id,
+      request,
+      url
+    }) => ({
+      id,
+      request,
+      url
+    }));
+  }
+  get numMetaRequests() {
+    return Object.keys(this.#metaRequests).length;
+  }
+  getMetaRequest(id) {
+    return this.#metaRequests[id];
+  }
+  saveMetadata(meta) {
+    this.#metaStore.set(meta.genesisHash, meta);
+    addMetadata(meta);
+  }
+  updateIconMeta(shouldClose) {
+    this.metaSubject.next(this.allMetaRequests);
+    this.#requestService.updateIconV2(shouldClose);
+  }
+  metaComplete = (id, resolve, reject) => {
+    const complete = () => {
+      delete this.#metaRequests[id];
+      this.updateIconMeta(true);
+    };
+    return {
+      reject: error => {
+        complete();
+        reject(error);
+      },
+      resolve: result => {
+        complete();
+        resolve(result);
+      }
+    };
+  };
+  injectMetadata(url, request) {
+    return new Promise((resolve, reject) => {
+      const id = getId();
+      this.#metaRequests[id] = {
+        ...this.metaComplete(id, resolve, reject),
+        id,
+        request,
+        url
+      };
+      this.updateIconMeta();
+      this.#requestService.popupOpen();
+    });
+  }
+}

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

@@ -0,0 +1,9 @@
+import RequestService from '@subwallet/extension-base/services/request-service';
+export default class PopupHandler {
+    #private;
+    constructor(requestService: RequestService);
+    updateIconV2(shouldClose?: boolean): void;
+    get popup(): number[];
+    popupClose(): void;
+    popupOpen(): void;
+}

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

@@ -0,0 +1,79 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
+import { getOS } from '@subwallet/extension-base/services/request-service/helper';
+import { DEFAULT_NOTIFICATION_TYPE } from '@subwallet/extension-base/services/setting-service/constants';
+const NOTIFICATION_URL = chrome.extension.getURL('notification.html');
+const OS = getOS();
+const extraHeight = OS === 'Linux' ? 0 : 28;
+const extraWidth = OS === 'Windows' ? 16 : 0;
+const POPUP_WINDOW_OPTS = {
+  focused: true,
+  height: 600 + extraHeight,
+  type: 'popup',
+  url: NOTIFICATION_URL,
+  width: 390 + extraWidth
+};
+const NORMAL_WINDOW_OPTS = {
+  focused: true,
+  type: 'normal',
+  url: NOTIFICATION_URL
+};
+export default class PopupHandler {
+  #requestService;
+  #notification = DEFAULT_NOTIFICATION_TYPE;
+  #windows = [];
+  constructor(requestService) {
+    this.#requestService = requestService;
+    const updateNotification = rs => {
+      this.#notification = rs.browserConfirmationType;
+    };
+    requestService.settingService.getSettings(updateNotification);
+    requestService.settingService.getSubject().subscribe({
+      next: updateNotification
+    });
+  }
+  updateIconV2(shouldClose) {
+    const numRequests = this.#requestService.numRequests;
+    const text = numRequests > 0 ? numRequests.toString() : '';
+    withErrorLog(() => {
+      var _chrome$browserAction;
+      return (_chrome$browserAction = chrome.browserAction) === null || _chrome$browserAction === void 0 ? void 0 : _chrome$browserAction.setBadgeText({
+        text
+      });
+    });
+    if (shouldClose && text === '') {
+      this.popupClose();
+    }
+  }
+  get popup() {
+    return this.#windows;
+  }
+  popupClose() {
+    this.#windows.forEach(id => withErrorLog(() => chrome.windows.remove(id)));
+    this.#windows = [];
+  }
+  popupOpen() {
+    if (this.#notification !== 'extension') {
+      chrome.windows.getCurrent(win => {
+        const popupOptions = {
+          ...(this.#notification === 'window' ? {
+            ...NORMAL_WINDOW_OPTS,
+            width: win.width,
+            height: win.height
+          } : POPUP_WINDOW_OPTS)
+        };
+        if (win) {
+          popupOptions.left = (win.left || 0) + (win.width || 0) - (popupOptions.width || 0) - 20;
+          popupOptions.top = (win.top || 0) + 80;
+        }
+        chrome.windows.create(popupOptions, window => {
+          if (window) {
+            this.#windows.push(window.id || 0);
+          }
+        });
+      });
+    }
+  }
+}

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

@@ -0,0 +1,17 @@
+import { AccountJson, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { SignRequest } from '@subwallet/extension-base/services/request-service/types';
+import { BehaviorSubject } from 'rxjs';
+import { SignerPayloadJSON } from '@polkadot/types/types/extrinsic';
+export default class SubstrateRequestHandler {
+    #private;
+    readonly signSubject: BehaviorSubject<SigningRequest[]>;
+    constructor(requestService: RequestService);
+    getSignRequest(id: string): SignRequest | undefined;
+    get allSubstrateRequests(): SigningRequest[];
+    private updateIconSign;
+    private signComplete;
+    get numSubstrateRequests(): number;
+    sign(url: string, request: RequestSign, account: AccountJson): Promise<ResponseSigning>;
+    signTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON): Promise<ResponseSigning>;
+}