@subwallet/extension-base 1.3.29-1 → 1.3.31-0

package/constants/remind-notification-time.js

@@ -2,6 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { fetchStaticData } from '@subwallet/extension-base/utils';
-export const fetchLastestRemindNotificationTime = async () => {
+export const fetchLatestRemindNotificationTime = async () => {
   return await fetchStaticData('config/remind-notification-time');
 };

package/core/logic-validation/swap.d.ts

@@ -1,7 +1,18 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { SwapQuote } from '@subwallet/extension-base/types';
 import { AssetHubPreValidationMetadata, ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SimpleSwapValidationMetadata, SwapErrorType } from '@subwallet/extension-base/types/swap';
+interface RequestValidateSwap {
+    chainInfo: _ChainInfo;
+    fromToken: _ChainAsset;
+    fromTokenBalance: string;
+    feeToken: _ChainAsset;
+    feeTokenBalance: string;
+    feeAmount: string;
+    swapAmount: string;
+    minSwapAmount?: string;
+}
 export declare function _validateBalanceToSwapOnAssetHub(fromToken: _ChainAsset, feeToken: _ChainAsset, feeTokenChainInfo: _ChainInfo, feeAmount: string, fromTokenBalance: string, feeTokenBalance: string, swapAmount: string, isXcmOk: boolean, minSwap?: string): TransactionError | undefined;
 export declare function _validateBalanceToSwap(fromToken: _ChainAsset, feeToken: _ChainAsset, feeTokenChainInfo: _ChainInfo, feeAmount: string, fromTokenBalance: string, feeTokenBalance: string, swapAmount: string, isXcmOk: boolean, minSwap?: string): TransactionError | undefined;
 export declare function _validateSwapRecipient(destChainInfo: _ChainInfo, recipient: string): TransactionError | undefined;
@@ -9,3 +20,7 @@ export declare function _getChainflipEarlyValidationError(error: SwapErrorType,
 export declare function _getEarlyHydradxValidationError(error: SwapErrorType, metadata: HydradxPreValidationMetadata): SwapError;
 export declare function _getEarlyAssetHubValidationError(error: SwapErrorType, metadata: AssetHubPreValidationMetadata): SwapError;
 export declare function _getSimpleSwapEarlyValidationError(error: SwapErrorType, metadata: SimpleSwapValidationMetadata): SwapError;
+export declare function _validateQuoteV2(selectedQuote: SwapQuote): TransactionError | undefined;
+export declare function _validateBalanceToSwapV2(request: RequestValidateSwap): TransactionError | undefined;
+export declare function _validateSwapRecipientV2(destChainInfo: _ChainInfo, recipient: string | undefined): TransactionError | undefined;
+export {};

package/core/logic-validation/swap.js

@@ -100,7 +100,7 @@ export function _getChainflipEarlyValidationError(error, metadata) {
     case SwapErrorType.UNKNOWN:
       return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
     case SwapErrorType.ERROR_FETCHING_QUOTE:
-      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+      return new SwapError(error, 'No swap quote found. Change your network endpoint or adjust amount and try again');
     default:
       return new SwapError(error);
   }
@@ -116,7 +116,7 @@ export function _getEarlyHydradxValidationError(error, metadata) {
     case SwapErrorType.UNKNOWN:
       return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
     case SwapErrorType.ERROR_FETCHING_QUOTE:
-      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+      return new SwapError(error, 'No swap quote found. Change your network endpoint or adjust amount and try again');
     default:
       return new SwapError(error);
   }
@@ -130,7 +130,7 @@ export function _getEarlyAssetHubValidationError(error, metadata) {
     case SwapErrorType.UNKNOWN:
       return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
     case SwapErrorType.ERROR_FETCHING_QUOTE:
-      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+      return new SwapError(error, 'No swap quote found. Change your network endpoint or adjust amount and try again');
     case SwapErrorType.MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT:
       return new SwapError(error, 'You swap too much. It make pool not enough existential deposit');
     // TODO: i18n this
@@ -159,8 +159,64 @@ export function _getSimpleSwapEarlyValidationError(error, metadata) {
     case SwapErrorType.UNKNOWN:
       return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
     case SwapErrorType.ERROR_FETCHING_QUOTE:
-      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+      return new SwapError(error, 'No swap quote found. Change your network endpoint or adjust amount and try again');
     default:
       return new SwapError(error);
   }
+}
+export function _validateQuoteV2(selectedQuote) {
+  if (!selectedQuote) {
+    return new TransactionError(BasicTxErrorType.INTERNAL_ERROR);
+  }
+
+  // Check swapQuote alive
+  if (selectedQuote.aliveUntil <= +Date.now()) {
+    return new TransactionError(SwapErrorType.QUOTE_TIMEOUT);
+  }
+  return undefined;
+}
+export function _validateBalanceToSwapV2(request) {
+  const {
+    chainInfo,
+    feeAmount,
+    feeToken,
+    feeTokenBalance,
+    fromToken,
+    fromTokenBalance,
+    minSwapAmount,
+    swapAmount
+  } = request;
+  const bnFromTokenBalance = BigN(fromTokenBalance);
+  if (new BigN(feeTokenBalance).lte(feeAmount)) {
+    return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeToken.symbol} (${chainInfo.name}) to pay transaction fee`);
+  }
+  if (fromToken.slug === feeToken.slug) {
+    // todo: need review and refactor
+    if (bnFromTokenBalance.lte(BigN(feeAmount).plus(swapAmount))) {
+      return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
+    }
+  } else {
+    if (bnFromTokenBalance.lt(swapAmount)) {
+      return new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromToken.symbol} and try again.`);
+    }
+  }
+  if (minSwapAmount) {
+    if (bnFromTokenBalance.lte(minSwapAmount)) {
+      const parsedMinSwapValue = formatNumber(minSwapAmount, _getAssetDecimals(fromToken));
+      return new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromToken.symbol} to start swapping. Deposit ${fromToken.symbol} and try again.`); // todo: min swap or amount?
+    }
+  }
+
+  return undefined;
+}
+export function _validateSwapRecipientV2(destChainInfo, recipient) {
+  if (!recipient) {
+    return undefined;
+  }
+  const isEvmAddress = isEthereumAddress(recipient);
+  const isEvmDestChain = _isChainEvmCompatible(destChainInfo);
+  if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+    return new TransactionError(SwapErrorType.INVALID_RECIPIENT);
+  }
+  return undefined;
 }

package/core/logic-validation/transfer.d.ts

@@ -17,3 +17,4 @@ export declare function estimateFeeForTransaction(validationResponse: SWTransact
 export declare function checkSigningAccountForTransaction(validationResponse: SWTransactionResponse, chainInfoMap: Record<string, _ChainInfo>): void;
 export declare function checkBalanceWithTransactionFee(validationResponse: SWTransactionResponse, transactionInput: SWTransactionInput, nativeTokenInfo: _ChainAsset, nativeTokenAvailable: AmountData): void;
 export declare function checkTonAddressBounceableAndAccountNotActive(tonApi: _TonApi, validationResponse: SWTransactionResponse): Promise<void>;
+export declare function validateXcmMinAmountToMythos(destChain: string, destToken: string, amount: string): TransactionError | undefined;

package/core/logic-validation/transfer.js

@@ -315,7 +315,8 @@ export async function estimateFeeForTransaction(validationResponse, transaction,
   if (transaction) {
     try {
       if (isSubstrateTransaction(transaction)) {
-        estimateFee.value = (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
+        var _validationResponse$x;
+        estimateFee.value = (_validationResponse$x = validationResponse.xcmFeeDryRun) !== null && _validationResponse$x !== void 0 ? _validationResponse$x : (await transaction.paymentInfo(validationResponse.address)).partialFee.toString();
       } else if (isTonTransaction(transaction)) {
         estimateFee.value = transaction.estimateFee; // todo: might need to update logic estimate fee inside for future actions excluding normal transfer Ton and Jetton
       } else if (isCardanoTransaction(transaction)) {
@@ -443,4 +444,14 @@ function isTonAddressBounceable(address) {
 async function isAccountActive(tonApi, address) {
   const state = await tonApi.getAccountState(address);
   return state === 'active';
+}
+export function validateXcmMinAmountToMythos(destChain, destToken, amount) {
+  const MYTHOS_DESTINATION_FEE = '2500000000000000000';
+  const errorMsg = 'Enter an amount higher than 2.5 MYTH to pay cross-chain fee and avoid your MYTH being lost after the transaction';
+  if (destChain === 'mythos' && destToken === 'mythos-NATIVE-MYTH') {
+    if (BigN(amount).lte(MYTHOS_DESTINATION_FEE)) {
+      return new TransactionError(TransferTxErrorType.NOT_ENOUGH_VALUE, t(errorMsg));
+    }
+  }
+  return undefined;
 }

package/core/substrate/xcm-parser.d.ts

@@ -55,4 +55,5 @@ export declare function _isAvailBridgeXcm(originChainInfo: _ChainInfo, destChain
 export declare function _isMythosFromHydrationToMythos(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo, assetSlug: string): boolean;
 export declare function _isPolygonBridgeXcm(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
 export declare function _isPosBridgeXcm(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
+export declare function _isAcrossBridgeXcm(originChainInfo: _ChainInfo, destChainInfo: _ChainInfo): boolean;
 export declare function _adaptX1Interior(_assetIdentifier: Record<string, any>, version: number): Record<string, any>;

package/core/substrate/xcm-parser.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { _isAcrossChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge';
 import { isAvailChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/availBridge';
 import { _isPolygonChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/polygonBridge';
 import { _isPosChainBridge } from '@subwallet/extension-base/services/balance-service/transfer/xcm/posBridge';
@@ -127,7 +128,9 @@ export function _isPolygonBridgeXcm(originChainInfo, destChainInfo) {
 export function _isPosBridgeXcm(originChainInfo, destChainInfo) {
   return _isPosChainBridge(originChainInfo.slug, destChainInfo.slug);
 }
-
+export function _isAcrossBridgeXcm(originChainInfo, destChainInfo) {
+  return _isAcrossChainBridge(originChainInfo.slug, destChainInfo.slug);
+}
 // ---------------------------------------------------------------------------------------------------------------------
 
 function _getMultiLocationParent(originChainInfo, isWithinSameConsensus) {

package/core/utils.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
-import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ExtrinsicType, SufficientChainsDetails } from '@subwallet/extension-base/background/KoniTypes';
 import { LedgerMustCheckType, ValidateRecipientParams } from '@subwallet/extension-base/core/types';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
 import { AccountJson } from '@subwallet/extension-base/types';
@@ -15,4 +15,4 @@ export declare function _isValidTonAddressFormat(validateRecipientParams: Valida
 export declare function _isValidCardanoAddressFormat(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isNotDuplicateAddress(validateRecipientParams: ValidateRecipientParams): string;
 export declare function _isSupportLedgerAccount(validateRecipientParams: ValidateRecipientParams): string;
-export declare const _isSufficientToken: (tokenInfo: _ChainAsset, substrateApi: _SubstrateApi) => Promise<boolean>;
+export declare const _isSufficientToken: (tokenInfo: _ChainAsset, substrateApi: _SubstrateApi, sufficientChain: SufficientChainsDetails) => Promise<boolean>;

package/core/utils.js

@@ -5,7 +5,6 @@ import { _AssetType } from '@subwallet/chain-list/types';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { BalanceAccountType } from '@subwallet/extension-base/core/substrate/types';
 import { tonAddressInfo } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
-import { SUFFICIENT_CHAIN } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getTokenOnChainAssetId, _getXcmAssetMultilocation, _isBridgedToken, _isChainCardanoCompatible, _isChainEvmCompatible, _isChainSubstrateCompatible, _isChainTonCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { isAddressAndChainCompatible, isSameAddress, reformatAddress } from '@subwallet/extension-base/utils';
 import { isAddress, isCardanoTestnetAddress, isTonAddress } from '@subwallet/keyring';
@@ -132,27 +131,49 @@ export function _isSupportLedgerAccount(validateRecipientParams) {
   }
   return '';
 }
-export const _isSufficientToken = async (tokenInfo, substrateApi) => {
-  // todo: remove const and detect by pallets instead
-  if (SUFFICIENT_CHAIN.includes(tokenInfo.originChain) && tokenInfo.assetType !== _AssetType.NATIVE) {
+export const _isSufficientToken = async (tokenInfo, substrateApi, sufficientChain) => {
+  var _tokenInfo$metadata;
+  if (tokenInfo.assetType !== _AssetType.NATIVE) {
     const assetId = _isBridgedToken(tokenInfo) ? _getXcmAssetMultilocation(tokenInfo) : _getTokenOnChainAssetId(tokenInfo);
+    const chainSlug = tokenInfo.originChain;
     const queryParams = {
       section: 'query',
-      module: 'foreignAssets',
-      method: 'asset',
       args: [assetId]
     };
-    if (!_isBridgedToken(tokenInfo)) {
+    if (sufficientChain.assetHubPallet.includes(chainSlug)) {
+      if (!_isBridgedToken(tokenInfo)) {
+        queryParams.module = 'assets';
+      } else {
+        queryParams.module = 'foreignAssets';
+      }
+      queryParams.method = 'asset';
+    }
+    if (sufficientChain.assetRegistryPallet.includes(chainSlug)) {
+      queryParams.module = 'assetRegistry';
+      queryParams.method = 'assets';
+    }
+    if (sufficientChain.assetsPallet.includes(chainSlug)) {
       queryParams.module = 'assets';
+      queryParams.method = 'asset';
+    }
+    if (sufficientChain.foreignAssetsPallet.includes(chainSlug)) {
+      queryParams.module = 'foreignAsset';
+      queryParams.method = 'asset';
+    }
+    try {
+      if (queryParams.method && queryParams.module) {
+        const metadata = await substrateApi.makeRpcQuery(queryParams);
+        if ((metadata === null || metadata === void 0 ? void 0 : metadata.isSufficient) !== undefined) {
+          return metadata === null || metadata === void 0 ? void 0 : metadata.isSufficient;
+        }
+      }
+    } catch (e) {
+      console.error(e);
     }
-    const metadata = await substrateApi.makeRpcQuery(queryParams);
-    return metadata.isSufficient;
   }
-
-  // todo
-  // if (tokenInfo.metadata?.isSufficient) {
-  //   return tokenInfo.metadata?.isSufficient;
-  // }
-
+  if ((_tokenInfo$metadata = tokenInfo.metadata) !== null && _tokenInfo$metadata !== void 0 && _tokenInfo$metadata.isSufficient) {
+    var _tokenInfo$metadata2;
+    return (_tokenInfo$metadata2 = tokenInfo.metadata) === null || _tokenInfo$metadata2 === void 0 ? void 0 : _tokenInfo$metadata2.isSufficient;
+  }
   return false;
 };

package/koni/background/handlers/Extension.d.ts

@@ -129,6 +129,7 @@ export default class KoniExtension {
     private removeCustomChain;
     private disableChain;
     private enableChain;
+    private enableChainWithPriorityAssets;
     private reconnectChain;
     private validateNetwork;
     private resetDefaultNetwork;
@@ -255,7 +256,6 @@ export default class KoniExtension {
     private subscribeBuyTokens;
     private subscribeBuyServices;
     private subscribeSwapPairs;
-    private getOptimalSwapProcessOnSelectQuote;
     private handleSwapRequest;
     private handleSwapRequestV2;
     private getLatestSwapQuote;