@subwallet/extension-base 1.3.34-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();
@@ -1435,44 +1659,65 @@ class TransactionService {
       this.handleTransactionTimeout(emitter, eventData);
       emitter.emit('send', eventData); // This event is needed after sending transaction with queue
 
+      let isBroadcast = false;
+      let isInBlock = false;
+      let isFinish = false;
       rs.send(txState => {
         // handle events, logs, history
         if (!txState || !txState.status) {
           return;
         }
-        if (txState.status.isInBlock) {
-          eventData.eventLogs = txState.events;
-          if (!eventData.extrinsicHash || eventData.extrinsicHash === '' || !(0, _util.isHex)(eventData.extrinsicHash)) {
+
+        // Broadcast transaction
+        if (!isBroadcast) {
+          if (txState.status.isBroadcast || txState.status.isInBlock || txState.status.isFinalized) {
             eventData.extrinsicHash = txState.txHash.toHex();
+            isBroadcast = true;
+            if (!isFinish) {
+              emitter.emit('extrinsicHash', eventData);
+            }
+          }
+        }
+
+        // Transaction in block
+        if (!isInBlock) {
+          if (txState.status.isInBlock || txState.status.isFinalized) {
             eventData.blockHash = txState.status.asInBlock.toHex();
-            emitter.emit('extrinsicHash', eventData);
+            eventData.eventLogs = txState.events;
+            isInBlock = true;
           }
         }
-        if (txState.status.isFinalized) {
-          eventData.extrinsicHash = txState.txHash.toHex();
-          eventData.eventLogs = txState.events;
-          // TODO: push block hash and block number into eventData
-          txState.events.filter(_ref13 => {
-            let {
-              event: {
-                section
-              }
-            } = _ref13;
-            return section === 'system';
-          }).forEach(_ref14 => {
-            let {
-              event: {
-                data: [error],
-                method
-              }
-            } = _ref14;
-            if (method === 'ExtrinsicFailed') {
-              eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
-              emitter.emit('error', eventData);
-            } else if (method === 'ExtrinsicSuccess') {
-              emitter.emit('success', eventData);
+
+        // Transaction finished
+        if (!isFinish) {
+          if (txState.status.isInBlock || txState.status.isFinalized) {
+            if (!eventData.extrinsicHash) {
+              eventData.extrinsicHash = txState.txHash.toHex();
             }
-          });
+            txState.events.filter(_ref15 => {
+              let {
+                event: {
+                  section
+                }
+              } = _ref15;
+              return section === 'system';
+            }).forEach(_ref16 => {
+              let {
+                event: {
+                  data: [error],
+                  method
+                }
+              } = _ref16;
+              if (method === 'ExtrinsicFailed') {
+                eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
+                emitter.emit('error', eventData);
+                isFinish = true;
+              } else if (method === 'ExtrinsicSuccess') {
+                emitter.emit('success', eventData);
+                isFinish = true;
+              }
+            });
+          }
         }
       }).catch(e => {
         eventData.errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
@@ -1485,7 +1730,7 @@ class TransactionService {
     });
     return emitter;
   }
-  signAndSendTonTransaction(_ref15) {
+  signAndSendTonTransaction(_ref17) {
     let {
       address,
       chain,
@@ -1494,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 = {
@@ -1511,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));
@@ -1550,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);
@@ -1580,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,
@@ -1596,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));
@@ -1791,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/core/logic-validation/request.js

@@ -351,7 +351,7 @@ export async function validationEvmDataTransactionMiddleware(koni, url, payload)
             transaction.maxPriorityFeePerGas = feeCombine.maxPriorityFeePerGas;
           } else if (feeCombine.gasPrice) {
             estimateGas = new BigN(feeCombine.gasPrice || 0).multipliedBy(gasLimit).toFixed(0);
-            transaction.maxPriorityFeePerGas = feeCombine.gasPrice;
+            transaction.gasPrice = feeCombine.gasPrice;
           }
         }
       } catch (e) {

package/koni/background/handlers/Extension.d.ts

@@ -91,6 +91,7 @@ export default class KoniExtension {
     private updateAssetSetting;
     private getPrice;
     private getHistoryTokenPrice;
+    private checkCoinGeckoPriceSupport;
     private subscribeCurrentTokenPrice;
     private setPriceCurrency;
     private subscribePrice;

package/koni/background/handlers/Extension.js

@@ -880,6 +880,9 @@ export default class KoniExtension {
   }) {
     return this.#koniState.priceService.getHistoryTokenPriceData(priceId, timeframe);
   }
+  checkCoinGeckoPriceSupport(priceId) {
+    return this.#koniState.priceService.checkCoinGeckoPriceSupport(priceId);
+  }
   subscribeCurrentTokenPrice(priceId, id, port) {
     const cb = createSubscription(id, port);
     const {
@@ -1443,7 +1446,8 @@ export default class KoniExtension {
         xcmFeeDryRun = dryRunInfo.fee;
       }
       if (isAcrossBridgeTransfer) {
-        const metadata = await getAcrossQuote(params);
+        const data = await getAcrossQuote(params);
+        const metadata = data.metadata;
         inputData.metadata = {
           amountOut: metadata.outputAmount,
           rate: metadata.rate,
@@ -2583,11 +2587,12 @@ export default class KoniExtension {
     let registry = new TypeRegistry();
     if (isJsonPayload(payload)) {
       const [, chainInfo] = this.#koniState.findNetworkKeyByGenesisHash(payload.genesisHash);
-      const allRegistry = [setupApiRegistry(chainInfo, this.#koniState), setupDatabaseRegistry(await this.#koniState.chainService.getMetadataByHash(payload.genesisHash), chainInfo, payload), setupDappRegistry(this.#koniState.knownMetadata.find(meta => meta.genesisHash === payload.genesisHash), payload)].filter(item => item !== null && item.registry !== undefined);
-      if (allRegistry.length === 0) {
+      const registries = await Promise.all([setupApiRegistry(chainInfo, this.#koniState), setupDatabaseRegistry(chainInfo, payload, this.#koniState), setupDappRegistry(payload, this.#koniState)]);
+      const validRegistries = registries.filter(item => !!(item !== null && item !== void 0 && item.registry));
+      if (validRegistries.length === 0) {
         registry.setSignedExtensions(payload.signedExtensions);
       } else {
-        registry = getSuitableRegistry(allRegistry, payload);
+        registry = getSuitableRegistry(validRegistries, payload);
       }
     }
     const result = request.sign(registry, pair);
@@ -2715,6 +2720,7 @@ export default class KoniExtension {
   getTransaction({
     id
   }) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const {
       transaction,
       ...transactionResult
@@ -2725,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,
@@ -3762,6 +3769,7 @@ export default class KoniExtension {
       chainType,
       extrinsic,
       extrinsicType,
+      isDutch,
       isPermit,
       transferNativeAmount,
       txChain,
@@ -3818,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,
@@ -4271,6 +4297,8 @@ export default class KoniExtension {
         return await this.subscribePrice(id, port);
       case 'pri(price.getHistory)':
         return await this.getHistoryTokenPrice(request);
+      case 'pri(price.checkCoinGeckoPriceSupport)':
+        return this.checkCoinGeckoPriceSupport(request);
       case 'pri(price.subscribeCurrentTokenPrice)':
         return this.subscribeCurrentTokenPrice(request, id, port);
       case 'pri(settings.savePriceCurrency)':

package/koni/background/utils.d.ts

@@ -1,6 +1,4 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
-import { MetadataItem } from '@subwallet/extension-base/background/KoniTypes';
-import { MetadataDef } from '@subwallet/extension-inject/types';
 import { Registry, SignerPayloadJSON } from '@polkadot/types/types';
 import KoniState from './handlers/State';
 export interface RegistrySource {
@@ -8,6 +6,6 @@ export interface RegistrySource {
     specVersion: string | number;
 }
 export declare function getSuitableRegistry(registries: RegistrySource[], payload: SignerPayloadJSON): Registry;
-export declare function setupApiRegistry(chainInfo: _ChainInfo | undefined, koniState: KoniState): RegistrySource | null;
-export declare function setupDatabaseRegistry(metadata: MetadataItem, chainInfo: _ChainInfo | undefined, payload: SignerPayloadJSON): RegistrySource | null;
-export declare function setupDappRegistry(metadata: MetadataDef, payload: SignerPayloadJSON): RegistrySource | null;
+export declare function setupApiRegistry(chainInfo: _ChainInfo | undefined, koniState: KoniState): Promise<RegistrySource | null>;
+export declare function setupDatabaseRegistry(chainInfo: _ChainInfo | undefined, payload: SignerPayloadJSON, koniState: KoniState): Promise<RegistrySource | null>;
+export declare function setupDappRegistry(payload: SignerPayloadJSON, koniState: KoniState): Promise<RegistrySource | null>;