@subwallet/extension-base 1.3.40-0 → 1.3.42-0

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

@@ -1,6 +1,9 @@
 import { SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
 import { CurrentAccountInfo } from '@subwallet/extension-base/types';
 export interface EventRegistry {
+    'general.init': [boolean];
+    'general.start': [boolean];
+    'general.start_full': [boolean];
     'general.sleep': [boolean];
     'general.wakeup': [boolean];
     'crypto.ready': [boolean];

package/services/fee-service/service.js

@@ -10,7 +10,8 @@ export default class FeeService {
     evm: {},
     substrate: {},
     ton: {},
-    cardano: {}
+    cardano: {},
+    bitcoin: {}
   };
   constructor(state) {
     this.state = state;
@@ -101,10 +102,9 @@ export default class FeeService {
           if (cancel) {
             clearInterval(interval);
           } else {
-            const api = this.state.getEvmApi(chain);
-
             // TODO: Handle case type === evm and not have api
             if (type === 'evm') {
+              const api = this.state.getEvmApi(chain);
               if (api) {
                 calculateGasFeeParams(api, chain).then(info => {
                   observer.next(info);
@@ -126,6 +126,11 @@ export default class FeeService {
                   options: undefined
                 });
               }
+            } else if (type === 'bitcoin') {
+              const api = this.state.getBitcoinApi(chain);
+              api.api.getRecommendedFeeRate().then(info => {
+                observer.next(info);
+              }).catch(console.error);
             } else {
               observer.next({
                 type,

package/services/hiro-service/index.d.ts

@@ -0,0 +1,17 @@
+import { Brc20BalanceFetchedData, Brc20MetadataFetchedData, InscriptionFetchedData } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+export declare class HiroService extends BaseApiRequestStrategy {
+    baseUrl: string;
+    private constructor();
+    private headers;
+    isRateLimited(): boolean;
+    getUrl(path: string): string;
+    getBRC20Metadata(ticker: string): Promise<Brc20MetadataFetchedData>;
+    getAddressBRC20BalanceInfo(address: string, params: Record<string, string>): Promise<Brc20BalanceFetchedData>;
+    getAddressInscriptionsInfo(params: Record<string, string>): Promise<InscriptionFetchedData>;
+    getInscriptionContent(inscriptionId: string): Promise<Record<string, any>>;
+    getPreviewUrl(inscriptionId: string): string;
+    private static mainnet;
+    private static testnet;
+    static getInstance(isTestnet?: boolean): HiroService;
+}

package/services/hiro-service/index.js

@@ -0,0 +1,88 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { SWError } from '@subwallet/extension-base/background/errors/SWError';
+import { _BTC_SERVICE_TOKEN } from '@subwallet/extension-base/services/chain-service/constants';
+import { BaseApiRequestStrategy } from '@subwallet/extension-base/strategy/api-request-strategy';
+import { BaseApiRequestContext } from '@subwallet/extension-base/strategy/api-request-strategy/context/base';
+import { getRequest } from '@subwallet/extension-base/strategy/api-request-strategy/utils';
+const BITCOIN_API_URL = 'https://btc-api.koni.studio';
+const BITCOIN_API_URL_TEST = 'https://api-testnet.openbit.app';
+export class HiroService extends BaseApiRequestStrategy {
+  constructor(url) {
+    const context = new BaseApiRequestContext();
+    super(context);
+    this.baseUrl = url;
+  }
+  headers = {
+    'Content-Type': 'application/json',
+    Authorization: `Bearer ${_BTC_SERVICE_TOKEN}`
+  };
+  isRateLimited() {
+    return false;
+  }
+  getUrl(path) {
+    return `${this.baseUrl}/${path}`;
+  }
+  getBRC20Metadata(ticker) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`brc-20/tokens/${ticker}`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('HiroService.getBRC20Metadata', rs.message);
+      }
+      return rs.result;
+    }, 3);
+  }
+  getAddressBRC20BalanceInfo(address, params) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`brc-20/balances/${address}`), params, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('HiroService.getAddressBRC20BalanceInfo', rs.message);
+      }
+      return rs.result;
+    }, 3);
+  }
+  getAddressInscriptionsInfo(params) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl('inscriptions'), params, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('HiroService.getAddressInscriptionsInfo', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+  getInscriptionContent(inscriptionId) {
+    return this.addRequest(async () => {
+      const _rs = await getRequest(this.getUrl(`inscriptions/${inscriptionId}/content`), undefined, this.headers);
+      const rs = await _rs.json();
+      if (rs.status_code !== 200) {
+        throw new SWError('HiroService.getInscriptionContent', rs.message);
+      }
+      return rs.result;
+    }, 0);
+  }
+
+  // todo: handle token authen for url preview
+  getPreviewUrl(inscriptionId) {
+    return `${BITCOIN_API_URL}/inscriptions/${inscriptionId}/content`;
+  }
+
+  // Singleton
+
+  static getInstance(isTestnet = false) {
+    if (isTestnet) {
+      if (!HiroService.testnet) {
+        HiroService.testnet = new HiroService(BITCOIN_API_URL_TEST);
+      }
+      return HiroService.testnet;
+    } else {
+      if (!HiroService.mainnet) {
+        HiroService.mainnet = new HiroService(BITCOIN_API_URL);
+      }
+      return HiroService.mainnet;
+    }
+  }
+}

package/services/hiro-service/utils/index.d.ts

@@ -0,0 +1,6 @@
+import { Brc20Metadata } from '@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types';
+export declare function getBrc20Metadata(isTestnet: boolean | undefined, ticker: string): Promise<Brc20Metadata>;
+export declare function getInscriptionContent(isTestnet: boolean, inscriptionId: string): Promise<Record<string, any>>;
+export declare function getAddressInscriptions(address: string, isTestnet: boolean, offset?: number, limit?: number): Promise<import("@subwallet/extension-base/services/chain-service/handler/bitcoin/strategy/types").Inscription[]>;
+export declare function getPreviewUrl(inscriptionId: string): string;
+export declare function isValidBrc20Ticker(ticker: string): boolean;

package/services/hiro-service/utils/index.js

@@ -0,0 +1,72 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { HiroService } from '@subwallet/extension-base/services/hiro-service';
+
+// todo: handle inscription testnet
+export async function getBrc20Metadata(isTestnet = false, ticker) {
+  const hiroService = HiroService.getInstance(isTestnet);
+  const defaultMetadata = {
+    ticker: '',
+    decimals: 0
+  };
+  try {
+    const response = await hiroService.getBRC20Metadata(ticker);
+    const rs = response === null || response === void 0 ? void 0 : response.token;
+    if (rs) {
+      return {
+        ticker: rs.ticker,
+        decimals: rs.decimals
+      };
+    }
+    return defaultMetadata;
+  } catch (error) {
+    console.log(`Error on request brc20 metadata with ticker ${ticker}`);
+    return defaultMetadata;
+  }
+}
+export async function getInscriptionContent(isTestnet, inscriptionId) {
+  const hiroService = HiroService.getInstance(isTestnet);
+  try {
+    return await hiroService.getInscriptionContent(inscriptionId);
+  } catch (error) {
+    console.log(`Error on request inscription ${inscriptionId} content`);
+    return {};
+  }
+}
+
+// todo: handle large inscriptions
+export async function getAddressInscriptions(address, isTestnet, offset = 0, limit = 25) {
+  const hiroService = HiroService.getInstance(isTestnet);
+  try {
+    const response = await hiroService.getAddressInscriptionsInfo({
+      limit: String(limit),
+      offset: String(offset),
+      address: String(address)
+    });
+    return response.results;
+  } catch (error) {
+    console.error(`Failed to get ${address} inscriptions with offset ${offset} and limit ${limit}`, error);
+    throw error;
+  }
+}
+export function getPreviewUrl(inscriptionId) {
+  const hiroService = HiroService.getInstance();
+  try {
+    return hiroService.getPreviewUrl(inscriptionId);
+  } catch (error) {
+    console.error(`Failed to get inscription ${inscriptionId} preview url`, error);
+    throw error;
+  }
+}
+export function isValidBrc20Ticker(ticker) {
+  const bytesLength = getByteLength(ticker);
+  return bytesLength === 4 || bytesLength === 5;
+}
+function getByteLength(str) {
+  const encoder = new TextEncoder();
+  const encodedStr = encoder.encode(str);
+
+  // Return the length of the encoded array, which represents the number of bytes
+  return encodedStr.length;
+}

package/services/history-service/bitcoin-history.d.ts

@@ -0,0 +1,4 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { BitcoinTx } from '@subwallet/extension-base/types';
+export declare function parseBitcoinTransferData(address: string, transferItem: BitcoinTx, chainInfo: _ChainInfo): TransactionHistoryItem;

package/services/history-service/bitcoin-history.js

@@ -0,0 +1,52 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType, ExtrinsicStatus, ExtrinsicType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+function isSender(address, transferItem) {
+  return transferItem.vin.some(i => i.prevout.scriptpubkey_address === address);
+}
+export function parseBitcoinTransferData(address, transferItem, chainInfo) {
+  var _chainInfo$bitcoinInf, _chainInfo$bitcoinInf2, _transferItem$vin$, _transferItem$vin$$pr, _transferItem$vout$;
+  const chainType = ChainType.BITCOIN;
+  const nativeDecimals = ((_chainInfo$bitcoinInf = chainInfo.bitcoinInfo) === null || _chainInfo$bitcoinInf === void 0 ? void 0 : _chainInfo$bitcoinInf.decimals) || 8;
+  const nativeSymbol = ((_chainInfo$bitcoinInf2 = chainInfo.bitcoinInfo) === null || _chainInfo$bitcoinInf2 === void 0 ? void 0 : _chainInfo$bitcoinInf2.symbol) || '';
+  const isCurrentAddressSender = isSender(address, transferItem);
+  const sender = isCurrentAddressSender ? address : ((_transferItem$vin$ = transferItem.vin[0]) === null || _transferItem$vin$ === void 0 ? void 0 : (_transferItem$vin$$pr = _transferItem$vin$.prevout) === null || _transferItem$vin$$pr === void 0 ? void 0 : _transferItem$vin$$pr.scriptpubkey_address) || '';
+  const receiver = isCurrentAddressSender ? ((_transferItem$vout$ = transferItem.vout[0]) === null || _transferItem$vout$ === void 0 ? void 0 : _transferItem$vout$.scriptpubkey_address) || '' : address;
+  const amountValue = (() => {
+    const targetAddress = isCurrentAddressSender ? receiver : address;
+    const vouts = transferItem.vout.filter(i => i.scriptpubkey_address === targetAddress);
+    if (vouts.length) {
+      return vouts.reduce((total, item) => total + item.value, 0).toString();
+    } else {
+      return '0';
+    }
+  })();
+  return {
+    address,
+    origin: 'blockstream',
+    time: 0,
+    // From api, cannot get time submit transaction
+    blockTime: transferItem.status.block_time ? transferItem.status.block_time * 1000 : undefined,
+    chainType,
+    type: ExtrinsicType.TRANSFER_BALANCE,
+    extrinsicHash: transferItem.txid,
+    chain: chainInfo.slug,
+    direction: address === sender ? TransactionDirection.SEND : TransactionDirection.RECEIVED,
+    fee: {
+      value: `${transferItem.fee}`,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    from: sender,
+    to: receiver,
+    blockNumber: transferItem.status.block_height || 0,
+    blockHash: transferItem.status.block_hash || '',
+    amount: {
+      value: amountValue,
+      decimals: nativeDecimals,
+      symbol: nativeSymbol
+    },
+    status: transferItem.status.confirmed ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.PROCESSING
+  };
+}

package/services/history-service/helpers/recoverHistoryStatus.d.ts

@@ -6,12 +6,14 @@ export declare enum HistoryRecoverStatus {
     API_INACTIVE = "API_INACTIVE",
     LACK_INFO = "LACK_INFO",
     FAIL_DETECT = "FAIL_DETECT",
-    UNKNOWN = "UNKNOWN"
+    UNKNOWN = "UNKNOWN",
+    TX_PENDING = "TX_PENDING"
 }
 export interface TransactionRecoverResult {
     status: HistoryRecoverStatus;
     extrinsicHash?: string;
     blockHash?: string;
     blockNumber?: number;
+    blockTime?: number;
 }
 export declare const historyRecover: (history: TransactionHistoryItem, chainService: ChainService) => Promise<TransactionRecoverResult>;

package/services/history-service/helpers/recoverHistoryStatus.js

@@ -11,6 +11,7 @@ export let HistoryRecoverStatus;
   HistoryRecoverStatus["LACK_INFO"] = "LACK_INFO";
   HistoryRecoverStatus["FAIL_DETECT"] = "FAIL_DETECT";
   HistoryRecoverStatus["UNKNOWN"] = "UNKNOWN";
+  HistoryRecoverStatus["TX_PENDING"] = "TX_PENDING";
 })(HistoryRecoverStatus || (HistoryRecoverStatus = {}));
 const BLOCK_LIMIT = 6;
 const substrateRecover = async (history, chainService) => {
@@ -204,6 +205,80 @@ const evmRecover = async (history, chainService) => {
     };
   }
 };
