@subwallet/extension-base 1.3.78-0 → 1.3.80-0

package/services/nft-service/nft-handlers/evm/evm-nft-handler.js

@@ -0,0 +1,171 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { _AssetType } from '@subwallet/chain-list/types';
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
+import { baseParseIPFSUrl, getAddressesByChainType } from '@subwallet/extension-base/utils';
+import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
+import { BaseNftHandler } from "../base-nft-handler.js";
+export class EvmNftHandler extends BaseNftHandler {
+  filterAddresses(addresses) {
+    return getAddressesByChainType(addresses, [ChainType.EVM]);
+  }
+  mapSdkToNftItem(rawInstance, collectionId, owner) {
+    var _rawInstance$token_ty, _rawInstance$id;
+    const metadata = rawInstance.metadata || {};
+    const image = metadata.image || rawInstance.image_url || rawInstance.media_url || '';
+    const attributes = Array.isArray(metadata.attributes) ? metadata.attributes : [];
+    let rarity;
+    const properties = {};
+    for (const attr of attributes) {
+      try {
+        var _attr$trait_type;
+        const key = (_attr$trait_type = attr.trait_type) === null || _attr$trait_type === void 0 ? void 0 : _attr$trait_type.trim();
+        if (!key) {
+          continue;
+        }
+        let value = attr.value;
+        if (typeof value === 'string') {
+          const lower = value.toLowerCase();
+          if (lower === 'true') {
+            value = true;
+          }
+          if (lower === 'false') {
+            value = false;
+          }
+        }
+        properties[key] = value;
+        if (key.toLowerCase() === 'rarity') {
+          rarity = String(value);
+        }
+      } catch {
+        // ignore
+      }
+    }
+    const normalizedType = (_rawInstance$token_ty = rawInstance.token_type) === null || _rawInstance$token_ty === void 0 ? void 0 : _rawInstance$token_ty.replace('-', '').toUpperCase();
+    if (!['ERC721'].includes(normalizedType)) {
+      return null;
+    }
+    return {
+      id: ((_rawInstance$id = rawInstance.id) === null || _rawInstance$id === void 0 ? void 0 : _rawInstance$id.toString()) || '',
+      chain: this.chain,
+      collectionId,
+      owner: rawInstance.owner || owner,
+      name: metadata.name || `#${rawInstance.id}`,
+      image: baseParseIPFSUrl(image),
+      externalUrl: rawInstance.external_app_url || undefined,
+      rarity,
+      description: metadata.description || undefined,
+      properties: Object.keys(properties).length > 0 ? properties : null,
+      type: normalizedType === 'ERC721' ? _AssetType.ERC721 : _AssetType.ERC721,
+      originAsset: undefined,
+      rmrk_ver: undefined,
+      onChainOption: undefined,
+      assetHubType: undefined
+    };
+  }
+  mapSdkToCollection(raw) {
+    var _raw$token_instances;
+    const token = raw.token || {};
+    return {
+      collectionId: token.address_hash,
+      chain: this.chain,
+      collectionName: token.name || token.symbol || 'Unknown Collection',
+      image: token.icon_url || undefined,
+      itemCount: Number(raw.amount) || ((_raw$token_instances = raw.token_instances) === null || _raw$token_instances === void 0 ? void 0 : _raw$token_instances.length) || 0,
+      externalUrl: undefined,
+      originAsset: undefined
+    };
+  }
+
+  // ==================== 1. PREVIEW – Used for cron / background ====================
+  async fetchPreview(addresses) {
+    const items = [];
+    const collections = [];
+    const api = subwalletApiSdk.nftDetectionApi;
+    if (!(api !== null && api !== void 0 && api.getEvmNftCollectionsByAddress)) {
+      console.warn('[EvmNftHandler] Preview API not available');
+      return {
+        items,
+        collections
+      };
+    }
+    for (const address of addresses) {
+      try {
+        const rawData = await api.getEvmNftCollectionsByAddress(address);
+        for (const [chain, sdkCollections] of Object.entries(rawData)) {
+          if (chain !== this.chain || !Array.isArray(sdkCollections)) {
+            continue;
+          }
+          for (const col of sdkCollections) {
+            const collection = this.mapSdkToCollection(col);
+            collections.push(collection);
+            if (Array.isArray(col.token_instances)) {
+              const mapped = col.token_instances.map(inst => this.mapSdkToNftItem(inst, collection.collectionId, address)).filter(i => i !== null);
+              items.push(...mapped);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`[EvmNftHandler] Preview failed for ${address}`, error);
+      }
+    }
+    return {
+      items: items,
+      collections: collections
+    };
+  }
+
+  // ==================== 2. FULL – At collection details screen ====================
+  async fetchFullListNftOfACollection(request) {
+    const items = [];
+    const collections = [];
+    const {
+      chainInfo,
+      collectionId,
+      owners
+    } = request;
+    const chainId = _getEvmChainId(chainInfo);
+    if (!collectionId || !owners || !chainId) {
+      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+      return {
+        items,
+        collections
+      };
+    }
+    try {
+      const nftDetectionApi = subwalletApiSdk.nftDetectionApi;
+      if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getAllNftInstances)) {
+        console.warn('[NftService] getAllNftInstances not available');
+        return {
+          items,
+          collections
+        };
+      }
+      const ownerList = Array.isArray(owners) ? owners : [owners];
+      for (const eachOwner of ownerList) {
+        try {
+          const instances = await nftDetectionApi.getAllNftInstances(collectionId, eachOwner, chainId.toString());
+          if (!Array.isArray(instances)) {
+            continue;
+          }
+          const mappedItems = instances.map(inst => this.mapSdkToNftItem(inst, collectionId, eachOwner)).filter(i => Boolean(i));
+          items.push(...mappedItems);
+        } catch (innerErr) {
+          console.warn(`[NftService] getAllNftInstances failed for ${eachOwner}`, innerErr);
+        }
+      }
+    } catch (err) {
+      console.error(`[NftDetectionService] getFullNftInstancesByCollection error for ${collectionId}`, err);
+      return {
+        items: [],
+        collections: []
+      };
+    }
+    return {
+      items: items,
+      collections: collections
+    };
+  }
+}

