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

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

@@ -8,6 +8,7 @@ exports.AssetHubSwapHandler = void 0;
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
 var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -27,7 +28,18 @@ class AssetHubSwapHandler {
   isReady = false;
   constructor(chainService, balanceService, feeService, chain) {
     const chainInfo = chainService.getChainInfoByKey(chain);
-    const providerSlug = chain === 'statemint' ? _swap2.SwapProviderId.POLKADOT_ASSET_HUB : chain === 'statemine' ? _swap2.SwapProviderId.KUSAMA_ASSET_HUB : _swap2.SwapProviderId.ROCOCO_ASSET_HUB;
+    const providerSlug = function () {
+      switch (chain) {
+        case 'statemint':
+          return _swap2.SwapProviderId.POLKADOT_ASSET_HUB;
+        case 'statemine':
+          return _swap2.SwapProviderId.KUSAMA_ASSET_HUB;
+        case 'westend_assethub':
+          return _swap2.SwapProviderId.WESTEND_ASSET_HUB;
+        default:
+          return _swap2.SwapProviderId.ROCOCO_ASSET_HUB;
+      }
+    }();
     this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
       balanceService,
       chainService,
@@ -85,21 +97,13 @@ class AssetHubSwapHandler {
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
       const originalChainInfo = this.chainService.getChainInfoByKey(this.chain);
-      const step = {
-        metadata: {
-          sendingValue: bnAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: _serviceBase.CommonStepType.XCM
-      };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
       const id = (0, _getId.getId)();
       const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeChainInfo.slug, 'substrate');
       const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
         originTokenInfo: alternativeAsset,
         destinationTokenInfo: fromAsset,
+        // Mock sending value to get payment info
         sendingValue: bnAmount.toString(),
         recipient: params.request.address,
         sender: params.request.address,
@@ -113,12 +117,27 @@ class AssetHubSwapHandler {
       const fee = {
         feeComponent: [{
           feeType: _swap2.SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          amount: Math.round(xcmFeeInfo.partialFee * _constants.XCM_MIN_AMOUNT_RATIO).toString(),
           tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
         }],
         defaultFeeToken: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo),
         feeOptions: [(0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)]
       };
+      let bnTransferAmount = bnAmount.minus(bnFromAssetBalance);
+      if ((0, _utils._isNativeToken)(alternativeAsset)) {
+        const bnXcmFee = new _bignumber.default(fee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
+
+        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
+      }
+      const step = {
+        metadata: {
+          sendingValue: bnTransferAmount.toString(),
+          originTokenInfo: alternativeAsset,
+          destinationTokenInfo: fromAsset
+        },
+        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
+        type: _serviceBase.CommonStepType.XCM
+      };
       return [step, fee];
     } catch (e) {
       console.error('Error creating xcm step', e);

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

@@ -11,6 +11,7 @@ var _types = require("@subwallet/chain-list/types");
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
 var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -100,21 +101,13 @@ class HydradxHandler {
     try {
       const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
       const destChainInfo = this.chainService.getChainInfoByKey(this.chain());
-      const step = {
-        metadata: {
-          sendingValue: bnAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: _serviceBase.CommonStepType.XCM
-      };
       const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
       const id = (0, _getId.getId)();
       const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeAsset.originChain, 'substrate');
       const xcmTransfer = await (0, _xcm.createXcmExtrinsic)({
         originTokenInfo: alternativeAsset,
         destinationTokenInfo: fromAsset,
+        // Mock sending value to get payment info
         sendingValue: bnAmount.toString(),
         recipient: params.request.address,
         substrateApi: xcmOriginSubstrateApi,
@@ -128,12 +121,27 @@ class HydradxHandler {
       const fee = {
         feeComponent: [{
           feeType: _swap2.SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          amount: Math.round(xcmFeeInfo.partialFee * _constants.XCM_MIN_AMOUNT_RATIO).toString(),
           tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
         }],
         defaultFeeToken: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo),
         feeOptions: [(0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)]
       };
+      let bnTransferAmount = bnAmount.minus(bnFromAssetBalance);
+      if ((0, _utils._isNativeToken)(alternativeAsset)) {
+        const bnXcmFee = new _bignumber.default(fee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
+
+        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
+      }
+      const step = {
+        metadata: {
+          sendingValue: bnTransferAmount.toString(),
+          originTokenInfo: alternativeAsset,
+          destinationTokenInfo: fromAsset
+        },
+        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
+        type: _serviceBase.CommonStepType.XCM
+      };
       return [step, fee];
     } catch (e) {
       console.error('Error creating xcm step', e);

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

@@ -165,6 +165,9 @@ class SwapService {
         case _swap.SwapProviderId.ROCOCO_ASSET_HUB:
           this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'rococo_assethub');
           break;
+        case _swap.SwapProviderId.WESTEND_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, this.state.feeService, 'westend_assethub');
+          break;
         case _swap.SwapProviderId.SIMPLE_SWAP:
           this.handlers[providerId] = new _simpleswapHandler.SimpleSwapHandler(this.chainService, this.state.balanceService, this.state.feeService);
           break;

package/cjs/services/swap-service/utils.js

@@ -73,6 +73,7 @@ const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [_swap2.SwapProviderId.POLKADOT_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
   [_swap2.SwapProviderId.KUSAMA_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
   [_swap2.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
+  [_swap2.SwapProviderId.WESTEND_ASSET_HUB]: ['westend_assethub'],
   [_swap2.SwapProviderId.SIMPLE_SWAP]: ['bittensor', _chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.POLKADOT]
 };
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = _PROVIDER_TO_SUPPORTED_PAIR_MAP;

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

@@ -36,8 +36,10 @@ var _util = require("@polkadot/util");
 // SPDX-License-Identifier: Apache-2.0
 
 class TransactionService {
-  transactionSubject = new _rxjs.BehaviorSubject({});
   watchTransactionSubscribes = {};
+  aliveProcessMap = new Map();
+  transactionSubject = new _rxjs.BehaviorSubject({});
+  aliveProcessSubject = new _rxjs.BehaviorSubject(this.aliveProcessMap);
   get transactions() {
     return this.transactionSubject.getValue();
   }
@@ -66,11 +68,13 @@ class TransactionService {
     return [];
   }
   async validateTransaction(transactionInput) {
+    var _transactionInput$ste;
     const validationResponse = {
       ...transactionInput,
       status: undefined,
       errors: transactionInput.errors || [],
-      warnings: transactionInput.warnings || []
+      warnings: transactionInput.warnings || [],
+      processId: (_transactionInput$ste = transactionInput.step) === null || _transactionInput$ste === void 0 ? void 0 : _transactionInput$ste.processId
     };
     const {
       additionalValidator,
@@ -137,6 +141,44 @@ class TransactionService {
   getTransactionSubject() {
     return this.transactionSubject;
   }
+  get observables() {
+    const transactionSubject = this.transactionSubject;
+    const aliveProcessSubject = this.aliveProcessSubject;
+    return {
+      get transaction() {
+        return transactionSubject.asObservable();
+      },
+      get aliveProcess() {
+        return aliveProcessSubject.asObservable().pipe((0, _rxjs.map)(aliveProcessMap => {
+          const aliveProcessRecord = {};
+          aliveProcessMap.forEach((value, key) => {
+            aliveProcessRecord[key] = value;
+          });
+          return aliveProcessRecord;
+        }));
+      }
+    };
+  }
+  get values() {
+    const transactionSubject = this.transactionSubject;
+    const aliveProcessSubject = this.aliveProcessSubject;
+    return {
+      get transaction() {
+        return transactionSubject.value;
+      },
+      get aliveProcess() {
+        const aliveProcessMap = aliveProcessSubject.value;
+        const aliveProcessRecord = {};
+        aliveProcessMap.forEach((value, key) => {
+          aliveProcessRecord[key] = value;
+        });
+        return aliveProcessRecord;
+      }
+    };
+  }
+  updateAliveProcess() {
+    this.aliveProcessSubject.next(this.aliveProcessMap);
+  }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
     const transactionId = (0, _helpers.getTransactionId)(transaction.chainType, transaction.chain, isInternal, (0, _helpers2.isWalletConnectRequest)(transaction.id));
@@ -214,6 +256,12 @@ class TransactionService {
           resolve();
         }
       });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
     });
 
     // @ts-ignore
@@ -226,20 +274,39 @@ class TransactionService {
     // Send Transaction
     const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : this.signAndSendTonTransaction(transaction));
     const {
-      eventsHandler
+      eventsHandler,
+      step
     } = transaction;
     emitter.on('signed', data => {
       this.onSigned(data);
     });
     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
@@ -247,12 +314,33 @@ class TransactionService {
         ...data,
         errors: [...data.errors, new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]
       });
+      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;
+        });
+        if (rejectError) {
+          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
@@ -283,6 +371,7 @@ class TransactionService {
     return (0, _utils3.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
+    var _transaction$step;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -306,7 +395,8 @@ class TransactionService {
       blockHash: '',
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
-      startBlock: startBlock || 0
+      startBlock: startBlock || 0,
+      processId: (_transaction$step = transaction.step) === null || _transaction$step === void 0 ? void 0 : _transaction$step.processId
     };
     const nativeAsset = (0, _utils2._getChainNativeTokenBasicInfo)(chainInfo);
     const baseNativeAmount = {
@@ -659,6 +749,7 @@ class TransactionService {
 
     // Create Input History Transaction History
     this.state.historyService.insertHistories(this.transactionToHistories(id, startBlock, nonce)).catch(console.error);
+    this.createProcessNotification(id).catch(console.error);
     console.debug(`Transaction "${id}" is sent`);
   }
   onHasTransactionHash(_ref3) {
@@ -871,6 +962,8 @@ class TransactionService {
       address,
       chain,
       id,
+      isPassConfirmation,
+      step,
       transaction,
       url
     } = _ref7;
@@ -948,7 +1041,8 @@ class TransactionService {
       id,
       errors: [],
       warnings: [],
-      extrinsicHash: id
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
     };
     if (isInjected) {
       this.state.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async _ref8 => {
@@ -1016,7 +1110,9 @@ class TransactionService {
         emitter.emit('error', eventData);
       });
     } else {
-      this.state.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async _ref9 => {
+      this.state.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {
+        isPassConfirmation
+      }).then(async _ref9 => {
         let {
           isApproved,
           payload
@@ -1084,6 +1180,8 @@ class TransactionService {
       feeCustom,
       id,
       nonNativeTokenPayFeeSlug,
+      signAfterCreate,
+      step,
       transaction,
       url
     } = _ref10;
@@ -1094,7 +1192,8 @@ class TransactionService {
       id,
       errors: [],
       warnings: [],
-      extrinsicHash: id
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
     };
     const extrinsic = transaction;
     // const registry = extrinsic.registry;
@@ -1106,7 +1205,7 @@ class TransactionService {
           const {
             signature,
             signedTransaction
-          } = await this.state.requestService.signInternalTransaction(id, address, url || _constants2.EXTENSION_REQUEST_URL, payload);
+          } = await this.state.requestService.signInternalTransaction(id, address, url || _constants2.EXTENSION_REQUEST_URL, payload, signAfterCreate);
           return {
             id: new Date().getTime(),
             signature,
@@ -1195,6 +1294,7 @@ class TransactionService {
       chain,
       extrinsicType,
       id,
+      step,
       transaction,
       url
     } = _ref13;
@@ -1204,7 +1304,8 @@ class TransactionService {
       id,
       errors: [],
       warnings: [],
-      extrinsicHash: id
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
     };
     const payload = transaction;
     const signer = message => {
@@ -1325,6 +1426,114 @@ class TransactionService {
       extrinsicHash: transaction.extrinsicHash
     }).catch(console.error);
   }
+  async createProcessIfNeed(process) {
+    if (!this.aliveProcessMap.has(process.id)) {
+      this.aliveProcessMap.set(process.id, process);
+      this.updateAliveProcess();
+      await this.state.dbService.upsertProcessTransaction(process);
+    }
+  }
+  checkProcessExist(processId) {
+    return this.aliveProcessMap.has(processId);
+  }
+  deleteProcess(step) {
+    const {
+      processId
+    } = step;
+    this.aliveProcessMap.delete(processId);
+    this.state.dbService.deleteProcessTransactionById(processId).catch(console.error);
+    this.updateAliveProcess();
+  }
+  updateProcessStepStatus(step, data) {
+    const {
+      processId,
+      stepId
+    } = step;
+    const process = this.aliveProcessMap.get(processId);
+    if (process) {
+      const step = process.steps.find(item => item.id === stepId);
+      if (step) {
+        Object.assign(step, data);
+        if ([_types.StepStatus.PREPARE || _types.StepStatus.PROCESSING].includes(step.status)) {
+          process.currentStepId = step.id;
+        }
+        if (step.status === _types.StepStatus.COMPLETE) {
+          const nextStep = process.steps.find(item => item.id === stepId + 1);
+          if (nextStep) {
+            nextStep.status = _types.StepStatus.PREPARE;
+            process.currentStepId = nextStep.id;
+          }
+        } else if ([_types.StepStatus.FAILED, _types.StepStatus.TIMEOUT].includes(step.status)) {
+          const nextSteps = process.steps.filter(item => item.id > stepId);
+          nextSteps.forEach(item => {
+            item.status = _types.StepStatus.CANCELLED;
+          });
+        }
+      }
+      if (process.steps.some(item => [_types.StepStatus.PROCESSING, _types.StepStatus.SUBMITTING].includes(item.status))) {
+        process.status = _types.StepStatus.PROCESSING;
+      }
+      if (process.steps.some(item => item.status === _types.StepStatus.TIMEOUT)) {
+        process.status = _types.StepStatus.TIMEOUT;
+      }
+      if (process.steps.every(item => item.status === _types.StepStatus.COMPLETE)) {
+        const lastStep = process.steps[process.steps.length - 1];
+        process.lastTransactionChain = lastStep.chain;
+        process.lastTransactionId = lastStep.transactionId;
+        process.status = _types.StepStatus.COMPLETE;
+      }
+      if (process.steps.some(item => item.status === _types.StepStatus.FAILED)) {
+        process.status = _types.StepStatus.FAILED;
+      }
+      this.aliveProcessMap.set(processId, process);
+      this.state.dbService.upsertProcessTransaction(process).catch(console.error);
+      if ([_types.StepStatus.COMPLETE, _types.StepStatus.FAILED, _types.StepStatus.TIMEOUT].includes(process.status)) {
+        this.aliveProcessMap.delete(processId);
+      }
+      this.updateAliveProcess();
+    } else {
+      this.state.dbService.getProcessTransactionById(processId).then(process => {
+        if (process) {
+          const step = process.steps.find(item => item.id === stepId);
+          if (step && step.status === _types.StepStatus.TIMEOUT && [_types.StepStatus.COMPLETE, _types.StepStatus.FAILED].includes(data.status)) {
+            Object.assign(step, data);
+            const isLastStep = process.steps[process.steps.length - 1].id = stepId;
+            if (isLastStep) {
+              process.status = data.status;
+            }
+            this.state.dbService.upsertProcessTransaction(process).catch(console.error);
+          }
+        }
+      }).catch(console.error);
+    }
+  }
+  async updateProcessInfo(id, combineInfo, step) {
+    const process = this.aliveProcessMap.get(id);
+    if (process) {
+      if (step) {
+        const index = process.steps.findIndex(item => item.id === (step === null || step === void 0 ? void 0 : step.id));
+        if (index !== -1) {
+          process.steps[index] = step;
+        }
+      }
+      if (combineInfo) {
+        process.combineInfo = combineInfo;
+      }
+      this.aliveProcessMap.set(process.id, process);
+      this.updateAliveProcess();
+      await this.state.dbService.upsertProcessTransaction(process);
+    }
+  }
+  async createProcessNotification(transactionId) {
+    var _transaction$step2;
+    const transaction = this.getTransaction(transactionId);
+    if (transaction && (_transaction$step2 = transaction.step) !== null && _transaction$step2 !== void 0 && _transaction$step2.processId) {
+      const process = this.aliveProcessMap.get(transaction.step.processId);
+      if (process) {
+        await this.state.inappNotificationService.createProcessNotification(process);
+      }
+    }
+  }
   resetWallet() {
     this.transactionSubject.next({});
   }

package/cjs/types/index.js

@@ -156,4 +156,15 @@ Object.keys(_yield).forEach(function (key) {
       return _yield[key];
     }
   });
+});
+var _setting = require("./setting");
+Object.keys(_setting).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _setting[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _setting[key];
+    }
+  });
 });

package/cjs/types/setting.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/swap/index.js

@@ -38,9 +38,12 @@ exports.SwapProviderId = SwapProviderId;
   SwapProviderId["POLKADOT_ASSET_HUB"] = "POLKADOT_ASSET_HUB";
   SwapProviderId["KUSAMA_ASSET_HUB"] = "KUSAMA_ASSET_HUB";
   SwapProviderId["ROCOCO_ASSET_HUB"] = "ROCOCO_ASSET_HUB";
+  SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
 })(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.SIMPLE_SWAP];
+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];
 exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
 // process handling
 let SwapFeeType;

package/cjs/types/transaction/index.js

@@ -25,6 +25,17 @@ Object.keys(_error).forEach(function (key) {
     }
   });
 });
+var _process = require("./process");
+Object.keys(_process).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _process[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _process[key];
+    }
+  });
+});
 var _request = require("./request");
 Object.keys(_request).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/cjs/types/transaction/process.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StepStatus = exports.ProcessType = exports.PROCESSING_STEP_STATUS = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+let ProcessType;