+const bitcoinRecover = async (history, chainService) => {
+  const {
+    chain,
+    extrinsicHash
+  } = history;
+  const result = {
+    status: HistoryRecoverStatus.UNKNOWN
+  };
+
+  // TODO: 1. Consider rebroadcasting transaction if stuck in mempool
+
+  try {
+    const bitcoinApi = chainService.getBitcoinApi(chain);
+    if (bitcoinApi) {
+      const api = bitcoinApi.api;
+      if (extrinsicHash) {
+        try {
+          const timeout = new Promise(resolve => {
+            setTimeout(() => {
+              resolve(undefined);
+            }, 60000);
+          });
+          const txStatus = await Promise.race([api.getTransactionStatus(extrinsicHash), timeout]);
+          if (!txStatus) {
+            return {
+              ...result,
+              status: HistoryRecoverStatus.API_INACTIVE
+            };
+          }
+          if (txStatus.confirmed) {
+            const transactionDetail = await Promise.race([api.getTransactionDetail(extrinsicHash), timeout]);
+            if (transactionDetail) {
+              result.blockHash = transactionDetail.status.block_hash || undefined;
+              result.blockNumber = transactionDetail.status.block_height || undefined;
+              result.blockTime = transactionDetail.status.block_time ? transactionDetail.status.block_time * 1000 : undefined;
+              return {
+                ...result,
+                status: HistoryRecoverStatus.SUCCESS
+              };
+            }
+            return {
+              ...result,
+              status: HistoryRecoverStatus.API_INACTIVE
+            };
+          } else {
+            return {
+              ...result,
+              status: HistoryRecoverStatus.TX_PENDING
+            };
+          }
+        } catch (e) {
+          // Fail when cannot find transaction
+          return {
+            ...result,
+            status: HistoryRecoverStatus.FAILED
+          };
+        }
+      }
+      return {
+        status: HistoryRecoverStatus.FAIL_DETECT
+      };
+    } else {
+      console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
+      return {
+        status: HistoryRecoverStatus.API_INACTIVE
+      };
+    }
+  } catch (e) {
+    console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
+    return {
+      status: HistoryRecoverStatus.UNKNOWN
+    };
+  }
+};
 
 // undefined: Cannot check status
 // true: Transaction success
