@subwallet/extension-base 1.3.22-0 → 1.3.24-0

package/cjs/services/transaction-service/index.js

@@ -40,6 +40,7 @@ class TransactionService {
   aliveProcessMap = new Map();
   transactionSubject = new _rxjs.BehaviorSubject({});
   aliveProcessSubject = new _rxjs.BehaviorSubject(this.aliveProcessMap);
+  cacheProcessInfo = {};
   get transactions() {
     return this.transactionSubject.getValue();
   }
@@ -96,8 +97,6 @@ class TransactionService {
       (0, _transfer.checkSupportForAction)(validationResponse, blockedActionsMap);
     }
     const transaction = transactionInput.transaction;
-    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
-    const tokenPayFeeInfo = transactionInput.nonNativeTokenPayFeeSlug ? this.chainService.getAssetBySlug(transactionInput.nonNativeTokenPayFeeSlug) : undefined;
 
     // Check duplicated transaction
     validationResponse.errors.push(...this.checkDuplicate(transactionInput));
@@ -110,16 +109,25 @@ class TransactionService {
     const substrateApi = this.state.chainService.getSubstrateApi(chainInfo.slug);
     const evmApi = this.state.chainService.getEvmApi(chainInfo.slug);
     const tonApi = this.state.chainService.getTonApi(chainInfo.slug);
-    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !evmApi; // todo: should split isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api
+    const cardanoApi = this.state.chainService.getCardanoApi(chainInfo.slug);
+    // todo: should split into isEvmTx && isNoEvmApi. Because other chains type also has no Evm Api. Same to all blockchain.
+    // todo: refactor check evmTransaction.
+    const isNoEvmApi = transaction && !(0, _helpers.isSubstrateTransaction)(transaction) && !(0, _helpers.isTonTransaction)(transaction) && !(0, _helpers.isCardanoTransaction)(transaction) && !evmApi;
     const isNoTonApi = transaction && (0, _helpers.isTonTransaction)(transaction) && !tonApi;
-    if (isNoEvmApi || isNoTonApi) {
+    const isNoCardanoApi = transaction && (0, _helpers.isCardanoTransaction)(transaction) && !cardanoApi;
+    if (isNoEvmApi || isNoTonApi || isNoCardanoApi) {
       validationResponse.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
     }
 
     // Estimate fee for transaction
     const id = (0, _getId.getId)();
     const feeInfo = await this.state.feeService.subscribeChainFee(id, chain, 'evm');
-    validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, feeInfo, nativeTokenInfo, tokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
+    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
+    const tokenPayFeeSlug = transactionInput.tokenPayFeeSlug;
+    const isNonNativeTokenPayFee = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug);
+    const nonNativeTokenPayFeeInfo = isNonNativeTokenPayFee ? this.chainService.getAssetBySlug(tokenPayFeeSlug) : undefined;
+    const priceMap = (await this.state.priceService.getPrice()).priceMap;
+    validationResponse.estimateFee = await (0, _transfer.estimateFeeForTransaction)(validationResponse, transaction, chainInfo, evmApi, substrateApi, priceMap, feeInfo, nativeTokenInfo, nonNativeTokenPayFeeInfo, transactionInput.isTransferLocalTokenAndPayThatTokenAsFee);
     const chainInfoMap = this.state.chainService.getChainInfoMap();
 
     // Check account signing transaction
@@ -176,6 +184,10 @@ class TransactionService {
       }
     };
   }
+  getCacheInfo(processId, step) {
+    var _this$cacheProcessInf;
+    return ((_this$cacheProcessInf = this.cacheProcessInfo[processId]) === null || _this$cacheProcessInf === void 0 ? void 0 : _this$cacheProcessInf[step]) || '';
+  }
   updateAliveProcess() {
     this.aliveProcessSubject.next(this.aliveProcessMap);
   }