+exports.ProcessType = ProcessType;
+(function (ProcessType) {
+  ProcessType["SWAP"] = "swap";
+  ProcessType["EARNING"] = "earning";
+})(ProcessType || (exports.ProcessType = ProcessType = {}));
+let StepStatus;
+exports.StepStatus = StepStatus;
+(function (StepStatus) {
+  StepStatus["QUEUED"] = "QUEUED";
+  StepStatus["PREPARE"] = "PREPARE";
+  StepStatus["SUBMITTING"] = "SUBMITTING";
+  StepStatus["PROCESSING"] = "PROCESSING";
+  StepStatus["COMPLETE"] = "COMPLETE";
+  StepStatus["FAILED"] = "FAILED";
+  StepStatus["CANCELLED"] = "CANCELLED";
+  StepStatus["TIMEOUT"] = "TIMEOUT";
+})(StepStatus || (exports.StepStatus = StepStatus = {}));
+const PROCESSING_STEP_STATUS = [StepStatus.PREPARE, StepStatus.SUBMITTING, StepStatus.PROCESSING];
+exports.PROCESSING_STEP_STATUS = PROCESSING_STEP_STATUS;

package/cjs/types/yield/actions/join/submit.js

@@ -1 +1,16 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EarningProcessType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+// Result after create extrinsic
+let EarningProcessType;
+exports.EarningProcessType = EarningProcessType;
+(function (EarningProcessType) {
+  EarningProcessType["NOMINATION_POOL"] = "NOMINATION_POOL";
+  EarningProcessType["NATIVE_STAKING"] = "NATIVE_STAKING";
+  EarningProcessType["YIELD"] = "YIELD";
+})(EarningProcessType || (exports.EarningProcessType = EarningProcessType = {}));

