@subwallet/extension-base 1.3.55-1 → 1.3.57-0

package/cjs/koni/api/nft/config.js

@@ -47,7 +47,7 @@ const ODYSSEY_ENDPOINT = 'https://indexer-v2.dev.aurascan.io/api/v2/graphql';
 // export const UNIQUE_SCAN_ENDPOINT = 'https://explorer-api.unique.network/v1/graphql';
 // export const QUARTZ_SCAN_ENDPOINT = 'https://hasura-quartz.unique.network/v1/graphql';
 exports.ODYSSEY_ENDPOINT = ODYSSEY_ENDPOINT;
-const VARA_SCAN_ENDPOINT = 'https://nft-explorer.vara-network.io/graphql';
+const VARA_SCAN_ENDPOINT = 'https://nft-explorer.vara.network/graphql';
 exports.VARA_SCAN_ENDPOINT = VARA_SCAN_ENDPOINT;
 const AVAIL_LIGHT_CLIENT_NFT = 'https://indexer.availspace.app/graphql'; // 'https://indexer-nft.availspace.app/graphql';
 exports.AVAIL_LIGHT_CLIENT_NFT = AVAIL_LIGHT_CLIENT_NFT;

package/cjs/koni/api/staking/bonding/utils.js

@@ -249,6 +249,8 @@ function getYieldAvailableActionsByType(yieldPoolInfo) {
     const chain = yieldPoolInfo.chain;
     if (_constants2._STAKING_CHAIN_GROUP.para.includes(chain)) {
       return [YieldAction.STAKE, YieldAction.UNSTAKE, YieldAction.WITHDRAW, YieldAction.CANCEL_UNSTAKE];
+    } else if (_constants2._STAKING_CHAIN_GROUP.energy.includes(chain)) {
+      return [YieldAction.STAKE, YieldAction.UNSTAKE, YieldAction.WITHDRAW, YieldAction.CANCEL_UNSTAKE];
     } else if (_constants2._STAKING_CHAIN_GROUP.astar.includes(chain)) {
       return [YieldAction.STAKE, YieldAction.CLAIM_REWARD, YieldAction.UNSTAKE, YieldAction.WITHDRAW];
     } else if (_constants2._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {

package/cjs/koni/background/handlers/Extension.js

@@ -329,6 +329,11 @@ class KoniExtension {
       const accountProxiesFiltered = accountProxies.filter(accountProxy => {
         var _accountProxy$account;
         const signMode = (_accountProxy$account = accountProxy.accounts[0]) === null || _accountProxy$account === void 0 ? void 0 : _accountProxy$account.signMode;
+        if (signMode === _types4.AccountSignMode.GENERIC_LEDGER) {
+          if (accountProxy.chainTypes.includes(_types4.AccountChainType.ETHEREUM)) {
+            return (0, _utils6._isChainCompatibleLedgerEvm)(chainInfo);
+          }
+        }
         if (signMode === _types4.AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
           if (actionType === _types2.ActionType.SEND_NFT) {
             return false;

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.55-1'
+  version: '1.3.57-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/chain-service/constants.js

@@ -120,7 +120,10 @@ const _STAKING_ERA_LENGTH_MAP = {
   analog_timechain: 12,
   muse_testnet: 25 * 6 / 60 / 60,
   // 25 blocks per session
-  mythos: 24
+  mythos: 24,
+  energy_web_x_testnet: 22 * 12 / 3600,
+  // 22 blocks per era, 1 block per 12s
+  energy_web_x: 7200 * 12 / 3600 // 24 hours, 7200 blocks per era, 1 block per 12s
 };
 exports._STAKING_ERA_LENGTH_MAP = _STAKING_ERA_LENGTH_MAP;
 const _EXPECTED_BLOCK_TIME = {
@@ -156,7 +159,9 @@ const _EXPECTED_BLOCK_TIME = {
   avail_mainnet: 20,
   dentnet: 3,
   muse_testnet: 6,
-  mythos: 6
+  mythos: 6,
+  energy_web_x_testnet: 12,
+  energy_web_x: 12
 };
 exports._EXPECTED_BLOCK_TIME = _EXPECTED_BLOCK_TIME;
 const _PARACHAIN_INFLATION_DISTRIBUTION = {

package/cjs/services/chain-service/utils/index.js

@@ -851,9 +851,6 @@ const _isChainInfoCompatibleWithAccountInfo = (chainInfo, accountInfo) => {
     if (accountSignMode === _types3.AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
       return _isSubstrateEvmCompatibleChain(chainInfo) && _types4.EthereumKeypairTypes.includes(accountType);
     }
-    if (accountSignMode === _types3.AccountSignMode.GENERIC_LEDGER) {
-      return _isChainCompatibleLedgerEvm(chainInfo) && _types4.EthereumKeypairTypes.includes(accountType);
-    }
     return _isChainEvmCompatible(chainInfo) && _types4.EthereumKeypairTypes.includes(accountType);
   }
   if (accountChainType === _types3.AccountChainType.TON) {

package/cjs/services/chain-service/utils/patch.js

@@ -12,7 +12,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = process.env.PATCH_CHAIN_LIST_URL || (PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev');
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-const ChainListVersion = '0.2.113'; // update this when build chain-list
+const ChainListVersion = '0.2.114'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 exports.ChainListVersion = ChainListVersion;

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

@@ -24,6 +24,7 @@ const _STAKING_CHAIN_GROUP = {
   krest_network: ['krest_network'],
   manta: ['manta_network'],
   bittensor: ['bittensor', 'bittensor_testnet'],
+  energy: ['energy_web_x_testnet', 'energy_web_x'],
   mythos: ['mythos', 'muse_testnet']
 };
 exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;

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

@@ -0,0 +1,394 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/earning-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+var _basePara = _interopRequireDefault(require("./base-para"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class EnergyNativeStakingPoolHandler extends _basePara.default {
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const chainApi = this.substrateApi;
+    const nativeToken = this.nativeToken;
+    const defaultCallback = async () => {
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        }
+      };
+      const poolInfo = await this.getPoolInfo();
+      !poolInfo && callback(data);
+    };
+    if (!this.isActive) {
+      await defaultCallback();
+      return () => {
+        cancel = true;
+      };
+    }
+    await defaultCallback();
+    await chainApi.isReady;
+    const unsub = await chainApi.api.query.parachainStaking.era(async _era => {
+      var _chainApi$api$consts, _chainApi$api$consts$, _chainApi$api$consts$2, _chainApi$api$consts$3, _chainApi$api$query$p;
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const eraObj = _era.toHuman();
+      const era = (0, _utils3.parseRawNumber)(eraObj.current);
+      const maxNominations = (_chainApi$api$consts = chainApi.api.consts) === null || _chainApi$api$consts === void 0 ? void 0 : (_chainApi$api$consts$ = _chainApi$api$consts.parachainStaking) === null || _chainApi$api$consts$ === void 0 ? void 0 : (_chainApi$api$consts$2 = _chainApi$api$consts$.maxNominationsPerNominator) === null || _chainApi$api$consts$2 === void 0 ? void 0 : _chainApi$api$consts$2.toString();
+      const maxTopNominatorsPerCollator = (_chainApi$api$consts$3 = chainApi.api.consts.parachainStaking.maxTopNominationsPerCandidate) === null || _chainApi$api$consts$3 === void 0 ? void 0 : _chainApi$api$consts$3.toPrimitive();
+      const [_totalStake, unstakingDelay] = await Promise.all([(_chainApi$api$query$p = chainApi.api.query.parachainStaking) === null || _chainApi$api$query$p === void 0 ? void 0 : _chainApi$api$query$p.staked(era), chainApi.api.query.parachainStaking.delay()]);
+      const totalStake = _totalStake ? new _util.BN(_totalStake.toString()) : _util.BN_ZERO;
+      const eraTime = _constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default; // in hours
+      const unstakingPeriod = parseInt(unstakingDelay.toString()) * eraTime;
+      const minStake = '0';
+      const minToHuman = (0, _utils3.formatNumber)(minStake.toString(), nativeToken.decimals || 0, _utils3.balanceFormatter);
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription(minToHuman)
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug
+          }],
+          maxCandidatePerFarmer: parseInt(maxNominations),
+          maxWithdrawalRequestPerFarmer: 1,
+          // by default
+          earningThreshold: {
+            join: minStake.toString(),
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          farmerCount: 0,
+          // TODO recheck
+          era,
+          eraTime,
+          totalApy: undefined,
+          // not have
+          tvl: totalStake.toString(),
+          unstakingPeriod: unstakingPeriod
+        },
+        maxPoolMembers: maxTopNominatorsPerCollator
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, substrateApi, nominatorState) {
+    const nominationList = [];
+    const unstakingMap = {};
+    const substrateIdentityApi = this.substrateIdentityApi;
+    let bnTotalActiveStake = _util.BN_ZERO;
+    let bnTotalStake = _util.BN_ZERO;
+    let bnTotalUnstaking = _util.BN_ZERO;
+    const _eraInfo = await substrateApi.api.query.parachainStaking.era();
+    const roundInfo = _eraInfo.toPrimitive();
+    const currentRound = roundInfo.current;
+    await Promise.all(nominatorState.nominations.map(async nomination => {
+      const [_nominationScheduledRequests, [identity], _collatorInfo, _currentBlock, _currentTimestamp] = await Promise.all([substrateApi.api.query.parachainStaking.nominationScheduledRequests(nomination.owner), (0, _utils2.parseIdentity)(substrateIdentityApi, nomination.owner), substrateApi.api.query.parachainStaking.candidateInfo(nomination.owner), substrateApi.api.query.system.number(), substrateApi.api.query.timestamp.now()]);
+      const currentBlock = _currentBlock.toPrimitive();
+      const currentTimestamp = _currentTimestamp.toPrimitive();
+      const collatorInfo = _collatorInfo.toPrimitive();
+      const minNomination = collatorInfo === null || collatorInfo === void 0 ? void 0 : collatorInfo.lowestTopNominationAmount.toString();
+      const nominationScheduledRequests = _nominationScheduledRequests.toPrimitive();
+      let hasUnstaking = false;
+      let nominationStatus = _types.EarningStatus.NOT_EARNING;
+
+      // parse unstaking info
+      if (nominationScheduledRequests) {
+        for (const scheduledRequest of nominationScheduledRequests) {
+          if ((0, _utils3.reformatAddress)(scheduledRequest.nominator, 0) === (0, _utils3.reformatAddress)(address, 0)) {
+            // add network prefix
+            const isClaimable = scheduledRequest.whenExecutable - parseInt(currentRound) <= 0;
+            const remainingEra = scheduledRequest.whenExecutable - parseInt(currentRound);
+            const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+            const claimable = Object.values(scheduledRequest.action)[0];
+
+            // noted: target timestamp in parachainStaking easily volatile if block time volatile
+            const targetBlock = remainingEra * parseInt(roundInfo.length) + parseInt(roundInfo.first);
+            const remainingBlock = targetBlock - currentBlock;
+            const targetTimestampMs = remainingBlock * _constants._EXPECTED_BLOCK_TIME[chainInfo.slug] * 1000 + currentTimestamp;
+            unstakingMap[nomination.owner] = {
+              chain: chainInfo.slug,
+              status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+              validatorAddress: nomination.owner,
+              claimable: claimable.toString(),
+              waitingTime,
+              targetTimestampMs: targetTimestampMs
+            };
+            hasUnstaking = true;
+            break; // only handle 1 scheduledRequest per collator
+          }
+        }
+      }
+
+      const bnStake = new _util.BN(nomination.amount);
+      const bnUnstakeBalance = unstakingMap[nomination.owner] ? new _util.BN(unstakingMap[nomination.owner].claimable) : _util.BN_ZERO;
+      const bnActiveStake = bnStake.sub(bnUnstakeBalance);
+      if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minNomination))) {
+        nominationStatus = _types.EarningStatus.EARNING_REWARD;
+      }
+      bnTotalActiveStake = bnTotalActiveStake.add(bnActiveStake);
+      bnTotalStake = bnTotalStake.add(bnStake);
+      bnTotalUnstaking = bnTotalUnstaking.add(bnUnstakeBalance);
+      nominationList.push({
+        chain: chainInfo.slug,
+        status: nominationStatus,
+        validatorAddress: nomination.owner,
+        validatorIdentity: identity,
+        activeStake: bnActiveStake.toString(),
+        hasUnstaking,
+        validatorMinStake: collatorInfo.lowestTopNominationAmount.toString()
+      });
+    }));
+    const stakingStatus = (0, _utils.getEarningStatusByNominations)(bnTotalActiveStake, nominationList);
+    const totalStake = bnTotalStake.toString();
+    const activeStake = bnTotalActiveStake.toString();
+    const unstakingBalance = bnTotalUnstaking.toString();
+    const tokenInfo = this.state.chainService.getAssetBySlug(this.nativeToken.slug);
+    await this.createWithdrawNotifications(Object.values(unstakingMap), tokenInfo, address);
+    return {
+      status: stakingStatus,
+      totalStake,
+      balanceToken: this.nativeToken.slug,
+      activeStake: activeStake,
+      unstakeBalance: unstakingBalance,
+      isBondedBefore: !!nominationList.length,
+      nominations: nominationList,
+      unstakings: Object.values(unstakingMap)
+    };
+  }
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const defaultInfo = this.baseInfo;
+    const chainInfo = this.chainInfo;
+    await substrateApi.isReady;
+    const unsub = await substrateApi.api.query.parachainStaking.nominatorState.multi(useAddresses, async ledgers => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (ledgers) {
+        await Promise.all(ledgers.map(async (_nominatorState, i) => {
+          const nominatorState = _nominatorState.toPrimitive();
+          const owner = (0, _utils3.reformatAddress)(useAddresses[i], 42);
+          if (nominatorState) {
+            const nominatorMetadata = await this.parseNominatorMetadata(chainInfo, owner, substrateApi, nominatorState);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          } else {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              status: _types.EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+  async checkAccountHaveStake(useAddresses) {
+    var _substrateApi$api$que, _substrateApi$api$que2, _substrateApi$api$que3;
+    const result = [];
+    const substrateApi = await this.substrateApi.isReady;
+    const ledgers = await ((_substrateApi$api$que = substrateApi.api.query.parachainStaking) === null || _substrateApi$api$que === void 0 ? void 0 : (_substrateApi$api$que2 = _substrateApi$api$que.nominatorState) === null || _substrateApi$api$que2 === void 0 ? void 0 : (_substrateApi$api$que3 = _substrateApi$api$que2.multi) === null || _substrateApi$api$que3 === void 0 ? void 0 : _substrateApi$api$que3.call(_substrateApi$api$que2, useAddresses));
+    if (!ledgers) {
+      return [];
+    }
+    for (let i = 0; i < useAddresses.length; i++) {
+      const owner = useAddresses[i];
+      const nominatorState = ledgers[i].toPrimitive();
+      if (nominatorState && nominatorState.total > 0) {
+        result.push(owner);
+      }
+    }
+    return result;
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+  async getPoolTargets() {
+    const apiProps = await this.substrateApi.isReady;
+    const substrateIdentityApi = this.substrateIdentityApi;
+    const allCollators = [];
+    const [_allCollators, _selectedCandidates] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo.entries(),
+    // use it when energy support collatorCommission
+    // apiProps.api.query.parachainStaking.collatorCommission(),
+    apiProps.api.query.parachainStaking.selectedCandidates()]);
+    const maxNominationPerCollator = apiProps.api.consts.parachainStaking.maxTopNominationsPerCandidate.toString();
+    const selectedCollators = _selectedCandidates.toPrimitive();
+    for (const collator of _allCollators) {
+      const _collatorAddress = collator[0].toHuman();
+      const collatorAddress = _collatorAddress[0];
+      const collatorInfo = collator[1].toPrimitive();
+      const bnTotalStake = new _util.BN(collatorInfo.totalCounted);
+      const bnOwnStake = new _util.BN(collatorInfo.bond);
+      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+      const bnMinBond = new _util.BN(collatorInfo.lowestTopNominationAmount);
+      const maxNominatorRewarded = parseInt(maxNominationPerCollator);
+      if (selectedCollators.includes(collatorAddress)) {
+        allCollators.push({
+          commission: 0,
+          expectedReturn: 0,
+          address: collatorAddress,
+          totalStake: bnTotalStake.toString(),
+          ownStake: bnOwnStake.toString(),
+          otherStake: bnOtherStake.toString(),
+          nominatorCount: collatorInfo.nominationCount,
+          blocked: false,
+          isVerified: false,
+          minBond: bnMinBond.toString(),
+          chain: this.chain,
+          isCrowded: collatorInfo.nominationCount >= maxNominatorRewarded
+        });
+      }
+    }
+    const extraInfoMap = {};
+    await Promise.all(allCollators.map(async collator => {
+      const [_info, [identity, isReasonable]] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo(collator.address), (0, _utils2.parseIdentity)(substrateIdentityApi, collator.address)]);
+      const rawInfo = _info.toHuman();
+      const active = (rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.status) === 'Active';
+      extraInfoMap[collator.address] = {
+        identity,
+        isVerified: isReasonable,
+        active
+      };
+    }));
+    for (const validator of allCollators) {
+      validator.blocked = !extraInfoMap[validator.address].active;
+      validator.identity = extraInfoMap[validator.address].identity;
+      validator.isVerified = extraInfoMap[validator.address].isVerified;
+    }
+    return allCollators;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    const {
+      amount,
+      selectedValidators
+    } = data;
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const selectedCollatorInfo = selectedValidators[0];
+    const {
+      address: selectedCollatorAddress,
+      nominatorCount: selectedCollatorNominatorCount
+    } = selectedCollatorInfo;
+    const compoundResult = extrinsic => {
+      return Promise.resolve([extrinsic, {
+        slug: this.nativeToken.slug,
+        amount: '0'
+      }]);
+    };
+    if (!positionInfo) {
+      const extrinsic = apiPromise.api.tx.parachainStaking.nominate(selectedCollatorAddress, binaryAmount, new _util.BN(selectedCollatorNominatorCount), 0);
+      return compoundResult(extrinsic);
+    }
+    const {
+      bondedValidators,
+      nominationCount
+    } = (0, _utils.getBondedValidators)(positionInfo.nominations);
+    const parsedSelectedCollatorAddress = (0, _utils3.reformatAddress)(selectedCollatorInfo.address, 0);
+    if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+      const extrinsic = apiPromise.api.tx.parachainStaking.nominate(selectedCollatorAddress, binaryAmount, new _util.BN(selectedCollatorNominatorCount), nominationCount);
+      return compoundResult(extrinsic);
+    } else {
+      const extrinsic = apiPromise.api.tx.parachainStaking.bondExtra(selectedCollatorAddress, binaryAmount);
+      return compoundResult(extrinsic);
+    }
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const unstakeAll = (0, _utils.isUnstakeAll)(selectedTarget, poolPosition.nominations, amount);
+    let extrinsic;
+    if (!unstakeAll) {
+      extrinsic = apiPromise.api.tx.parachainStaking.scheduleNominatorUnbond(selectedTarget, binaryAmount);
+    } else {
+      extrinsic = apiPromise.api.tx.parachainStaking.scheduleRevokeNomination(selectedTarget);
+    }
+    return [_KoniTypes.ExtrinsicType.STAKING_UNBOND, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake(params) {
+    const {
+      selectedUnstaking
+    } = params;
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.cancelNominationRequest(selectedUnstaking.validatorAddress);
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const collatorAddress = unstakingInfo.validatorAddress;
+    if (!collatorAddress) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.executeNominationRequest(address, collatorAddress);
+  }
+
+  /* Other actions */
+}
+exports.default = EnergyNativeStakingPoolHandler;

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

@@ -16,6 +16,12 @@ Object.defineProperty(exports, "AstarNativeStakingPoolHandler", {
     return _astar.default;
   }
 });
+Object.defineProperty(exports, "EnergyNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _energy.default;
+  }
+});
 Object.defineProperty(exports, "ParaNativeStakingPoolHandler", {
   enumerable: true,
   get: function () {
@@ -45,4 +51,5 @@ var _astar = _interopRequireDefault(require("./astar"));
 var _relayChain = _interopRequireDefault(require("./relay-chain"));
 var _paraChain = _interopRequireDefault(require("./para-chain"));
 var _tao = _interopRequireDefault(require("./tao"));
-var _dtao = _interopRequireDefault(require("./dtao"));
+var _dtao = _interopRequireDefault(require("./dtao"));
+var _energy = _interopRequireDefault(require("./energy"));

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

@@ -100,6 +100,9 @@ class EarningService {
       if (_constants2._STAKING_CHAIN_GROUP.mythos.includes(chain)) {
         handlers.push(new _mythos.default(this.state, chain));
       }
+      if (_constants2._STAKING_CHAIN_GROUP.energy.includes(chain)) {
+        handlers.push(new _handlers.EnergyNativeStakingPoolHandler(this.state, chain));
+      }
       if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         const ahChain = ahMapChain[chain];
         if (ahChain) {

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

@@ -120,6 +120,8 @@ function isActionFromValidator(stakingType, chain) {
     return true;
   } else if (_constants._STAKING_CHAIN_GROUP.mythos.includes(chain)) {
     return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.energy.includes(chain)) {
+    return true;
   }
   return false;
 }

package/cjs/services/keyring-service/context/handlers/Json.js

@@ -117,10 +117,10 @@ class AccountJsonHandler extends _Base.AccountBaseHandler {
             name: (exists === null || exists === void 0 ? void 0 : exists.name) || (exists === null || exists === void 0 ? void 0 : exists.address) || _pair.address
           }
         }));
+        const _name = _pair.meta.name || '';
+        const nameExists = this.state.checkNameExists(_name);
         _uiKeyring.keyring.restoreAccount(file, password, withMasterPassword);
         const pair = _uiKeyring.keyring.getPair(_pair.address);
-        const _name = pair.meta.name || '';
-        const nameExists = this.state.checkNameExists(_name);
         if (nameExists) {
           const newName = _name.concat(' - ').concat((0, _getId.generateRandomString)());
           _uiKeyring.keyring.saveAccountMeta(pair, {

package/cjs/services/migration-service/scripts/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = exports.MYTHOS_MIGRATION_KEY = exports.EVERYTIME = void 0;
+var _MigrateChainPatrol = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateChainPatrol"));
 var _ClearMetadataDatabase = _interopRequireDefault(require("./databases/ClearMetadataDatabase"));
 var _ClearMetadataForMythos = _interopRequireDefault(require("./databases/ClearMetadataForMythos"));
 var _MigrateAssetSetting = _interopRequireDefault(require("./databases/MigrateAssetSetting"));
@@ -74,6 +75,7 @@ var _default = {
   [MYTHOS_MIGRATION_KEY]: _ClearMetadataForMythos.default,
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
-  '1.3.42-01': _MigrateNewUnifiedAccount.default
+  '1.3.42-01': _MigrateNewUnifiedAccount.default,
+  '1.3.54-01': _MigrateChainPatrol.default
 };
 exports.default = _default;

package/cjs/services/setting-service/constants.js

@@ -17,7 +17,7 @@ const DEFAULT_AUTO_LOCK_TIME = 15;
 exports.DEFAULT_AUTO_LOCK_TIME = DEFAULT_AUTO_LOCK_TIME;
 const DEFAULT_UNLOCK_TYPE = _utils.targetIsExtension ? _KoniTypes.WalletUnlockType.ALWAYS_REQUIRED : _KoniTypes.WalletUnlockType.WHEN_NEEDED;
 exports.DEFAULT_UNLOCK_TYPE = DEFAULT_UNLOCK_TYPE;
-const DEFAULT_CHAIN_PATROL_ENABLE = false;
+const DEFAULT_CHAIN_PATROL_ENABLE = true;
 exports.DEFAULT_CHAIN_PATROL_ENABLE = DEFAULT_CHAIN_PATROL_ENABLE;
 const DEFAULT_LANGUAGE = 'en';
 exports.DEFAULT_LANGUAGE = DEFAULT_LANGUAGE;

package/koni/api/nft/config.d.ts

@@ -12,7 +12,7 @@ export declare const BIT_COUNTRY_LAND_ESTATE_METADATA_API = "https://pioneer-api
 export declare const BIT_COUNTRY_THUMBNAIL_RESOLVER = "https://res.cloudinary.com/ddftctzph/image/upload/c_scale,q_100,w_250/production-ipfs/asset/";
 export declare const CF_IPFS_GATEWAY = "https://cf-ipfs.com/ipfs/";
 export declare const ODYSSEY_ENDPOINT = "https://indexer-v2.dev.aurascan.io/api/v2/graphql";
-export declare const VARA_SCAN_ENDPOINT = "https://nft-explorer.vara-network.io/graphql";
+export declare const VARA_SCAN_ENDPOINT = "https://nft-explorer.vara.network/graphql";
 export declare const AVAIL_LIGHT_CLIENT_NFT = "https://indexer.availspace.app/graphql";
 export declare const UNIQUE_SCAN_ENDPOINT = "https://api-unique.uniquescan.io/v1/graphql";
 export declare const QUARTZ_SCAN_ENDPOINT = "https://api-quartz.uniquescan.io/v1/graphql";

package/koni/api/nft/config.js

@@ -26,7 +26,7 @@ export const ODYSSEY_ENDPOINT = 'https://indexer-v2.dev.aurascan.io/api/v2/graph
 // export const UNIQUE_SCAN_ENDPOINT = 'https://explorer-api.unique.network/v1/graphql';
 // export const QUARTZ_SCAN_ENDPOINT = 'https://hasura-quartz.unique.network/v1/graphql';
 
-export const VARA_SCAN_ENDPOINT = 'https://nft-explorer.vara-network.io/graphql';
+export const VARA_SCAN_ENDPOINT = 'https://nft-explorer.vara.network/graphql';
 export const AVAIL_LIGHT_CLIENT_NFT = 'https://indexer.availspace.app/graphql'; // 'https://indexer-nft.availspace.app/graphql';
 
 export const UNIQUE_SCAN_ENDPOINT = 'https://api-unique.uniquescan.io/v1/graphql';

package/koni/api/staking/bonding/utils.js

@@ -206,6 +206,8 @@ export function getYieldAvailableActionsByType(yieldPoolInfo) {
     const chain = yieldPoolInfo.chain;
     if (_STAKING_CHAIN_GROUP.para.includes(chain)) {
       return [YieldAction.STAKE, YieldAction.UNSTAKE, YieldAction.WITHDRAW, YieldAction.CANCEL_UNSTAKE];
+    } else if (_STAKING_CHAIN_GROUP.energy.includes(chain)) {
+      return [YieldAction.STAKE, YieldAction.UNSTAKE, YieldAction.WITHDRAW, YieldAction.CANCEL_UNSTAKE];
     } else if (_STAKING_CHAIN_GROUP.astar.includes(chain)) {
       return [YieldAction.STAKE, YieldAction.CLAIM_REWARD, YieldAction.UNSTAKE, YieldAction.WITHDRAW];
     } else if (_STAKING_CHAIN_GROUP.amplitude.includes(chain)) {

package/koni/background/handlers/Extension.js

@@ -39,7 +39,7 @@ import { _isPosChainBridge, getClaimPosBridge } from '@subwallet/extension-base/
 import { estimateXcmFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm/utils';
 import { _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainBitcoinCompatible, _isChainEnabled, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByBitcoin, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainBitcoinCompatible, _isChainCompatibleLedgerEvm, _isChainEnabled, _isChainEvmCompatible, _isChainSubstrateCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isNativeTokenBySlug, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByBitcoin, _isTokenTransferredByCardano, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
 import { calculateToAmountByReservePool } from '@subwallet/extension-base/services/fee-service/utils';
 import { batchExtrinsicSetFeeHydration, getAssetHubTokensCanPayFee, getHydrationTokensCanPayFee } from '@subwallet/extension-base/services/fee-service/utils/tokenPayFee';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
@@ -47,7 +47,7 @@ import { DEFAULT_AUTO_LOCK_TIME } from '@subwallet/extension-base/services/setti
 import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectNamespace } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { AccountsStore } from '@subwallet/extension-base/stores';
-import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
+import { AccountChainType, AccountSignMode, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
 import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, combineBitcoinFee, createPromiseHandler, createTransactionFromRLP, detectTransferTxType, filterUneconomicalUtxos, getAccountSignMode, getSizeInfo, getTransferableBitcoinUtxos, isSameAddress, isSubstrateEcdsaLedgerAssetSupported, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -312,6 +312,11 @@ export default class KoniExtension {
       const accountProxiesFiltered = accountProxies.filter(accountProxy => {
         var _accountProxy$account;
         const signMode = (_accountProxy$account = accountProxy.accounts[0]) === null || _accountProxy$account === void 0 ? void 0 : _accountProxy$account.signMode;
+        if (signMode === AccountSignMode.GENERIC_LEDGER) {
+          if (accountProxy.chainTypes.includes(AccountChainType.ETHEREUM)) {
+            return _isChainCompatibleLedgerEvm(chainInfo);
+          }
+        }
         if (signMode === AccountSignMode.ECDSA_SUBSTRATE_LEDGER) {
           if (actionType === ActionType.SEND_NFT) {
             return false;