package/services/nft-service/nft-handlers/registry.d.ts

@@ -0,0 +1,11 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { BaseNftHandler } from '@subwallet/extension-base/services/nft-service/nft-handlers/base-nft-handler';
+export interface NftHandlerDescriptor {
+    id: string;
+    supports(chainInfo: _ChainInfo): boolean;
+    supportsFetchFullNftList: boolean;
+    create(chainSlug: string, state: KoniState): BaseNftHandler;
+}
+export declare function isNftV2Chain(chainInfo: _ChainInfo, registry: NftHandlerDescriptor[]): boolean;
+export declare const NFT_HANDLER_REGISTRY: NftHandlerDescriptor[];

package/services/nft-service/nft-handlers/registry.js

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { NFT_CHAIN_GROUPS_MIGRATED } from '@subwallet/extension-base/services/chain-service/constants';
+import { _isChainSupportEvmNft } from '@subwallet/extension-base/services/chain-service/utils';
+import { EvmNftHandler } from '@subwallet/extension-base/services/nft-service/nft-handlers/evm/evm-nft-handler';
+import { UniqueNftHandler } from '@subwallet/extension-base/services/nft-service/nft-handlers/unique/unique-nft-handler';
+export function isNftV2Chain(chainInfo, registry) {
+  return registry.some(desc => desc.supports(chainInfo));
+}
+
+// todo list: only update into when migration
+export const NFT_HANDLER_REGISTRY = [{
+  id: 'evm',
+  supports: chainInfo => _isChainSupportEvmNft(chainInfo),
+  supportsFetchFullNftList: true,
+  create: chain => new EvmNftHandler(chain)
+}, {
+  id: 'unique_network',
+  supports: chainInfo => NFT_CHAIN_GROUPS_MIGRATED.unique_network.includes(chainInfo.slug),
+  supportsFetchFullNftList: false,
+  create: chain => new UniqueNftHandler(chain)
+}
+// {
+//   id: 'ordinal',
+//   supports: (chainInfo) => _isSupportOrdinal(chainInfo.slug),
+//   create: (chain, state) => new OrdinalNftHandler(chain, state)
+// }
+];

package/services/nft-service/nft-handlers/unique/unique-nft-handler.d.ts

