@subwallet/extension-base 1.3.10-0 → 1.3.12-0

package/services/swap-service/handler/simpleswap-handler.js

@@ -0,0 +1,434 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getSimpleSwapEarlyValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
+import { _getAssetDecimals, _getChainNativeTokenSlug, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
+import BigN, { BigNumber } from 'bignumber.js';
+import { getERC20TransactionObject, getEVMTransactionObject } from "../../balance-service/transfer/smart-contract.js";
+import { createTransferExtrinsic, getTransferMockTxFee } from "../../balance-service/transfer/token.js";
+import { calculateSwapRate, SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING, SWAP_QUOTE_TIMEOUT_MAP } from "../utils.js";
+import { SwapBaseHandler } from "./base-handler.js";
+const apiUrl = 'https://api.simpleswap.io';
+export const simpleSwapApiKey = process.env.SIMPLE_SWAP_API_KEY || '';
+const toBNString = (input, decimal) => {
+  const raw = new BigNumber(input);
+  return raw.shiftedBy(decimal).integerValue(BigNumber.ROUND_CEIL).toFixed();
+};
+const fetchSwapList = async params => {
+  const swapListParams = new URLSearchParams({
+    api_key: `${simpleSwapApiKey}`,
+    fixed: 'false',
+    symbol: params.fromSymbol
+  });
+  const response = await fetch(`${apiUrl}/get_pairs?${swapListParams.toString()}`, {
+    headers: {
+      accept: 'application/json'
+    }
+  });
+  return await response.json();
+};
+const fetchRanges = async params => {
+  const rangesParams = new URLSearchParams({
+    api_key: `${simpleSwapApiKey}`,
+    fixed: 'false',
+    currency_from: params.fromSymbol,
+    currency_to: params.toSymbol
+  });
+  const response = await fetch(`${apiUrl}/get_ranges?${rangesParams.toString()}`, {
+    headers: {
+      accept: 'application/json'
+    }
+  });
+  return await response.json();
+};
+async function getEstimate(request, fromAsset, toAsset) {
+  const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+  const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+  const assetDecimals = _getAssetDecimals(fromAsset);
+  if (!fromSymbol || !toSymbol) {
+    throw new SwapError(SwapErrorType.ASSET_NOT_SUPPORTED);
+  }
+  const formatedAmount = formatNumber(request.fromAmount, assetDecimals, s => s);
+  const params = new URLSearchParams({
+    api_key: `${simpleSwapApiKey}`,
+    fixed: 'false',
+    currency_from: fromSymbol,
+    currency_to: toSymbol,
+    amount: formatedAmount
+  });
+  try {
+    const response = await fetch(`${apiUrl}/get_estimated?${params.toString()}`, {
+      headers: {
+        accept: 'application/json'
+      }
+    });
+    if (!response.ok) {
+      throw new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+    const resToAmount = await response.json();
+    const toAmount = toBNString(resToAmount, _getAssetDecimals(toAsset));
+    const bnToAmount = new BigN(toAmount);
+    const walletFeeRate = 4 / 1000;
+    const toAmountBeforeFee = bnToAmount.dividedBy(new BigN(1 - walletFeeRate));
+    const walletFeeAmount = toAmountBeforeFee.multipliedBy(4).dividedBy(1000).toString();
+    return {
+      toAmount,
+      walletFeeAmount
+    };
+  } catch (err) {
+    console.error('Error:', err);
+    throw new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
+  }
+}
+const createSwapRequest = async params => {
+  const fromDecimals = _getAssetDecimals(params.fromAsset);
+  const toDecimals = _getAssetDecimals(params.toAsset);
+  const formatedAmount = formatNumber(params.fromAmount, fromDecimals, s => s);
+  const requestBody = {
+    fixed: false,
+    currency_from: params.fromSymbol,
+    currency_to: params.toSymbol,
+    amount: formatedAmount,
+    // Convert to small number due to require of api
+    address_to: params.receiver,
+    extra_id_to: '',
+    user_refund_address: params.sender,
+    user_refund_extra_id: ''
+  };
+  const response = await fetch(`${apiUrl}/create_exchange?api_key=${simpleSwapApiKey}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const depositAddressResponse = await response.json();
+  return {
+    id: depositAddressResponse.id,
+    addressFrom: depositAddressResponse.address_from,
+    amountTo: toBNString(depositAddressResponse.amount_to, toDecimals)
+  };
+};
+export class SimpleSwapHandler {
+  constructor(chainService, balanceService) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: 'SimpleSwap',
+      providerSlug: SwapProviderId.SIMPLE_SWAP
+    });
+    this.providerSlug = SwapProviderId.SIMPLE_SWAP;
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = BigInt(amount);
+    if (bnAmount <= BigInt(0)) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')]);
+    }
+    let isXcmOk = false;
+    for (const [index, step] of params.process.steps.entries()) {
+      const getErrors = async () => {
+        switch (step.type) {
+          case CommonStepType.DEFAULT:
+            return Promise.resolve([]);
+          case CommonStepType.TOKEN_APPROVAL:
+            return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+          default:
+            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === CommonStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get balanceService() {
+    return this.swapBaseHandler.balanceService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  get name() {
+    return this.swapBaseHandler.name;
+  }
+  get slug() {
+    return this.swapBaseHandler.slug;
+  }
+  async getSwapQuote(request) {
+    try {
+      var _metadata$maxSwap;
+      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+      if (!fromAsset || !toAsset) {
+        return new SwapError(SwapErrorType.UNKNOWN);
+      }
+      const earlyValidation = await this.validateSwapRequest(request);
+      const metadata = earlyValidation.metadata;
+      if (earlyValidation.error) {
+        return _getSimpleSwapEarlyValidationError(earlyValidation.error, metadata);
+      }
+      const {
+        toAmount,
+        walletFeeAmount
+      } = await getEstimate(request, fromAsset, toAsset);
+      const fromAmount = request.fromAmount;
+      const rate = calculateSwapRate(request.fromAmount, toAmount, fromAsset, toAsset);
+      const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+      const fromChainNativeTokenSlug = _getChainNativeTokenSlug(fromChain);
+      const defaultFeeToken = _isNativeToken(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
+      const chainType = _isChainSubstrateCompatible(fromChain) ? ChainType.SUBSTRATE : ChainType.EVM;
+      let api;
+      if (chainType === ChainType.SUBSTRATE) {
+        api = this.chainService.getSubstrateApi(fromChain.slug);
+      } else {
+        api = this.chainService.getEvmApi(fromChain.slug);
+      }
+      const networkFeeAmount = await getTransferMockTxFee(request.address, fromChain, fromAsset, api);
+      const networkFee = {
+        tokenSlug: fromChainNativeTokenSlug,
+        amount: networkFeeAmount.toString(),
+        feeType: SwapFeeType.NETWORK_FEE
+      };
+      const walletFee = {
+        tokenSlug: toAsset.slug,
+        amount: walletFeeAmount,
+        feeType: SwapFeeType.WALLET_FEE
+      };
+      return {
+        pair: request.pair,
+        fromAmount,
+        toAmount,
+        rate,
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
+        minSwap: toBNString(metadata.minSwap.value, _getAssetDecimals(fromAsset)),
+        maxSwap: toBNString((_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value, _getAssetDecimals(fromAsset)),
+        estimatedArrivalTime: 3600,
+        isLowLiquidity: false,
+        feeInfo: {
+          feeComponent: [networkFee, walletFee],
+          defaultFeeToken,
+          feeOptions: [defaultFeeToken]
+        },
+        route: {
+          path: [fromAsset.slug, toAsset.slug]
+        }
+      };
+    } catch (e) {
+      return new SwapError(SwapErrorType.UNKNOWN);
+    }
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep]);
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async validateSwapRequest(request) {
+    try {
+      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+      if (!fromAsset || !toAsset) {
+        return {
+          error: SwapErrorType.ERROR_FETCHING_QUOTE
+        };
+      }
+      const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+      const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+      if (!fromSymbol || !toSymbol) {
+        return {
+          error: SwapErrorType.ASSET_NOT_SUPPORTED
+        };
+      }
+      try {
+        const swapList = await fetchSwapList({
+          fromSymbol
+        });
+        if (!swapList.includes(toSymbol)) {
+          return {
+            error: SwapErrorType.ASSET_NOT_SUPPORTED
+          };
+        }
+      } catch (err) {
+        console.error('Error:', err);
+      }
+      const ranges = await fetchRanges({
+        fromSymbol,
+        toSymbol
+      });
+      const {
+        max,
+        min
+      } = ranges;
+      const bnMin = toBNString(min, _getAssetDecimals(fromAsset));
+      const bnAmount = BigInt(request.fromAmount);
+      if (bnAmount < BigInt(bnMin)) {
+        return {
+          error: SwapErrorType.NOT_MEET_MIN_SWAP,
+          metadata: {
+            minSwap: {
+              value: min,
+              symbol: fromAsset.symbol
+            },
+            maxSwap: max ? {
+              value: max,
+              symbol: fromAsset.symbol
+            } : undefined,
+            chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
+          }
+        };
+      }
+      if (max && bnAmount > BigInt(toBNString(max, _getAssetDecimals(fromAsset)))) {
+        return {
+          error: SwapErrorType.SWAP_EXCEED_ALLOWANCE,
+          metadata: {
+            minSwap: {
+              value: min,
+              symbol: fromAsset.symbol
+            },
+            maxSwap: {
+              value: max,
+              symbol: fromAsset.symbol
+            },
+            chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
+          }
+        };
+      }
+      return {
+        metadata: {
+          minSwap: {
+            value: min,
+            symbol: fromAsset.symbol
+          },
+          maxSwap: max ? {
+            value: max,
+            symbol: fromAsset.symbol
+          } : undefined,
+          chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
+        }
+      };
+    } catch (e) {
+      console.error(e);
+      return {
+        error: SwapErrorType.UNKNOWN
+      };
+    }
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async handleSubmitStep(params) {
+    const {
+      address,
+      quote,
+      recipient
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const toAsset = this.chainService.getAssetBySlug(pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : ChainType.EVM;
+    const sender = _reformatAddressWithChain(address, chainInfo);
+    const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : sender, toChainInfo);
+    const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+    const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+    const {
+      fromAmount
+    } = quote;
+    const {
+      addressFrom,
+      amountTo,
+      id
+    } = await createSwapRequest({
+      fromSymbol,
+      toSymbol,
+      fromAmount,
+      fromAsset,
+      receiver,
+      sender,
+      toAsset
+    });
+
+    // Validate the amount to be swapped
+    const rate = BigN(amountTo).div(BigN(quote.toAmount)).multipliedBy(100);
+    if (rate.lt(95)) {
+      throw new SwapError(SwapErrorType.NOT_MEET_MIN_EXPECTED);
+    }
+
+    // Can modify quote.toAmount to amountTo after confirm real amount received
+
+    const txData = {
+      id: id,
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient: receiver,
+      process: params.process
+    };
+    let extrinsic;
+    if (chainType === ChainType.SUBSTRATE) {
+      const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+      const substrateApi = await chainApi.isReady;
+      const [submittableExtrinsic] = await createTransferExtrinsic({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi,
+        to: addressFrom,
+        tokenInfo: fromAsset,
+        transferAll: false,
+        value: quote.fromAmount
+      });
+      extrinsic = submittableExtrinsic;
+    } else {
+      if (_isNativeToken(fromAsset)) {
+        const [transactionConfig] = await getEVMTransactionObject(chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      } else {
+        const [transactionConfig] = await getERC20TransactionObject(_getContractAddressOfToken(fromAsset), chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      }
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? quote.fromAmount : '0',
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+}

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

@@ -2,8 +2,9 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { ServiceStatus, ServiceWithProcessInterface, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { CommonOptimalPath } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapPair, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { OptimalSwapPathParams, SwapPair, SwapProviderId, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 import { PromiseHandler } from '@subwallet/extension-base/utils';
+export declare const _isChainSupportedByProvider: (providerSlug: SwapProviderId, chain: string) => boolean;
 export declare class SwapService implements ServiceWithProcessInterface, StoppableServiceInterface {
     protected readonly state: KoniState;
     private eventService;

package/services/swap-service/index.js

@@ -13,6 +13,11 @@ import { DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/typ
 import { _SUPPORTED_SWAP_PROVIDERS, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import { createPromiseHandler } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
+import { SimpleSwapHandler } from "./handler/simpleswap-handler.js";
+export const _isChainSupportedByProvider = (providerSlug, chain) => {
+  const supportedChains = _PROVIDER_TO_SUPPORTED_PAIR_MAP[providerSlug];
+  return supportedChains ? supportedChains.includes(chain) : false;
+};
 export class SwapService {
   swapPairSubject = new BehaviorSubject([]);
   handlers = {};
@@ -29,7 +34,7 @@ export class SwapService {
     const swappingSrcChain = this.chainService.getAssetBySlug(request.pair.from).originChain;
     await Promise.all(Object.values(this.handlers).map(async handler => {
       // temporary solution to reduce number of requests to providers, will work as long as there's only 1 provider for 1 chain
-      if (!_PROVIDER_TO_SUPPORTED_PAIR_MAP[handler.providerSlug].includes(swappingSrcChain)) {
+      if (!_isChainSupportedByProvider(handler.providerSlug, swappingSrcChain)) {
         return;
       }
       if (handler.init && handler.isReady === false) {
@@ -116,7 +121,10 @@ export class SwapService {
       quoteError = (preferredErrorResp === null || preferredErrorResp === void 0 ? void 0 : preferredErrorResp.error) || (defaultErrorResp === null || defaultErrorResp === void 0 ? void 0 : defaultErrorResp.error);
     } else {
       var _selectedQuote;
-      selectedQuote = availableQuotes[0];
+      selectedQuote = availableQuotes.find(quote => {
+        var _request$currentQuote;
+        return quote.provider.id === ((_request$currentQuote = request.currentQuote) === null || _request$currentQuote === void 0 ? void 0 : _request$currentQuote.id);
+      }) || availableQuotes[0];
       aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + SWAP_QUOTE_TIMEOUT_MAP.default;
     }
     return {
@@ -150,6 +158,9 @@ export class SwapService {
         case SwapProviderId.ROCOCO_ASSET_HUB:
           this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'rococo_assethub');
           break;
+        case SwapProviderId.SIMPLE_SWAP:
+          this.handlers[providerId] = new SimpleSwapHandler(this.chainService, this.state.balanceService);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

package/services/swap-service/utils.d.ts

@@ -3,10 +3,12 @@ import { _ChainAsset } from '@subwallet/chain-list/types';
 import { SwapPair } from '@subwallet/extension-base/types/swap';
 export declare const CHAIN_FLIP_TESTNET_EXPLORER = "https://blocks-perseverance.chainflip.io";
 export declare const CHAIN_FLIP_MAINNET_EXPLORER = "https://scan.chainflip.io";
+export declare const SIMPLE_SWAP_EXPLORER = "https://simpleswap.io";
 export declare const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING: Record<string, Chain>;
 export declare const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING: Record<string, Chain>;
 export declare const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING: Record<string, Asset>;
 export declare const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string, Asset>;
+export declare const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING: Record<string, string>;
 export declare const SWAP_QUOTE_TIMEOUT_MAP: Record<string, number>;
 export declare const _PROVIDER_TO_SUPPORTED_PAIR_MAP: Record<string, string[]>;
 export declare function getSwapAlternativeAsset(swapPair: SwapPair): string | undefined;

package/services/swap-service/utils.js

@@ -9,6 +9,7 @@ import { SwapProviderId } from '@subwallet/extension-base/types/swap';
 import BigN from 'bignumber.js';
 export const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
 export const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
+export const SIMPLE_SWAP_EXPLORER = 'https://simpleswap.io';
 export const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
   [COMMON_CHAIN_SLUGS.POLKADOT]: Chains.Polkadot,
   [COMMON_CHAIN_SLUGS.ETHEREUM]: Chains.Ethereum,
@@ -29,6 +30,13 @@ export const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
   [COMMON_ASSETS.ETH_SEPOLIA]: Assets.ETH,
   [COMMON_ASSETS.USDC_SEPOLIA]: Assets.USDC
 };
+export const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = {
+  'bittensor-NATIVE-TAO': 'tao',
+  [COMMON_ASSETS.ETH]: 'eth',
+  [COMMON_ASSETS.DOT]: 'dot',
+  [COMMON_ASSETS.USDC_ETHEREUM]: 'usdc',
+  [COMMON_ASSETS.USDT_ETHEREUM]: 'usdterc20'
+};
 export const SWAP_QUOTE_TIMEOUT_MAP = {
   // in milliseconds
   default: 30000,
@@ -42,7 +50,8 @@ export const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [SwapProviderId.CHAIN_FLIP_TESTNET]: [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
   [SwapProviderId.POLKADOT_ASSET_HUB]: [COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
   [SwapProviderId.KUSAMA_ASSET_HUB]: [COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
-  [SwapProviderId.ROCOCO_ASSET_HUB]: [COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB]
+  [SwapProviderId.ROCOCO_ASSET_HUB]: [COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
+  [SwapProviderId.SIMPLE_SWAP]: ['bittensor', COMMON_CHAIN_SLUGS.ETHEREUM, COMMON_CHAIN_SLUGS.POLKADOT]
 };
 export function getSwapAlternativeAsset(swapPair) {
   var _swapPair$metadata;

package/services/transaction-service/index.js

@@ -15,7 +15,7 @@ import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction, isTon
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
 import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
-import { _isRuntimeUpdated, anyNumberToBN, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
+import { anyNumberToBN, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { BN_ZERO } from '@subwallet/extension-base/utils/number';
@@ -1047,7 +1047,7 @@ export default class TransactionService {
     }
     return emitter;
   }
-  async signAndSendSubstrateTransaction({
+  signAndSendSubstrateTransaction({
     address,
     chain,
     id,
@@ -1062,8 +1062,9 @@ export default class TransactionService {
       extrinsicHash: id
     };
     const extrinsic = transaction;
-    const registry = extrinsic.registry;
-    const signedExtensions = registry.signedExtensions;
+    // const registry = extrinsic.registry;
+    // const signedExtensions = registry.signedExtensions;
+
     const signerOption = {
       signer: {
         signPayload: async payload => {
@@ -1080,13 +1081,16 @@ export default class TransactionService {
       },
       withSignedTransaction: true
     };
-    if (_isRuntimeUpdated(signedExtensions)) {
-      const metadataHash = await this.state.chainService.calculateMetadataHash(chain);
-      if (metadataHash) {
-        signerOption.mode = 1;
-        signerOption.metadataHash = metadataHash;
-      }
-    }
+
+    // if (_isRuntimeUpdated(signedExtensions)) {
+    //   const metadataHash = await this.state.chainService.calculateMetadataHash(chain);
+    //
+    //   if (metadataHash) {
+    //     signerOption.mode = 1;
+    //     signerOption.metadataHash = metadataHash;
+    //   }
+    // }
+
     extrinsic.signAsync(address, signerOption).then(async rs => {
       // Emit signed event
       emitter.emit('signed', eventData);

package/services/transaction-service/utils.d.ts

@@ -1,6 +1,7 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { ExtrinsicDataTypeMap, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { ChainflipSwapTxData } from '@subwallet/extension-base/types/swap';
+import { ChainflipSwapTxData, SimpleSwapTxData } from '@subwallet/extension-base/types/swap';
 export declare function parseTransactionData<T extends ExtrinsicType>(data: unknown): ExtrinsicDataTypeMap[T];
 export declare function getExplorerLink(chainInfo: _ChainInfo, value: string, type: 'account' | 'tx'): string | undefined;
 export declare function getChainflipExplorerLink(data: ChainflipSwapTxData, chainInfo: _ChainInfo): string;
+export declare function getSimpleSwapExplorerLink(data: SimpleSwapTxData): string;

package/services/transaction-service/utils.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { _getBlockExplorerFromChain, _isChainTestNet, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
-import { CHAIN_FLIP_MAINNET_EXPLORER, CHAIN_FLIP_TESTNET_EXPLORER } from '@subwallet/extension-base/services/swap-service/utils';
+import { CHAIN_FLIP_MAINNET_EXPLORER, CHAIN_FLIP_TESTNET_EXPLORER, SIMPLE_SWAP_EXPLORER } from '@subwallet/extension-base/services/swap-service/utils';
 // @ts-ignore
 export function parseTransactionData(data) {
   // @ts-ignore
@@ -31,6 +31,9 @@ function getBlockExplorerAccountRoute(explorerLink) {
   if (explorerLink.includes('tangle.statescan.io')) {
     return '#/accounts';
   }
+  if (explorerLink.includes('laos.statescan.io')) {
+    return '#/accounts';
+  }
   if (explorerLink.includes('explorer.zkverify.io')) {
     return 'account';
   }
@@ -46,7 +49,7 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
-  if (['invarch'].includes(chainInfo.slug)) {
+  if (['invarch', 'tangle'].includes(chainInfo.slug)) {
     return '#/extrinsics';
   }
   return 'extrinsic';
@@ -62,6 +65,9 @@ export function getExplorerLink(chainInfo, value, type) {
       return undefined;
     }
     const route = getBlockExplorerTxRoute(chainInfo);
+    if (chainInfo.slug === 'tangle') {
+      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${value}${route}/${value}`;
+    }
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   return undefined;
@@ -69,4 +75,8 @@ export function getExplorerLink(chainInfo, value, type) {
 export function getChainflipExplorerLink(data, chainInfo) {
   const chainflipDomain = _isChainTestNet(chainInfo) ? CHAIN_FLIP_TESTNET_EXPLORER : CHAIN_FLIP_MAINNET_EXPLORER;
   return `${chainflipDomain}/channels/${data.depositChannelId}`;
+}
+export function getSimpleSwapExplorerLink(data) {
+  const simpleswapDomain = SIMPLE_SWAP_EXPLORER;
+  return `${simpleswapDomain}/exchange?id=${data.id}`;
 }

package/types/account/info/keyring.d.ts

@@ -52,6 +52,8 @@ export interface AccountLedgerData {
     originGenesisHash?: string | null;
     /** Ledger's availableGenesisHashes */
     availableGenesisHashes?: string[];
+    /** Is Ledger recovery chain */
+    isLedgerRecovery?: boolean;
 }
 /**
  * @interface AccountInjectData