@subwallet/extension-base 1.3.29-0 → 1.3.30-0

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

@@ -5,8 +5,7 @@ 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 { _getAssetDecimals, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
-import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN, { BigNumber } from 'bignumber.js';
@@ -61,33 +60,6 @@ export class SimpleSwapHandler {
     });
     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;
   }
@@ -103,26 +75,32 @@ export class SimpleSwapHandler {
   get slug() {
     return this.swapBaseHandler.slug;
   }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
-  }
   generateOptimalProcessV2(params) {
     return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
   }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: SwapStepType.SWAP,
-        metadata: {
-          sendingValue: params.request.fromAmount.toString(),
-          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
-          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
-        }
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+  async getSubmitStep(params, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
     }
-    return Promise.resolve(undefined);
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const submitStep = {
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(params.request.address, originChain),
+        receiver: _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain),
+        version: 2
+      }
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
   }
   async handleSwapProcess(params) {
     const {
@@ -171,6 +149,7 @@ export class SimpleSwapHandler {
       sender,
       toAsset
     });
+    console.log('simpleswap data', id, addressFrom);
     if (!id || id.length === 0 || !addressFrom || addressFrom.length === 0) {
       throw new SwapError(SwapErrorType.UNKNOWN);
     }

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

@@ -1,7 +1,7 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
-import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, PermitSwapData, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, PermitSwapData, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { TransactionConfig } from 'web3-core';
 import { BalanceService } from '../../balance-service';
 import { ChainService } from '../../chain-service';
@@ -21,12 +21,10 @@ export declare class UniswapHandler implements SwapBaseInterface {
     get balanceService(): BalanceService;
     get feeService(): FeeService;
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
-    getApprovalStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getPermitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    getApprovalStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getPermitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     private tokenApproveSpending;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;

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

@@ -4,8 +4,8 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { validateTypedSignMessageDataV3V4 } from '@subwallet/extension-base/core/logic-validation';
-import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
-import { BasicTxErrorType, CommonStepType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
 import BigNumber from 'bignumber.js';
 import { _getContractAddressOfToken, _isNativeToken } from "../../chain-service/utils/index.js";
 import { calculateGasFeeParams } from "../../fee-service/utils/index.js";
@@ -58,13 +58,10 @@ export class UniswapHandler {
   get providerInfo() {
     return this.swapBaseHandler.providerInfo;
   }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
-  }
   generateOptimalProcessV2(params) {
     return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
   }
-  async getApprovalStep(params) {
+  async getApprovalStep(params, stepIndex) {
     if (params.selectedQuote) {
       const walletAddress = params.request.address;
       const fromAmount = params.selectedQuote.fromAmount;
@@ -97,7 +94,7 @@ export class UniswapHandler {
     }
     return Promise.resolve(undefined);
   }
-  async getPermitStep(params) {
+  async getPermitStep(params, stepIndex) {
     if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
       const submitStep = {
         name: 'Permit Step',
@@ -118,47 +115,29 @@ export class UniswapHandler {
     }
     return Promise.resolve(undefined);
   }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: SwapStepType.SWAP,
-        metadata: {
-          sendingValue: params.request.fromAmount.toString(),
-          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
-          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
-        }
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    return Promise.resolve(undefined);
-  }
-  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')]);
+  async getSubmitStep(params, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
     }
-    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.resolve([]);
-          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;
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const submitStep = {
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(params.request.address, originChain),
+        receiver: _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain),
+        version: 2
       }
-    }
-    return [];
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
   }
   async handleSwapProcess(params) {
     const {

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

@@ -1,13 +1,11 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { ServiceStatus, ServiceWithProcessInterface, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
-import { DynamicSwapAction } from '@subwallet/extension-base/services/swap-service/interface';
-import { OptimalSwapPathParamsV2, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
+import { DynamicSwapAction, OptimalSwapPathParamsV2, SwapRequestV2, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { CommonOptimalSwapPath } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapPair, SwapProviderId, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData } from '@subwallet/extension-base/types/swap';
+import { SwapPair, SwapQuoteResponse, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData } 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 {
+export declare class SwapService implements StoppableServiceInterface {
     protected readonly state: KoniState;
     private eventService;
     private readonly chainService;
@@ -18,15 +16,11 @@ export declare class SwapService implements ServiceWithProcessInterface, Stoppab
     status: ServiceStatus;
     constructor(state: KoniState);
     private askProvidersForQuote;
-    private getDefaultProcess;
     private getDefaultProcessV2;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
-    generateOptimalProcessWithoutPath(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
-    handleSwapRequest(request: SwapRequest): Promise<SwapRequestResult>;
-    handleSwapRequestV2(request: SwapRequest): Promise<SwapRequestResult>;
-    getAvailablePath(request: SwapRequest): [DynamicSwapAction[], SwapRequest | undefined];
-    getLatestQuoteFromSwapRequest(request: SwapRequest): Promise<{
+    handleSwapRequestV2(request: SwapRequestV2): Promise<SwapRequestResult>;
+    getAvailablePath(request: SwapRequestV2): [DynamicSwapAction[], SwapRequestV2 | undefined];
+    getLatestQuoteFromSwapRequest(request: SwapRequestV2): Promise<{
         path: DynamicSwapAction[];
         swapQuoteResponse: SwapQuoteResponse;
     }>;
@@ -38,7 +32,7 @@ export declare class SwapService implements ServiceWithProcessInterface, Stoppab
     waitForStarted(): Promise<void>;
     waitForStopped(): Promise<void>;
     getSwapPairs(): SwapPair[];
-    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     subscribeSwapPairs(callback: (pairs: SwapPair[]) => void): import("rxjs").Subscription;
 }