@subwallet/extension-base 1.2.32-0 → 1.3.1

package/cjs/services/earning-service/handlers/native-staking/base-para.js

@@ -39,10 +39,10 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
     const chainInfo = this.chainInfo;
     const bnAmount = new _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     if (!poolInfo || !poolInfo.statistic) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const errors = [];
     const selectedCollator = selectedValidators[0];
@@ -56,7 +56,7 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
     const existUnstakeErrorMessage = (0, _utils.getExistUnstakeErrorMessage)(chainInfo.slug, _KoniTypes.StakingType.NOMINATED, true);
     if (!poolPosition || poolPosition.status === _types.EarningStatus.NOT_STAKING) {
       if (!bnTotalStake.gte(bnMinStake)) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
       }
       return errors;
     }
@@ -67,11 +67,11 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
     if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
       // new delegation
       if (!bnTotalStake.gte(bnMinStake)) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
       }
       const delegationCount = poolPosition.nominations.length + 1;
       if (delegationCount > maxValidator) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
       }
     } else {
       let currentDelegationAmount = '0';
@@ -85,10 +85,10 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
       }
       bnTotalStake = bnTotalStake.add(new _util.BN(currentDelegationAmount));
       if (!bnTotalStake.gte(bnMinStake)) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
       }
       if (hasUnstaking) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
       }
     }
     return errors;
@@ -106,14 +106,14 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
     const poolInfo = await this.getPoolInfo();
     const poolPosition = await this.getPoolPosition(address);
     if (!poolInfo || !poolInfo.statistic || !poolPosition || fastLeave || !selectedTarget) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (fastLeave) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS)];
     }
     const bnAmount = new _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
+      errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
     }
     let targetNomination;
     for (const nomination of poolPosition.nominations) {
@@ -123,7 +123,7 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
       }
     }
     if (!targetNomination) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
       return errors;
     }
     const bnActiveStake = new _util.BN(targetNomination.activeStake);
@@ -133,10 +133,10 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
     const bnMinStake = _util.BN.max(bnCollatorMinStake, bnChainMinStake);
     const existUnstakeErrorMessage = (0, _utils.getExistUnstakeErrorMessage)(this.chain, _KoniTypes.StakingType.NOMINATED);
     if (targetNomination.hasUnstaking) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
     }
     if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(bnMinStake))) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.INVALID_ACTIVE_STAKE));
     }
     return errors;
   }

package/cjs/services/earning-service/handlers/native-staking/base.js

