@subwallet/extension-base 1.2.25-0 → 1.2.25-1

package/cjs/core/logic-validation/request.js

@@ -0,0 +1,488 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertErrorMessage = convertErrorMessage;
+exports.generateValidationProcess = generateValidationProcess;
+exports.validationAuthMiddleware = validationAuthMiddleware;
+exports.validationAuthWCMiddleware = validationAuthWCMiddleware;
+exports.validationConnectMiddleware = validationConnectMiddleware;
+exports.validationEvmDataTransactionMiddleware = validationEvmDataTransactionMiddleware;
+exports.validationEvmSignMessageMiddleware = validationEvmSignMessageMiddleware;
+var _EvmProviderError = require("@subwallet/extension-base/background/errors/EvmProviderError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/fee-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _parseTransaction = require("@subwallet/extension-base/utils/eth/parseTransaction");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _utils3 = require("@walletconnect/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _bn = _interopRequireDefault(require("bn.js"));
+var _i18next = require("i18next");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+async function generateValidationProcess(koni, url, payloadValidate, validationMiddlewareSteps, topic) {
+  let resultValidated = payloadValidate;
+  for (const step of validationMiddlewareSteps) {
+    resultValidated = await step(koni, url, resultValidated, topic);
+    if (resultValidated.errorPosition === 'dApp') {
+      throw resultValidated.errors[0];
+    } else if (resultValidated.errorPosition === 'ui') {
+      break;
+    }
+  }
+  return resultValidated;
+}
+async function validationAuthMiddleware(koni, url, payload) {
+  const {
+    address,
+    errors
+  } = payload;
+  if (!address || !(0, _util.isString)(address)) {
+    payload.errorPosition = 'dApp';
+    const [message] = convertErrorMessage('Not found address to sign');
+    errors.push(new Error(message));
+  } else {
+    try {
+      payload.pair = _uiKeyring.keyring.getPair(address);
+      if (!payload.pair) {
+        payload.errorPosition = 'dApp';
+        const [message] = convertErrorMessage('Unable to find account');
+        errors.push(new Error(message));
+      } else {
+        const authList = await koni.getAuthList();
+        const authInfo = authList[(0, _utils2.stripUrl)(url)];
+        if (!authInfo || !authInfo.isAllowed || !authInfo.isAllowedMap[payload.pair.address]) {
+          payload.errorPosition = 'dApp';
+          const [message] = convertErrorMessage('Account not in allowed list', '');
+          errors.push(new Error(message));
+        }
+        payload.authInfo = authInfo;
+      }
+    } catch (e) {
+      const [message] = convertErrorMessage(e.message);
+      payload.errorPosition = 'dApp';
+      errors.push(new Error(message));
+    }
+  }
+  return payload;
+}
+async function validationConnectMiddleware(koni, url, payload) {
+  let currentChain;
+  let autoActiveChain = false;
+  let {
+    address,
+    authInfo,
+    errors,
+    networkKey
+  } = {
+    ...payload
+  };
+  const handleError = message_ => {
+    payload.errorPosition = 'ui';
+    payload.confirmationType = 'errorConnectNetwork';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.CHAIN_DISCONNECTED, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (authInfo !== null && authInfo !== void 0 && authInfo.currentEvmNetworkKey) {
+    currentChain = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentEvmNetworkKey;
+  }
+  if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
+    autoActiveChain = true;
+  }
+  const currentEvmNetwork = koni.requestService.getDAppChainInfo({
+    autoActive: autoActiveChain,
+    accessType: 'evm',
+    defaultChain: currentChain,
+    url
+  });
+  networkKey = networkKey || (currentEvmNetwork === null || currentEvmNetwork === void 0 ? void 0 : currentEvmNetwork.slug) || '';
+  if (networkKey) {
+    const chainStatus = koni.getChainStateByKey(networkKey);
+    const chainInfo = koni.getChainInfo(networkKey);
+    if (!chainStatus.active) {
+      try {
+        await koni.chainService.enableChain(networkKey);
+      } catch (e) {
+        handleError('Can not active chain: ' + chainInfo.name);
+      }
+    }
+    const evmApi = koni.getEvmApi(networkKey);
+    const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
+    let currentProviderConnected = false;
+    const checkProviderConnected = async () => {
+      try {
+        currentProviderConnected = !!(await web3.eth.getBalance(address));
+      } catch (e) {
+        handleError(e.message);
+      }
+    };
+
+    // Calculate transaction data
+    try {
+      await Promise.race([checkProviderConnected(), (0, _utils2.wait)(3000).then(async () => {
+        if (!currentProviderConnected) {
+          await koni.chainService.initSingleApi(networkKey);
+          await checkProviderConnected();
+        }
+      })]);
+    } catch (e) {
+      handleError(e.message);
+    }
+  } else {
+    handleError('This network is currently not supported');
+  }
+  return {
+    ...payload,
+    networkKey,
+    errors
+  };
+}
+async function validationEvmDataTransactionMiddleware(koni, url, payload) {
+  const errors = payload.errors || [];
+  let estimateGas = '';
+  const transactionParams = payload.payloadAfterValidated;
+  const {
+    address: fromAddress,
+    networkKey,
+    pair
+  } = payload;
+  const evmApi = koni.getEvmApi(networkKey || '');
+  const web3 = evmApi === null || evmApi === void 0 ? void 0 : evmApi.api;
+  const autoFormatNumber = val => {
+    if (typeof val === 'string' && val.startsWith('0x')) {
+      return new _bn.default(val.replace('0x', ''), 16).toString();
+    } else if (typeof val === 'number') {
+      return val.toString();
+    }
+    return val;
+  };
+  const handleError = message_ => {
+    payload.errorPosition = 'ui';
+    payload.confirmationType = 'evmWatchTransactionRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(error);
+  };
+  if (!web3) {
+    handleError('connection error');
+  }
+  const transaction = {
+    from: transactionParams.from,
+    to: transactionParams.to,
+    value: autoFormatNumber(transactionParams.value),
+    gas: autoFormatNumber(transactionParams.gas),
+    gasPrice: autoFormatNumber(transactionParams.gasPrice || transactionParams.gasLimit),
+    maxPriorityFeePerGas: autoFormatNumber(transactionParams.maxPriorityFeePerGas),
+    maxFeePerGas: autoFormatNumber(transactionParams.maxFeePerGas),
+    data: transactionParams.data
+  };
+
+  // Address is validated in before step
+  if (!fromAddress || !(0, _utilCrypto.isEthereumAddress)(fromAddress)) {
+    handleError('the sender address must be the ethereum address type');
+  }
+  if (transaction.to && !(0, _utilCrypto.isEthereumAddress)(transaction.to)) {
+    handleError('invalid recipient address');
+  }
+  if (fromAddress === transaction.to) {
+    handleError('receiving address must be different from sending address');
+  }
+  if (!transaction.to) {
+    if (transaction.data) {
+      if (transaction.value) {
+        try {
+          const valueBn = new _bignumber.default(transaction.value.toString());
+          if (!valueBn.eq(_utils2.BN_ZERO)) {
+            handleError('Recipient address not found');
+          }
+        } catch (e) {
+          handleError('invalid number');
+        }
+      }
+    } else {
+      handleError('Recipient address not found');
+    }
+  }
+  if (!transaction.gas) {
+    const getTransactionGas = async () => {
+      try {
+        transaction.gas = await web3.eth.estimateGas({
+          ...transaction
+        });
+      } catch (e) {
+        handleError(e.message);
+      }
+    };
+
+    // Calculate transaction data
+    try {
+      await Promise.race([getTransactionGas(), (0, _utils2.wait)(3000).then(async () => {
+        if (!transaction.gas) {
+          await koni.chainService.initSingleApi(networkKey || '');
+          await getTransactionGas();
+        }
+      })]);
+    } catch (e) {
+      handleError(e.message);
+    }
+  }
+  if (!transaction.gas) {
+    handleError(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR).message);
+  } else {
+    if (transactionParams.maxPriorityFeePerGas && transactionParams.maxFeePerGas) {
+      const maxFee = new _bignumber.default(transactionParams.maxFeePerGas);
+      estimateGas = maxFee.multipliedBy(transaction.gas).toFixed(0);
+    } else if (transactionParams.gasPrice) {
+      estimateGas = new _bignumber.default(transactionParams.gasPrice).multipliedBy(transaction.gas).toFixed(0);
+    } else {
+      try {
+        const priority = await (0, _utils.calculateGasFeeParams)(evmApi, networkKey || '');
+        if (priority.baseGasFee) {
+          transaction.maxPriorityFeePerGas = priority.maxPriorityFeePerGas.toString();
+          transaction.maxFeePerGas = priority.maxFeePerGas.toString();
+          const maxFee = priority.maxFeePerGas;
+          estimateGas = maxFee.multipliedBy(transaction.gas).toFixed(0);
+        } else {
+          transaction.gasPrice = priority.gasPrice;
+          estimateGas = new _bignumber.default(priority.gasPrice).multipliedBy(transaction.gas).toFixed(0);
+        }
+      } catch (e) {
+        handleError(e.message);
+      }
+    }
+    try {
+      // Validate balance
+      const balance = new _bn.default((await web3.eth.getBalance(fromAddress)) || 0);
+      if (!estimateGas) {
+        handleError('Can\'t calculate estimate gas fee');
+      } else if (balance.lt(new _bn.default(estimateGas).add(new _bn.default(autoFormatNumber(transactionParams.value) || '0')))) {
+        handleError('Insufficient balance');
+      }
+    } catch (e) {
+      handleError(e.message);
+    }
+  }
+  const pair_ = pair || _uiKeyring.keyring.getPair(fromAddress);
+  const account = {
+    address: fromAddress,
+    ...(pair_ === null || pair_ === void 0 ? void 0 : pair_.meta)
+  };
+  try {
+    transaction.nonce = await web3.eth.getTransactionCount(fromAddress);
+  } catch (e) {
+    handleError(e.message);
+  }
+  const hasError = errors && errors.length > 0 || !networkKey;
+  const evmNetwork = koni.getChainInfo(networkKey || '');
+  let isToContract = false;
+  let hashPayload = '';
+  let parseData = '';
+  try {
+    hashPayload = hasError ? '' : koni.transactionService.generateHashPayload(networkKey, transaction);
+    isToContract = await (0, _parseTransaction.isContractAddress)(transaction.to || '', evmApi);
+    parseData = isToContract ? transaction.data && !hasError ? (await (0, _parseTransaction.parseContractInput)(transaction.data, transaction.to || '', evmNetwork)).result : '' : transaction.data || '';
+  } catch (e) {
+    handleError(e.message);
+  }
+  return {
+    ...payload,
+    errors,
+    payloadAfterValidated: {
+      ...transaction,
+      account,
+      estimateGas,
+      hashPayload,
+      isToContract,
+      parseData,
+      canSign: !hasError
+    }
+  };
+}
+async function validationEvmSignMessageMiddleware(koni, url, payload_) {
+  const {
+    address,
+    errors,
+    method,
+    pair: pair_
+  } = payload_;
+  let payload = payload_.payloadAfterValidated;
+  const {
+    promise,
+    resolve
+  } = (0, _utils2.createPromiseHandler)();
+  let hashPayload = '';
+  let canSign = false;
+  const handleError = message_ => {
+    payload_.errorPosition = 'ui';
+    payload_.confirmationType = 'evmSignatureRequest';
+    const [message, name] = convertErrorMessage(message_);
+    const error = new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, message, undefined, name);
+    console.error(error);
+    errors.push(new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, message, undefined, name));
+  };
+  if (address === '' || !payload) {
+    handleError('Not found address or payload to sign');
+  }
+  const pair = pair_ || _uiKeyring.keyring.getPair(address);
+  const account = {
+    address: pair.address,
+    ...pair.meta
+  };
+  if (method) {
+    if (['eth_sign', 'personal_sign', 'eth_signTypedData', 'eth_signTypedData_v1', 'eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) < 0) {
+      handleError('Unsupported action');
+    }
+    if (['eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) > -1) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment
+      payload = JSON.parse(payload);
+    }
+    switch (method) {
+      case 'personal_sign':
+        canSign = true;
+        hashPayload = payload;
+        break;
+      case 'eth_sign':
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v1':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+        if (!account.isExternal) {
+          canSign = true;
+        }
+        break;
+      default:
+        handleError('Unsupported action');
+    }
+  } else {
+    handleError('Unsupported method');
+  }
+  const payloadAfterValidated = {
+    account: account,
+    type: method || '',
+    payload: payload,
+    hashPayload: hashPayload,
+    canSign: canSign,
+    id: ''
+  };
+  resolve({
+    ...payload_,
+    errors,
+    payloadAfterValidated
+  });
+  return promise;
+}
+function validationAuthWCMiddleware(koni, url, payload, topic) {
+  const {
+    promise,
+    resolve
+  } = (0, _utils2.createPromiseHandler)();
+  const {
+    address,
+    errors
+  } = payload;
+  if (!topic) {
+    payload.errorPosition = 'dApp';
+    errors.push(new Error((0, _utils3.getSdkError)('UNAUTHORIZED_EXTEND_REQUEST').message));
+  } else {
+    const requestSession = koni.walletConnectService.getSession(topic);
+    let sessionAccounts = [];
+    if ((0, _utilCrypto.isEthereumAddress)(address)) {
+      var _requestSession$names;
+      sessionAccounts = ((_requestSession$names = requestSession.namespaces.eip155.accounts) === null || _requestSession$names === void 0 ? void 0 : _requestSession$names.map(account => account.split(':')[2])) || sessionAccounts;
+    } else {
+      var _requestSession$names2;
+      sessionAccounts = ((_requestSession$names2 = requestSession.namespaces.polkadot.accounts) === null || _requestSession$names2 === void 0 ? void 0 : _requestSession$names2.map(account => account.split(':')[2])) || sessionAccounts;
+    }
+    if (!address || !(0, _util.isString)(address)) {
+      payload.errorPosition = 'dApp';
+      const [message] = convertErrorMessage('Unable to find account');
+      errors.push(new Error(message));
+    } else {
+      try {
+        payload.pair = _uiKeyring.keyring.getPair(address);
+        if (!payload.pair) {
+          payload.errorPosition = 'dApp';
+          const [message] = convertErrorMessage('Unable to find account');
+          errors.push(new Error(message));
+        }
+        const isExitsAccount = sessionAccounts.find(account => (0, _utils2.isSameAddress)(account, address));
+        if (!isExitsAccount) {
+          payload.errorPosition = 'dApp';
+          const [message] = convertErrorMessage('Account not in allowed list');
+          errors.push(new Error(message));
+        }
+      } catch (e) {
+        const [message] = convertErrorMessage(e.message);
+        payload.errorPosition = 'dApp';
+        errors.push(new Error(message));
+      }
+    }
+  }
+  resolve({
+    ...payload,
+    errors
+  });
+  return promise;
+}
+function convertErrorMessage(message_, name) {
+  const message = message_.toLowerCase();
+
+  // Network error
+  if (message.includes('connection error') || message.includes('connection not open') || message.includes('connection timeout') || message.includes('can not active chain') || message.includes('invalid json rpc')) {
+    return [(0, _i18next.t)('Re-enable the network or change RPC on the extension and try again'), (0, _i18next.t)('Unstable network connection')];
+  }
+  if (message.includes('network is currently not supported')) {
+    return [(0, _i18next.t)('This network is not yet supported on SubWallet. |Import the network|https://docs.subwallet.app/main/extension-user-guide/customize-your-networks#import-networks| on SubWallet and try again'), (0, _i18next.t)('Network not supported')];
+  }
+
+  // Authentication
+  if (message.includes('not found address to sign') || message.includes('unable to find account') || message.includes('unable to retrieve keypair')) {
+    return ['Address not found on SubWallet. Re-check the address information in the extension then try again'];
+  }
+  if (message.includes('account not in allowed list')) {
+    return ['Account disconnected from the dApp. Open the extension to re-connect the account and try again'];
+  }
+
+  // Transaction
+
+  if (message.includes('recipient address not found')) {
+    return [(0, _i18next.t)('Enter recipient address and try again'), (0, _i18next.t)('Recipient address not found')];
+  }
+  if (message.includes('is not a number') || message.includes('invalid number value') || message.includes('invalid bignumberish')) {
+    return [(0, _i18next.t)('Amount must be an integer. Enter an integer and try again'), (0, _i18next.t)('Invalid amount')];
+  }
+  if (message.includes('calculate estimate gas fee') || message.includes('invalidcode')) {
+    return [(0, _i18next.t)('Unable to calculate estimated gas for this transaction. Try again or contact support at agent@subwallet.app'), (0, _i18next.t)('Gas calculation error')];
+  }
+  if (message.includes('invalid recipient address')) {
+    return [(0, _i18next.t)('Make sure the recipient address is valid and in the same type as the sender address, then try again'), (0, _i18next.t)('Invalid recipient address')];
+  }
+  if (message.includes('must be different from sending address')) {
+    return [(0, _i18next.t)('The recipient address must be different from the sender address'), (0, _i18next.t)('Invalid recipient address')];
+  }
+  if (message.includes('the sender address must be the ethereum address type')) {
+    return [(0, _i18next.t)('The sender address must be the ethereum address type'), (0, _i18next.t)('Invalid address type')];
+  }
+  if (message.includes('insufficient balance') || message.includes('insufficient funds')) {
+    return [(0, _i18next.t)('Insufficient balance on the sender address. Top up your balance and try again'), (0, _i18next.t)('Unable to sign transaction')];
+  }
+
+  // Sign Message
+  if (message.includes('not found address or payload to sign')) {
+    return [(0, _i18next.t)('An error occurred when signing this request. Try again or contact support at agent@subwallet.app'), (0, _i18next.t)('Unable to sign message')];
+  }
+  if (message.includes('unsupported method') || message.includes('unsupported action')) {
+    return [(0, _i18next.t)('This sign method is not supported by SubWallet. Try again or contact support at agent@subwallet.app'), (0, _i18next.t)('Method not supported')];
+  }
+  return [message, name || ''];
+}