@@ -212,12 +287,29 @@ export const historyRecover = async (history, chainService) => {
   const {
     chainType
   } = history;
-  if (chainType) {
-    const checkFunction = chainType === 'substrate' ? substrateRecover : evmRecover;
-    return await checkFunction(history, chainService);
-  } else {
+  if (!chainType) {
     return {
       status: HistoryRecoverStatus.LACK_INFO
     };
   }
+  const recoverFunctions = {
+    substrate: substrateRecover,
+    evm: evmRecover,
+    bitcoin: bitcoinRecover
+  };
+  const checkFunction = recoverFunctions[chainType];
+  if (!checkFunction) {
+    console.warn(`Chain type ${chainType} is not supported for recoverHistory`);
+    return {
+      status: HistoryRecoverStatus.UNKNOWN
+    };
+  }
+  try {
+    return await checkFunction(history, chainService);
+  } catch (error) {
+    console.error(`Failed to recover history for chain type ${chainType}:`, error);
+    return {
+      status: HistoryRecoverStatus.FAILED
+    };
+  }
 };

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

@@ -24,6 +24,7 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
      * @todo: Must improve performance of this function
      * */
     private fetchSubscanTransactionHistory;
+    private fetchBitcoinTransactionHistory;
     subscribeHistories(chain: string, proxyId: string, cb: (items: TransactionHistoryItem[]) => void): {
         unsubscribe: () => void;
         value: TransactionHistoryItem<ExtrinsicType.TRANSFER_BALANCE>[];

package/services/history-service/index.js

@@ -4,7 +4,8 @@
 import { ChainType, ExtrinsicStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { CRON_RECOVER_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
-import { _isChainEvmCompatible, _isChainSubstrateCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainBitcoinCompatible, _isChainEvmCompatible, _isChainSubstrateCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { parseBitcoinTransferData } from '@subwallet/extension-base/services/history-service/bitcoin-history';
 import { historyRecover, HistoryRecoverStatus } from '@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus';
 import { getExtrinsicParserKey } from '@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper';
 import { parseSubscanExtrinsicData, parseSubscanTransferData } from '@subwallet/extension-base/services/history-service/subscan-history';
@@ -142,20 +143,48 @@ export class HistoryService {
       console.log('fetchAllPossibleTransferItems-receive error', e);
     });
   }
+
+  // Only 1 address is passed in
+  async fetchBitcoinTransactionHistory(chain, addresses) {
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const chainState = this.chainService.getChainStateByKey(chain);
+    if (!chainState.active) {
+      return;
+    }
+    const bitcoinApi = this.chainService.getBitcoinApi(chain);
+    const allParsedItems = [];
+    for (const address of addresses) {
+      const transferItems = await bitcoinApi.api.getAddressTransaction(address);
+      const parsedItems = transferItems.map((item, index) => {
+        const parsedItem = parseBitcoinTransferData(address, item, chainInfo);
+        return {
+          ...parsedItem,
+          apiTxIndex: index
+        };
+      });
+      allParsedItems.push(...parsedItems);
+    }
+    await this.addHistoryItems(allParsedItems);
+  }
   subscribeHistories(chain, proxyId, cb) {
     const addresses = this.keyringService.context.getDecodedAddresses(proxyId, false);
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
     const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
     const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
+    const bitcoinAddresses = getAddressesByChainType(addresses, [ChainType.BITCOIN], chainInfo);
     const subscription = this.historySubject.subscribe(items => {
       cb(items.filter(filterHistoryItemByAddressAndChain(chain, addresses)));
     });
-    const chainInfo = this.chainService.getChainInfoByKey(chain);
     if (_isChainSubstrateCompatible(chainInfo)) {
       if (_isChainEvmCompatible(chainInfo)) {
         this.fetchSubscanTransactionHistory(chain, evmAddresses);
       } else {
         this.fetchSubscanTransactionHistory(chain, substrateAddresses);
       }
+    } else if (_isChainBitcoinCompatible(chainInfo)) {
+      this.fetchBitcoinTransactionHistory(chain, bitcoinAddresses).catch(e => {
+        console.log('fetchBitcoinTransactionHistory Error', e);
+      });
     }
     return {
       unsubscribe: subscription.unsubscribe,
@@ -195,7 +224,8 @@ export class HistoryService {
       if (needUpdateItem) {
         updateRecords.push({
           ...needUpdateItem,
-          status: item.status
+          status: item.status,
+          apiTxIndex: item.apiTxIndex
         });
         return;
       }
@@ -248,6 +278,9 @@ export class HistoryService {
       switch (recoverResult.status) {
         case HistoryRecoverStatus.API_INACTIVE:
           break;
+        case HistoryRecoverStatus.TX_PENDING:
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
+          break;
         case HistoryRecoverStatus.FAILED:
         case HistoryRecoverStatus.SUCCESS:
           updateData.status = recoverResult.status === HistoryRecoverStatus.SUCCESS ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL;
@@ -285,7 +318,12 @@ export class HistoryService {
     const histories = await this.dbService.getHistories();
     this.#needRecoveryHistories = {};
     histories.filter(history => {
-      return [ExtrinsicStatus.PROCESSING, ExtrinsicStatus.SUBMITTING].includes(history.status);
+      if ([ExtrinsicStatus.PROCESSING, ExtrinsicStatus.SUBMITTING].includes(history.status)) {
+        return true;
+      } else if (history.status === ExtrinsicStatus.SUCCESS && history.chainType === 'bitcoin') {
+        return !history.blockTime;
+      }
+      return false;
     }).filter(history => {
       if (history.type === ExtrinsicType.TRANSFER_XCM) {
         const data = history.additionalInfo;

package/services/keyring-service/context/handlers/Derive.js

@@ -4,12 +4,12 @@
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { CommonAccountErrorType, DeriveErrorType, SWCommonAccountError, SWDeriveError } from '@subwallet/extension-base/types';
 import { createAccountProxyId, derivePair, findSoloNextDerive, findUnifiedNextDerive, getSoloDerivationInfo, parseUnifiedSuriToDerivationPath, validateDerivationPath } from '@subwallet/extension-base/utils';
-import { EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, EthereumKeypairTypes, SubstrateKeypairTypes } from '@subwallet/keyring/types';
 import { keyring } from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { assert } from '@polkadot/util';
 import { AccountBaseHandler } from "./Base.js";
-const validDeriveKeypairTypes = [...SubstrateKeypairTypes, ...EthereumKeypairTypes, 'ton', 'cardano'];
+const validDeriveKeypairTypes = [...SubstrateKeypairTypes, ...EthereumKeypairTypes, 'ton', 'cardano', ...BitcoinKeypairTypes];
 
 /**
  * @class AccountDeriveHandler

package/services/keyring-service/context/handlers/Migration.js

@@ -74,7 +74,7 @@ export class AccountMigrationHandler extends AccountBaseHandler {
           proxyId
         }).result;
         const newChainTypes = Object.values(AccountChainType).filter(type => !unifiedAccount.chainTypes.includes(type) && SUPPORTED_ACCOUNT_CHAIN_TYPES.includes(type));
-        const keypairTypes = newChainTypes.map(chainType => getDefaultKeypairTypeFromAccountChainType(chainType));
+        const keypairTypes = newChainTypes.flatMap(chainType => getDefaultKeypairTypeFromAccountChainType(chainType));
         keypairTypes.forEach(type => {
           const suri = getSuri(mnemonic, type);
           const pair = keyring.createFromUri(suri, {}, type);
@@ -178,7 +178,7 @@ export class AccountMigrationHandler extends AccountBaseHandler {
         password,
         proxyId: firstAccountOldProxyId
       }).result;
-      const keypairTypes = SUPPORTED_ACCOUNT_CHAIN_TYPES.map(chainType => getDefaultKeypairTypeFromAccountChainType(chainType));
+      const keypairTypes = SUPPORTED_ACCOUNT_CHAIN_TYPES.flatMap(chainType => getDefaultKeypairTypeFromAccountChainType(chainType));
       keypairTypes.forEach(type => {
         const suri = getSuri(mnemonic, type);
         const pair = keyring.createFromUri(suri, {}, type);

package/services/keyring-service/context/handlers/Mnemonic.js

@@ -4,6 +4,7 @@
 import { CommonAccountErrorType, SWCommonAccountError } from '@subwallet/extension-base/types';
 import { createAccountProxyId, getSuri } from '@subwallet/extension-base/utils';
 import { tonMnemonicGenerate } from '@subwallet/keyring';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, EthereumKeypairTypes } from '@subwallet/keyring/types';
 import { tonMnemonicValidate } from '@subwallet/keyring/utils';
 import { keyring } from '@subwallet/ui-keyring';
 import { t } from 'i18next';
@@ -27,7 +28,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     mnemonic: _seed,
     type = 'general'
   }) {
-    const types = type === 'general' ? ['sr25519', 'ethereum', 'ton', 'cardano'] : ['ton-native'];
+    const types = type === 'general' ? ['sr25519', ...EthereumKeypairTypes, 'ton', ...CardanoKeypairTypes, ...BitcoinKeypairTypes] : ['ton-native'];
     const seed = _seed || type === 'general' ? mnemonicGenerate(length) : await tonMnemonicGenerate(length);
     const rs = {
       mnemonic: seed,
@@ -60,7 +61,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
       try {
         assert(mnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
         mnemonicTypes = 'general';
-        pairTypes = ['sr25519', 'ethereum', 'ton'];
+        pairTypes = ['sr25519', ...EthereumKeypairTypes, 'ton', ...CardanoKeypairTypes, ...BitcoinKeypairTypes];
       } catch (e) {
         assert(tonMnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
         mnemonicTypes = 'ton';
@@ -97,7 +98,7 @@ export class AccountMnemonicHandler extends AccountBaseHandler {
     const addressDict = {};
     let changedAccount = false;
     const hasMasterPassword = keyring.keyring.hasMasterPassword;
-    const types = type ? [type] : ['sr25519', 'ethereum', 'ton', 'cardano'];
+    const types = type ? [type] : ['sr25519', ...EthereumKeypairTypes, 'ton', ...CardanoKeypairTypes, ...BitcoinKeypairTypes];
     if (!hasMasterPassword) {
       if (!password) {
         throw Error(t('The password of each account is needed to set up master password'));

package/services/migration-service/scripts/MigrateNewUnifiedAccount.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateNewUnifiedAccount extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateNewUnifiedAccount.js

@@ -0,0 +1,21 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateNewUnifiedAccount extends BaseMigrationJob {
+  async run() {
+    try {
+      return new Promise(resolve => {
+        this.state.settingService.getSettings(currentSettings => {
+          this.state.settingService.setSettings({
+            ...currentSettings,
+            isAcknowledgedUnifiedAccountMigration: false
+          });
+          resolve();
+        });
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}

package/services/migration-service/scripts/index.js

@@ -22,6 +22,7 @@ import EnableVaraChain from "./EnableVaraChain.js";
 import MigrateAuthUrls from "./MigrateAuthUrls.js";
 import MigrateImportedToken from "./MigrateImportedToken.js";
 import MigrateNetworkSettings from "./MigrateNetworkSettings.js";
+import MigrateNewUnifiedAccount from "./MigrateNewUnifiedAccount.js";
 import MigrateTokenDecimals from "./MigrateTokenDecimals.js";
 import MigrateTransactionHistory from "./MigrateTransactionHistory.js";
 import MigrateTransactionHistoryBridge from "./MigrateTransactionHistoryBridge.js";
@@ -61,7 +62,8 @@ export default {
   '1.3.6-01': MigrateTransactionHistoryBridge,
   '1.3.10-01': ClearMetadataDatabase,
   '1.3.26-01': DisableZeroBalanceTokens,
-  [MYTHOS_MIGRATION_KEY]: ClearMetadataForMythos
+  [MYTHOS_MIGRATION_KEY]: ClearMetadataForMythos,
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
+  '1.3.42-01': MigrateNewUnifiedAccount
 };