@@ -145,7 +145,7 @@ class BaseNativeStakingPoolHandler extends _base.default {
   /* Leave pool action */
 
   async handleYieldRedeem(amount, address, selectedTarget) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
 
   /* Leave pool action */
@@ -153,7 +153,7 @@ class BaseNativeStakingPoolHandler extends _base.default {
   /* Other action */
 
   async handleYieldClaimReward(address, bondReward) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
 
   /* Other actions */

package/cjs/services/earning-service/handlers/native-staking/para-chain.js

@@ -468,7 +468,7 @@ class ParaNativeStakingPoolHandler extends _basePara.default {
     const binaryAmount = new _util.BN(amount);
     const poolPosition = await this.getPoolPosition(address);
     if (!selectedTarget || !poolPosition) {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
     }
     const unstakeAll = (0, _utils.isUnstakeAll)(selectedTarget, poolPosition.nominations, amount);
     let extrinsic;
@@ -494,7 +494,7 @@ class ParaNativeStakingPoolHandler extends _basePara.default {
   async handleYieldWithdraw(address, unstakingInfo) {
     const collatorAddress = unstakingInfo.validatorAddress;
     if (!collatorAddress) {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
     }
     const chainApi = await this.substrateApi.isReady;
     return chainApi.api.tx.parachainStaking.executeDelegationRequest(address, collatorAddress);

package/cjs/services/earning-service/handlers/native-staking/relay-chain.js

@@ -298,7 +298,7 @@ class RelayNativeStakingPoolHandler extends _base.default {
     const chainApi = await this.substrateApi.isReady;
     const poolInfo = await this.getPoolInfo();
     if (!poolInfo || !poolInfo.statistic) {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
     }
     const [_era, _activeEraInfo] = await Promise.all([chainApi.api.query.staking.currentEra(), chainApi.api.query.staking.activeEra()]);
     const currentEra = _era.toString();
@@ -471,14 +471,14 @@ class RelayNativeStakingPoolHandler extends _base.default {
     const chainInfo = this.chainInfo;
     const bnAmount = new _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')]);
+      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')]);
     }
     if (!_poolInfo) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const poolInfo = _poolInfo;
     if (!poolInfo.statistic) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const errors = [];
     let bnTotalStake = new _util.BN(amount);
@@ -487,20 +487,20 @@ class RelayNativeStakingPoolHandler extends _base.default {
     const maxValidatorErrorMessage = (0, _utils.getMaxValidatorErrorMessage)(chainInfo, poolInfo.statistic.maxCandidatePerFarmer);
     if (!poolPosition || poolPosition.status === _types.EarningStatus.NOT_STAKING) {
       if (!bnTotalStake.gte(bnMinStake)) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
       }
       if (selectedValidators.length > poolInfo.statistic.maxCandidatePerFarmer) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
       }
       return errors;
     }
     const bnCurrentActiveStake = new _util.BN(poolPosition.activeStake);
     bnTotalStake = bnTotalStake.add(bnCurrentActiveStake);
     if (!bnTotalStake.gte(bnMinStake)) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
     }
     if (selectedValidators.length > poolInfo.statistic.maxCandidatePerFarmer) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
     }
     return errors;
   }
@@ -586,7 +586,7 @@ class RelayNativeStakingPoolHandler extends _base.default {
     if (bondTx && nominateTx) {
       return compoundTransactions(bondTx, nominateTx);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
 
@@ -599,24 +599,24 @@ class RelayNativeStakingPoolHandler extends _base.default {
     const poolInfo = await this.getPoolInfo();
     const poolPosition = await this.getPoolPosition(address);
     if (!poolInfo || !poolInfo.statistic || !poolPosition || fastLeave) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (fastLeave) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS)];
     }
     const bnAmount = new _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
+      errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
     }
     const bnActiveStake = new _util.BN(poolPosition.activeStake);
     const bnRemainingStake = bnActiveStake.sub(new _util.BN(amount));
     const minStake = new _util.BN(poolInfo.statistic.earningThreshold.join || '0');
     const maxUnstake = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
     if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.INVALID_ACTIVE_STAKE));
     }
     if (poolPosition.unstakings.length > maxUnstake) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
         replace: {
           number: maxUnstake
         }
@@ -628,7 +628,7 @@ class RelayNativeStakingPoolHandler extends _base.default {
     const chainApi = await this.substrateApi.isReady;
     const poolPosition = await this.getPoolPosition(address);
     if (!poolPosition) {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
     }
     let extrinsic;
     const binaryAmount = new _util.BN(amount);

package/cjs/services/earning-service/handlers/nomination-pool/index.js

@@ -381,7 +381,7 @@ class NominationPoolHandler extends _base.default {
       targets
     } = params;
     if (!targets || !targets.length) {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
     }
     const data = {
       amount,
@@ -409,10 +409,10 @@ class NominationPoolHandler extends _base.default {
     const _poolInfo = await this.getPoolInfo();
     const bnAmount = new _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     if (!_poolInfo || !_poolInfo.statistic) {
-      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const poolInfo = _poolInfo;
     const chainInfo = this.chainInfo;
@@ -426,17 +426,17 @@ class NominationPoolHandler extends _base.default {
     const minStakeErrorMessage = (0, _utils.getMinStakeErrorMessage)(chainInfo, bnMinStake);
     const existUnstakeErrorMessage = (0, _utils.getExistUnstakeErrorMessage)(chainInfo.slug, _KoniTypes.StakingType.POOLED, true);
     if (selectedPool.state !== 'Open') {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INACTIVE_NOMINATION_POOL));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.INACTIVE_NOMINATION_POOL));
     }
     if (positionInfo) {
       const bnCurrentActiveStake = new _util.BN(positionInfo.activeStake);
       bnTotalStake = bnTotalStake.add(bnCurrentActiveStake);
       if (positionInfo.unstakings.length > 0 && bnCurrentActiveStake.isZero()) {
-        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+        errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
       }
     }
     if (!bnTotalStake.gte(bnMinStake)) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
     }
     return errors;
   }
