@subwallet/extension-base 1.0.7-2 → 1.0.9-0

package/services/chain-service/constants.js

@@ -22,11 +22,11 @@ export const _PURE_EVM_CHAINS = ['binance', 'binance_test', 'ethereum', 'ethereu
 // Get balance----------------------------------------------------------------------------------------------------------
 
 export const _BALANCE_CHAIN_GROUP = {
-  kintsugi: ['kintsugi', 'interlay', 'kintsugi_test'],
+  kintsugi: ['kintsugi', 'interlay', 'kintsugi_test', 'mangatax_para'],
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
-  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2'],
+  bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'] // perhaps there are some runtime updates
 };
 
@@ -176,11 +176,13 @@ export const _KNOWN_CHAIN_INFLATION_PARAMS = {
 export const _TRANSFER_NOT_SUPPORTED_CHAINS = ['subspace_gemini_3a', 'kulupu', 'joystream', 'equilibrium_parachain', 'genshiro_testnet', 'genshiro'];
 export const _TRANSFER_CHAIN_GROUP = {
   acala: ['karura', 'acala', 'acala_testnet'],
-  kintsugi: ['kintsugi', 'kintsugi_test', 'interlay'],
+  kintsugi: ['kintsugi', 'kintsugi_test', 'interlay', 'bifrost_dot', 'hydradx_main', 'mangatax_para'],
   genshiro: ['genshiro_testnet', 'genshiro', 'equilibrium_parachain'],
   crab: ['crab', 'pangolin'],
-  bitcountry: ['pioneer', 'bitcountry'],
-  statemine: ['statemint', 'statemine', 'darwinia2']
+  bitcountry: ['pioneer', 'bitcountry', 'bifrost'],
+  statemine: ['statemint', 'statemine', 'darwinia2', 'astar', 'shiden', 'shibuya', 'parallel'],
+  riochain: ['riochain'],
+  sora_substrate: ['sora_substrate']
 };
 export const _BALANCE_PARSING_CHAIN_GROUP = {
   bobabeam: ['bobabeam', 'bobabase']
@@ -189,7 +191,7 @@ export const _BALANCE_PARSING_CHAIN_GROUP = {
 // XCM------------------------------------------------------------------------------------------------------------------
 
 export const _XCM_CHAIN_GROUP = {
-  polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint'],
+  polkadotXcm: ['astar', 'shiden', 'statemine', 'statemint', 'equilibrium_parachain'],
   xcmPallet: ['polkadot', 'kusama']
   // default is xTokens pallet
 };

package/services/chain-service/index.js

@@ -40,21 +40,25 @@ export class ChainService {
     this.chainInfoMapSubject.next(this.dataMap.chainInfoMap);
     this.chainStateMapSubject.next(this.dataMap.chainStateMap);
     this.assetRegistrySubject.next(this.dataMap.assetRegistry);
-    this.xcmRefMapSubject.next(this.getXcmRefMap());
+    this.xcmRefMapSubject.next(this.dataMap.assetRefMap);
     this.logger = createLogger('chain-service');
     this.refreshChainStateInterval(3000, 6);
   }
 
   // Getter
   getXcmRefMap() {
-    const result = {};
-    Object.entries(AssetRefMap).forEach(([key, assetRef]) => {
-      if (assetRef.path === _AssetRefPath.XCM) {
-        result[key] = assetRef;
-      }
-    });
-    return result;
+    return this.dataMap.assetRefMap;
+    // const result: Record<string, _AssetRef> = {};
+    //
+    // Object.entries(AssetRefMap).forEach(([key, assetRef]) => {
+    //   if (assetRef.path === _AssetRefPath.XCM) {
+    //     result[key] = assetRef;
+    //   }
+    // });
+    //
+    // return result;
   }
+
   getEvmApi(slug) {
     return this.evmChainHandler.getEvmApiByChain(slug);
   }
@@ -356,6 +360,7 @@ export class ChainService {
     this.chainInfoMapSubject.next(this.getChainInfoMap());
     this.chainStateMapSubject.next(this.getChainStateMap());
     this.assetRegistrySubject.next(this.getAssetRegistry());
+    this.xcmRefMapSubject.next(this.dataMap.assetRefMap);
     this.initApis();
     await this.initAssetSettings();
   }

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

@@ -26,7 +26,6 @@ export declare function _getSubstrateRelayParent(chainInfo: _ChainInfo): string;
 export declare function _getSubstrateGenesisHash(chainInfo: _ChainInfo): string;
 export declare function _isChainSupportSubstrateStaking(chainInfo: _ChainInfo): boolean;
 export declare function _isChainEnabled(chainState: _ChainState): boolean;
-export declare function _isSubstrateParachain(chainInfo: _ChainInfo): boolean;
 export declare function _getChainSubstrateAddressPrefix(chainInfo: _ChainInfo): number;
 export declare function _isChainSupportNativeNft(chainInfo: _ChainInfo): boolean;
 export declare function _isChainSupportEvmNft(chainInfo: _ChainInfo): boolean;

package/services/chain-service/utils.js

@@ -130,9 +130,6 @@ export function _isChainSupportSubstrateStaking(chainInfo) {
 export function _isChainEnabled(chainState) {
   return chainState.active;
 }
-export function _isSubstrateParachain(chainInfo) {
-  return chainInfo.substrateInfo !== null && chainInfo.substrateInfo.paraId !== null;
-}
 export function _getChainSubstrateAddressPrefix(chainInfo) {
   var _chainInfo$substrateI5, _chainInfo$substrateI6;
   return (_chainInfo$substrateI5 = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI6 = chainInfo.substrateInfo) === null || _chainInfo$substrateI6 === void 0 ? void 0 : _chainInfo$substrateI6.addressPrefix) !== null && _chainInfo$substrateI5 !== void 0 ? _chainInfo$substrateI5 : -1;
@@ -259,7 +256,7 @@ export function _isSubstrateRelayChain(chainInfo) {
 }
 export function _isSubstrateParaChain(chainInfo) {
   var _chainInfo$substrateI11;
-  return ((_chainInfo$substrateI11 = chainInfo.substrateInfo) === null || _chainInfo$substrateI11 === void 0 ? void 0 : _chainInfo$substrateI11.chainType) === _SubstrateChainType.PARACHAIN;
+  return chainInfo.substrateInfo !== null && chainInfo.substrateInfo.paraId !== null && ((_chainInfo$substrateI11 = chainInfo.substrateInfo) === null || _chainInfo$substrateI11 === void 0 ? void 0 : _chainInfo$substrateI11.chainType) === _SubstrateChainType.PARACHAIN;
 }
 export function _getEvmAbiExplorer(chainInfo) {
   var _chainInfo$evmInfo3;

package/services/history-service/constants/index.d.ts

@@ -0,0 +1,2 @@
+export declare const MAX_FETCH_PAGE_PER_SESSION = 25;
+export declare const MIN__NUM_HISTORY_PER_ACCOUNT = 50;

package/services/history-service/constants/index.js

@@ -0,0 +1,5 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export const MAX_FETCH_PAGE_PER_SESSION = 25;
+export const MIN__NUM_HISTORY_PER_ACCOUNT = 50;

package/services/history-service/subsquid-multi-chain-history.d.ts

@@ -27,4 +27,4 @@ export interface ParseInputType {
 export declare type TransactionBasicData = Pick<TransactionHistoryItem, 'address' | 'origin' | 'time' | 'chainType' | 'from' | 'direction' | 'blockNumber' | 'blockHash' | 'chain' | 'data'>;
 export declare type TransactionSpecifyType = Pick<TransactionHistoryItem, 'to' | 'type' | 'status' | 'fee' | 'amount' | 'tip' | 'signature' | 'extrinsicHash'>;
 export declare function parseSubsquidTransactionData(address: string, type: SubsquidTransactionType, historyItem: MultiHistoryData, chainInfo: _ChainInfo, args: any, data: any): TransactionHistoryItem;
-export declare function fetchMultiChainHistories(addresses: string[], chainMap: Record<string, _ChainInfo>, maxPage?: number): Promise<TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[]>;
+export declare function fetchMultiChainHistories(addresses: string[], chainMap: Record<string, _ChainInfo>, maxPage?: number, countMap?: Record<string, number>, _lastId?: string): Promise<TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[]>;

package/services/history-service/subsquid-multi-chain-history.js

@@ -3,7 +3,9 @@
 
 import { ApolloClient, createHttpLink, gql, InMemoryCache } from '@apollo/client';
 import { ChainType, ExtrinsicStatus, ExtrinsicType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+import { MAX_FETCH_PAGE_PER_SESSION, MIN__NUM_HISTORY_PER_ACCOUNT } from '@subwallet/extension-base/services/history-service/constants';
 import fetch from 'cross-fetch';
+import { isArray } from '@polkadot/util';
 import { decodeAddress, encodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
 const MULTI_CHAIN_URL = 'https://squid.subsquid.io/multi-chain-tx/v/v1/graphql';
 const MultiChainTxClient = new ApolloClient({
@@ -71,6 +73,17 @@ function generateSignature(input) {
   const vHex = parseInt(v).toString(16);
   return `0x${rHex}${sHex}${vHex}`;
 }
+const parseArgs = args => {
+  if (isArray(args)) {
+    return {
+      from: args[0],
+      to: args[1],
+      amount: args[2]
+    };
+  } else {
+    return args;
+  }
+};
 export function parseSubsquidTransactionData(address, type, historyItem, chainInfo, args, data) {
   var _chainInfo$substrateI, _chainInfo$evmInfo, _chainInfo$substrateI2, _chainInfo$evmInfo2;
   const chainType = chainInfo.substrateInfo ? ChainType.SUBSTRATE : ChainType.EVM;
@@ -91,7 +104,7 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
       {
         transactionType = ExtrinsicType.TRANSFER_BALANCE;
         const extrinsic = data.extrinsic;
-        const parsedArgs = args;
+        const parsedArgs = parseArgs(args);
         to = autoFormatAddress(parsedArgs.to);
         from = autoFormatAddress(parsedArgs.from);
         amount = parsedArgs.amount;
@@ -196,10 +209,10 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
     status: success ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL
   };
 }
-export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25) {
+export async function fetchMultiChainHistories(addresses, chainMap, maxPage = MAX_FETCH_PAGE_PER_SESSION, countMap = {}, _lastId) {
   const responseData = [];
   let currentPage = 0;
-  let lastId;
+  let lastId = _lastId;
   while (true) {
     try {
       if (maxPage) {
@@ -228,6 +241,9 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
   }
   const histories = [];
   const lowerAddresses = addresses.map(a => a.toLowerCase());
+  for (const lowerAddress of lowerAddresses) {
+    countMap[lowerAddress] = countMap[lowerAddress] || 0;
+  }
   responseData.forEach(historyItem => {
     const {
       _data,
@@ -248,6 +264,10 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
 
       return;
     }
+    usedAddresses.forEach(address => {
+      const adr = address.toLowerCase();
+      countMap[adr] = (countMap[adr] || 0) + 1;
+    });
     usedAddresses.forEach(address => {
       try {
         const transactionData = parseSubsquidTransactionData(address, name, historyItem, chainInfo, parseData(args), parseData(_data));
@@ -257,5 +277,18 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
       }
     });
   });
+  if (currentPage > 1) {
+    const retryAddresses = [];
+    for (const [address, number] of Object.entries(countMap)) {
+      if (number < MIN__NUM_HISTORY_PER_ACCOUNT) {
+        retryAddresses.push(address);
+      }
+    }
+    const _addresses = addresses.filter(add => retryAddresses.includes(add.toLowerCase()));
+    if (_addresses.length > 0) {
+      const retryHistories = await fetchMultiChainHistories(_addresses, chainMap, maxPage, countMap, lastId);
+      histories.push(...retryHistories);
+    }
+  }
   return histories;
 }

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

@@ -1,5 +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 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

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 let transactionCount = 0;
 let validationCount = 0;
 export const getTransactionId = (chainType, chain, isInternal) => {
@@ -11,4 +12,45 @@ export const getValidationId = (chainType, chain) => {
 };
 export const isSubstrateTransaction = tx => {
   return !!tx.send;
+};
+const typeName = type => {
+  switch (type) {
+    case ExtrinsicType.TRANSFER_BALANCE:
+    case ExtrinsicType.TRANSFER_TOKEN:
+    case ExtrinsicType.TRANSFER_XCM:
+      return 'Transfer';
+    case ExtrinsicType.SEND_NFT:
+      return 'Send NFT';
+    case ExtrinsicType.CROWDLOAN:
+      return 'Crowdloan contribution';
+    case ExtrinsicType.STAKING_JOIN_POOL:
+      return 'Join pool';
+    case ExtrinsicType.STAKING_LEAVE_POOL:
+      return 'Leave pool';
+    case ExtrinsicType.STAKING_BOND:
+      return 'Bond';
+    case ExtrinsicType.STAKING_UNBOND:
+      return 'Unbond';
+    case ExtrinsicType.STAKING_CLAIM_REWARD:
+      return 'Claim reward';
+    case ExtrinsicType.STAKING_WITHDRAW:
+      return 'Withdraw';
+    case ExtrinsicType.STAKING_CANCEL_UNSTAKE:
+      return 'Cancel unstake';
+    case ExtrinsicType.STAKING_COMPOUNDING:
+      return 'Stake compound';
+    case ExtrinsicType.EVM_EXECUTE:
+      return 'EVM execute';
+    case ExtrinsicType.STAKING_CANCEL_COMPOUNDING:
+      return 'Cancel compounding';
+    case ExtrinsicType.STAKING_POOL_WITHDRAW:
+      return 'Withdraw pool';
+    case ExtrinsicType.UNKNOWN:
+    default:
+      return 'unknown';
+  }
+};
+export const getBaseTransactionInfo = (transaction, chainInfoMap) => {
+  var _chainInfoMap$transac;
+  return `${typeName(transaction.extrinsicType)} on ${((_chainInfoMap$transac = chainInfoMap[transaction.chain]) === null || _chainInfoMap$transac === void 0 ? void 0 : _chainInfoMap$transac.name) || 'unknown network'}`;
 };

package/services/transaction-service/index.js

@@ -6,11 +6,12 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { BasicTxErrorType, BasicTxWarningCode, ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainNativeTokenBasicInfo, _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
 import { parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
-import { getTransactionId, isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { getExplorerLink, 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';
@@ -19,7 +20,7 @@ import keyring from '@subwallet/ui-keyring';
 import EventEmitter from 'eventemitter3';
 import RLP from 'rlp';
 import { BehaviorSubject } from 'rxjs';
-import { u8aToHex } from '@polkadot/util';
+import { isHex, u8aToHex } from '@polkadot/util';
 export default class TransactionService {
   transactionSubject = new BehaviorSubject({});
   get transactions() {
@@ -109,6 +110,10 @@ export default class TransactionService {
             }
           }
         } catch (e) {
+          const error = e;
+          if (error.message.includes('gas required exceeds allowance')) {
+            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+          }
           estimateFee.value = '0';
         }
       }
@@ -135,16 +140,22 @@ export default class TransactionService {
     const balanceNum = parseInt(balance.value);
     const edNum = parseInt(existentialDeposit);
     const transferNativeNum = parseInt(transferNative);
-    if (!isTransferAll) {
-      if (transferNativeNum + feeNum > balanceNum) {
+    if (transferNativeNum + feeNum > balanceNum) {
+      if (!isTransferAll) {
         validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
       } else {
-        if (balanceNum - (transferNativeNum + feeNum) <= edNum) {
-          if (edAsWarning) {
-            validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
-          } else {
-            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
-          }
+        if ([..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.genshiro, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.statemine].includes(chain)) {
+          // Chain not have transfer all function
+          validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+        }
+      }
+    }
+    if (!isTransferAll) {
+      if (balanceNum - (transferNativeNum + feeNum) < edNum) {
+        if (edAsWarning) {
+          validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+        } else {
+          validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
         }
       }
     }
@@ -206,6 +217,7 @@ export default class TransactionService {
       // @ts-ignore
       'transaction' in validatedTransaction && delete validatedTransaction.transaction;
       'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+      'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
       return validatedTransaction;
     }
     validatedTransaction.warnings = [];
@@ -227,11 +239,15 @@ export default class TransactionService {
     // @ts-ignore
     'transaction' in validatedTransaction && delete validatedTransaction.transaction;
     'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : await this.signAndSendEvmTransaction(transaction);
+    const {
+      eventsHandler
+    } = transaction;
     emitter.on('signed', data => {
       this.onSigned(data);
     });
@@ -255,6 +271,7 @@ export default class TransactionService {
 
     // Todo: handle any event with transaction.eventsHandler
 
+    eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
     return emitter;
   }
   removeTransaction(id) {
@@ -281,6 +298,7 @@ export default class TransactionService {
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
     const transaction = this.getTransaction(id);
+    const extrinsicType = transaction.extrinsicType;
     const historyItem = {
       origin: 'app',
       chain: transaction.chain,
@@ -311,7 +329,7 @@ export default class TransactionService {
     };
 
     // Fill data by extrinsicType
-    switch (transaction.extrinsicType) {
+    switch (extrinsicType) {
       case ExtrinsicType.TRANSFER_BALANCE:
         {
           const inputData = parseTransactionData(transaction.data);
@@ -350,9 +368,10 @@ export default class TransactionService {
           };
 
           // @ts-ignore
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           historyItem.additionalInfo = {
-            destinationChain: (inputData === null || inputData === void 0 ? void 0 : inputData.destinationNetworkKey) || ''
+            destinationChain: (inputData === null || inputData === void 0 ? void 0 : inputData.destinationNetworkKey) || '',
+            originalChain: inputData.originNetworkKey || '',
+            fee: transaction.estimateFee
           };
           eventLogs && parseXcmEventLogs(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
         }
@@ -451,11 +470,22 @@ export default class TransactionService {
       // Return one more history record if transaction send to account in the wallets
       const toAccount = (historyItem === null || historyItem === void 0 ? void 0 : historyItem.to) && keyring.getPair(historyItem.to);
       if (toAccount) {
-        return [historyItem, {
+        const receiverHistory = {
           ...historyItem,
           address: toAccount.address,
           direction: TransactionDirection.RECEIVED
-        }];
+        };
+        switch (extrinsicType) {
+          case ExtrinsicType.TRANSFER_XCM:
+            {
+              const inputData = parseTransactionData(transaction.data);
+              receiverHistory.chain = inputData.destinationNetworkKey;
+              break;
+            }
+          default:
+            break;
+        }
+        return [historyItem, receiverHistory];
       }
     } catch (e) {
       console.warn(e);
@@ -543,10 +573,11 @@ export default class TransactionService {
       blockNumber: blockNumber || 0,
       blockHash: blockHash || ''
     }).catch(console.error);
+    const info = isHex(extrinsicHash) ? extrinsicHash : getBaseTransactionInfo(transaction, this.chainService.getChainInfoMap());
     this.notificationService.notify({
       type: NotificationType.SUCCESS,
       title: 'Transaction completed',
-      message: `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} completed`,
+      message: `Transaction ${info} completed`,
       action: {
         url: this.getTransactionLink(id)
       },
@@ -577,10 +608,11 @@ export default class TransactionService {
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
+      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.chainService.getChainInfoMap());
       this.notificationService.notify({
         type: NotificationType.ERROR,
         title: 'Transaction failed',
-        message: `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} failed`,
+        message: `Transaction ${info} failed`,
         action: {
           url: this.getTransactionLink(id)
         },
@@ -674,7 +706,8 @@ export default class TransactionService {
     const eventData = {
       id,
       errors: [],
-      warnings: []
+      warnings: [],
+      extrinsicHash: id
     };
     this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
       isApproved,
@@ -745,7 +778,8 @@ export default class TransactionService {
     const eventData = {
       id,
       errors: [],
-      warnings: []
+      warnings: [],
+      extrinsicHash: id
     };
     transaction.signAsync(address, {
       signer: {
@@ -775,7 +809,7 @@ export default class TransactionService {
         }
         if (txState.status.isInBlock) {
           eventData.eventLogs = txState.events;
-          if (!eventData.extrinsicHash || eventData.extrinsicHash === '') {
+          if (!eventData.extrinsicHash || eventData.extrinsicHash === '' || !isHex(eventData.extrinsicHash)) {
             eventData.extrinsicHash = txState.txHash.toHex();
             eventData.blockHash = txState.status.asInBlock.toHex();
             emitter.emit('extrinsicHash', eventData);

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

@@ -21,8 +21,8 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
     additionalValidator?: (inputTransaction: SWTransactionResponse) => Promise<void>;
     eventsHandler?: (eventEmitter: TransactionEmitter) => void;
 }
-export declare type SWTransactionResult = Omit<SWTransaction, 'transaction' | 'additionalValidator'>;
-declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator'>>;
+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 {
     transaction?: SWTransaction['transaction'] | null;
     warnings?: SWTransaction['warnings'];

package/utils/eth/parseTransaction/index.js

@@ -100,44 +100,59 @@ export const isContractAddress = async (address, evmApi) => {
     return code !== '0x';
   }
 };
+const parseInputWithAbi = (input, abi) => {
+  const decoder = new InputDataDecoder(abi);
+  const raw = decoder.decodeData(input);
+  if (raw.method && raw.methodName) {
+    const temp = {
+      method: raw.method,
+      methodName: raw.methodName,
+      args: []
+    };
+    raw.types.forEach((type, index) => {
+      temp.args.push(parseResult(type, raw.inputs[index], raw.names[index]));
+    });
+    return temp;
+  } else {
+    return null;
+  }
+};
 export const parseContractInput = async (input, contractAddress, network) => {
-  let result = input;
-
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const _ABIs = [...ABIs];
+  for (const abi of ABIs) {
+    const temp = parseInputWithAbi(input, abi);
+    if (temp) {
+      return {
+        result: temp
+      };
+    }
+  }
   if (contractAddress && network) {
+    console.log('parseOnline');
     if (_getEvmAbiExplorer(network)) {
-      const res = await axios.get(_getEvmAbiExplorer(network), {
-        params: {
-          address: contractAddress
-        }
-      });
+      try {
+        const res = await axios.get(_getEvmAbiExplorer(network), {
+          params: {
+            address: contractAddress
+          },
+          timeout: 3000
+        });
 
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      if (res.status === 200 && res.data.status === '1') {
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        _ABIs.unshift(res.data.result);
-      }
-    }
-  }
-  for (const abi of _ABIs) {
-    const decoder = new InputDataDecoder(abi);
-    const raw = decoder.decodeData(input);
-    if (raw.method && raw.methodName) {
-      const temp = {
-        method: raw.method,
-        methodName: raw.methodName,
-        args: []
-      };
-      raw.types.forEach((type, index) => {
-        temp.args.push(parseResult(type, raw.inputs[index], raw.names[index]));
-      });
-      result = temp;
-      break;
+        if (res.status === 200 && res.data.status === '1') {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+          const abi = res.data.result;
+          const temp = parseInputWithAbi(input, abi);
+          if (temp) {
+            return {
+              result: temp
+            };
+          }
+        }
+      } catch (e) {}
     }
   }
   return {
-    result
+    result: input
   };
 };
 const getChainInfoByChainId = (networkMap, chainId) => {
@@ -179,42 +194,37 @@ export const parseEvmRlp = async (data, networkMap, evmApiMap) => {
     nonce: new BigN(tx.nonce).toNumber()
   };
   const network = getChainInfoByChainId(networkMap, parseInt(tx.ethereumChainId));
-
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const _ABIs = [...ABIs];
+  for (const abi of ABIs) {
+    const temp = parseInputWithAbi(tx.data, abi);
+    if (temp) {
+      result.data = temp;
+      return result;
+    }
+  }
   if (tx.action && network) {
     if (await isContractAddress(tx.action, evmApiMap[network.slug])) {
       if (_getEvmAbiExplorer(network) !== '') {
-        const res = await axios.get(_getEvmAbiExplorer(network), {
-          params: {
-            address: tx.action
-          }
-        });
+        try {
+          const res = await axios.get(_getEvmAbiExplorer(network), {
+            params: {
+              address: tx.action
+            },
+            timeout: 2000
+          });
 
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-        if (res.status === 200 && res.data.status === '1') {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          _ABIs.unshift(res.data.result);
-        }
+          if (res.status === 200 && res.data.status === '1') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+            const abi = res.data.result;
+            const temp = parseInputWithAbi(tx.data, abi);
+            if (temp) {
+              result.data = temp;
+              return result;
+            }
+          }
+        } catch (e) {}
       }
     }
   }
-  for (const abi of _ABIs) {
-    const decoder = new InputDataDecoder(abi);
-    const raw = decoder.decodeData(tx.data);
-    if (raw.method && raw.methodName) {
-      const temp = {
-        method: raw.method,
-        methodName: raw.methodName,
-        args: []
-      };
-      raw.types.forEach((type, index) => {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
-        temp.args.push(parseResult(type, raw.inputs[index], raw.names[index]));
-      });
-      result.data = temp;
-      break;
-    }
-  }
   return result;
 };