@@ -0,0 +1,12 @@
+import { NftDetailRequest, NftFullListRequest, NftItem } from '@subwallet/extension-base/background/KoniTypes';
+import { BaseNftHandler, NftHandlerResult } from '../base-nft-handler';
+export declare class UniqueNftHandler extends BaseNftHandler {
+    filterAddresses(addresses: string[]): string[];
+    private mapUniqueCollections;
+    private mapUniqueRootNftToItem;
+    private mapBundleTreeToNftItem;
+    fetchNftBundle(collectionId: number | string, tokenId: string, topmostOwner: string): Promise<NftItem | null>;
+    fetchPreview(addresses: string[]): Promise<NftHandlerResult>;
+    fetchFullListNftOfACollection(request: NftFullListRequest): Promise<NftHandlerResult>;
+    fetchNftDetail(request: NftDetailRequest): Promise<NftHandlerResult>;
+}

package/services/nft-service/nft-handlers/unique/unique-nft-handler.js

@@ -0,0 +1,177 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainType } from '@subwallet/extension-base/background/KoniTypes';
+import { getAddressesByChainType } from '@subwallet/extension-base/utils';
+import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
+import { BaseNftHandler } from "../base-nft-handler.js";
+export class UniqueNftHandler extends BaseNftHandler {
+  filterAddresses(addresses) {
+    return getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
+  }
+  mapUniqueCollections(raws) {
+    var _raws$collectionCover;
+    return {
+      collectionId: raws.collectionId.toString(),
+      chain: this.chain,
+      collectionName: raws.collectionName || 'Unknown Collection',
+      image: ((_raws$collectionCover = raws.collectionCover) === null || _raws$collectionCover === void 0 ? void 0 : _raws$collectionCover.url) || undefined,
+      externalUrl: undefined,
+      originAsset: undefined
+    };
+  }
+  mapUniqueRootNftToItem(raw, owner) {
+    return {
+      id: raw.tokenId.toString(),
+      chain: this.chain,
+      collectionId: raw.collectionId.toString(),
+      name: raw.name || `#${raw.tokenId}`,
+      image: raw.image || undefined,
+      description: raw.description || undefined,
+      owner: owner,
+      isBundle: false,
+      properties: null
+    };
+  }
+  mapBundleTreeToNftItem(node, topmostOwner, level = 0, parentId) {
+    const item = {
+      id: node.tokenId.toString(),
+      chain: this.chain,
+      collectionId: node.collectionId.toString(),
+      name: node.name || `#${node.tokenId}`,
+      image: node.image || undefined,
+      description: node.description || undefined,
+      owner: topmostOwner,
+      isBundle: node.nested && node.nested.length > 0 && level === 0,
+      properties: null,
+      nestingLevel: level,
+      parentId: level > 0 ? parentId : undefined
+    };
+    if (node.nested && node.nested.length > 0) {
+      item.nestingTokens = node.nested.map(child => this.mapBundleTreeToNftItem(child, topmostOwner, level + 1, item.id));
+    }
+    return item;
+  }
+  async fetchNftBundle(collectionId, tokenId, topmostOwner) {
+    const api = subwalletApiSdk.uniqueNftDetectionApi;
+    if (!api) {
+      return null;
+    }
+    try {
+      const treeData = await api.getNftBundleTree(collectionId, tokenId);
+      if (!treeData) {
+        return null;
+      }
+      return this.mapBundleTreeToNftItem(treeData, topmostOwner, 0, tokenId);
+    } catch (e) {
+      console.error('[UniqueNftHandler] Failed to fetch bundle tree', e);
+      return null;
+    }
+  }
+
+  // ==================== MAIN HANDLER ====================
+
+  async fetchPreview(addresses) {
+    const items = [];
+    const collectionsMap = new Map();
+    const api = subwalletApiSdk.uniqueNftDetectionApi;
+    if (!api) {
+      return {
+        items: [],
+        collections: []
+      };
+    }
+    try {
+      await Promise.all(addresses.map(async address => {
+        // 1. Collections
+        const sdkCollections = await api.getUniqueCollectionsByTokenOwner(address);
+        for (const col of sdkCollections) {
+          const collection = this.mapUniqueCollections(col);
+          if (!collectionsMap.has(collection.collectionId)) {
+            collectionsMap.set(collection.collectionId, collection);
+          }
+        }
+
+        // 2. Root NFTs
+        const sdkNfts = await api.getAllUniqueRootNfts({
+          owner: address
+        });
+        for (const rootNft of sdkNfts) {
+          items.push(this.mapUniqueRootNftToItem(rootNft, address));
+        }
+      }));
+    } catch (e) {
+      console.error(`[UniqueNftHandler] Failed to fetch for ${this.chain}`, e);
+    }
+    return {
+      items,
+      collections: Array.from(collectionsMap.values())
+    };
+  }
+  async fetchFullListNftOfACollection(request) {
+    const items = [];
+    const collections = [];
+    const {
+      collectionId,
+      owners,
+      tokenIds
+    } = request;
+    if (!collectionId || !owners || !tokenIds) {
+      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+      return {
+        items,
+        collections
+      };
+    }
+    for (const id of tokenIds) {
+      const fullTree = await this.fetchNftBundle(collectionId, id, owners[0]);
+      if (fullTree) {
+        items.push(fullTree);
+      }
+    }
+    return {
+      items: items,
+      collections: collections
+    };
+  }
+  async fetchNftDetail(request) {
+    const items = [];
+    const collections = [];
+    const api = subwalletApiSdk.uniqueNftDetectionApi;
+    if (!api) {
+      return {
+        items: [],
+        collections: []
+      };
+    }
+    const {
+      collectionId,
+      tokenId
+    } = request;
+    if (!collectionId || !tokenId) {
+      return {
+        items,
+        collections
+      };
+    }
+    try {
+      const rawNft = await api.getNftDetail(collectionId, tokenId);
+      if (!rawNft) {
+        return {
+          items: [],
+          collections: []
+        };
+      }
+      const nftItem = this.mapUniqueRootNftToItem(rawNft, rawNft.owner);
+      return {
+        items: [nftItem],
+        collections: []
+      };
+    } catch (e) {
+      return {
+        items: [],
+        collections: []
+      };
+    }
+  }
+}