package/cjs/core/logic-validation/transfer.js

@@ -50,32 +50,49 @@ function validateTransferRequest(tokenInfo, from, to, value, transferAll) {
   }
   return [errors, keypair, transferValue];
 }
-function additionalValidateTransfer(tokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable) {
+function additionalValidateTransfer(tokenInfo, nativeTokenInfo, extrinsicType, receiverTransferTokenFreeBalance, transferAmount, senderTransferTokenTransferable, receiverNativeTransferable) {
   const minAmount = (0, _utils._getTokenMinAmount)(tokenInfo);
-  let warning;
-  let error;
+  const nativeMinAmount = (0, _utils._getTokenMinAmount)(nativeTokenInfo);
+  const warnings = [];
+  const errors = [];
 
-  // Check ed of not native token for sender
+  // Check ed of not native token for sender after sending
   if (extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_TOKEN && senderTransferTokenTransferable) {
     if (new _bignumber.default(senderTransferTokenTransferable).minus(transferAmount).lt(minAmount)) {
-      warning = new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+      const warning = new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+      warnings.push(warning);
+    }
+  }
+
+  // Check ed for receiver before sending
+  if (extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_TOKEN && receiverNativeTransferable) {
+    if (new _bignumber.default(receiverNativeTransferable).lt(nativeMinAmount)) {
+      const error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has {{amount}} {{nativeSymbol}} which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
+        replace: {
+          amount: receiverNativeTransferable,
+          nativeSymbol: nativeTokenInfo.symbol,
+          localSymbol: tokenInfo.symbol
+        }
+      }));
+      errors.push(error);
     }
   }
 
