@subwallet/extension-base 1.2.13-0 → 1.2.15-0

package/services/chain-service/index.js

@@ -18,10 +18,27 @@ import { logger as createLogger } from '@polkadot/util/logger';
 const filterChainInfoMap = (data, ignoredChains) => {
   return Object.fromEntries(Object.entries(data).filter(([slug, info]) => !info.bitcoinInfo && !ignoredChains.includes(slug)));
 };
-const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'rollux_evm'];
+const ignoredList = ['bevm', 'bevmTest', 'bevm_testnet', 'layerEdge_testnet', 'merlinEvm', 'botanixEvmTest', 'syscoin_evm', 'syscoin_evm_testnet', 'rollux_evm', 'rollux_testnet', 'boolAlpha', 'boolBeta_testnet'];
 const filterAssetInfoMap = (chainInfo, assets) => {
   return Object.fromEntries(Object.entries(assets).filter(([, info]) => chainInfo[info.originChain]));
 };
+
+// const rawAssetRefMap = (assetRefMap: Record<string, _AssetRef>) => {
+//   const result: Record<string, _AssetRef> = {};
+//
+//   Object.entries(assetRefMap).forEach(([key, assetRef]) => {
+//     const originChainInfo = ChainInfoMap[assetRef.srcChain];
+//     const destChainInfo = ChainInfoMap[assetRef.destChain];
+//     const isSnowBridgeXcm = assetRef.path === _AssetRefPath.XCM && _isSnowBridgeXcm(originChainInfo, destChainInfo);
+//
+//     if (!isSnowBridgeXcm) {
+//       result[key] = assetRef;
+//     }
+//   });
+//
+//   return result;
+// };
+
 export class ChainService {
   dataMap = {
     chainInfoMap: {},
@@ -444,10 +461,6 @@ export class ChainService {
 
     // TODO: reconsider the flow of initiation
     this.multiChainAssetMapSubject.next(MultiChainAssetMap);
-    // const storedAssetRefMap = await this.dbService.getAssetRefMap();
-    //
-    // this.dataMap.assetRefMap = storedAssetRefMap && Object.values(storedAssetRefMap).length > 0 ? storedAssetRefMap : AssetRefMap;
-
     await this.initChains();
     this.chainInfoMapSubject.next(this.getChainInfoMap());
     this.assetRegistrySubject.next(this.getAssetRegistry());
@@ -642,6 +655,34 @@ export class ChainService {
     }
     const onUpdateStatus = status => {
       const slug = chainInfo.slug;
+      const isActive = this.getChainStateByKey(slug).active;
+      const isConnectProblem = status !== _ChainConnectionStatus.CONNECTING && status !== _ChainConnectionStatus.CONNECTED;
+      const isLightRpc = endpoint.startsWith('light');
+      if (isActive && isConnectProblem && !isLightRpc) {
+        const reportApiUrl = 'https://api-cache.subwallet.app/api/health-check/report-rpc';
+        const requestBody = {
+          chainSlug: slug,
+          chainStatus: status,
+          rpcReport: {
+            [providerName]: endpoint
+          },
+          configStatus: {
+            countUnstable: 10,
+            countDie: 20
+          }
+        };
+        fetch(reportApiUrl, {
+          // can get status from this response
+          method: 'POST',
+          headers: {
+            'X-API-KEY': '9b1c94a5e1f3a2d9f8b2a4d6e1f3a2d9',
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify(requestBody)
+        })
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        .then(() => {}).catch(error => console.error('Error connecting to the report API:', error));
+      }
       this.updateChainConnectionStatus(slug, status);
     };
     if (chainInfo.substrateInfo !== null && chainInfo.substrateInfo !== undefined) {
@@ -651,6 +692,7 @@ export class ChainService {
       //
       //   this.substrateChainHandler.setSubstrateApi(chainInfo.slug, chainApi);
       // } else {
+
       const chainApi = await this.substrateChainHandler.initApi(chainInfo.slug, endpoint, {
         providerName,
         onUpdateStatus

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

@@ -18,6 +18,11 @@ export declare enum _ChainConnectionStatus {
     UNSTABLE = "UNSTABLE",
     CONNECTING = "CONNECTING"
 }
+export interface ReportRpc {
+    runningRpc: Record<string, string>;
+    unstableRpc: Record<string, string>;
+    dieRpc: Record<string, string>;
+}
 export interface _ChainState {
     slug: string;
     active: boolean;

package/services/earning-service/handlers/liquid-staking/acala.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getTokenOnChainInfo } from '@subwallet/extension-base/services/chain-service/utils';
 import { fakeAddress } from '@subwallet/extension-base/services/earning-service/constants';
 import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
@@ -9,6 +10,9 @@ import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import BaseLiquidStakingPoolHandler from "./base.js";
 const GRAPHQL_API = 'https://api.polkawallet.io/acala-liquid-staking-subql';
 const EXCHANGE_RATE_REQUEST = 'query { dailySummaries(first:30, orderBy:TIMESTAMP_DESC) {nodes { exchangeRate timestamp }}}';
+function convertDerivativeToken(amount, exchangeRate, decimals) {
+  return amount.mul(new BN(exchangeRate)).div(BN_TEN.pow(new BN(decimals)));
+}
 export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
   altInputAsset = 'polkadot-NATIVE-DOT';
   derivativeAssets = ['acala-LOCAL-LDOT'];
@@ -22,8 +26,7 @@ export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPool
     defaultUnstake: true,
     fastUnstake: true,
     cancelUnstake: false,
-    withdraw: false,
-    // TODO: Change after verify unstake info
+    withdraw: true,
     claimReward: false
   };
   constructor(state, chain) {
@@ -111,30 +114,55 @@ export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPool
         return;
       }
       const balances = _balances;
-      const redeemRequests = await substrateApi.api.query.homa.redeemRequests.multi(useAddresses);
-      // This rate is multiple with decimals
-      const exchangeRate = await this.getExchangeRate();
-      const decimals = BN_TEN.pow(new BN(this.rateDecimals));
+      const [redeemRequests, exchangeRate, _currentEra] = await Promise.all([substrateApi.api.query.homa.redeemRequests.multi(useAddresses), this.getExchangeRate(), substrateApi.api.query.homa.relayChainCurrentEra()]);
+      const currentEra = _currentEra.toPrimitive();
       for (let i = 0; i < balances.length; i++) {
         const balanceItem = balances[i];
         const address = useAddresses[i];
         const activeTotalBalance = balanceItem.free || BN_ZERO;
-        let totalBalance = activeTotalBalance.mul(new BN(exchangeRate)).div(decimals);
+        let totalBalance = convertDerivativeToken(activeTotalBalance, exchangeRate, this.rateDecimals);
         let unlockingBalance = BN_ZERO;
         const unstakings = [];
+
+        // Handle redeem request
         const redeemRequest = redeemRequests[i].toPrimitive();
         if (redeemRequest) {
-          // If withdrawable = false, redeem request is claimed
-          const [redeemAmount, withdrawable] = redeemRequest;
-
-          // Redeem amount in derivative token
-          const amount = new BN(redeemAmount).mul(new BN(exchangeRate)).div(decimals);
-          totalBalance = totalBalance.add(amount);
-          unlockingBalance = unlockingBalance.add(amount);
+          const [derivativeRedeemAmount, _] = redeemRequest;
+          const redeemAmount = convertDerivativeToken(new BN(derivativeRedeemAmount), exchangeRate, this.rateDecimals);
+          totalBalance = totalBalance.add(redeemAmount);
+          unlockingBalance = unlockingBalance.add(redeemAmount);
           unstakings.push({
             chain: this.chain,
-            status: withdrawable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
-            claimable: amount.toString()
+            status: UnstakingStatus.UNLOCKING,
+            claimable: redeemAmount.toString(),
+            waitingTime: 28 * _STAKING_ERA_LENGTH_MAP.polkadot // up to 29 day (in case non-fast-match
+          });
+        }
+
+        // Handle unbondings
+        const unbondings = await substrateApi.api.query.homa.unbondings.entries(address);
+        if (unbondings.length > 0) {
+          unbondings.forEach(([unbondingInfo, unbondingValue]) => {
+            // @ts-ignore
+            const _targetEra = unbondingInfo.toHuman()[1];
+            const targetEra = parseInt(_targetEra.replaceAll(',', ''));
+            const amount = new BN(unbondingValue.toPrimitive());
+            totalBalance = totalBalance.add(amount);
+            unlockingBalance = unlockingBalance.add(amount);
+            if (targetEra > currentEra) {
+              unstakings.push({
+                chain: this.chain,
+                status: UnstakingStatus.UNLOCKING,
+                claimable: amount.toString(),
+                waitingTime: (targetEra - currentEra) * _STAKING_ERA_LENGTH_MAP.polkadot // Todo: Handle exact timestamp?
+              });
+            } else {
+              unstakings.push({
+                chain: this.chain,
+                status: UnstakingStatus.CLAIMABLE,
+                claimable: amount.toString()
+              });
+            }
           });
         }
         const result = {
@@ -225,7 +253,8 @@ export default class AcalaLiquidStakingPoolHandler extends BaseLiquidStakingPool
   }
   async handleYieldUnstake(amount, address, selectedTarget) {
     const chainApi = await this.substrateApi.isReady;
-    const extrinsic = chainApi.api.tx.homa.requestRedeem(amount, false);
+    const extrinsic = chainApi.api.tx.homa.requestRedeem(amount, true); // set true to allow fast match
+
     return [ExtrinsicType.UNSTAKE_LDOT, extrinsic];
   }
   async handleYieldWithdraw(address, unstakingInfo) {

package/services/migration-service/scripts/databases/ReloadMetadata.d.ts

@@ -0,0 +1,5 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class ReloadMetadata extends BaseMigrationJob {
+    protected chains: string[];
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/databases/ReloadMetadata.js

@@ -0,0 +1,27 @@
+// 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 ReloadMetadata extends BaseMigrationJob {
+  chains = ['goldberg_testnet'];
+  async run() {
+    const activeChains = this.state.chainService.getActiveChains();
+    for (const chain of this.chains) {
+      const item = await this.state.dbService.stores.metadata.getMetadata(chain);
+      if (item) {
+        // @ts-ignore
+        await this.state.dbService.stores.metadata.remove(item.genesisHash);
+        const isActive = activeChains.includes(chain);
+        if (isActive) {
+          this.state.chainService.disableChain(chain);
+          setTimeout(() => {
+            this.state.chainService.enableChain(chain).catch(console.error);
+          }, 500);
+        }
+      }
+    }
+    // Clear all old metadata data
+
+    return Promise.resolve();
+  }
+}

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

@@ -2,9 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import AutoEnableSomeTokens from '@subwallet/extension-base/services/migration-service/scripts/databases/AutoEnableSomeTokens';
+import ReloadMetadata from '@subwallet/extension-base/services/migration-service/scripts/databases/ReloadMetadata';
 import DeleteEarningData from '@subwallet/extension-base/services/migration-service/scripts/DeleteEarningData';
 import MigrateRemoveGenesisHash from '@subwallet/extension-base/services/migration-service/scripts/MigrateRemoveGenesisHash';
 import MigrateTransactionHistoryBySymbol from '@subwallet/extension-base/services/migration-service/scripts/MigrateTransactionHistoryBySymbol';
+import ClearMetadataDatabase from "./databases/ClearMetadataDatabase.js";
 import MigrateAssetSetting from "./databases/MigrateAssetSetting.js";
 import MigrateEarningVersion from "./databases/MigrateEarningVersion.js";
 import MigrateEthProvider from "./providers/MigrateEthProvider.js";
@@ -12,7 +14,6 @@ import MigratePioneerProvider from "./providers/MigratePioneerProvider.js";
 import MigrateProvidersV1M1P24 from "./providers/MigrateProvidersV1M1P24.js";
 import MigratePolygonUSDCProvider from "./tokens/MigratePolygonUSDCProvider.js";
 import AutoEnableChainsTokens from "./AutoEnableChainsTokens.js";
-import ClearMetadataDatabase from "./ClearMetadataDatabase.js";
 import DeleteChain from "./DeleteChain.js";
 import DeleteChainStaking from "./DeleteChainStaking.js";
 import EnableVaraChain from "./EnableVaraChain.js";
@@ -55,7 +56,8 @@ export default {
   '1.1.69-03': MigrateAssetSetting,
   '1.1.69-02': MigrateTransactionHistoryBySymbol,
   '1.2.69-01': MigrateRemoveGenesisHash,
-  '1.2.1-01': ClearMetadataDatabase
+  '1.2.1-01': ClearMetadataDatabase,
+  '1.2.13-01': ReloadMetadata
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

package/services/price-service/coingecko.js

@@ -2,12 +2,22 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { staticData, StaticKey } from '@subwallet/extension-base/utils/staticData';
+import { isArray } from '@polkadot/util';
 const DEFAULT_CURRENCY = 'USD';
 let useBackupApi = false;
 export const getExchangeRateMap = async () => {
+  let response;
   try {
-    const response = await fetch('https://api-cache.subwallet.app/exchange-rate');
-    const responseDataExchangeRate = (await response.json()) || {};
+    var _response, _response2;
+    try {
+      response = await fetch('https://api-cache.subwallet.app/exchange-rate');
+    } catch (e) {}
+    if (((_response = response) === null || _response === void 0 ? void 0 : _response.status) !== 200) {
+      try {
+        response = await fetch('https://static-cache.subwallet.app/exchange-rate/data.json');
+      } catch (e) {}
+    }
+    const responseDataExchangeRate = (await ((_response2 = response) === null || _response2 === void 0 ? void 0 : _response2.json())) || {};
     const exchangeRateMap = Object.keys(responseDataExchangeRate.conversion_rates).reduce((map, exchangeKey) => {
       if (!staticData[StaticKey.CURRENCY_SYMBOL][exchangeKey]) {
         return map;
@@ -20,42 +30,54 @@ export const getExchangeRateMap = async () => {
     }, {});
     return exchangeRateMap;
   } catch (e) {
-    console.warn('Failed to get exchange rate');
     return {};
   }
 };
 export const getPriceMap = async (priceIds, currency = 'USD') => {
-  var _rs, _rs2;
   const idStr = Array.from(priceIds).join(',');
-  let rs;
-  if (!useBackupApi) {
-    try {
-      rs = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency.toLowerCase()}&per_page=250&ids=${idStr}`);
-    } catch (err) {
+  let response;
+  try {
+    var _response3, _response5;
+    if (!useBackupApi) {
+      try {
+        response = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency.toLowerCase()}&per_page=250&ids=${idStr}`);
+      } catch (err) {
+        useBackupApi = true;
+      }
+    }
+    if (useBackupApi || ((_response3 = response) === null || _response3 === void 0 ? void 0 : _response3.status) !== 200) {
+      var _response4;
       useBackupApi = true;
+      try {
+        response = await fetch(`https://api-cache.subwallet.app/api/price/get?ids=${idStr}`);
+      } catch (e) {}
+      if (((_response4 = response) === null || _response4 === void 0 ? void 0 : _response4.status) !== 200) {
+        try {
+          response = await fetch('https://static-cache.subwallet.app/price/data.json');
+        } catch (e) {}
+      }
     }
+    const generateDataPriceRaw = (await ((_response5 = response) === null || _response5 === void 0 ? void 0 : _response5.json())) || [];
+    const responseDataPrice = isArray(generateDataPriceRaw) ? generateDataPriceRaw : Object.entries(generateDataPriceRaw).map(([id, value]) => ({
+      ...value,
+      id
+    }));
+    const currencyData = staticData[StaticKey.CURRENCY_SYMBOL][currency || DEFAULT_CURRENCY];
+    const priceMap = {};
+    const price24hMap = {};
+    responseDataPrice.forEach(val => {
+      const currentPrice = val.current_price || 0;
+      const price24h = currentPrice - (val.price_change_24h || 0);
+      priceMap[val.id] = currentPrice;
+      price24hMap[val.id] = price24h;
+    });
+    return {
+      currency,
+      currencyData,
+      priceMap,
+      price24hMap
+    };
+  } catch (e) {
+    return {};
   }
-  if (useBackupApi || ((_rs = rs) === null || _rs === void 0 ? void 0 : _rs.status) !== 200) {
-    useBackupApi = true;
-    rs = await fetch(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
-  }
-  if (((_rs2 = rs) === null || _rs2 === void 0 ? void 0 : _rs2.status) !== 200) {
-    console.warn('Failed to get token price');
-  }
-  const responseDataPrice = (await rs.json()) || [];
-  const currencyData = staticData[StaticKey.CURRENCY_SYMBOL][currency || DEFAULT_CURRENCY];
-  const priceMap = {};
-  const price24hMap = {};
-  responseDataPrice.forEach(val => {
-    const currentPrice = val.current_price || 0;
-    const price24h = currentPrice - (val.price_change_24h || 0);
-    priceMap[val.id] = currentPrice;
-    price24hMap[val.id] = price24h;
-  });
-  return {
-    currency,
-    currencyData,
-    priceMap,
-    price24hMap
-  };
 };

package/services/price-service/index.js

@@ -6,9 +6,10 @@ import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { getExchangeRateMap, getPriceMap } from '@subwallet/extension-base/services/price-service/coingecko';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { CurrentCurrencyStore } from '@subwallet/extension-base/stores';
+import { wait } from '@subwallet/extension-base/utils';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { staticData, StaticKey } from '@subwallet/extension-base/utils/staticData';
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, combineLatest } from 'rxjs';
 const DEFAULT_CURRENCY = 'USD';
 const DEFAULT_PRICE_SUBJECT = {
   currency: DEFAULT_CURRENCY,
@@ -22,6 +23,9 @@ const DEFAULT_PRICE_SUBJECT = {
   price24hMap: {},
   exchangeRateMap: {}
 };
+const checkFetchSuccess = (obj1, obj2) => {
+  return Object.keys(obj1).length > 0 && Object.keys(obj2).length > 0;
+};
 export class PriceService {
   priceIds = new Set();
   currency = new CurrentCurrencyStore();
@@ -43,10 +47,15 @@ export class PriceService {
     this.init().then(() => this.getCurrentCurrency(updateCurrency)).catch(console.error);
   }
   async getTokenPrice(priceIds, currency, resolve, reject) {
-    await Promise.all([getExchangeRateMap(), getPriceMap(priceIds, currency)]).then(([exchangeRateMap, priceMap]) => {
-      this.rawExchangeRateMap.next(exchangeRateMap);
-      this.rawPriceSubject.next(priceMap);
-    });
+    const getPriceData = async () => {
+      await Promise.all([getExchangeRateMap(), getPriceMap(priceIds, currency)]).then(([exchangeRateMap, priceMap]) => {
+        if (checkFetchSuccess(priceMap, exchangeRateMap)) {
+          this.rawExchangeRateMap.next(exchangeRateMap);
+          this.rawPriceSubject.next(priceMap);
+        }
+      });
+    };
+    await Promise.race([getPriceData(), wait(10 * 1000)]);
   }
   getCurrentCurrencySubject() {
     return this.currency.getSubject();
@@ -82,17 +91,27 @@ export class PriceService {
     })();
   }
   async calculatePriceMap(currency) {
-    const {
+    let {
       price24hMap,
       priceMap
     } = this.rawPriceSubject.value;
-    const exchangeRateData = this.rawExchangeRateMap.value;
+    let exchangeRateData = this.rawExchangeRateMap.value;
+    const priceStored = await this.dbService.getPriceStore(currency);
     const currencyKey = currency || DEFAULT_CURRENCY;
     if (Object.keys(this.rawPriceSubject.value).length === 0) {
-      return;
+      if (priceStored !== null && priceStored !== void 0 && priceStored.exchangeRateMap) {
+        exchangeRateData = priceStored.exchangeRateMap;
+      }
     }
     if (Object.keys(exchangeRateData).length === 0) {
-      return;
+      if (priceStored !== null && priceStored !== void 0 && priceStored.price24hMap) {
+        price24hMap = {
+          ...priceStored.price24hMap
+        };
+        priceMap = {
+          ...priceStored.priceMap
+        };
+      }
     }
     const finalPriceMap = {
       priceMap: {
@@ -158,8 +177,7 @@ export class PriceService {
         this.refreshPriceMapByAction();
       }
     };
-    this.getCurrentCurrencySubject().subscribe(currency => {
-      console.log('Currency changed', currency);
+    combineLatest([this.getCurrentCurrencySubject(), this.rawPriceSubject, this.rawExchangeRateMap]).subscribe(([currency]) => {
       this.calculatePriceMap(currency).then(data => {
         if (data) {
           this.priceSubject.next(data);

package/services/storage-service/db-stores/BaseStore.d.ts

@@ -7,6 +7,9 @@ export default class BaseStore<T> {
     get table(): Table<T, unknown>;
     upsert(record: T): Promise<unknown>;
     bulkUpsert(records: T[]): Promise<unknown>;
+    /**
+     * @todo Must update, delete function need the key not the record
+     * */
     remove(record: T): Promise<void>;
     clear(): Promise<void>;
 }

package/services/storage-service/db-stores/BaseStore.js

@@ -16,6 +16,10 @@ export default class BaseStore {
   bulkUpsert(records) {
     return this.table.bulkPut(records);
   }
+
+  /**
+   * @todo Must update, delete function need the key not the record
+   * */
   remove(record) {
     return this.table.delete(record);
   }

package/services/swap-service/handler/asset-hub/handler.d.ts

@@ -0,0 +1,31 @@
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
+import { AssetHubSwapEarlyValidation, OptimalSwapPathParams, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { SwapBaseInterface } from '../base-handler';
+export declare class AssetHubSwapHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    private readonly chain;
+    private router;
+    isReady: boolean;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService, chain: string);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    init(): Promise<void>;
+    getXcmStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    validateSwapStep(params: ValidateSwapProcessParams, isXcmOk: boolean, stepIndex: number): Promise<TransactionError[]>;
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    validateSwapRequest(request: SwapRequest): Promise<AssetHubSwapEarlyValidation>;
+}