@subwallet/extension-base 0.7.10-0 → 0.8.1-wr2x

package/services/transaction-service/index.js

@@ -0,0 +1,592 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, BasicTxWarningCode, ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { _getChainNativeTokenBasicInfo, _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
+import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
+import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
+import { getTransactionId, isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { getTransactionLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
+import { anyNumberToBN } from '@subwallet/extension-base/utils/eth';
+import { parseTxAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
+import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import keyring from '@subwallet/ui-keyring';
+import EventEmitter from 'eventemitter3';
+import RLP from 'rlp';
+import { BehaviorSubject } from 'rxjs';
+import { u8aToHex } from '@polkadot/util';
+export default class TransactionService {
+  transactionSubject = new BehaviorSubject({});
+  get transactions() {
+    return this.transactionSubject.getValue();
+  }
+  constructor(chainService, requestService, balanceService, historyService) {
+    this.chainService = chainService;
+    this.requestService = requestService;
+    this.balanceService = balanceService;
+    this.historyService = historyService;
+  }
+  get allTransactions() {
+    return Object.values(this.transactions);
+  }
+  get processingTransactions() {
+    return this.allTransactions.filter(t => t.status === ExtrinsicStatus.PENDING || t.status === ExtrinsicStatus.PROCESSING);
+  }
+  getTransaction(id) {
+    return this.transactions[id];
+  }
+  checkDuplicate(transaction) {
+    // Check duplicated transaction
+    const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain);
+    if (existed.length > 0) {
+      return [new TransactionError(BasicTxErrorType.DUPLICATE_TRANSACTION)];
+    }
+    return [];
+  }
+  async generalValidate(validationInput) {
+    const validation = {
+      ...validationInput,
+      errors: validationInput.errors || [],
+      warnings: validationInput.warnings || []
+    };
+    const {
+      additionalValidator,
+      address,
+      chain,
+      transaction
+    } = validation;
+
+    // Check duplicate transaction
+    validation.errors.push(...this.checkDuplicate(validationInput));
+
+    // Return unsupported error if not found transaction
+    if (!transaction) {
+      validation.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+    const validationResponse = {
+      status: undefined,
+      ...validation
+    };
+
+    // Estimate fee
+    const estimateFee = {
+      symbol: '',
+      decimals: 0,
+      value: ''
+    };
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    if (!chainInfo) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, "Can't find network"));
+    } else {
+      const {
+        decimals,
+        symbol
+      } = _getChainNativeTokenBasicInfo(chainInfo);
+      estimateFee.decimals = decimals;
+      estimateFee.symbol = symbol;
+      if (transaction) {
+        try {
+          if (isSubstrateTransaction(transaction)) {
+            estimateFee.value = (await transaction.paymentInfo(address)).partialFee.toString();
+          } else {
+            const web3 = this.chainService.getEvmApi(chain);
+            if (!web3) {
+              validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED));
+            } else {
+              const gasPrice = await web3.api.eth.getGasPrice();
+              const gasLimit = await web3.api.eth.estimateGas(transaction);
+              estimateFee.value = (gasLimit * parseInt(gasPrice)).toString();
+            }
+          }
+        } catch (e) {
+          estimateFee.value = '0';
+        }
+      }
+    }
+    validationResponse.estimateFee = estimateFee;
+
+    // Read-only account
+    const pair = keyring.getPair(address);
+    if (!pair) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Can\'t find account'));
+    } else {
+      var _pair$meta;
+      if ((_pair$meta = pair.meta) !== null && _pair$meta !== void 0 && _pair$meta.isReadOnly) {
+        validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'This is read-only account'));
+      }
+    }
+
+    // Balance
+    const transferNative = validationResponse.transferNativeAmount || '0';
+    const nativeTokenInfo = this.chainService.getNativeTokenInfo(chain);
+    const balance = await this.balanceService.getFreeBalance(chain, address, this.chainService.getSubstrateApiMap(), this.chainService.getEvmApiMap());
+    const existentialDeposit = nativeTokenInfo.minAmount || '0';
+    const feeNum = parseInt(estimateFee.value);
+    const balanceNum = parseInt(balance);
+    const edNum = parseInt(existentialDeposit);
+    const transferNativeNum = parseInt(transferNative);
+    if (transferNativeNum + feeNum > balanceNum) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+    } else {
+      if (balanceNum - (transferNativeNum + feeNum) <= edNum) {
+        validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+      }
+    }
+
+    // Validate transaction with additionalValidator method
+    additionalValidator && (await additionalValidator(validationResponse));
+    return validationResponse;
+  }
+  getTransactionSubject() {
+    return this.transactionSubject;
+  }
+  fillTransactionDefaultInfo(transaction) {
+    const isInternal = !transaction.url;
+    return {
+      ...transaction,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      url: transaction.url || EXTENSION_REQUEST_URL,
+      status: ExtrinsicStatus.PENDING,
+      isInternal,
+      id: getTransactionId(transaction.chainType, transaction.chain, isInternal),
+      extrinsicHash: ''
+    };
+  }
+  async addTransaction(inputTransaction) {
+    const transactions = this.transactions;
+    // Fill transaction default info
+    const transaction = this.fillTransactionDefaultInfo(inputTransaction);
+
+    // Add Transaction
+    transactions[transaction.id] = transaction;
+    this.transactionSubject.next({
+      ...transactions
+    });
+    console.log(transaction);
+
+    // Send transaction
+    return await this.sendTransaction(transaction);
+  }
+  generateBeforeHandleResponseErrors(errors) {
+    return {
+      errors,
+      additionalValidator: undefined,
+      address: '',
+      chain: '',
+      chainType: ChainType.SUBSTRATE,
+      data: undefined,
+      extrinsicType: ExtrinsicType.UNKNOWN,
+      transferNativeAmount: undefined,
+      url: undefined,
+      warnings: []
+    };
+  }
+  async handleTransaction(transaction) {
+    const validatedTransaction = await this.generalValidate(transaction);
+    const stopByErrors = validatedTransaction.errors.length > 0;
+    const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
+    if (stopByErrors || stopByWarnings) {
+      return validatedTransaction;
+    }
+    const emitter = await this.addTransaction(validatedTransaction);
+    await new Promise(resolve => {
+      emitter.on('extrinsicHash', data => {
+        validatedTransaction.extrinsicHash = data.extrinsicHash;
+        resolve();
+      });
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+    return validatedTransaction;
+  }
+  async sendTransaction(transaction) {
+    // Send Transaction
+    const emitter = transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : await this.signAndSendEvmTransaction(transaction);
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+    });
+    emitter.on('success', data => {
+      this.onSuccess(data);
+    });
+    emitter.on('error', data => {
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
+      });
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    return emitter;
+  }
+  removeTransaction(id) {
+    if (this.transactions[id]) {
+      delete this.transactions[id];
+      this.transactionSubject.next({
+        ...this.transactions
+      });
+    }
+  }
+  updateTransaction(id, data) {
+    const transaction = this.transactions[id];
+    if (transaction) {
+      this.transactions[id] = {
+        ...transaction,
+        ...data
+      };
+    }
+  }
+  getTransactionLink(id) {
+    const transaction = this.getTransaction(id);
+    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    return getTransactionLink(chainInfo, transaction.extrinsicHash);
+  }
+  transactionToHistory(id) {
+    const transaction = this.getTransaction(id);
+    const historyItem = {
+      chain: transaction.chain,
+      direction: TransactionDirection.SEND,
+      type: transaction.extrinsicType,
+      from: transaction.address,
+      to: '',
+      chainType: transaction.chainType,
+      address: transaction.address,
+      status: ExtrinsicStatus.PROCESSING,
+      extrinsicHash: transaction.extrinsicHash,
+      time: transaction.createdAt.getTime(),
+      fee: transaction.estimateFee,
+      blockNumber: 0,
+      blockHash: ''
+    };
+    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
+    const baseNativeAmount = {
+      value: '0',
+      decimals: nativeAsset.decimals,
+      symbol: nativeAsset.symbol
+    };
+
+    // Fill data by extrinsicType
+    switch (transaction.extrinsicType) {
+      case ExtrinsicType.TRANSFER_BALANCE:
+      case ExtrinsicType.TRANSFER_TOKEN:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.to;
+          const {
+            decimals,
+            symbol
+          } = this.chainService.getAssetBySlug(data.tokenSlug);
+          historyItem.amount = {
+            value: data.value || '0',
+            decimals: decimals || 0,
+            symbol
+          };
+        }
+        break;
+      case ExtrinsicType.TRANSFER_XCM:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.to;
+          const {
+            decimals,
+            symbol
+          } = this.chainService.getAssetBySlug(data.sendingTokenSlug);
+          historyItem.amount = {
+            value: data.value || '0',
+            decimals: decimals || 0,
+            symbol
+          };
+        }
+        break;
+      case ExtrinsicType.SEND_NFT:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.recipientAddress;
+        }
+        break;
+      case ExtrinsicType.CROWDLOAN:
+        break;
+      case ExtrinsicType.STAKING_BOND:
+      case ExtrinsicType.STAKING_STAKE:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount.toString() || '0'
+          };
+          // Todo: Need fill data
+          // historyItem.to = data.nominatorMetadata;
+        }
+
+        break;
+      case ExtrinsicType.STAKING_UNBOND:
+      case ExtrinsicType.STAKING_UNSTAKE:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount.toString() || '0'
+          };
+        }
+        break;
+      case ExtrinsicType.STAKING_CLAIM_REWARD:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+        }
+        break;
+      case ExtrinsicType.STAKING_WITHDRAW:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+        }
+        break;
+      case ExtrinsicType.STAKING_COMPOUNDING:
+        break;
+      case ExtrinsicType.STAKING_CANCEL_COMPOUNDING:
+        break;
+      case ExtrinsicType.EVM_EXECUTE:
+        // Todo: Update historyItem.to
+        break;
+      case ExtrinsicType.UNKNOWN:
+        break;
+    }
+    return historyItem;
+  }
+  onHasTransactionHash({
+    extrinsicHash,
+    id
+  }) {
+    // Write processing transaction history
+    this.updateTransaction(id, {
+      extrinsicHash,
+      status: ExtrinsicStatus.PROCESSING
+    });
+    this.historyService.insertHistory(this.transactionToHistory(id)).catch(console.error);
+    console.log(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
+  }
+  onSuccess({
+    blockHash,
+    blockNumber,
+    id
+  }) {
+    const transaction = this.getTransaction(id);
+    this.updateTransaction(id, {
+      status: ExtrinsicStatus.SUCCESS
+    });
+    console.log('Transaction completed', id, transaction.extrinsicHash);
+
+    // Write success transaction history
+    this.historyService.updateHistory(transaction.chain, transaction.extrinsicHash, {
+      status: ExtrinsicStatus.SUCCESS,
+      blockNumber: blockNumber || 0,
+      blockHash: blockHash || ''
+    }).catch(console.error);
+    NotificationService.createNotification('Transaction completed', `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} completed`, this.getTransactionLink(id));
+  }
+  onFailed({
+    blockHash,
+    blockNumber,
+    errors,
+    id
+  }) {
+    const transaction = this.getTransaction(id);
+    if (transaction) {
+      this.updateTransaction(id, {
+        status: ExtrinsicStatus.FAIL,
+        errors
+      });
+      console.log('Transaction failed', id, transaction.extrinsicHash);
+
+      // Write failed transaction history
+      this.historyService.updateHistory(transaction.chain, transaction.extrinsicHash, {
+        status: ExtrinsicStatus.FAIL,
+        blockNumber: blockNumber || 0,
+        blockHash: blockHash || ''
+      }).catch(console.error);
+      NotificationService.createNotification('Transaction failed', `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} failed`, this.getTransactionLink(id));
+    }
+
+    // Log transaction errors
+    console.error(errors);
+  }
+  generateHashPayload(chain, transaction) {
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const txObject = {
+      nonce: transaction.nonce || 1,
+      from: transaction.from,
+      gasPrice: anyNumberToBN(transaction.gasPrice).toNumber(),
+      gasLimit: anyNumberToBN(transaction.gas).toNumber(),
+      to: transaction.to !== undefined ? transaction.to : '',
+      value: anyNumberToBN(transaction.value).toNumber(),
+      data: transaction.data ? transaction.data : '',
+      chainId: _getEvmChainId(chainInfo)
+    };
+    const data = [txObject.nonce, txObject.gasPrice, txObject.gasLimit, txObject.to, txObject.value, txObject.data, txObject.chainId, new Uint8Array([0x00]), new Uint8Array([0x00])];
+    const encoded = RLP.encode(data);
+    return u8aToHex(encoded);
+  }
+  async signAndSendEvmTransaction({
+    address,
+    chain,
+    id,
+    transaction,
+    url
+  }) {
+    const payload = transaction;
+    const evmApi = this.chainService.getEvmApi(chain);
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const accountPair = keyring.getPair(address);
+    const account = {
+      address,
+      ...accountPair.meta
+    };
+    if (!payload.account) {
+      payload.account = account;
+    }
+
+    // Allow sign transaction
+    payload.canSign = true;
+
+    // Fill contract info
+    if (!payload.parseData) {
+      const isToContract = await isContractAddress(payload.to || '', evmApi);
+      payload.isToContract = isToContract;
+      payload.parseData = isToContract ? payload.data ? (await parseContractInput(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
+    }
+
+    // Set unique nonce to avoid transaction errors
+    if (!payload.nonce) {
+      const evmApi = this.chainService.getEvmApi(chain);
+      payload.nonce = await evmApi.api.eth.getTransactionCount(address);
+    }
+    if (!payload.chainId) {
+      var _chainInfo$evmInfo$ev, _chainInfo$evmInfo;
+      payload.chainId = (_chainInfo$evmInfo$ev = (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) !== null && _chainInfo$evmInfo$ev !== void 0 ? _chainInfo$evmInfo$ev : 1;
+    }
+
+    // Autofill from
+    if (!payload.from) {
+      payload.from = address;
+    }
+    const isExternal = !!account.isExternal;
+
+    // generate hashPayload for EVM transaction
+    payload.hashPayload = this.generateHashPayload(chain, payload);
+    const emitter = new EventEmitter();
+    const txObject = {
+      nonce: payload.nonce || 1,
+      from: payload.from,
+      gasPrice: anyNumberToBN(payload.gasPrice).toNumber(),
+      gasLimit: anyNumberToBN(payload.gas).toNumber(),
+      to: payload.to !== undefined ? payload.to : '',
+      value: anyNumberToBN(payload.value).toNumber(),
+      data: payload.data ? payload.data : '',
+      chainId: payload.chainId
+    };
+    const eventData = {
+      id,
+      errors: [],
+      warnings: []
+    };
+    this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        let signedTransaction;
+        if (!payload) {
+          throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
+        }
+        const web3Api = this.chainService.getEvmApi(chain).api;
+        if (!isExternal) {
+          signedTransaction = payload;
+        } else {
+          const signed = parseTxAndSignature(txObject, payload);
+          const recover = web3Api.eth.accounts.recoverTransaction(signed);
+          if (recover.toLowerCase() !== account.address.toLowerCase()) {
+            throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
+          }
+          signedTransaction = signed;
+        }
+        signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
+          eventData.extrinsicHash = hash;
+          emitter.emit('extrinsicHash', eventData);
+        }).once('receipt', rs => {
+          eventData.blockHash = rs.blockHash;
+          eventData.blockNumber = rs.blockNumber;
+          emitter.emit('success', eventData);
+        }).once('error', e => {
+          eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          emitter.emit('error', eventData);
+        }).catch(e => {
+          eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, e.message));
+          emitter.emit('error', eventData);
+        });
+      } else {
+        this.removeTransaction(id);
+        eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST, 'User Rejected'));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendSubstrateTransaction({
+    address,
+    id,
+    transaction,
+    url
+  }) {
+    const emitter = new EventEmitter();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: []
+    };
+    console.debug(address, transaction);
+    transaction.signAsync(address, {
+      signer: {
+        signPayload: async payload => {
+          const signing = await this.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload);
+          return {
+            id: new Date().getTime(),
+            signature: signing.signature
+          };
+        }
+      }
+    }).then(rs => {
+      // Handle and emit event from runningTransaction
+      rs.send().then(result => {
+        eventData.extrinsicHash = result.toHex();
+        emitter.emit('extrinsicHash', eventData);
+      }).then(() => {
+        emitter.emit('success', eventData);
+      }).catch(e => {
+        eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+        emitter.emit('error', eventData);
+      });
+      // Todo add more event listener to handle and update history for XCM transaction
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+}

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

@@ -0,0 +1,45 @@
+import { AmountData, ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
+import EventEmitter from 'eventemitter3';
+import { TransactionConfig } from 'web3-core';
+import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
+export interface SWTransaction extends ValidateTransactionResponse {
+    id: string;
+    url?: string;
+    isInternal: boolean;
+    chain: string;
+    chainType: ChainType;
+    address: string;
+    data: ExtrinsicDataTypeMap[ExtrinsicType];
+    status: ExtrinsicStatus;
+    extrinsicHash: string;
+    extrinsicType: ExtrinsicType;
+    createdAt: Date;
+    updatedAt: Date;
+    ignoreWarnings?: boolean;
+    estimateFee?: AmountData;
+    transaction: SubmittableExtrinsic | TransactionConfig;
+    additionalValidator?: (inputTransaction: SWTransactionResponse) => Promise<void>;
+    eventsHandler?: (eventEmitter: TransactionEmitter) => void;
+}
+export declare type SWTransactionResult = Omit<SWTransaction, 'transaction'>;
+declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator'>>;
+export interface SWTransactionInput extends SwInputBase {
+    transaction?: SWTransaction['transaction'] | null;
+    warnings?: SWTransaction['warnings'];
+    errors?: SWTransaction['errors'];
+}
+export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>>;
+export declare type ValidateTransactionResponseInput = SWTransactionInput;
+export declare type TransactionEmitter = EventEmitter<TransactionEventMap>;
+export interface TransactionEventResponse extends ValidateTransactionResponse {
+    id: string;
+    extrinsicHash?: string;
+    blockHash?: string;
+    blockNumber?: number;
+}
+export interface TransactionEventMap {
+    extrinsicHash: (response: TransactionEventResponse) => void;
+    error: (response: TransactionEventResponse) => void;
+    success: (response: TransactionEventResponse) => void;
+}
+export {};

package/services/transaction-service/types.js

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

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

@@ -0,0 +1,4 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicDataTypeMap, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+export declare function parseTransactionData<T extends ExtrinsicType>(data: unknown): ExtrinsicDataTypeMap[T];
+export declare function getTransactionLink(chainInfo: _ChainInfo, extrinsicHash: string): string | undefined;

package/services/transaction-service/utils.js

@@ -0,0 +1,23 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export function parseTransactionData(data) {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+  return data;
+}
+export function getTransactionLink(chainInfo, extrinsicHash) {
+  if (chainInfo.evmInfo) {
+    var _chainInfo$evmInfo;
+    const explorerLink = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.blockExplorer;
+    if (explorerLink) {
+      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
+    }
+  } else {
+    var _chainInfo$substrateI;
+    const explorerLink = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI = chainInfo.substrateInfo) === null || _chainInfo$substrateI === void 0 ? void 0 : _chainInfo$substrateI.blockExplorer;
+    if (explorerLink) {
+      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+    }
+  }
+  return undefined;
+}

package/signers/substrates/KeyringSigner.d.ts

@@ -1,6 +1,6 @@
 import type { Signer, SignerResult } from '@polkadot/api/types';
 import type { Registry, SignerPayloadJSON } from '@polkadot/types/types';
-import { KeyringPair } from '@polkadot/keyring/types';
+import { KeyringPair } from '@subwallet/keyring/types';
 interface KeyringSignerProps {
     registry: Registry;
     keyPair: KeyringPair;

package/stores/AccountRef.d.ts

@@ -0,0 +1,5 @@
+import { AccountRef } from '@subwallet/extension-base/background/KoniTypes';
+import SubscribableStore from '@subwallet/extension-base/stores/SubscribableStore';
+export default class AccountRefStore extends SubscribableStore<Array<AccountRef>> {
+    constructor();
+}