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

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/number.d.ts

@@ -0,0 +1,9 @@
+import BigNumber from 'bignumber.js';
+export declare const BN_TEN: BigNumber;
+export interface NumberFormatter {
+    (input: string, metadata?: Record<string, number>): string;
+}
+export declare const balanceFormatter: NumberFormatter;
+export declare const PREDEFINED_FORMATTER: Record<string, NumberFormatter>;
+export declare const toBNString: (input: string | number | BigNumber, decimal: number) => string;
+export declare const formatNumber: (input: string | number | BigNumber, decimal: number, formatter: NumberFormatter, metadata?: Record<string, number>) => string;

package/utils/number.js

@@ -0,0 +1,100 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BigNumber from 'bignumber.js';
+export const BN_TEN = new BigNumber(10);
+// Clear zero from end, use with decimal only
+const clearZero = result => {
+  let index = result.length - 1;
+  while (result[index] === '0') {
+    result = result.slice(0, index);
+    index--;
+  }
+  return result;
+};
+const NUM_1T = new BigNumber(1e12);
+const TLIM = new BigNumber(1e17);
+const NUM_1B = new BigNumber(1e9);
+const BLIM = new BigNumber(1e14);
+const NUM_1M = new BigNumber(1e6);
+const NUM_100M = new BigNumber(1e8);
+export const balanceFormatter = (input, metadata) => {
+  const absGteOne = new BigNumber(input).abs().gte(1);
+  const minNumberFormat = (metadata === null || metadata === void 0 ? void 0 : metadata.minNumberFormat) || 2;
+  const maxNumberFormat = (metadata === null || metadata === void 0 ? void 0 : metadata.maxNumberFormat) || 6;
+  const [int, decimal = '0'] = input.split('.');
+  let _decimal = '';
+  if (absGteOne) {
+    const intNumber = new BigNumber(int);
+    const max = BN_TEN.pow(maxNumberFormat);
+
+    // If count of number in integer part greater or equal maxNumberFormat, do not show decimal
+    if (intNumber.gte(max)) {
+      if (intNumber.gte(NUM_100M)) {
+        if (intNumber.gte(BLIM)) {
+          if (intNumber.gte(TLIM)) {
+            return `${intNumber.dividedBy(NUM_1T).toFixed(2)} T`;
+          }
+          return `${intNumber.dividedBy(NUM_1B).toFixed(2)} B`;
+        }
+        return `${intNumber.dividedBy(NUM_1M).toFixed(2)} M`;
+      }
+      return int;
+    }
+
+    // Get only minNumberFormat number at decimal
+    if (decimal.length <= minNumberFormat) {
+      _decimal = decimal;
+    } else {
+      _decimal = decimal.slice(0, minNumberFormat);
+    }
+
+    // Clear zero number for decimal
+    _decimal = clearZero(_decimal);
+  } else {
+    // Index of cursor
+    let index = 0;
+
+    // Count of not zero number in decimal
+    let current = 0;
+
+    // Find a not zero number in decimal
+    let metNotZero = false;
+
+    // Get at least minNumberFormat number not 0 from index 0
+    // If count of 0 number at prefix greater or equal maxNumberFormat should stop and return 0
+
+    // current === minNumberFormat: get enough number
+    // index === decimal.length: end of decimal
+    // index === maxNumberFormat: reach limit of 0 number at prefix
+    while (current < minNumberFormat && index < decimal.length && (index < maxNumberFormat || metNotZero)) {
+      const _char = decimal[index];
+      _decimal += _char;
+      index++;
+      if (_char !== '0') {
+        metNotZero = true;
+      }
+      if (metNotZero) {
+        current++;
+      }
+    }
+
+    // Clear zero number for decimal
+    _decimal = clearZero(_decimal);
+  }
+  if (_decimal) {
+    return `${int}.${_decimal}`;
+  }
+  return int;
+};
+export const PREDEFINED_FORMATTER = {
+  balance: balanceFormatter
+};
+export const toBNString = (input, decimal) => {
+  const raw = new BigNumber(input);
+  return raw.multipliedBy(BN_TEN.pow(decimal)).toFixed();
+};
+export const formatNumber = (input, decimal, formatter, metadata) => {
+  const raw = new BigNumber(input).dividedBy(BN_TEN.pow(decimal)).toFixed();
+  return formatter(raw, metadata);
+};