@@ -510,24 +510,24 @@ class NominationPoolHandler extends _base.default {
     const poolInfo = await this.getPoolInfo();
     const poolPosition = await this.getPoolPosition(address);
     if (!poolInfo || !poolPosition || fastLeave || !poolInfo.statistic) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (fastLeave) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS)];
     }
     const bnAmount = new _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
+      errors.push(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
     }
     const bnActiveStake = new _util.BN(poolPosition.activeStake);
     const bnRemainingStake = bnActiveStake.sub(new _util.BN(amount));
     const minStake = new _util.BN(poolInfo.statistic.earningThreshold.join || '0');
     const maxUnstake = poolInfo.statistic.maxWithdrawalRequestPerFarmer;
     if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(minStake))) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE));
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.INVALID_ACTIVE_STAKE));
     }
     if (poolPosition.unstakings.length > maxUnstake) {
-      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
+      errors.push(new _TransactionError.TransactionError(_types.StakingTxErrorType.EXCEED_MAX_UNSTAKING, (0, _i18next.t)('You cannot unstake more than {{number}} times', {
         replace: {
           number: maxUnstake
         }
@@ -536,13 +536,13 @@ class NominationPoolHandler extends _base.default {
     return Promise.resolve(errors);
   }
   async handleYieldRedeem(amount, address, selectedTarget) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
   async handleYieldUnstake(amount, address, selectedTarget) {
     const chainApi = await this.substrateApi.isReady;
     const poolPosition = await this.getPoolPosition(address);
     if (!poolPosition) {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
     }
     const extrinsic = chainApi.api.tx.nominationPools.unbond({
       Id: poolPosition.address
@@ -555,7 +555,7 @@ class NominationPoolHandler extends _base.default {
   /* Other action */
 
   handleYieldCancelUnstake(params) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
   async handleYieldClaimReward(address, bondReward) {
     const chainApi = await this.substrateApi.isReady;

package/cjs/services/earning-service/handlers/special.js

@@ -268,7 +268,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   /* Validate join action */
 
   async validateTokenApproveStep(params, path) {
-    return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED)]);
+    return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)]);
   }
   async validateXcmStep(params, path, bnInputTokenBalance) {
     const processValidation = {
@@ -315,11 +315,11 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   async validateJoinStep(id, params, path, bnInputTokenBalance, isXcmOk) {
     const _poolInfo = await this.getPoolInfo();
     if (!_poolInfo) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     const poolInfo = _poolInfo;
     if (!poolInfo.statistic) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     const processValidation = {
       ok: true,
@@ -375,7 +375,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const bnInputTokenBalance = new _util.BN(inputTokenBalance.value || '0');
     const bnAmount = new _util.BN(params.amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     let isXcmOk = false;
     for (const step of path.steps) {
@@ -406,7 +406,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   /* Submit join action */
 
   async handleTokenApproveStep(data, path) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
   async handleXcmStep(data, path, xcmFee) {
     const {
@@ -456,7 +456,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
     const type = path.steps[currentStep].type;
     switch (type) {
       case _types.YieldStepType.DEFAULT:
-        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
       case _types.YieldStepType.TOKEN_APPROVAL:
         return this.handleTokenApproveStep(data, path);
       case _types.YieldStepType.XCM:
@@ -476,7 +476,7 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   /* Leave pool action */
 
   handleYieldUnstake(amount, address, selectedTarget) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
 
   /* Leave pool action */
@@ -484,13 +484,13 @@ class BaseSpecialStakingPoolHandler extends _base.default {
   /* Other action */
 
   handleYieldCancelUnstake() {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
   handleYieldClaimReward(address, bondReward) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
   handleYieldWithdraw(address, unstakingInfo) {
-    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
   }
 
   /* Other actions */

package/cjs/services/earning-service/service.js

@@ -260,7 +260,7 @@ class EarningService {
     if (handler) {
       return handler.isPoolSupportAlternativeFee;
     } else {
-      throw new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR);
+      throw new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR);
     }
   }
   subscribeMinAmountPercent() {
@@ -380,7 +380,10 @@ class EarningService {
   async subscribePoolPositions(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const {
+      evm: evmAddresses,
+      substrate: substrateAddresses
+    } = (0, _utils2.categoryAddresses)(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
@@ -430,7 +433,7 @@ class EarningService {
   async getYieldPositionFromDB() {
     await this.eventService.waitChainReady;
     await this.eventService.waitKeyringReady;
-    const addresses = this.state.getDecodedAddresses();
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
     const existedYieldPosition = await this.dbService.getYieldNominationPoolPosition(addresses, this.state.activeChainSlugs);
     const yieldPositionInfo = this.yieldPositionSubject.getValue();
     existedYieldPosition.forEach(item => {
@@ -486,7 +489,7 @@ class EarningService {
   async runSubscribePoolsPosition() {
     await this.eventService.waitKeyringReady;
     this.runUnsubscribePoolsPosition();
-    const addresses = this.state.getDecodedAddresses();
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
     this.subscribePoolPositions(addresses, data => {
       this.updateYieldPosition(data);
     }).then(rs => {
@@ -525,7 +528,10 @@ class EarningService {
   async getPoolReward(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const {
+      evm: evmAddresses,
+      substrate: substrateAddresses
+    } = (0, _utils2.categoryAddresses)(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
@@ -555,7 +561,7 @@ class EarningService {
     return this.earningRewardSubject.getValue();
   }
   runSubscribeStakingRewardInterval() {
-    const addresses = this.state.getDecodedAddresses();
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
     if (!addresses.length) {
       return;
     }
@@ -576,7 +582,10 @@ class EarningService {
   async fetchPoolRewardHistory(addresses, callback) {
     let cancel = false;
     await this.eventService.waitChainReady;
-    const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+    const {
+      evm: evmAddresses,
+      substrate: substrateAddresses
+    } = (0, _utils2.categoryAddresses)(addresses);
     const activeChains = this.state.activeChainSlugs;
     const unsubList = [];
     for (const handler of Object.values(this.handlers)) {
@@ -620,7 +629,7 @@ class EarningService {
   }
   runSubscribeEarningRewardHistoryInterval() {
     this.runUnsubscribeEarningRewardHistoryInterval();
-    const addresses = this.state.getDecodedAddresses();
+    const addresses = this.state.keyringService.context.getDecodedAddresses();
     if (!addresses.length) {
       return;
     }
@@ -677,7 +686,7 @@ class EarningService {
     if (handler) {
       return handler.earlyValidate(request);
     } else {
-      throw new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR);
+      throw new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR);
     }
   }
   async generateOptimalSteps(params) {
@@ -689,7 +698,7 @@ class EarningService {
     if (handler) {
       return handler.generateOptimalPath(params);
     } else {
-      throw new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR);
+      throw new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR);
     }
   }
   async validateYieldJoin(params) {
@@ -701,7 +710,7 @@ class EarningService {
     if (handler) {
       return handler.validateYieldJoin(params.data, params.path);
     } else {
-      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)];
     }
   }
   async handleYieldJoin(params) {
@@ -713,7 +722,7 @@ class EarningService {
     if (handler) {
       return handler.handleYieldJoin(params.data, params.path, params.currentStep);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
 
@@ -730,7 +739,7 @@ class EarningService {
     if (handler) {
       return handler.validateYieldLeave(params.amount, params.address, params.fastLeave, params.selectedTarget);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
   async handleYieldLeave(params) {
@@ -742,7 +751,7 @@ class EarningService {
     if (handler) {
       return handler.handleYieldLeave(params.fastLeave, params.amount, params.address, params.selectedTarget);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
 
@@ -759,7 +768,7 @@ class EarningService {
     if (handler) {
       return handler.handleYieldWithdraw(params.address, params.unstakingInfo);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
   async handleYieldCancelUnstake(params) {
@@ -771,7 +780,7 @@ class EarningService {
     if (handler) {
       return handler.handleYieldCancelUnstake(params);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
   async handleYieldClaimReward(params) {
@@ -783,7 +792,7 @@ class EarningService {
     if (handler) {
       return handler.handleYieldClaimReward(params.address, params.bondReward);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
 

package/cjs/services/history-service/helpers/subscan-extrinsic-parser-helper.js

@@ -33,7 +33,7 @@ function balanceTransferParserFunction(item) {
       // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       const toPublicKey = p.value.id || p.value.Id;
       if (toPublicKey) {
-        item.to = (0, _utilCrypto.encodeAddress)(autoAddPublicKeyPrefix(toPublicKey), 42);
+        item.to = (0, _utilCrypto.encodeAddress)(autoAddPublicKeyPrefix(toPublicKey), item === null || item === void 0 ? void 0 : item.addressPrefix);
       }
     } else if (p.name === 'value') {
       if (item.amount) {

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

@@ -7,19 +7,20 @@ exports.HistoryService = void 0;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _types = require("@subwallet/extension-base/services/base/types");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _recoverHistoryStatus = require("@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus");
 var _subscanExtrinsicParserHelper = require("@subwallet/extension-base/services/history-service/helpers/subscan-extrinsic-parser-helper");
 var _subscanHistory = require("@subwallet/extension-base/services/history-service/subscan-history");
-var _utils = require("@subwallet/extension-base/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
 var _promise = require("@subwallet/extension-base/utils/promise");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _rxjs = require("rxjs");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-function filterHistoryItemByAddressAndChain(chain, address) {
+function filterHistoryItemByAddressAndChain(chain, addresses) {
   return item => {
-    return item.chain === chain && item.address === address;
+    return item.chain === chain && addresses.includes(item.address);
   };
 }
 class HistoryService {
@@ -47,7 +48,7 @@ class HistoryService {
     const historyRecords = [];
 
     // Fill additional info
-    const accountMap = Object.entries(this.keyringService.accounts).reduce((map, _ref) => {
+    const accountMap = Object.entries(this.keyringService.context.pairs).reduce((map, _ref) => {
       let [address, account] = _ref;
       map[address.toLowerCase()] = account.json.meta.name || address;
       return map;
@@ -75,11 +76,17 @@ class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
-  fetchSubscanTransactionHistory(chain, address) {
-    if (!this.subscanService.checkSupportedSubscanChain(chain)) {
+
+  /**
+   * @todo: Must improve performance of this function
+   * */
+  fetchSubscanTransactionHistory(chain, addresses) {
+    if (!this.subscanService.checkSupportedSubscanChain(chain) || !addresses.length) {
       return;
     }
     const chainInfo = this.chainService.getChainInfoByKey(chain);
+    // For now, we only use the first address
+    const address = addresses[0];
     const excludeExtrinsicParserKeys = ['balances.transfer_all'];
 
     // Note: fetchAllPossibleExtrinsicItems and fetchAllPossibleTransferItems-receive can run parallelly
@@ -142,15 +149,26 @@ class HistoryService {
       console.log('fetchAllPossibleTransferItems-receive error', e);
     });
   }
-  subscribeHistories(chain, address, cb) {
-    const _address = (0, _utils.reformatAddress)(address);
+  subscribeHistories(chain, proxyId, cb) {
+    const addresses = this.keyringService.context.getDecodedAddresses(proxyId, false);
+    const {
+      evm,
+      substrate
+    } = (0, _utils2.categoryAddresses)(addresses);
     const subscription = this.historySubject.subscribe(items => {
-      cb(items.filter(filterHistoryItemByAddressAndChain(chain, _address)));
+      cb(items.filter(filterHistoryItemByAddressAndChain(chain, addresses)));
     });
-    this.fetchSubscanTransactionHistory(chain, _address);
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    if ((0, _utils._isChainSubstrateCompatible)(chainInfo)) {
+      if ((0, _utils._isChainEvmCompatible)(chainInfo)) {
+        this.fetchSubscanTransactionHistory(chain, evm);
+      } else {
+        this.fetchSubscanTransactionHistory(chain, substrate);
+      }
+    }
     return {
       unsubscribe: subscription.unsubscribe,
-      value: this.historySubject.getValue().filter(filterHistoryItemByAddressAndChain(chain, _address))
+      value: this.historySubject.getValue().filter(filterHistoryItemByAddressAndChain(chain, addresses))
     };
   }
   async updateHistories(chain, extrinsicHash, updateData) {