@subwallet/extension-base 1.3.35-0 → 1.3.36-0

package/cjs/services/transaction-service/index.js

@@ -207,6 +207,22 @@ class TransactionService {
       extrinsicHash: transactionId
     };
   }
+  fillDutchTransactionDefaultInfo(transaction) {
+    const isInternal = !transaction.url;
+    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
+    return {
+      ...transaction,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      url: transaction.url || _constants2.EXTENSION_REQUEST_URL,
+      status: _KoniTypes.ExtrinsicStatus.QUEUED,
+      isInternal,
+      id: transactionId,
+      extrinsicHash: transactionId
+    };
+  }
   async addTransaction(inputTransaction) {
     const transactions = this.transactions;
     // Fill transaction default info
@@ -219,6 +235,15 @@ class TransactionService {
     });
     return await this.sendTransaction(transaction);
   }
+  addDutchTransaction(inputTransaction) {
+    const transactions = this.transactions;
+    const transaction = this.fillDutchTransactionDefaultInfo(inputTransaction);
+    transactions[transaction.id] = transaction;
+    this.transactionSubject.next({
+      ...transactions
+    });
+    return this.sendDutchTransaction(transaction);
+  }
   generateBeforeHandleResponseErrors(errors) {
     return {
       errors,
@@ -334,6 +359,62 @@ class TransactionService {
     'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
     return validatedTransaction;
   }
+  async handleDutchTransaction(transaction) {
+    var _transaction$step2;
+    const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, true);
+    const validatedTransaction = {
+      ...transaction,
+      id: transactionId,
+      extrinsicHash: '',
+      status: undefined,
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
+    };
+    const txInput = {
+      ...transaction,
+      isInternal: true,
+      status: _KoniTypes.ExtrinsicStatus.QUEUED,
+      id: transactionId,
+      extrinsicHash: transactionId,
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime()
+    };
+    const emitter = this.addDutchTransaction(txInput);
+    await new Promise(resolve => {
+      if (transaction.resolveOnDone) {
+        emitter.on('success', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      } else {
+        emitter.on('signed', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      }
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
+    'eventsHandler' in validatedTransaction && delete validatedTransaction.eventsHandler;
+    return validatedTransaction;
+  }
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : transaction.chainType === 'cardano' ? this.signAndSendCardanoTransaction(transaction) : this.signAndSendTonTransaction(transaction));
@@ -381,10 +462,7 @@ class TransactionService {
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          if ([_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
-            return true;
-          }
-          return false;
+          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -457,10 +535,7 @@ class TransactionService {
       if (step) {
         const rejectError = data.errors.find(error => {
           // TODO: REFACTOR ERROR CODE
-          if ([_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
-            return true;
-          }
-          return false;
+          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
         });
 
         /**
@@ -482,6 +557,83 @@ class TransactionService {
     eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
     return emitter;
   }
+  sendDutchTransaction(transaction) {
+    // Send Transaction
+    const emitter = this.signAndSendEvmDutchTransaction(transaction);
+    const {
+      eventsHandler,
+      step
+    } = transaction;
+    emitter.on('send', data => {
+      this.onSend(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          transactionId: transaction.id,
+          status: _types.StepStatus.SUBMITTING,
+          chain: transaction.chain
+        });
+      }
+    });
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          extrinsicHash: data.extrinsicHash,
+          status: _types.StepStatus.PROCESSING
+        });
+      }
+    });
+    emitter.on('success', data => {
+      this.handlePostProcessing(data.id);
+      this.onSuccess(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: _types.StepStatus.COMPLETE
+        });
+      }
+    });
+    emitter.on('error', data => {
+      // this.handlePostProcessing(data.id); // might enable this later
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
+      });
+      if (step) {
+        const rejectError = data.errors.find(error => {
+          // TODO: REFACTOR ERROR CODE
+          return [_types.BasicTxErrorType.UNABLE_TO_SIGN, _types.BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType);
+        });
+
+        /**
+         * Now simple check, first step have step id = 1.
+         * Improve to fetch the process from db
+         * */
+        if (rejectError && step.stepId === 1) {
+          this.deleteProcess(step);
+        } else {
+          this.updateProcessStepStatus(step, {
+            status: _types.StepStatus.FAILED
+          });
+        }
+      }
+    });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.TIMEOUT)]
+      });
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: _types.StepStatus.TIMEOUT
+        });
+      }
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    eventsHandler === null || eventsHandler === void 0 ? void 0 : eventsHandler(emitter);
+    return emitter;
+  }
   removeTransaction(id) {
     if (this.transactions[id]) {
       delete this.transactions[id];
@@ -505,7 +657,7 @@ class TransactionService {
     return (0, _utils3.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
-    var _transaction$step2;
+    var _transaction$step3;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -530,7 +682,7 @@ class TransactionService {
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0,
-      processId: (_transaction$step2 = transaction.step) === null || _transaction$step2 === void 0 ? void 0 : _transaction$step2.processId
+      processId: (_transaction$step3 = transaction.step) === null || _transaction$step3 === void 0 ? void 0 : _transaction$step3.processId
     };
     const nativeAsset = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     const baseNativeAmount = {
@@ -1369,7 +1521,79 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendSubstrateTransaction(_ref12) {
+  signAndSendEvmDutchTransaction(_ref12) {
+    let {
+      address,
+      id,
+      isPassConfirmation,
+      step,
+      transaction,
+      url
+    } = _ref12;
+    const emitter = new _eventemitter.default();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: [],
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+
+    // todo: review this object
+    const evmSignaturePayload = {
+      id: id,
+      type: 'eth_signTypedData_v4',
+      payload: transaction,
+      address: address,
+      hashPayload: '',
+      canSign: true,
+      processId: step === null || step === void 0 ? void 0 : step.processId
+    };
+    this.state.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'submitApiRequest', evmSignaturePayload, {
+      isPassConfirmation
+    }).then(_ref13 => {
+      let {
+        isApproved,
+        payload: signature
+      } = _ref13;
+      if (isApproved) {
+        emitter.emit('signed', eventData);
+        emitter.emit('send', eventData);
+        transaction.submitSwapOrder().then(isSendSuccess => {
+          if (!isSendSuccess) {
+            throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, (0, _i18next.t)('Failed to sign'));
+          }
+          this.handleTransactionTimeout(emitter, eventData);
+          transaction.cronCheckTxSuccess().then(order => {
+            if (!order) {
+              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED));
+              emitter.emit('error', eventData);
+            } else {
+              eventData.extrinsicHash = order.txHash;
+              emitter.emit('extrinsicHash', eventData);
+              emitter.emit('success', eventData);
+            }
+          }).catch(e => {
+            eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, (0, _i18next.t)(e.message)));
+            emitter.emit('error', eventData);
+          });
+        }).catch(e => {
+          eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SEND, (0, _i18next.t)(e.message)));
+          emitter.emit('error', eventData);
+        });
+      } else {
+        this.removeTransaction(id);
+        eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNABLE_TO_SIGN, (0, _i18next.t)(e.message)));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendSubstrateTransaction(_ref14) {
     var _this$state$chainServ;
     let {
       address,
@@ -1381,7 +1605,7 @@ class TransactionService {
       tokenPayFeeSlug,
       transaction,
       url
-    } = _ref12;
+    } = _ref14;
     const tip = (feeCustom === null || feeCustom === void 0 ? void 0 : feeCustom.tip) || '0';
     const feeAssetId = tokenPayFeeSlug && !(0, _utils2._isNativeTokenBySlug)(tokenPayFeeSlug) && _constants._SUPPORT_TOKEN_PAY_FEE_GROUP.assetHub.includes(chain) ? (_this$state$chainServ = this.state.chainService.getAssetBySlug(tokenPayFeeSlug).metadata) === null || _this$state$chainServ === void 0 ? void 0 : _this$state$chainServ.multilocation : undefined;
     const emitter = new _eventemitter.default();
@@ -1470,20 +1694,20 @@ class TransactionService {
             if (!eventData.extrinsicHash) {
               eventData.extrinsicHash = txState.txHash.toHex();
             }
-            txState.events.filter(_ref13 => {
+            txState.events.filter(_ref15 => {
               let {
                 event: {
                   section
                 }
-              } = _ref13;
+              } = _ref15;
               return section === 'system';
-            }).forEach(_ref14 => {
+            }).forEach(_ref16 => {
               let {
                 event: {
                   data: [error],
                   method
                 }
-              } = _ref14;
+              } = _ref16;
               if (method === 'ExtrinsicFailed') {
                 eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
                 emitter.emit('error', eventData);
@@ -1506,7 +1730,7 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendTonTransaction(_ref15) {
+  signAndSendTonTransaction(_ref17) {
     let {
       address,
       chain,
@@ -1515,7 +1739,7 @@ class TransactionService {
       step,
       transaction,
       url
-    } = _ref15;
+    } = _ref17;
     const walletContract = _uiKeyring.default.getPair(address).ton.currentContract;
     const emitter = new _eventemitter.default();
     const eventData = {
@@ -1532,11 +1756,11 @@ class TransactionService {
           ...payload,
           messagePayload: (0, _utils.cellToBase64Str)(message),
           messages: []
-        }, {}).then(_ref16 => {
+        }, {}).then(_ref18 => {
           let {
             isApproved,
             payload
-          } = _ref16;
+          } = _ref18;
           if (!isApproved) {
             this.removeTransaction(id);
             eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
@@ -1571,8 +1795,8 @@ class TransactionService {
         if (!externalMsgHash) {
           return;
         }
-        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref17 => {
-          let [status, hex] = _ref17;
+        tonApi.getStatusByExtMsgHash(externalMsgHash, extrinsicType).then(_ref19 => {
+          let [status, hex] = _ref19;
           if (status && hex) {
             eventData.extrinsicHash = hex;
             emitter.emit('extrinsicHash', eventData);
@@ -1601,13 +1825,13 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendCardanoTransaction(_ref18) {
+  signAndSendCardanoTransaction(_ref20) {
     let {
       chain,
       id,
       transaction,
       url
-    } = _ref18;
+    } = _ref20;
     const emitter = new _eventemitter.default();
     const eventData = {
       id,
@@ -1617,11 +1841,11 @@ class TransactionService {
     };
     const transactionConfig = transaction;
     const cardanoApi = this.state.chainService.getCardanoApi(chain);
-    this.state.requestService.addConfirmationCardano(id, url || _constants2.EXTENSION_REQUEST_URL, 'cardanoSendTransactionRequest', transactionConfig, {}).then(_ref19 => {
+    this.state.requestService.addConfirmationCardano(id, url || _constants2.EXTENSION_REQUEST_URL, 'cardanoSendTransactionRequest', transactionConfig, {}).then(_ref21 => {
       let {
         isApproved,
         payload
-      } = _ref19;
+      } = _ref21;
       if (!isApproved) {
         this.removeTransaction(id);
         eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.USER_REJECT_REQUEST));
@@ -1812,9 +2036,9 @@ class TransactionService {
     }
   }
   async createProcessNotification(transactionId) {
-    var _transaction$step3;
+    var _transaction$step4;
     const transaction = this.getTransaction(transactionId);
-    if (transaction && (_transaction$step3 = transaction.step) !== null && _transaction$step3 !== void 0 && _transaction$step3.processId) {
+    if (transaction && (_transaction$step4 = transaction.step) !== null && _transaction$step4 !== void 0 && _transaction$step4.processId) {
       const process = this.aliveProcessMap.get(transaction.step.processId);
       if (process) {
         await this.state.inappNotificationService.createProcessNotification(process);

package/cjs/types/swap/index.js

@@ -42,13 +42,14 @@ exports.SwapProviderId = SwapProviderId;
   SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
   SwapProviderId["UNISWAP"] = "UNISWAP";
+  SwapProviderId["KYBER"] = "KYBER";
 })(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
 const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET,
 // SwapProviderId.HYDRADX_TESTNET,
 SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB,
 // SwapProviderId.ROCOCO_ASSET_HUB,
 // SwapProviderId.WESTEND_ASSET_HUB,
-SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP];
+SwapProviderId.SIMPLE_SWAP, SwapProviderId.UNISWAP, SwapProviderId.KYBER];
 exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
 // process handling
 let SwapFeeType;

package/koni/background/handlers/Extension.js

@@ -2720,6 +2720,7 @@ export default class KoniExtension {
   getTransaction({
     id
   }) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const {
       transaction,
       ...transactionResult
@@ -2730,6 +2731,7 @@ export default class KoniExtension {
     const cb = createSubscription(id, port);
     function convertRs(rs, processMap) {
       return Object.fromEntries(Object.entries(rs).map(([key, value]) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const {
           additionalValidator,
           eventsHandler,
@@ -3767,6 +3769,7 @@ export default class KoniExtension {
       chainType,
       extrinsic,
       extrinsicType,
+      isDutch,
       isPermit,
       transferNativeAmount,
       txChain,
@@ -3823,6 +3826,24 @@ export default class KoniExtension {
         step
       });
     }
+    if (isDutch) {
+      return await this.#koniState.transactionService.handleDutchTransaction({
+        address,
+        chain: txChain,
+        transaction: extrinsic,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        data: txData,
+        extrinsicType,
+        // change this depends on step
+        chainType,
+        resolveOnDone: !isLastStep,
+        transferNativeAmount,
+        ...this.createPassConfirmationParams(isPassConfirmation),
+        errorOnTimeOut,
+        eventsHandler,
+        step
+      });
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.3.35-0",
+  "version": "1.3.36-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1911,6 +1911,11 @@
       "require": "./cjs/services/swap-service/handler/hydradx-handler.js",
       "default": "./services/swap-service/handler/hydradx-handler.js"
     },
+    "./services/swap-service/handler/kyber-handler": {
+      "types": "./services/swap-service/handler/kyber-handler.d.ts",
+      "require": "./cjs/services/swap-service/handler/kyber-handler.js",
+      "default": "./services/swap-service/handler/kyber-handler.js"
+    },
     "./services/swap-service/handler/simpleswap-handler": {
       "types": "./services/swap-service/handler/simpleswap-handler.d.ts",
       "require": "./cjs/services/swap-service/handler/simpleswap-handler.js",
@@ -2705,12 +2710,12 @@
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
     "@subwallet/chain-list": "0.2.104",
-    "@subwallet/extension-base": "^1.3.35-0",
-    "@subwallet/extension-chains": "^1.3.35-0",
-    "@subwallet/extension-dapp": "^1.3.35-0",
-    "@subwallet/extension-inject": "^1.3.35-0",
+    "@subwallet/extension-base": "^1.3.36-0",
+    "@subwallet/extension-chains": "^1.3.36-0",
+    "@subwallet/extension-dapp": "^1.3.36-0",
+    "@subwallet/extension-inject": "^1.3.36-0",
     "@subwallet/keyring": "^0.1.11",
-    "@subwallet/subwallet-api-sdk": "^1.3.35-0",
+    "@subwallet/subwallet-api-sdk": "^1.3.36-0",
     "@subwallet/ui-keyring": "^0.1.11",
     "@ton/core": "^0.56.3",
     "@ton/crypto": "^3.2.0",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.3.35-0'
+  version: '1.3.36-0'
 };

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

@@ -1,4 +1,4 @@
-import { SWTransaction } from '@subwallet/extension-base/services/transaction-service/types';
+import { SWTransactionBase } from '@subwallet/extension-base/services/transaction-service/types';
 import { CurrentAccountInfo } from '@subwallet/extension-base/types';
 export interface EventRegistry {
     'general.sleep': [boolean];
@@ -27,13 +27,13 @@ export interface EventRegistry {
     'asset.ready': [boolean];
     'asset.online.ready': [boolean];
     'asset.updateState': [string];
-    'transaction.done': [SWTransaction];
-    'transaction.failed': [SWTransaction | undefined];
-    'transaction.timeout': [SWTransaction | undefined];
+    'transaction.done': [SWTransactionBase];
+    'transaction.failed': [SWTransactionBase | undefined];
+    'transaction.timeout': [SWTransactionBase | undefined];
     'transaction.submitStaking': [string];
-    'transaction.transferNft': [SWTransaction | undefined];
+    'transaction.transferNft': [SWTransactionBase | undefined];
     'mantaPay.initSync': [string | undefined];
-    'mantaPay.submitTransaction': [SWTransaction | undefined];
+    'mantaPay.submitTransaction': [SWTransactionBase | undefined];
     'mantaPay.enable': [string];
     'migration.done': [boolean];
     'campaign.ready': [boolean];

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

@@ -22,7 +22,8 @@ export default class EvmRequestHandler {
     evmSignatureRequest: {},
     evmSendTransactionRequest: {},
     evmWatchTransactionRequest: {},
-    errorConnectNetwork: {}
+    errorConnectNetwork: {},
+    submitApiRequest: {}
   });
   confirmationsPromiseMap = {};
   constructor(requestService) {
@@ -214,6 +215,8 @@ export default class EvmRequestHandler {
         result.payload = await this.signMessage(request);
       } else if (t === 'evmSendTransactionRequest') {
         result.payload = await this.signTransaction(request);
+      } else if (t === 'submitApiRequest') {
+        return;
       }
       if (t === 'evmSignatureRequest' || t === 'evmSendTransactionRequest') {
         const isAlwaysRequired = await this.#requestService.settingService.isAlwaysRequired;

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

@@ -0,0 +1,28 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BalanceService } from '../../balance-service';
+import { ChainService } from '../../chain-service';
+import FeeService from '../../fee-service/service';
+import TransactionService from '../../transaction-service';
+import { SwapBaseInterface } from './base-handler';
+export interface KyberSwapQuoteMetadata {
+    priceImpact?: string;
+}
+export declare const KYBER_CLIENT_ID: string;
+export declare class KyberHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    transactionService: TransactionService;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService, transactionService: TransactionService, feeService: FeeService);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get feeService(): FeeService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    getApprovalStep(params: OptimalSwapPathParamsV2): 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>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+}