package/defaults.d.ts

@@ -1,4 +1,4 @@
-declare const ALLOWED_PATH: readonly ["/", "/settings/security", "/accounts/connect-ledger", "/accounts/restore-json", "/accounts/detail", "/accounts/new-seed-phrase"];
+declare const ALLOWED_PATH: readonly ["/", "/settings/security", "/transaction-submission", "/accounts/connect-ledger", "/accounts/restore-json", "/accounts/detail", "/accounts/new-seed-phrase"];
 declare const PHISHING_PAGE_REDIRECT = "/phishing-page-detected";
 declare const EXTENSION_PREFIX: string;
 declare const ID_PREFIX: string;

package/defaults.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @polkadot/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-const ALLOWED_PATH = ['/', '/settings/security', '/accounts/connect-ledger', '/accounts/restore-json', '/accounts/detail', '/accounts/new-seed-phrase'];
+const ALLOWED_PATH = ['/', '/settings/security', '/transaction-submission', '/accounts/connect-ledger', '/accounts/restore-json', '/accounts/detail', '/accounts/new-seed-phrase'];
 const PHISHING_PAGE_REDIRECT = '/phishing-page-detected';
 const EXTENSION_PREFIX = process.env.EXTENSION_PREFIX || '';
 const ID_PREFIX = process.env.ID_PREFIX || EXTENSION_PREFIX || '';

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

@@ -80,6 +80,7 @@ export default class KoniExtension {
     private setShowZeroBalance;
     private setLanguage;
     private setShowBalance;
+    private setAllowOneSign;
     private subscribeAuthUrls;
     private saveCurrentAccountProxy;
     private getAssetSetting;
@@ -263,5 +264,9 @@ export default class KoniExtension {
     private submitClaimPolygonBridge;
     private subscribeLedgerGenericAllowChains;
     private subscribePriorityTokens;
+    private handleSubmitProcessTransaction;
+    private createPassConfirmationParams;
+    private subscribeProcessById;
+    private subscribeProcessAlive;
     handle<TMessageType extends MessageTypes>(id: string, type: TMessageType, request: RequestTypes[TMessageType], port: chrome.runtime.Port): Promise<ResponseType<TMessageType>>;
 }