@@ -270,9 +282,61 @@ class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handlePermitTransaction(transaction) {
+    var _transaction$step;
+    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, true);
+    const validatedTransaction = {
+      ...transaction,
+      id: transactionId,
+      extrinsicHash: '',
+      status: undefined,
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      processId: (_transaction$step = transaction.step) === null || _transaction$step === void 0 ? void 0 : _transaction$step.processId
+    };
+    const txInput = {
+      ...transaction,
+      isInternal: true,
+      status: _KoniTypes.ExtrinsicStatus.QUEUED,
+      id: transactionId,
+      extrinsicHash: transactionId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime()
+    };
+    const _data = transaction.data;
+    const emitter = this.sendPermitTransaction(txInput);
+    await new Promise((resolve, reject) => {
+      emitter.on('success', data => {
+        validatedTransaction.id = data.id;
+        validatedTransaction.extrinsicHash = data.extrinsicHash;
+        this.cacheProcessInfo[_data.processId] = {
+          [_data.step]: data.extrinsicHash
+        };
+        resolve();
+      });
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+
+    // @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 = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : this.signAndSendTonTransaction(transaction));
+    const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
     const {
       eventsHandler,
       step
@@ -322,7 +386,12 @@ class TransactionService {
           }
           return false;
         });
-        if (rejectError) {
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
           this.deleteProcess(step);
         } else {
           this.updateProcessStepStatus(step, {
@@ -348,6 +417,71 @@ class TransactionService {
     eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
     return emitter;
   }
+  sendPermitTransaction(transaction) {
+    // Send Transaction
+    const emitter = this.signAndSendEvmPermitTransaction(transaction);
+    const {
+      eventsHandler,
+      step
+    } = transaction;
+    emitter.on('send', data => {
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          transactionId: transaction.id,
+          status: _types.StepStatus.SUBMITTING,
+          chain: transaction.chain
+        });
+      }
+    });
+    emitter.on('extrinsicHash', data => {
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          extrinsicHash: data.extrinsicHash,
+          status: _types.StepStatus.PROCESSING
+        });
+      }
+    });
+    emitter.on('success', data => {
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: _types.StepStatus.COMPLETE
+        });
+      }
+    });
+    emitter.on('error', data => {
+      // this.handlePostProcessing(data.id); // might enable this later
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+      });
+      if (step) {
+        const rejectError = data.errors.find(error => {
+          // TODO: REFACTOR ERROR CODE
+          if ([_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
+            return true;
+          }
+          return false;
+        });
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
+          this.deleteProcess(step);
+        } else {
+          this.updateProcessStepStatus(step, {
+            status: _types.StepStatus.FAILED
+          });
+        }
+      }
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
+    return emitter;
+  }
   removeTransaction(id) {
     if (this.transactions[id]) {
       delete this.transactions[id];
@@ -371,7 +505,7 @@ class TransactionService {
     return (0, _utils3.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
-    var _transaction$step;
+    var _transaction$step2;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -396,7 +530,7 @@ class TransactionService {
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
-      processId: (_transaction$step = transaction.step) === null || _transaction$step === void 0 ? void 0 : _transaction$step.processId
+      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
     };
     const nativeAsset = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     const baseNativeAmount = {
@@ -1172,21 +1306,78 @@ class TransactionService {
     }
     return emitter;
   }
-  signAndSendSubstrateTransaction(_ref10) {
+  signAndSendEvmPermitTransaction(_ref10) {
+    let {
+      address,
+      id,
+      isPassConfirmation,
+      step,
+      transaction,
+      url
+    } = _ref10;
+    // Allow sign transaction
+    const canSign = true;
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    const evmSignaturePayload = {
+      id: id,
+      type: 'eth_signTypedData_v4',
+      payload: transaction,
+      address: address,
+      hashPayload: '',
+      canSign: canSign,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    this.state.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSignatureRequest', evmSignaturePayload, {
+      isPassConfirmation
+    }).then(_ref11 => {
+      let {
+        isApproved,
+        payload: signature
+      } = _ref11;
+      if (isApproved) {
+        // Emit signed event
+        emitter.emit('signed', eventData);
+        emitter.emit('send', eventData); // This event is needed after sending transaction with queue
+
+        if (!signature) {
+          throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Failed to sign'));
+        }
+        eventData.extrinsicHash = signature;
+        emitter.emit('extrinsicHash', eventData);
+        emitter.emit('success', eventData);
+      } else {
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendSubstrateTransaction(_ref12) {
     var _this$state$chainServ;
     let {
       address,
       chain,
       feeCustom,
       id,
-      nonNativeTokenPayFeeSlug,
       signAfterCreate,
       step,
+      tokenPayFeeSlug,
       transaction,
       url
-    } = _ref10;
+    } = _ref12;
     const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
-    const feeAssetId = nonNativeTokenPayFeeSlug ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(nonNativeTokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
+    const feeAssetId = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug) && _constants._SUPPORT_TOKEN_PAY_FEE_GROUP.assetHub.includes(chain) ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(tokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
     const emitter = new _eventemitter.default();
     const eventData = {
       id,
@@ -1255,20 +1446,20 @@ class TransactionService {
           eventData.extrinsicHash = txState.txHash.toHex();
           eventData.eventLogs = txState.events;
           // TODO: push block hash and block number into eventData
-          txState.events.filter(_ref11 => {
+          txState.events.filter(_ref13 => {
             let {
               event: {
                 section
               }
-            } = _ref11;
+            } = _ref13;
             return section === 'system';
-          }).forEach(_ref12 => {
+          }).forEach(_ref14 => {
             let {
               event: {
                 data: [error],
                 method
               }
-            } = _ref12;
+            } = _ref14;
             if (method === 'ExtrinsicFailed') {
               eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
               emitter.emit('error', eventData);
@@ -1288,7 +1479,7 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendTonTransaction(_ref13) {
+  signAndSendTonTransaction(_ref15) {
     let {
       address,
       chain,
@@ -1297,7 +1488,7 @@ class TransactionService {
       step,
       transaction,
       url
-    } = _ref13;
+    } = _ref15;
     const walletContract = _uiKeyring.default.getPair(address).ton.currentContract;
     const emitter = new _eventemitter.default();
     const eventData = {
@@ -1314,11 +1505,11 @@ class TransactionService {
           ...payload,
           messagePayload: (0, _utils.cellToBase64Str)(message),
           messages: []
-        }, {}).then(_ref14 => {
+        }, {}).then(_ref16 => {
           let {
             isApproved,
             payload
-          } = _ref14;
+          } = _ref16;
           if (!isApproved) {
             this.removeTransaction(id);
             eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
@@ -1336,7 +1527,7 @@ class TransactionService {
         });
       });
     };
-    const tonTransactionConfig = transaction;
+    const tonTransactionConfig = transaction; // todo: is this same as payload?
     const seqno = tonTransactionConfig.seqno;
     const messages = tonTransactionConfig.messages;
     const transferObjectPromise = (0, _utils.getTransferCellPromise)(walletContract, signer, payload, seqno, messages);
@@ -1353,8 +1544,8 @@ class TransactionService {
         if (!externalMsgHash) {
           return;
         }
-        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref15 => {
-          let [status, hex] = _ref15;
+        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref17 => {
+          let [status, hex] = _ref17;
           if (status && hex) {
             eventData.extrinsicHash = hex;
             emitter.emit('extrinsicHash', eventData);
@@ -1383,6 +1574,75 @@ class TransactionService {
     });
     return emitter;
   }
+  signAndSendCardanoTransaction(_ref18) {
+    let {
+      chain,
+      id,
+      transaction,
+      url
+    } = _ref18;
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id
+    };
+    const transactionConfig = transaction;
+    const cardanoApi = this.state.chainService.getCardanoApi(chain);
+    this.state.requestService.addConfirmationCardano(id, url || _constants2.EXTENSION_REQUEST_URL, 'cardanoSendTransactionRequest', transactionConfig, {}).then(_ref19 => {
+      let {
+        isApproved,
+        payload
+      } = _ref19;
+      if (!isApproved) {
+        this.removeTransaction(id);
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      } else {
+        if (!payload) {
+          throw new Error('Failed to sign');
+        }
+
+        // Emit signed event
+        emitter.emit('signed', eventData);
+
+        // Send transaction
+        this.handleTransactionTimeout(emitter, eventData);
+        emitter.emit('send', eventData);
+
+        // send qua api
+        cardanoApi.sendCardanoTxReturnHash(payload).then(txHash => {
+          if (!txHash) {
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+            emitter.emit('error', eventData);
+          }
+          eventData.extrinsicHash = txHash;
+          emitter.emit('extrinsicHash', eventData);
+
+          // todo: wait transaction by fetch txHash by API
+          cardanoApi.getStatusByTxHash(txHash, transactionConfig.cardanoTtlOffset).then(status => {
+            if (!status) {
+              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              emitter.emit('error', eventData);
+            }
+            emitter.emit('success', eventData);
+          }).catch(e => {
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+            emitter.emit('error', eventData);
+          });
+        }).catch(e => {
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          emitter.emit('error', eventData);
+        });
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
   handleTransactionTimeout(emitter, eventData) {
     const timeout = setTimeout(() => {
       const transaction = this.getTransaction(eventData.id);
@@ -1525,9 +1785,9 @@ class TransactionService {
     }
   }
   async createProcessNotification(transactionId) {
-    var _transaction$step2;
+    var _transaction$step3;
     const transaction = this.getTransaction(transactionId);
-    if (transaction && (_transaction$step2 = transaction.step) !== null && _transaction$step2 !== void 0 && _transaction$step2.processId) {
+    if (transaction && (_transaction$step3 = transaction.step) !== null && _transaction$step3 !== void 0 && _transaction$step3.processId) {
       const process = this.aliveProcessMap.get(transaction.step.processId);
       if (process) {
         await this.state.inappNotificationService.createProcessNotification(process);

package/cjs/services/transaction-service/utils.js

@@ -9,6 +9,7 @@ exports.getSimpleSwapExplorerLink = getSimpleSwapExplorerLink;
 exports.parseTransactionData = parseTransactionData;
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
+var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -55,6 +56,9 @@ function getBlockExplorerTxRoute(chainInfo) {
   if ((0, _utils._isPureEvmChain)(chainInfo)) {
     return 'tx';
   }
+  if ((0, _utils._isPureCardanoChain)(chainInfo)) {
+    return 'transaction';
+  }
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
@@ -69,7 +73,7 @@ function getExplorerLink(chainInfo, value, type) {
     const route = getBlockExplorerAccountRoute(explorerLink);
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
-  if (explorerLink && value.startsWith('0x')) {
+  if (explorerLink && (0, _util.isHex)((0, _util.hexAddPrefix)(value))) {
     if (chainInfo.slug === 'bittensor') {
       return undefined;
     }

package/cjs/types/account/info/keyring.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.AccountSignMode = exports.AccountChainType = exports.AccountActions = void 0;
+exports.SUPPORTED_ACCOUNT_CHAIN_TYPES = exports.AccountSignMode = exports.AccountChainType = exports.AccountActions = exports.ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = void 0;
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 /**
@@ -67,7 +67,18 @@ exports.AccountChainType = AccountChainType;
   AccountChainType["ETHEREUM"] = "ethereum";
   AccountChainType["BITCOIN"] = "bitcoin";
   AccountChainType["TON"] = "ton";
+  AccountChainType["CARDANO"] = "cardano";
 })(AccountChainType || (exports.AccountChainType = AccountChainType = {}));
+const ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = {
+  [AccountChainType.SUBSTRATE]: 1,
+  [AccountChainType.ETHEREUM]: 2,
+  [AccountChainType.TON]: 3,
+  [AccountChainType.CARDANO]: 4,
+  [AccountChainType.BITCOIN]: 5
+};
+exports.ACCOUNT_CHAIN_TYPE_ORDINAL_MAP = ACCOUNT_CHAIN_TYPE_ORDINAL_MAP;
+const SUPPORTED_ACCOUNT_CHAIN_TYPES = ['substrate', 'ethereum', 'ton', 'cardano'];
+exports.SUPPORTED_ACCOUNT_CHAIN_TYPES = SUPPORTED_ACCOUNT_CHAIN_TYPES;
 let AccountActions;
 /**
  * Represents the actions associated with an account.

package/cjs/types/fee/cardano.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/swap/index.js

@@ -27,6 +27,7 @@ let SwapStepType;
 exports.SwapStepType = SwapStepType;
 (function (SwapStepType) {
   SwapStepType["SWAP"] = "SWAP";
+  SwapStepType["PERMIT"] = "PERMIT";
 })(SwapStepType || (exports.SwapStepType = SwapStepType = {}));
 let SwapProviderId;
 exports.SwapProviderId = SwapProviderId;
@@ -40,10 +41,14 @@ exports.SwapProviderId = SwapProviderId;
   SwapProviderId["ROCOCO_ASSET_HUB"] = "ROCOCO_ASSET_HUB";
   SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
+  SwapProviderId["UNISWAP"] = "UNISWAP";
 })(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
-const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB,
+const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET,
+// SwapProviderId.HYDRADX_TESTNET,
+SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB,
+// SwapProviderId.ROCOCO_ASSET_HUB,
 // SwapProviderId.WESTEND_ASSET_HUB,
-SwapProviderId.SIMPLE_SWAP];
+SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP];
 exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
 // process handling
 let SwapFeeType;

package/cjs/utils/account/analyze.js

@@ -21,7 +21,8 @@ const isStrValidWithAddress = (str, account, chainInfo) => {
     } else if (account.address.toLowerCase().includes(str) || reformated.toLowerCase().includes(str)) {
       return 'valid';
     }
-  } else if (account.chainType === _types.AccountChainType.TON) {
+  } else if (account.chainType === _types.AccountChainType.TON || account.chainType === _types.AccountChainType.CARDANO) {
+    // todo: recheck for Cardano
     const isTestnet = chainInfo.isTestnet;
     const reformated = (0, _common.reformatAddress)(account.address, isTestnet ? 0 : 1);
     if (account.address.toLowerCase() === str || reformated.toLowerCase() === str) {

package/cjs/utils/account/common.js

@@ -3,13 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._reformatAddressWithChain = void 0;
-exports.categoryAddresses = categoryAddresses;
-exports.getAccountChainTypeForAddress = void 0;
+exports.getAccountChainTypeForAddress = exports._reformatAddressWithChain = void 0;
+exports.getAddressesByChainType = getAddressesByChainType;
+exports.getAddressesByChainTypeMap = getAddressesByChainTypeMap;
 exports.isAccountAll = isAccountAll;
 exports.modifyAccountName = void 0;
 exports.quickFormatAddressToCompare = quickFormatAddressToCompare;
 exports.reformatAddress = reformatAddress;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _types = require("@subwallet/extension-base/types");
@@ -50,10 +51,11 @@ function reformatAddress(address) {
   }
 }
 const _reformatAddressWithChain = (address, chainInfo) => {
+  // todo: check for cardano
   const chainType = (0, _utils._chainInfoToChainType)(chainInfo);
   if (chainType === _types.AccountChainType.SUBSTRATE) {
     return reformatAddress(address, (0, _utils._getChainSubstrateAddressPrefix)(chainInfo));
-  } else if (chainType === _types.AccountChainType.TON) {
+  } else if (chainType === _types.AccountChainType.TON || chainType === _types.AccountChainType.CARDANO) {
     const isTestnet = chainInfo.isTestnet;
     return reformatAddress(address, isTestnet ? 0 : 1);
   } else {
@@ -63,31 +65,38 @@ const _reformatAddressWithChain = (address, chainInfo) => {
 exports._reformatAddressWithChain = _reformatAddressWithChain;
 const getAccountChainTypeForAddress = address => {
   const type = (0, _keyring.getKeypairTypeByAddress)(address);
-  return (0, _utils2.getAccountChainType)(type);
+  return (0, _utils2.getAccountChainTypeFromKeypairType)(type);
 };
 exports.getAccountChainTypeForAddress = getAccountChainTypeForAddress;
-function categoryAddresses(addresses) {
-  const substrate = [];
-  const evm = [];
-  const ton = [];
-  const bitcoin = [];
+function getAddressesByChainType(addresses, chainTypes) {
+  const addressByChainTypeMap = getAddressesByChainTypeMap(addresses);
+  return chainTypes.map(chainType => {
+    return addressByChainTypeMap[chainType];
+  }).flat(); // todo: recheck
+}
+
+function getAddressesByChainTypeMap(addresses) {
+  const addressByChainType = {
+    substrate: [],
+    evm: [],
+    bitcoin: [],
+    ton: [],
+    cardano: []
+  };
   addresses.forEach(address => {
     if ((0, _utilCrypto.isEthereumAddress)(address)) {
-      evm.push(address);
+      addressByChainType.evm.push(address);
     } else if ((0, _keyring.isTonAddress)(address)) {
-      ton.push(address);
+      addressByChainType.ton.push(address);
     } else if ((0, _keyring.isBitcoinAddress)(address)) {
-      bitcoin.push(address);
+      addressByChainType.bitcoin.push(address);
+    } else if ((0, _keyring.isCardanoAddress)(address)) {
+      addressByChainType.cardano.push(address);
     } else {
-      substrate.push(address);
+      addressByChainType.substrate.push(address);
     }
   });
-  return {
-    bitcoin,
-    evm,
-    substrate,
-    ton
-  };
+  return addressByChainType;
 }
 function quickFormatAddressToCompare(address) {
   if (!(0, _keyring.isAddress)(address)) {