package/services/storage-service/DatabaseService.d.ts

@@ -83,7 +83,7 @@ export default class DatabaseService {
     addNft(address: string, nft: NftItem): Promise<unknown>;
     handleNftTransfer(chain: string, addresses: string[], nftItem: NftItem): import("dexie").PromiseExtended<number>;
     removeNfts(chain: string, address: string, collectionId: string, nftIds: string[]): import("dexie").PromiseExtended<number>;
-    removeNftsByAddress(address: string): import("dexie").PromiseExtended<number>;
+    removeNftsByAddress(address: string[]): import("dexie").PromiseExtended<number>;
     updateChainStore(item: IChain): Promise<unknown>;
     bulkUpdateChainStore(data: IChain[]): Promise<unknown>;
     removeFromChainStore(chains: string[]): Promise<number>;

package/services/storage-service/DatabaseService.js

@@ -393,7 +393,7 @@ export default class DatabaseService {
     return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
   }
   removeNftsByAddress(address) {
-    return this.stores.nft.removeNftsByAddress([address]);
+    return this.stores.nft.removeNftsByAddress(address);
   }
 
   // Chain

package/services/swap-service/handler/asset-hub/handler.js

@@ -64,7 +64,10 @@ export class AssetHubSwapHandler {
     const {
       path,
       request: {
-        fromAmount
+        address,
+        alternativeAddress,
+        fromAmount,
+        recipient
       },
       selectedQuote
     } = params;
@@ -86,12 +89,12 @@ export class AssetHubSwapHandler {
     const needModifyData = swapXcm || xcmSwapXcm;
     let bnSendingValue = BigN(fromAmount);
     let bnExpectedReceive = BigN(selectedQuote.toAmount);
-    const sender = _reformatAddressWithChain(params.request.address, originChain);
-    let receiver = _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain);
+    const sender = _reformatAddressWithChain(address, originChain, alternativeAddress);
+    let receiver = _reformatAddressWithChain(recipient || address, destinationChain);
     if (needModifyData) {
       bnSendingValue = bnSendingValue.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
       bnExpectedReceive = bnExpectedReceive.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
-      receiver = _reformatAddressWithChain(params.request.address, destinationChain);
+      receiver = _reformatAddressWithChain(address, destinationChain, alternativeAddress);
     }
     const submitStep = {
       name: 'Swap',

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

@@ -1,7 +1,6 @@
 import { _ChainAsset } from '@subwallet/chain-list/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { AssetHubSwapEarlyValidation, SwapPair, SwapRequest } from '@subwallet/extension-base/types/swap';
 import { SubmittableExtrinsic } from '@polkadot/api/types';
 export declare class AssetHubRouter {
     private readonly chain;
@@ -9,8 +8,5 @@ export declare class AssetHubRouter {
     constructor(chain: string, chainService: ChainService);
     get substrateApi(): _SubstrateApi;
     get nativeToken(): _ChainAsset;
-    buildPath(pair: SwapPair): Array<_ChainAsset>;
-    earlyValidateSwapValidation(request: SwapRequest): Promise<AssetHubSwapEarlyValidation>;
-    estimateAmountOut(pair: SwapPair, amountIn: string): Promise<string>;
     buildSwapExtrinsic(path: Array<_ChainAsset>, recipient: string, amountIn: string, amountOutMin: string): Promise<SubmittableExtrinsic<'promise'>>;
 }

package/services/swap-service/handler/asset-hub/router.js

@@ -1,10 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { _getTokenMinAmount } from '@subwallet/extension-base/services/chain-service/utils';
-import { buildSwapExtrinsic, checkLiquidityForPath, checkMinAmountForPath, estimatePriceImpactPct, estimateRateAfterForPath, estimateRateForPath, estimateTokensForPath, getReserveForPath } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
-import { SwapErrorType } from '@subwallet/extension-base/types/swap';
-import BigN from 'bignumber.js';
+import { buildSwapExtrinsic } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
 export class AssetHubRouter {
   constructor(chain, chainService) {
     this.chain = chain;
@@ -16,66 +13,6 @@ export class AssetHubRouter {
   get nativeToken() {
     return this.chainService.getNativeTokenInfo(this.chain);
   }
-  buildPath(pair) {
-    // const nativeToken = this.nativeToken;
-    // const nativeTokenSlug = nativeToken.slug;
-
-    const assetFrom = this.chainService.getAssetBySlug(pair.from);
-    const assetTo = this.chainService.getAssetBySlug(pair.to);
-    return [assetFrom, assetTo];
-    // if (pair.from === nativeTokenSlug || pair.to === nativeTokenSlug) {
-    //   return [assetFrom, assetTo];
-    // } else {
-    //   return [assetFrom, nativeToken, assetTo];
-    // }
-  }
-  async earlyValidateSwapValidation(request) {
-    const substrateApi = await this.substrateApi.isReady;
-    const paths = this.buildPath(request.pair);
-    const api = await substrateApi.api.isReady;
-    const amount = request.fromAmount;
-    const reserves = await getReserveForPath(api, paths);
-    const amounts = estimateTokensForPath(amount, reserves);
-    const marketRate = estimateRateForPath(reserves);
-    const marketRateAfter = estimateRateAfterForPath(amount, reserves);
-    const priceImpactPct = estimatePriceImpactPct(marketRate, marketRateAfter);
-    const errors = [];
-
-    // Check liquidity
-    const liquidityError = checkLiquidityForPath(amounts, reserves);
-    if (liquidityError) {
-      errors.push(liquidityError);
-    }
-
-    // Check amount token in pool after swap
-    const minAmounts = paths.map(asset => _getTokenMinAmount(asset));
-    const minAmountAfterSwapError = checkMinAmountForPath(reserves, amounts, minAmounts);
-    if (minAmountAfterSwapError) {
-      errors.push(minAmountAfterSwapError);
-    }
-    const bnAmount = new BigN(request.fromAmount);
-    if (bnAmount.lte(0)) {
-      errors.push(SwapErrorType.AMOUNT_CANNOT_BE_ZERO);
-    }
-    const metadata = {
-      chain: this.chainService.getChainInfoByKey(this.chain),
-      toAmount: amounts[amounts.length - 1],
-      quoteRate: marketRate,
-      priceImpactPct: priceImpactPct
-    };
-    return {
-      error: errors[0],
-      metadata
-    };
-  }
-  async estimateAmountOut(pair, amountIn) {
-    const substrateApi = await this.substrateApi.isReady;
-    const paths = this.buildPath(pair);
-    const api = await substrateApi.api.isReady;
-    const reserves = await getReserveForPath(api, paths);
-    const amounts = estimateTokensForPath(amountIn, reserves);
-    return amounts[amounts.length - 1];
-  }
   async buildSwapExtrinsic(path, recipient, amountIn, amountOutMin) {
     const substrateApi = await this.substrateApi.isReady;
     const api = await substrateApi.api.isReady;

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

@@ -71,6 +71,7 @@ export class SwapBaseHandler {
       path,
       request: {
         address,
+        alternativeAddress,
         fromAmount,
         recipient
       },
@@ -94,12 +95,12 @@ export class SwapBaseHandler {
       throw Error('Token or chain not found');
     }
     let recipientAddress;
-    const senderAddress = _reformatAddressWithChain(address, fromChainInfo);
+    const senderAddress = _reformatAddressWithChain(address, fromChainInfo, alternativeAddress);
     if (stepIndex === 0) {
-      recipientAddress = _reformatAddressWithChain(address, toChainInfo);
+      recipientAddress = _reformatAddressWithChain(address, toChainInfo, alternativeAddress);
     } else {
       // bridge after swap
-      recipientAddress = _reformatAddressWithChain(recipient || address, toChainInfo);
+      recipientAddress = _reformatAddressWithChain(recipient || address, toChainInfo, alternativeAddress);
     }
     if (!_isXcmWithinSameConsensus(fromChainInfo, toChainInfo) || _isSnowBridgeXcm(fromChainInfo, toChainInfo) || _isAcrossBridgeXcm(fromChainInfo, toChainInfo)) {
       return undefined;

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

@@ -108,7 +108,11 @@ export class HydradxHandler {
     const {
       path,
       request: {
-        fromAmount
+        address,
+        alternativeAddress,
+        fromAmount,
+        recipient,
+        slippage
       },
       selectedQuote
     } = params;
@@ -127,8 +131,8 @@ export class HydradxHandler {
     const destinationTokenInfo = this.chainService.getAssetBySlug(swapPairInfo.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
-    const sender = _reformatAddressWithChain(params.request.address, originChain);
-    let receiver = _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain);
+    const sender = _reformatAddressWithChain(address, originChain, alternativeAddress);
+    let receiver = _reformatAddressWithChain(recipient || address, destinationChain);
     const actionList = JSON.stringify(path.map(step => step.action));
     const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
     const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
@@ -152,7 +156,7 @@ export class HydradxHandler {
             slug: swapPairInfo.slug
           },
           fromAmount: bnSendingValue.toFixed(0, 1),
-          slippage: params.request.slippage
+          slippage: slippage
         });
       } catch (error) {
         throw new Error(`Failed to fetch swap quote: ${error.message}`);
@@ -163,7 +167,7 @@ export class HydradxHandler {
       }
       const overrideQuote = quoteAskResponse.quote;
       txHex = overrideQuote.metadata;
-      receiver = _reformatAddressWithChain(params.request.address, destinationChain);
+      receiver = _reformatAddressWithChain(address, destinationChain, alternativeAddress);
     }
     if (!txHex || !isHex(txHex)) {
       return Promise.resolve(undefined);

package/services/swap-service/index.js

@@ -103,8 +103,7 @@ export class SwapService {
     if (!params.selectedQuote) {
       return this.getDefaultProcessV2(params);
     } else {
-      var _params$request$curre;
-      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
+      const providerId = params.selectedQuote.provider.id;
       const handler = this.handlers[providerId];
       if (handler) {
         // todo: handle error response from generateOptimalProcess
@@ -129,6 +128,8 @@ export class SwapService {
     console.group('Swap Logger');
     console.log('path', path);
     console.log('swapQuoteResponse', swapQuoteResponse);
+
+    // Just to log routing type for Uniswap Quote
     if (swapQuoteResponse.optimalQuote && swapQuoteResponse.optimalQuote.metadata) {
       const routing = swapQuoteResponse.optimalQuote.metadata.routing;
       if (routing) {
@@ -147,7 +148,7 @@ export class SwapService {
     }
 
     // override fee for quote because some cases need estimate network fee on Extension (i.e. Optimex)
-    if (swapQuoteResponse.optimalQuote) {
+    if (swapQuoteResponse.optimalQuote && [SwapProviderId.OPTIMEX, SwapProviderId.OPTIMEX_TESTNET].includes(swapQuoteResponse.optimalQuote.provider.id)) {
       const swapIndex = optimalProcess.steps.findIndex(step => step.type === SwapStepType.SWAP);
       swapQuoteResponse.optimalQuote.feeInfo.feeComponent = optimalProcess.totalFee[swapIndex].feeComponent;
     }
@@ -190,7 +191,7 @@ export class SwapService {
     const swapAction = path.find(step => step.action === DynamicSwapType.SWAP);
     const directSwapRequest = swapAction ? {
       ...request,
-      address: _reformatAddressWithChain(request.address, this.chainService.getChainInfoByKey(_getAssetOriginChain(this.chainService.getAssetBySlug(swapAction.pair.from)))),
+      address: _reformatAddressWithChain(request.address, this.chainService.getChainInfoByKey(_getAssetOriginChain(this.chainService.getAssetBySlug(swapAction.pair.from))), request.alternativeAddress),
       pair: swapAction.pair
     } : undefined;
     if (!directSwapRequest) {