-  // Check ed for receiver
+  // Check ed for receiver after sending
   if (new _bignumber.default(receiverTransferTokenFreeBalance).plus(transferAmount).lt(minAmount)) {
     const atLeast = new _bignumber.default(minAmount).minus(receiverTransferTokenFreeBalance).plus((tokenInfo.decimals || 0) === 0 ? 0 : 1);
     const atLeastStr = (0, _utils3.formatNumber)(atLeast, tokenInfo.decimals || 0, _utils3.balanceFormatter, {
       maxNumberFormat: tokenInfo.decimals || 6
     });
-    error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
+    const error = new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
       replace: {
         amount: atLeastStr,
         symbol: tokenInfo.symbol
       }
     }));
+    errors.push(error);
   }
-  return [warning, error];
+  return [warnings, errors];
 }
 
 // xcm transfer

package/cjs/koni/api/staking/bonding/utils.js

@@ -129,7 +129,7 @@ function calculateChainStakedReturnV2(chainInfo, totalIssuance, erasPerDay, last
     const multiplier = dayRewardRate.dividedBy(100).plus(1).exponentiatedBy(365);
     inflationToStakers = new _bignumber.default(100).multipliedBy(multiplier).minus(100);
   }
-  const averageRewardRate = (['avail_mainnet'].includes(chainInfo.slug) ? inflation : inflationToStakers).dividedBy(supplyStaked);
+  const averageRewardRate = (['avail_mainnet', 'dentnet'].includes(chainInfo.slug) ? inflation : inflationToStakers).dividedBy(supplyStaked);
   return averageRewardRate.toNumber();
 }
 function calculateAlephZeroValidatorReturn(chainStakedReturn, commission) {
@@ -388,7 +388,7 @@ function getAvgValidatorEraReward(supportedDays, eraRewardHistory) {
   return sumEraReward.dividedBy(new _bignumber.default(supportedDays - failEra));
 }
 function getSupportedDaysByHistoryDepth(erasPerDay, maxSupportedEras, liveDay) {
-  const maxSupportDay = maxSupportedEras / erasPerDay;
+  const maxSupportDay = Math.floor(maxSupportedEras / erasPerDay);
   if (liveDay && liveDay <= 30) {
     return Math.min(liveDay - 1, maxSupportDay);
   }

package/cjs/koni/background/handlers/Extension.js

@@ -1706,18 +1706,23 @@ class KoniExtension {
     const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
     const additionalValidator = async inputTransaction => {
       let senderTransferTokenTransferable;
+      let receiverNativeTransferable;
 
       // Check ed for sender
       if (!isTransferNativeToken) {
-        const {
-          value
-        } = await this.getAddressTransferableBalance({
+        const [_senderTransferTokenTransferable, _receiverNativeTransferable] = await Promise.all([this.getAddressTransferableBalance({
           address: from,
           networkKey,
           token: tokenSlug,
           extrinsicType
-        });
-        senderTransferTokenTransferable = value;
+        }), this.getAddressTransferableBalance({
+          address: to,
+          networkKey,
+          token: nativeTokenSlug,
+          extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_BALANCE
+        })]);
+        senderTransferTokenTransferable = _senderTransferTokenTransferable.value;
+        receiverNativeTransferable = _receiverNativeTransferable.value;
       }
       const {
         value: receiverTransferTokenTransferable
@@ -1728,9 +1733,9 @@ class KoniExtension {
         extrinsicType
       }); // todo: shouldn't be just transferable, locked also counts
 
-      const [warning, error] = (0, _transfer.additionalValidateTransfer)(transferTokenInfo, extrinsicType, receiverTransferTokenTransferable, transferAmount.value, senderTransferTokenTransferable);
-      warning && inputTransaction.warnings.push(warning);
-      error && inputTransaction.errors.push(error);
+      const [warnings, errors] = (0, _transfer.additionalValidateTransfer)(transferTokenInfo, nativeTokenInfo, extrinsicType, receiverTransferTokenTransferable, transferAmount.value, senderTransferTokenTransferable, receiverNativeTransferable);
+      warnings.length && inputTransaction.warnings.push(...warnings);
+      errors.length && inputTransaction.errors.push(...errors);
     };
     return this.#koniState.transactionService.handleTransaction({
       errors,
@@ -4251,6 +4256,21 @@ class KoniExtension {
   }
   /* Swap service */
 
+  /* Ledger */
+
+  async subscribeLedgerGenericAllowChains(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    await this.#koniState.eventService.waitLedgerReady;
+    const subscription = this.#koniState.chainService.observable.ledgerGenericAllowChains.subscribe(cb);
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.chainService.value.ledgerGenericAllowChains;
+  }
+
+  /* Ledger */
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -4815,6 +4835,11 @@ class KoniExtension {
       case 'pri(swapService.handleSwapStep)':
         return this.handleSwapStep(request);
       /* Swap service */
+
+      /* Ledger */
+      case 'pri(ledger.generic.allow)':
+        return this.subscribeLedgerGenericAllowChains(id, port);
+      /* Ledger */
       // Default
       default:
         throw new Error(`Unable to handle message of type ${type}`);