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

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

@@ -5,7 +5,7 @@ import { AccountExternalErrorCode } from '@subwallet/extension-base/background/K
 import { AccountChainType, CommonAccountErrorType, SWCommonAccountError } from '@subwallet/extension-base/types';
 import { getKeypairTypeByAddress } from '@subwallet/keyring';
 import { decodePair } from '@subwallet/keyring/pair/decode';
-import { BitcoinKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
+import { BitcoinKeypairTypes, CardanoKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 import keyring from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import { assert, hexStripPrefix, hexToU8a, isHex, u8aToHex } from '@polkadot/util';
@@ -49,7 +49,7 @@ export class AccountSecretHandler extends AccountBaseHandler {
         isReadOnly,
         genesisHash: ''
       };
-      if ([...BitcoinKeypairTypes, ...TonKeypairTypes].includes(type) && isReadOnly) {
+      if ([...BitcoinKeypairTypes, ...TonKeypairTypes, ...CardanoKeypairTypes].includes(type) && isReadOnly) {
         meta.noPublicKey = true;
       }
       const result = keyring.keyring.addFromAddress(address, meta, null, type);

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

@@ -0,0 +1,2 @@
+import { AccountProxy } from '@subwallet/extension-base/types';
+export declare const hasAnyAccountForMigration: (allAccountProxies: AccountProxy[]) => boolean;

package/services/keyring-service/utils.js

@@ -0,0 +1,11 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export const hasAnyAccountForMigration = allAccountProxies => {
+  for (const account of allAccountProxies) {
+    if (account.isNeedMigrateUnifiedAccount) {
+      return true;
+    }
+  }
+  return false;
+};

package/services/request-service/handler/CardanoRequestHandler.d.ts

@@ -0,0 +1,16 @@
+import { ConfirmationDefinitionsCardano, ConfirmationsQueueCardano, ConfirmationsQueueItemOptions, ConfirmationTypeCardano, RequestConfirmationCompleteCardano } from '@subwallet/extension-base/background/KoniTypes';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import { BehaviorSubject } from 'rxjs';
+export default class CardanoRequestHandler {
+    #private;
+    private readonly confirmationsQueueSubjectCardano;
+    private readonly confirmationsPromiseMap;
+    constructor(requestService: RequestService);
+    get numCardanoRequests(): number;
+    getConfirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;
+    addConfirmationCardano<CT extends ConfirmationTypeCardano>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsCardano[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsCardano[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsCardano[CT][1]>;
+    completeConfirmationCardano(request: RequestConfirmationCompleteCardano): Promise<boolean>;
+    private decorateResult;
+    private signTransactionCardano;
+    resetWallet(): void;
+}

package/services/request-service/handler/CardanoRequestHandler.js

@@ -0,0 +1,163 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { isInternalRequest } from '@subwallet/extension-base/utils/request';
+import { keyring } from '@subwallet/ui-keyring';
+import { t } from 'i18next';
+import { BehaviorSubject } from 'rxjs';
+import { logger as createLogger } from '@polkadot/util/logger';
+export default class CardanoRequestHandler {
+  #requestService;
+  #logger;
+  confirmationsQueueSubjectCardano = new BehaviorSubject({
+    cardanoSignatureRequest: {},
+    cardanoSendTransactionRequest: {},
+    cardanoWatchTransactionRequest: {}
+  });
+  confirmationsPromiseMap = {};
+  constructor(requestService) {
+    this.#requestService = requestService;
+    this.#logger = createLogger('CardanoRequestHandler');
+  }
+  get numCardanoRequests() {
+    let count = 0;
+    Object.values(this.confirmationsQueueSubjectCardano.getValue()).forEach(x => {
+      count += Object.keys(x).length;
+    });
+    return count;
+  }
+  getConfirmationsQueueSubjectCardano() {
+    return this.confirmationsQueueSubjectCardano;
+  }
+  async addConfirmationCardano(id, url, type, payload, options = {}, validator) {
+    const confirmations = this.confirmationsQueueSubjectCardano.getValue();
+    const confirmationType = confirmations[type];
+    const payloadJson = JSON.stringify({});
+    const isInternal = isInternalRequest(url);
+    if (['cardanoSendTransactionRequest', 'cardanoSignatureRequest'].includes(type)) {
+      const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+      if (isAlwaysRequired) {
+        this.#requestService.keyringService.lock();
+      }
+    }
+
+    // Check duplicate request
+    const duplicated = Object.values(confirmationType).find(c => c.url === url && c.payloadJson === payloadJson);
+    if (duplicated) {
+      throw new Error('Cardano duplicate request'); // update this message.
+    }
+
+    confirmationType[id] = {
+      id,
+      url,
+      isInternal,
+      payload,
+      payloadJson,
+      ...options
+    };
+    const promise = new Promise((resolve, reject) => {
+      this.confirmationsPromiseMap[id] = {
+        validator: validator,
+        resolver: {
+          resolve: resolve,
+          reject: reject
+        }
+      };
+    });
+    this.confirmationsQueueSubjectCardano.next(confirmations);
+    if (!isInternal) {
+      this.#requestService.popupOpen();
+    }
+    this.#requestService.updateIconV2();
+    return promise;
+  }
+  async completeConfirmationCardano(request) {
+    const confirmations = this.confirmationsQueueSubjectCardano.getValue();
+    for (const ct in request) {
+      const type = ct;
+      const result = request[type];
+      const {
+        id
+      } = result;
+      const {
+        resolver,
+        validator
+      } = this.confirmationsPromiseMap[id];
+      const confirmation = confirmations[type][id];
+      if (!resolver || !confirmation) {
+        this.#logger.error(t('Unable to proceed. Please try again'), type, id);
+        throw new Error(t('Unable to proceed. Please try again'));
+      }
+
+      // Fill signature for some special type
+      await this.decorateResult(type, confirmation, result);
+
+      // Validate response from confirmation popup some info like password, response format....
+      const error = validator && validator(result);
+      if (error) {
+        resolver.reject(error);
+      }
+
+      // Delete confirmations from queue
+      delete this.confirmationsPromiseMap[id];
+      delete confirmations[type][id];
+      this.confirmationsQueueSubjectCardano.next(confirmations);
+
+      // Update icon, and close queue
+      this.#requestService.updateIconV2(this.#requestService.numAllRequests === 0);
+      resolver.resolve(result);
+    }
+
+    // TODO: Review later
+    return true;
+  }
+  async decorateResult(t, request, result) {
+    if (result.payload === '') {
+      if (t === 'cardanoSignatureRequest') {
+        // result.payload = await this.signMessage(request as ConfirmationDefinitions['evmSignatureRequest'][0]);
+      } else if (t === 'cardanoSendTransactionRequest') {
+        result.payload = this.signTransactionCardano(request);
+      }
+      if (t === 'cardanoSignatureRequest' || t === 'cardanoSendTransactionRequest') {
+        const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;
+        if (isAlwaysRequired) {
+          this.#requestService.keyringService.lock();
+        }
+      }
+    }
+  }
+  signTransactionCardano(confirmation) {
+    // alibaba
+    const transaction = confirmation.payload;
+    const {
+      cardanoPayload,
+      from
+    } = transaction;
+    const pair = keyring.getPair(from);
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    return pair.cardano.sign(cardanoPayload);
+  }
+  resetWallet() {
+    const confirmations = this.confirmationsQueueSubjectCardano.getValue();
+    for (const [type, requests] of Object.entries(confirmations)) {
+      for (const confirmation of Object.values(requests)) {
+        const {
+          id
+        } = confirmation;
+        const {
+          resolver
+        } = this.confirmationsPromiseMap[id];
+        if (!resolver || !confirmation) {
+          console.error('Not found confirmation', type, id);
+        } else {
+          resolver.reject(new Error('Reset wallet'));
+        }
+        delete this.confirmationsPromiseMap[id];
+        delete confirmations[type][id];
+      }
+    }
+    this.confirmationsQueueSubjectCardano.next(confirmations);
+  }
+}

package/services/request-service/handler/EvmRequestHandler.js

@@ -79,7 +79,7 @@ export default class EvmRequestHandler {
     }
     if (options.isPassConfirmation) {
       await this.completeConfirmation({
-        evmSendTransactionRequest: {
+        [type]: {
           id,
           url,
           isApproved: true,

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

@@ -1,4 +1,4 @@
-import { AuthRequestV2, ConfirmationDefinitions, ConfirmationDefinitionsTon, ConfirmationsQueue, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationType, ConfirmationTypeTon, RequestConfirmationComplete, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
+import { AuthRequestV2, ConfirmationDefinitions, ConfirmationDefinitionsCardano, ConfirmationDefinitionsTon, ConfirmationsQueue, ConfirmationsQueueCardano, ConfirmationsQueueItemOptions, ConfirmationsQueueTon, ConfirmationType, ConfirmationTypeCardano, ConfirmationTypeTon, RequestConfirmationComplete, RequestConfirmationCompleteCardano, RequestConfirmationCompleteTon } from '@subwallet/extension-base/background/KoniTypes';
 import { AccountAuthType, AuthorizeRequest, MetadataRequest, RequestAuthorizeTab, RequestSign, ResponseSigning, SigningRequest } from '@subwallet/extension-base/background/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
@@ -47,15 +47,18 @@ export default class RequestService {
     get numSubstrateRequests(): number;
     get numEvmRequests(): number;
     get numTonRequests(): number;
+    get numCardanoRequests(): number;
     get confirmationsQueueSubject(): BehaviorSubject<ConfirmationsQueue>;
     get confirmationsQueueSubjectTon(): BehaviorSubject<ConfirmationsQueueTon>;
+    get confirmationsQueueSubjectCardano(): BehaviorSubject<ConfirmationsQueueCardano>;
     getSignRequest(id: string): import("./types").SignRequest | undefined;
     signInternalTransaction(id: string, address: string, url: string, payload: SignerPayloadJSON, onSign?: (id: string) => void): Promise<ResponseSigning>;
     addConfirmation<CT extends ConfirmationType>(id: string, url: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): Promise<ConfirmationDefinitions[CT][1]>;
-    addConfirmationTon<CT extends ConfirmationTypeTon>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsTon[CT][0]['payload'], // todo: messages <-> payload
-    options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsTon[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsTon[CT][1]>;
+    addConfirmationTon<CT extends ConfirmationTypeTon>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsTon[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsTon[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsTon[CT][1]>;
+    addConfirmationCardano<CT extends ConfirmationTypeCardano>(id: string, url: string, type: CT, payload: ConfirmationDefinitionsCardano[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitionsCardano[CT][1]) => Error | undefined): Promise<ConfirmationDefinitionsCardano[CT][1]>;
     completeConfirmation(request: RequestConfirmationComplete): Promise<boolean>;
     completeConfirmationTon(request: RequestConfirmationCompleteTon): Promise<boolean>;
+    completeConfirmationCardano(request: RequestConfirmationCompleteCardano): Promise<boolean>;
     updateConfirmation<CT extends ConfirmationType>(id: string, type: CT, payload: ConfirmationDefinitions[CT][0]['payload'], options?: ConfirmationsQueueItemOptions, validator?: (input: ConfirmationDefinitions[CT][1]) => Error | undefined): void;
     getConnectWCRequest(id: string): import("@subwallet/extension-base/services/wallet-connect-service/types").RequestWalletConnectSession;
     get connectWCSubject(): BehaviorSubject<WalletConnectSessionRequest[]>;

package/services/request-service/index.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import CardanoRequestHandler from '@subwallet/extension-base/services/request-service/handler/CardanoRequestHandler';
 import TonRequestHandler from "./handler/TonRequestHandler.js";
 import { AuthRequestHandler, ConnectWCRequestHandler, EvmRequestHandler, MetadataRequestHandler, NotSupportWCRequestHandler, PopupHandler, SubstrateRequestHandler } from "./handler/index.js";
 export default class RequestService {
@@ -12,6 +13,7 @@ export default class RequestService {
   #substrateRequestHandler;
   #evmRequestHandler;
   #tonRequestHandler;
+  #cardanoRequestHandler;
   #connectWCRequestHandler;
   #notSupportWCRequestHandler;
 
@@ -26,6 +28,7 @@ export default class RequestService {
     this.#substrateRequestHandler = new SubstrateRequestHandler(this);
     this.#evmRequestHandler = new EvmRequestHandler(this);
     this.#tonRequestHandler = new TonRequestHandler(this);
+    this.#cardanoRequestHandler = new CardanoRequestHandler(this);
     this.#connectWCRequestHandler = new ConnectWCRequestHandler(this);
     this.#notSupportWCRequestHandler = new NotSupportWCRequestHandler(this);
 
@@ -33,7 +36,7 @@ export default class RequestService {
     this.updateIconV2();
   }
   get numAllRequests() {
-    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests;
+    return this.allSubstrateRequests.length + this.numEvmRequests + this.numTonRequests + this.numCardanoRequests;
   }
   updateIconV2(shouldClose) {
     this.#popupHandler.updateIconV2(shouldClose);
@@ -142,12 +145,18 @@ export default class RequestService {
   get numTonRequests() {
     return this.#tonRequestHandler.numTonRequests;
   }
+  get numCardanoRequests() {
+    return this.#cardanoRequestHandler.numCardanoRequests;
+  }
   get confirmationsQueueSubject() {
     return this.#evmRequestHandler.getConfirmationsQueueSubject();
   }
   get confirmationsQueueSubjectTon() {
     return this.#tonRequestHandler.getConfirmationsQueueSubjectTon();
   }
+  get confirmationsQueueSubjectCardano() {
+    return this.#cardanoRequestHandler.getConfirmationsQueueSubjectCardano();
+  }
   getSignRequest(id) {
     return this.#substrateRequestHandler.getSignRequest(id);
   }
@@ -157,17 +166,21 @@ export default class RequestService {
   addConfirmation(id, url, type, payload, options = {}, validator) {
     return this.#evmRequestHandler.addConfirmation(id, url, type, payload, options, validator);
   }
-  addConfirmationTon(id, url, type, payload,
-  // todo: messages <-> payload
-  options = {}, validator) {
+  addConfirmationTon(id, url, type, payload, options = {}, validator) {
     return this.#tonRequestHandler.addConfirmationTon(id, url, type, payload, options, validator);
   }
+  addConfirmationCardano(id, url, type, payload, options = {}, validator) {
+    return this.#cardanoRequestHandler.addConfirmationCardano(id, url, type, payload, options, validator);
+  }
   async completeConfirmation(request) {
     return await this.#evmRequestHandler.completeConfirmation(request);
   }
   async completeConfirmationTon(request) {
     return await this.#tonRequestHandler.completeConfirmationTon(request);
   }
+  async completeConfirmationCardano(request) {
+    return await this.#cardanoRequestHandler.completeConfirmationCardano(request);
+  }
   updateConfirmation(id, type, payload, options = {}, validator) {
     return this.#evmRequestHandler.updateConfirmation(id, type, payload, options, validator);
   }
@@ -208,13 +221,14 @@ export default class RequestService {
 
   // General methods
   get numRequests() {
-    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests;
+    return this.numMetaRequests + this.numAuthRequests + this.numSubstrateRequests + this.numEvmRequests + this.numConnectWCRequests + this.numNotSupportWCRequests + this.numTonRequests + this.numCardanoRequests;
   }
   resetWallet() {
     this.#authRequestHandler.resetWallet();
     this.#substrateRequestHandler.resetWallet();
     this.#evmRequestHandler.resetWallet();
     this.#tonRequestHandler.resetWallet();
+    this.#cardanoRequestHandler.resetWallet();
     this.#metadataRequestHandler.resetWallet();
     this.#connectWCRequestHandler.resetWallet();
     this.#notSupportWCRequestHandler.resetWallet();

package/services/setting-service/constants.d.ts

@@ -13,4 +13,7 @@ export declare const DEFAULT_ALL_LOGO = "";
 export declare const DEFAULT_CAMERA_ENABLE = false;
 export declare const DEFAULT_ALLOW_ONE_SIGN = true;
 export declare const DEFAULT_NOTIFICATION_SETUP: NotificationSetup;
+export declare const DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS = false;
+export declare const DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS = false;
+export declare const DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE = false;
 export declare const DEFAULT_SETTING: UiSettings;

package/services/setting-service/constants.js

@@ -30,6 +30,9 @@ export const DEFAULT_NOTIFICATION_SETUP = {
   }
 };
 
+export const DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS = false;
+export const DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS = false;
+export const DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE = false;
 export const DEFAULT_SETTING = {
   language: DEFAULT_LANGUAGE,
   currency: DEFAULT_CURRENCY,
@@ -43,6 +46,9 @@ export const DEFAULT_SETTING = {
   timeAutoLock: DEFAULT_AUTO_LOCK_TIME,
   enableChainPatrol: DEFAULT_CHAIN_PATROL_ENABLE,
   notificationSetup: DEFAULT_NOTIFICATION_SETUP,
+  isAcknowledgedUnifiedAccountMigration: DEFAULT_ACKNOWLEDGED_MIGRATION_STATUS,
+  isUnifiedAccountMigrationInProgress: DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_PROGRESS,
+  isUnifiedAccountMigrationDone: DEFAULT_UNIFIED_ACCOUNT_MIGRATION_IN_DONE,
   walletReference: '',
   allowOneSign: DEFAULT_ALLOW_ONE_SIGN
 };

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

@@ -134,6 +134,7 @@ export default class DatabaseService {
     markAllRead(proxyId: string): import("dexie").PromiseExtended<number>;
     switchReadStatus(params: RequestSwitchStatusParams): import("dexie").PromiseExtended<number>;
     removeAccountNotifications(proxyId: string): import("dexie").PromiseExtended<number>;
+    updateNotificationProxyId(proxyIds: string[], newProxyId: string, newName: string): void;
     exportDB(): Promise<string>;
     importDB(data: string): Promise<boolean>;
     getExportJson(): Promise<DexieExportJsonStructure>;

package/services/storage-service/DatabaseService.js

@@ -595,6 +595,9 @@ export default class DatabaseService {
   removeAccountNotifications(proxyId) {
     return this.stores.inappNotification.removeAccountNotifications(proxyId);
   }
+  updateNotificationProxyId(proxyIds, newProxyId, newName) {
+    return this.stores.inappNotification.updateNotificationProxyId(proxyIds, newProxyId, newName);
+  }
   async exportDB() {
     const blob = await exportDB(this._db, {
       filter: (table, value, key) => {

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

@@ -5,6 +5,7 @@ export default class InappNotificationStore extends BaseStore<_NotificationInfo>
     getNotificationInfo(id: string): Promise<_NotificationInfo | undefined>;
     getAll(): Promise<_NotificationInfo[]>;
     getNotificationsByParams(params: GetNotificationParams): Promise<_NotificationInfo[]>;
+    updateNotificationProxyId(proxyIds: string[], newProxyId: string, newName: string): void;
     cleanUpOldNotifications(overdueTime: number): Promise<number>;
     subscribeUnreadNotificationsCount(): import("dexie").Observable<Record<string, number>>;
     getUnreadNotificationsCountMap(): Promise<Record<string, number>>;

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

@@ -36,6 +36,12 @@ export default class InappNotificationStore extends BaseStore {
     });
     return filteredTable.toArray();
   }
+  updateNotificationProxyId(proxyIds, newProxyId, newName) {
+    this.table.where('proxyId').anyOfIgnoreCase(proxyIds).modify(item => {
+      item.proxyId = newProxyId;
+      item.title = item.title.replace(/\[.*?\]/, `[${newName}]`);
+    }).catch(console.error);
+  }
   async cleanUpOldNotifications(overdueTime) {
     const currentTimestamp = Date.now();
     return this.table.filter(item => item.time <= currentTimestamp - overdueTime).delete();

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

@@ -1,10 +1,9 @@
-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 FeeService from '@subwallet/extension-base/services/fee-service/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 { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 import { SwapBaseInterface } from '../base-handler';
 export declare class AssetHubSwapHandler implements SwapBaseInterface {
     private swapBaseHandler;
@@ -22,11 +21,9 @@ export declare class AssetHubSwapHandler implements SwapBaseInterface {
     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>;
 }

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

@@ -1,14 +1,13 @@
 // 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 { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
-import { _getEarlyAssetHubValidationError, _validateBalanceToSwapOnAssetHub, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
+import { _validateBalanceToSwapOnAssetHub, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { convertSwapRate, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { CommonStepType } from '@subwallet/extension-base/types/service-base';
 import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
@@ -16,7 +15,6 @@ import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN from 'bignumber.js';
 import { SwapBaseHandler } from "../base-handler.js";
 import { AssetHubRouter } from "./router.js";
-const PAH_LOW_LIQUIDITY_THRESHOLD = 0.15;
 export class AssetHubSwapHandler {
   isReady = false;
   constructor(chainService, balanceService, feeService, chain) {
@@ -150,57 +148,6 @@ export class AssetHubSwapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this), this.getSubmitStep.bind(this)]);
   }
-  async getSwapQuote(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const fromChainNativeTokenSlug = _getChainNativeTokenSlug(fromChain);
-    if (!this.isReady || !this.router) {
-      return new SwapError(SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    if (earlyValidation.error) {
-      const metadata = earlyValidation.metadata;
-      return _getEarlyAssetHubValidationError(earlyValidation.error, metadata);
-    }
-    try {
-      const paths = this.router.buildPath(request.pair);
-      const amountOut = earlyValidation.metadata.toAmount;
-      const toAmount = new BigN(amountOut);
-      const minReceive = toAmount.times(1 - request.slippage).integerValue(BigN.ROUND_DOWN);
-      const extrinsic = await this.router.buildSwapExtrinsic(paths, request.address, request.fromAmount, minReceive.toString());
-      const paymentInfo = await extrinsic.paymentInfo(request.address);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: paymentInfo.partialFee.toString(),
-        feeType: SwapFeeType.NETWORK_FEE
-      };
-      const feeTokenOptions = [fromChainNativeTokenSlug];
-      const selectedFeeToken = fromChainNativeTokenSlug;
-      const priceImpactPct = earlyValidation.metadata.priceImpactPct || '0';
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: toAmount.toString(),
-        rate: convertSwapRate(earlyValidation.metadata.quoteRate, fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
-        feeInfo: {
-          feeComponent: [networkFee],
-          defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: feeTokenOptions,
-          // TODO: enable fee options
-          selectedFeeToken
-        },
-        isLowLiquidity: Math.abs(parseFloat(priceImpactPct)) >= PAH_LOW_LIQUIDITY_THRESHOLD,
-        route: {
-          path: paths.map(asset => asset.slug)
-        }
-      };
-    } catch (e) {
-      return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
   async handleXcmStep(params) {
     const pair = params.quote.pair;
     const alternativeAssetSlug = getSwapAlternativeAsset(pair);
@@ -362,10 +309,4 @@ export class AssetHubSwapHandler {
     }
     return [];
   }
-  validateSwapRequest(request) {
-    if (!this.isReady || !this.router) {
-      throw new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-    return this.router.earlyValidateSwapValidation(request);
-  }
 }

package/services/swap-service/handler/base-handler.d.ts

@@ -1,16 +1,13 @@
-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 FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { GenSwapStepFunc, OptimalSwapPathParams, SwapEarlyValidation, SwapProvider, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { GenSwapStepFunc, OptimalSwapPathParams, SwapProvider, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export interface SwapBaseInterface {
     providerSlug: SwapProviderId;
-    getSwapQuote: (request: SwapRequest) => Promise<SwapQuote | SwapError>;
     generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<CommonOptimalPath>;
     getSubmitStep: (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    validateSwapRequest: (request: SwapRequest) => Promise<SwapEarlyValidation>;
     validateSwapProcess: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
     handleSwapProcess: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
     handleSubmitStep: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;

package/services/swap-service/handler/chainflip-handler.d.ts

@@ -1,31 +1,24 @@
-import { Asset } from '@chainflip/sdk/swap';
 import { COMMON_ASSETS } from '@subwallet/chain-list';
-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 FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export declare const CHAINFLIP_BROKER_API: string;
 export declare class ChainflipSwapHandler implements SwapBaseInterface {
-    private swapSdk;
     private readonly isTestnet;
     private swapBaseHandler;
     providerSlug: SwapProviderId;
+    private baseUrl;
     constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService, isTestnet?: boolean);
     get chainService(): ChainService;
     get balanceService(): BalanceService;
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
     get name(): string;
     get slug(): string;
-    get assetMapping(): Record<string, Asset>;
-    get chainMapping(): Record<string, import("@chainflip/sdk/dist/contracts-DmShvHR7").C>;
     get intermediaryAssetSlug(): COMMON_ASSETS.USDC_ETHEREUM | COMMON_ASSETS.USDC_SEPOLIA;
-    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
-    private parseSwapPath;
-    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;